1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
2 use Pleroma.Web.ConnCase
4 alias Pleroma.Web.TwitterAPI.TwitterAPI
5 alias Pleroma.{Repo, User, Activity, Notification}
6 alias Pleroma.Web.{OStatus, CommonAPI}
7 alias Pleroma.Web.ActivityPub.ActivityPub
10 import ExUnit.CaptureLog
12 test "the home timeline", %{conn: conn} do
14 following = insert(:user)
16 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
20 |> assign(:user, user)
21 |> get("/api/v1/timelines/home")
23 assert length(json_response(conn, 200)) == 0
25 {:ok, user} = User.follow(user, following)
29 |> assign(:user, user)
30 |> get("/api/v1/timelines/home")
32 assert [%{"content" => "test"}] = json_response(conn, 200)
35 test "the public timeline", %{conn: conn} do
36 following = insert(:user)
39 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
42 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
46 |> get("/api/v1/timelines/public", %{"local" => "False"})
48 assert length(json_response(conn, 200)) == 2
52 |> get("/api/v1/timelines/public", %{"local" => "True"})
54 assert [%{"content" => "test"}] = json_response(conn, 200)
58 |> get("/api/v1/timelines/public", %{"local" => "1"})
60 assert [%{"content" => "test"}] = json_response(conn, 200)
64 test "posting a status", %{conn: conn} do
67 idempotency_key = "Pikachu rocks!"
71 |> assign(:user, user)
72 |> put_req_header("idempotency-key", idempotency_key)
73 |> post("/api/v1/statuses", %{
75 "spoiler_text" => "2hu",
76 "sensitive" => "false"
79 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
81 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
83 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
84 json_response(conn_one, 200)
86 assert Repo.get(Activity, id)
90 |> assign(:user, user)
91 |> put_req_header("idempotency-key", idempotency_key)
92 |> post("/api/v1/statuses", %{
94 "spoiler_text" => "2hu",
95 "sensitive" => "false"
98 assert %{"id" => second_id} = json_response(conn_two, 200)
100 assert id == second_id
104 |> assign(:user, user)
105 |> post("/api/v1/statuses", %{
107 "spoiler_text" => "2hu",
108 "sensitive" => "false"
111 assert %{"id" => third_id} = json_response(conn_three, 200)
113 refute id == third_id
116 test "posting a sensitive status", %{conn: conn} do
121 |> assign(:user, user)
122 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
124 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
125 assert Repo.get(Activity, id)
128 test "posting a direct status", %{conn: conn} do
129 user1 = insert(:user)
130 user2 = insert(:user)
131 content = "direct cofe @#{user2.nickname}"
135 |> assign(:user, user1)
136 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
138 assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
139 assert activity = Repo.get(Activity, id)
140 assert activity.recipients == [user2.ap_id]
141 assert activity.data["to"] == [user2.ap_id]
142 assert activity.data["cc"] == []
145 test "direct timeline", %{conn: conn} do
146 user_one = insert(:user)
147 user_two = insert(:user)
149 {:ok, user_two} = User.follow(user_two, user_one)
152 CommonAPI.post(user_one, %{
153 "status" => "Hi @#{user_two.nickname}!",
154 "visibility" => "direct"
157 {:ok, _follower_only} =
158 CommonAPI.post(user_one, %{
159 "status" => "Hi @#{user_two.nickname}!",
160 "visibility" => "private"
163 # Only direct should be visible here
166 |> assign(:user, user_two)
167 |> get("api/v1/timelines/direct")
169 [status] = json_response(res_conn, 200)
171 assert %{"visibility" => "direct"} = status
172 assert status["url"] != direct.data["id"]
174 # Both should be visible here
177 |> assign(:user, user_two)
178 |> get("api/v1/timelines/home")
180 [_s1, _s2] = json_response(res_conn, 200)
183 test "replying to a status", %{conn: conn} do
186 {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
190 |> assign(:user, user)
191 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
193 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
195 activity = Repo.get(Activity, id)
197 assert activity.data["context"] == replied_to.data["context"]
198 assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
201 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
206 |> assign(:user, user)
207 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
209 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
211 activity = Repo.get(Activity, id)
216 test "verify_credentials", %{conn: conn} do
221 |> assign(:user, user)
222 |> get("/api/v1/accounts/verify_credentials")
224 assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
225 assert id == to_string(user.id)
228 test "verify_credentials default scope unlisted", %{conn: conn} do
229 user = insert(:user, %{info: %{"default_scope" => "unlisted"}})
233 |> assign(:user, user)
234 |> get("/api/v1/accounts/verify_credentials")
236 assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
237 assert id == to_string(user.id)
240 test "get a status", %{conn: conn} do
241 activity = insert(:note_activity)
245 |> get("/api/v1/statuses/#{activity.id}")
247 assert %{"id" => id} = json_response(conn, 200)
248 assert id == to_string(activity.id)
251 describe "deleting a status" do
252 test "when you created it", %{conn: conn} do
253 activity = insert(:note_activity)
254 author = User.get_by_ap_id(activity.data["actor"])
258 |> assign(:user, author)
259 |> delete("/api/v1/statuses/#{activity.id}")
261 assert %{} = json_response(conn, 200)
263 assert Repo.get(Activity, activity.id) == nil
266 test "when you didn't create it", %{conn: conn} do
267 activity = insert(:note_activity)
272 |> assign(:user, user)
273 |> delete("/api/v1/statuses/#{activity.id}")
275 assert %{"error" => _} = json_response(conn, 403)
277 assert Repo.get(Activity, activity.id) == activity
281 describe "filters" do
282 test "creating a filter", %{conn: conn} do
285 filter = %Pleroma.Filter{
292 |> assign(:user, user)
293 |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
295 assert response = json_response(conn, 200)
296 assert response["phrase"] == filter.phrase
297 assert response["context"] == filter.context
298 assert response["id"] != nil
299 assert response["id"] != ""
302 test "fetching a list of filters", %{conn: conn} do
305 query_one = %Pleroma.Filter{
312 query_two = %Pleroma.Filter{
319 {:ok, filter_one} = Pleroma.Filter.create(query_one)
320 {:ok, filter_two} = Pleroma.Filter.create(query_two)
324 |> assign(:user, user)
325 |> get("/api/v1/filters")
327 assert response = json_response(conn, 200)
330 test "get a filter", %{conn: conn} do
333 query = %Pleroma.Filter{
340 {:ok, filter} = Pleroma.Filter.create(query)
344 |> assign(:user, user)
345 |> get("/api/v1/filters/#{filter.filter_id}")
347 assert response = json_response(conn, 200)
350 test "update a filter", %{conn: conn} do
353 query = %Pleroma.Filter{
360 {:ok, filter} = Pleroma.Filter.create(query)
362 new = %Pleroma.Filter{
369 |> assign(:user, user)
370 |> put("/api/v1/filters/#{query.filter_id}", %{
375 assert response = json_response(conn, 200)
376 assert response["phrase"] == new.phrase
377 assert response["context"] == new.context
380 test "delete a filter", %{conn: conn} do
383 query = %Pleroma.Filter{
390 {:ok, filter} = Pleroma.Filter.create(query)
394 |> assign(:user, user)
395 |> delete("/api/v1/filters/#{filter.filter_id}")
397 assert response = json_response(conn, 200)
398 assert response == %{}
403 test "creating a list", %{conn: conn} do
408 |> assign(:user, user)
409 |> post("/api/v1/lists", %{"title" => "cuties"})
411 assert %{"title" => title} = json_response(conn, 200)
412 assert title == "cuties"
415 test "adding users to a list", %{conn: conn} do
417 other_user = insert(:user)
418 {:ok, list} = Pleroma.List.create("name", user)
422 |> assign(:user, user)
423 |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
425 assert %{} == json_response(conn, 200)
426 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
427 assert following == [other_user.follower_address]
430 test "removing users from a list", %{conn: conn} do
432 other_user = insert(:user)
433 third_user = insert(:user)
434 {:ok, list} = Pleroma.List.create("name", user)
435 {:ok, list} = Pleroma.List.follow(list, other_user)
436 {:ok, list} = Pleroma.List.follow(list, third_user)
440 |> assign(:user, user)
441 |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
443 assert %{} == json_response(conn, 200)
444 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
445 assert following == [third_user.follower_address]
448 test "listing users in a list", %{conn: conn} do
450 other_user = insert(:user)
451 {:ok, list} = Pleroma.List.create("name", user)
452 {:ok, list} = Pleroma.List.follow(list, other_user)
456 |> assign(:user, user)
457 |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
459 assert [%{"id" => id}] = json_response(conn, 200)
460 assert id == to_string(other_user.id)
463 test "retrieving a list", %{conn: conn} do
465 {:ok, list} = Pleroma.List.create("name", user)
469 |> assign(:user, user)
470 |> get("/api/v1/lists/#{list.id}")
472 assert %{"id" => id} = json_response(conn, 200)
473 assert id == to_string(list.id)
476 test "renaming a list", %{conn: conn} do
478 {:ok, list} = Pleroma.List.create("name", user)
482 |> assign(:user, user)
483 |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
485 assert %{"title" => name} = json_response(conn, 200)
486 assert name == "newname"
489 test "deleting a list", %{conn: conn} do
491 {:ok, list} = Pleroma.List.create("name", user)
495 |> assign(:user, user)
496 |> delete("/api/v1/lists/#{list.id}")
498 assert %{} = json_response(conn, 200)
499 assert is_nil(Repo.get(Pleroma.List, list.id))
502 test "list timeline", %{conn: conn} do
504 other_user = insert(:user)
505 {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
506 {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
507 {:ok, list} = Pleroma.List.create("name", user)
508 {:ok, list} = Pleroma.List.follow(list, other_user)
512 |> assign(:user, user)
513 |> get("/api/v1/timelines/list/#{list.id}")
515 assert [%{"id" => id}] = json_response(conn, 200)
517 assert id == to_string(activity_two.id)
520 test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
522 other_user = insert(:user)
523 {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
525 {:ok, activity_two} =
526 TwitterAPI.create_status(other_user, %{
527 "status" => "Marisa is cute.",
528 "visibility" => "private"
531 {:ok, list} = Pleroma.List.create("name", user)
532 {:ok, list} = Pleroma.List.follow(list, other_user)
536 |> assign(:user, user)
537 |> get("/api/v1/timelines/list/#{list.id}")
539 assert [%{"id" => id}] = json_response(conn, 200)
541 assert id == to_string(activity_one.id)
545 describe "notifications" do
546 test "list of notifications", %{conn: conn} do
548 other_user = insert(:user)
551 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
553 {:ok, [_notification]} = Notification.create_notifications(activity)
557 |> assign(:user, user)
558 |> get("/api/v1/notifications")
561 "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
563 assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
564 assert response == expected_response
567 test "getting a single notification", %{conn: conn} do
569 other_user = insert(:user)
572 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
574 {:ok, [notification]} = Notification.create_notifications(activity)
578 |> assign(:user, user)
579 |> get("/api/v1/notifications/#{notification.id}")
582 "hi <span><a href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
584 assert %{"status" => %{"content" => response}} = json_response(conn, 200)
585 assert response == expected_response
588 test "dismissing a single notification", %{conn: conn} do
590 other_user = insert(:user)
593 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
595 {:ok, [notification]} = Notification.create_notifications(activity)
599 |> assign(:user, user)
600 |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
602 assert %{} = json_response(conn, 200)
605 test "clearing all notifications", %{conn: conn} do
607 other_user = insert(:user)
610 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
612 {:ok, [_notification]} = Notification.create_notifications(activity)
616 |> assign(:user, user)
617 |> post("/api/v1/notifications/clear")
619 assert %{} = json_response(conn, 200)
623 |> assign(:user, user)
624 |> get("/api/v1/notifications")
626 assert all = json_response(conn, 200)
631 describe "reblogging" do
632 test "reblogs and returns the reblogged status", %{conn: conn} do
633 activity = insert(:note_activity)
638 |> assign(:user, user)
639 |> post("/api/v1/statuses/#{activity.id}/reblog")
641 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
642 json_response(conn, 200)
644 assert to_string(activity.id) == id
648 describe "unreblogging" do
649 test "unreblogs and returns the unreblogged status", %{conn: conn} do
650 activity = insert(:note_activity)
653 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
657 |> assign(:user, user)
658 |> post("/api/v1/statuses/#{activity.id}/unreblog")
660 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
662 assert to_string(activity.id) == id
666 describe "favoriting" do
667 test "favs a status and returns it", %{conn: conn} do
668 activity = insert(:note_activity)
673 |> assign(:user, user)
674 |> post("/api/v1/statuses/#{activity.id}/favourite")
676 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
677 json_response(conn, 200)
679 assert to_string(activity.id) == id
682 test "returns 500 for a wrong id", %{conn: conn} do
687 |> assign(:user, user)
688 |> post("/api/v1/statuses/1/favourite")
689 |> json_response(500)
691 assert resp == "Something went wrong"
695 describe "unfavoriting" do
696 test "unfavorites a status and returns it", %{conn: conn} do
697 activity = insert(:note_activity)
700 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
704 |> assign(:user, user)
705 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
707 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
708 json_response(conn, 200)
710 assert to_string(activity.id) == id
714 describe "user timelines" do
715 test "gets a users statuses", %{conn: conn} do
716 user_one = insert(:user)
717 user_two = insert(:user)
718 user_three = insert(:user)
720 {:ok, user_three} = User.follow(user_three, user_one)
722 {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
724 {:ok, direct_activity} =
725 CommonAPI.post(user_one, %{
726 "status" => "Hi, @#{user_two.nickname}.",
727 "visibility" => "direct"
730 {:ok, private_activity} =
731 CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
735 |> get("/api/v1/accounts/#{user_one.id}/statuses")
737 assert [%{"id" => id}] = json_response(resp, 200)
738 assert id == to_string(activity.id)
742 |> assign(:user, user_two)
743 |> get("/api/v1/accounts/#{user_one.id}/statuses")
745 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
746 assert id_one == to_string(direct_activity.id)
747 assert id_two == to_string(activity.id)
751 |> assign(:user, user_three)
752 |> get("/api/v1/accounts/#{user_one.id}/statuses")
754 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
755 assert id_one == to_string(private_activity.id)
756 assert id_two == to_string(activity.id)
759 test "unimplemented pinned statuses feature", %{conn: conn} do
760 note = insert(:note_activity)
761 user = User.get_by_ap_id(note.data["actor"])
765 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
767 assert json_response(conn, 200) == []
770 test "gets an users media", %{conn: conn} do
771 note = insert(:note_activity)
772 user = User.get_by_ap_id(note.data["actor"])
775 content_type: "image/jpg",
776 path: Path.absname("test/fixtures/image.jpg"),
777 filename: "an_image.jpg"
781 TwitterAPI.upload(file, "json")
785 TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
789 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
791 assert [%{"id" => id}] = json_response(conn, 200)
792 assert id == to_string(image_post.id)
796 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
798 assert [%{"id" => id}] = json_response(conn, 200)
799 assert id == to_string(image_post.id)
803 describe "user relationships" do
804 test "returns the relationships for the current user", %{conn: conn} do
806 other_user = insert(:user)
807 {:ok, user} = User.follow(user, other_user)
811 |> assign(:user, user)
812 |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
814 assert [relationship] = json_response(conn, 200)
816 assert to_string(other_user.id) == relationship["id"]
820 describe "locked accounts" do
821 test "/api/v1/follow_requests works" do
822 user = insert(:user, %{info: %{"locked" => true}})
823 other_user = insert(:user)
825 {:ok, activity} = ActivityPub.follow(other_user, user)
827 user = Repo.get(User, user.id)
828 other_user = Repo.get(User, other_user.id)
830 assert User.following?(other_user, user) == false
834 |> assign(:user, user)
835 |> get("/api/v1/follow_requests")
837 assert [relationship] = json_response(conn, 200)
838 assert to_string(other_user.id) == relationship["id"]
841 test "/api/v1/follow_requests/:id/authorize works" do
842 user = insert(:user, %{info: %{"locked" => true}})
843 other_user = insert(:user)
845 {:ok, activity} = ActivityPub.follow(other_user, user)
847 user = Repo.get(User, user.id)
848 other_user = Repo.get(User, other_user.id)
850 assert User.following?(other_user, user) == false
854 |> assign(:user, user)
855 |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
857 assert relationship = json_response(conn, 200)
858 assert to_string(other_user.id) == relationship["id"]
860 user = Repo.get(User, user.id)
861 other_user = Repo.get(User, other_user.id)
863 assert User.following?(other_user, user) == true
866 test "verify_credentials", %{conn: conn} do
867 user = insert(:user, %{info: %{"default_scope" => "private"}})
871 |> assign(:user, user)
872 |> get("/api/v1/accounts/verify_credentials")
874 assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
875 assert id == to_string(user.id)
878 test "/api/v1/follow_requests/:id/reject works" do
879 user = insert(:user, %{info: %{"locked" => true}})
880 other_user = insert(:user)
882 {:ok, activity} = ActivityPub.follow(other_user, user)
886 |> assign(:user, user)
887 |> post("/api/v1/follow_requests/#{other_user.id}/reject")
889 assert relationship = json_response(conn, 200)
890 assert to_string(other_user.id) == relationship["id"]
892 user = Repo.get(User, user.id)
893 other_user = Repo.get(User, other_user.id)
895 assert User.following?(other_user, user) == false
899 test "account fetching", %{conn: conn} do
904 |> get("/api/v1/accounts/#{user.id}")
906 assert %{"id" => id} = json_response(conn, 200)
907 assert id == to_string(user.id)
911 |> get("/api/v1/accounts/-1")
913 assert %{"error" => "Can't find user"} = json_response(conn, 404)
916 test "media upload", %{conn: conn} do
918 content_type: "image/jpg",
919 path: Path.absname("test/fixtures/image.jpg"),
920 filename: "an_image.jpg"
923 desc = "Description of the image"
929 |> assign(:user, user)
930 |> post("/api/v1/media", %{"file" => file, "description" => desc})
932 assert media = json_response(conn, 200)
934 assert media["type"] == "image"
935 assert media["description"] == desc
938 test "hashtag timeline", %{conn: conn} do
939 following = insert(:user)
942 {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
945 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
949 |> get("/api/v1/timelines/tag/2hu")
951 assert [%{"id" => id}] = json_response(nconn, 200)
953 assert id == to_string(activity.id)
955 # works for different capitalization too
958 |> get("/api/v1/timelines/tag/2HU")
960 assert [%{"id" => id}] = json_response(nconn, 200)
962 assert id == to_string(activity.id)
966 test "getting followers", %{conn: conn} do
968 other_user = insert(:user)
969 {:ok, user} = User.follow(user, other_user)
973 |> get("/api/v1/accounts/#{other_user.id}/followers")
975 assert [%{"id" => id}] = json_response(conn, 200)
976 assert id == to_string(user.id)
979 test "getting following", %{conn: conn} do
981 other_user = insert(:user)
982 {:ok, user} = User.follow(user, other_user)
986 |> get("/api/v1/accounts/#{user.id}/following")
988 assert [%{"id" => id}] = json_response(conn, 200)
989 assert id == to_string(other_user.id)
992 test "following / unfollowing a user", %{conn: conn} do
994 other_user = insert(:user)
998 |> assign(:user, user)
999 |> post("/api/v1/accounts/#{other_user.id}/follow")
1001 assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1003 user = Repo.get(User, user.id)
1007 |> assign(:user, user)
1008 |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1010 assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1012 user = Repo.get(User, user.id)
1016 |> assign(:user, user)
1017 |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1019 assert %{"id" => id} = json_response(conn, 200)
1020 assert id == to_string(other_user.id)
1023 test "blocking / unblocking a user", %{conn: conn} do
1024 user = insert(:user)
1025 other_user = insert(:user)
1029 |> assign(:user, user)
1030 |> post("/api/v1/accounts/#{other_user.id}/block")
1032 assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1034 user = Repo.get(User, user.id)
1038 |> assign(:user, user)
1039 |> post("/api/v1/accounts/#{other_user.id}/unblock")
1041 assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1044 test "getting a list of blocks", %{conn: conn} do
1045 user = insert(:user)
1046 other_user = insert(:user)
1048 {:ok, user} = User.block(user, other_user)
1052 |> assign(:user, user)
1053 |> get("/api/v1/blocks")
1055 other_user_id = to_string(other_user.id)
1056 assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1059 test "blocking / unblocking a domain", %{conn: conn} do
1060 user = insert(:user)
1061 other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1065 |> assign(:user, user)
1066 |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1068 assert %{} = json_response(conn, 200)
1069 user = User.get_cached_by_ap_id(user.ap_id)
1070 assert User.blocks?(user, other_user)
1074 |> assign(:user, user)
1075 |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1077 assert %{} = json_response(conn, 200)
1078 user = User.get_cached_by_ap_id(user.ap_id)
1079 refute User.blocks?(user, other_user)
1082 test "getting a list of domain blocks" do
1083 user = insert(:user)
1085 {:ok, user} = User.block_domain(user, "bad.site")
1086 {:ok, user} = User.block_domain(user, "even.worse.site")
1090 |> assign(:user, user)
1091 |> get("/api/v1/domain_blocks")
1093 domain_blocks = json_response(conn, 200)
1095 assert "bad.site" in domain_blocks
1096 assert "even.worse.site" in domain_blocks
1099 test "unimplemented mute endpoints" do
1100 user = insert(:user)
1101 other_user = insert(:user)
1104 |> Enum.each(fn endpoint ->
1107 |> assign(:user, user)
1108 |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1110 assert %{"id" => id} = json_response(conn, 200)
1111 assert id == to_string(other_user.id)
1115 test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1116 user = insert(:user)
1118 ["blocks", "domain_blocks", "mutes", "follow_requests"]
1119 |> Enum.each(fn endpoint ->
1122 |> assign(:user, user)
1123 |> get("/api/v1/#{endpoint}")
1125 assert [] = json_response(conn, 200)
1129 test "account search", %{conn: conn} do
1130 user = insert(:user)
1131 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1132 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1136 |> assign(:user, user)
1137 |> get("/api/v1/accounts/search", %{"q" => "shp"})
1138 |> json_response(200)
1140 result_ids = for result <- results, do: result["acct"]
1142 assert user_two.nickname in result_ids
1143 assert user_three.nickname in result_ids
1147 |> assign(:user, user)
1148 |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1149 |> json_response(200)
1151 result_ids = for result <- results, do: result["acct"]
1153 assert user_three.nickname in result_ids
1156 test "search", %{conn: conn} do
1157 user = insert(:user)
1158 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1159 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1161 {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1164 CommonAPI.post(user, %{
1165 "status" => "This is about 2hu, but private",
1166 "visibility" => "private"
1169 {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1173 |> get("/api/v1/search", %{"q" => "2hu"})
1175 assert results = json_response(conn, 200)
1177 [account | _] = results["accounts"]
1178 assert account["id"] == to_string(user_three.id)
1180 assert results["hashtags"] == []
1182 [status] = results["statuses"]
1183 assert status["id"] == to_string(activity.id)
1186 test "search fetches remote statuses", %{conn: conn} do
1190 |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1192 assert results = json_response(conn, 200)
1194 [status] = results["statuses"]
1195 assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1199 test "search fetches remote accounts", %{conn: conn} do
1202 |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1204 assert results = json_response(conn, 200)
1205 [account] = results["accounts"]
1206 assert account["acct"] == "shp@social.heldscal.la"
1209 test "returns the favorites of a user", %{conn: conn} do
1210 user = insert(:user)
1211 other_user = insert(:user)
1213 {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1214 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1216 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1220 |> assign(:user, user)
1221 |> get("/api/v1/favourites")
1223 assert [status] = json_response(conn, 200)
1224 assert status["id"] == to_string(activity.id)
1227 describe "updating credentials" do
1228 test "updates the user's bio", %{conn: conn} do
1229 user = insert(:user)
1233 |> assign(:user, user)
1234 |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
1236 assert user = json_response(conn, 200)
1237 assert user["note"] == "I drink #cofe"
1240 test "updates the user's name", %{conn: conn} do
1241 user = insert(:user)
1245 |> assign(:user, user)
1246 |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1248 assert user = json_response(conn, 200)
1249 assert user["display_name"] == "markorepairs"
1252 test "updates the user's avatar", %{conn: conn} do
1253 user = insert(:user)
1255 new_avatar = %Plug.Upload{
1256 content_type: "image/jpg",
1257 path: Path.absname("test/fixtures/image.jpg"),
1258 filename: "an_image.jpg"
1263 |> assign(:user, user)
1264 |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1266 assert user = json_response(conn, 200)
1267 assert user["avatar"] != "https://placehold.it/48x48"
1270 test "updates the user's banner", %{conn: conn} do
1271 user = insert(:user)
1273 new_header = %Plug.Upload{
1274 content_type: "image/jpg",
1275 path: Path.absname("test/fixtures/image.jpg"),
1276 filename: "an_image.jpg"
1281 |> assign(:user, user)
1282 |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1284 assert user = json_response(conn, 200)
1285 assert user["header"] != "https://placehold.it/700x335"
1289 test "get instance information", %{conn: conn} do
1290 insert(:user, %{local: true})
1291 user = insert(:user, %{local: true})
1292 insert(:user, %{local: false})
1294 {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1296 Pleroma.Stats.update_stats()
1300 |> get("/api/v1/instance")
1302 assert result = json_response(conn, 200)
1304 assert result["stats"]["user_count"] == 2
1305 assert result["stats"]["status_count"] == 1