1 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
2 use Pleroma.Web.ConnCase
4 alias Pleroma.Web.TwitterAPI.TwitterAPI
5 alias Pleroma.{Repo, User, Object, Activity, Notification}
6 alias Pleroma.Web.{OStatus, CommonAPI}
7 alias Pleroma.Web.ActivityPub.ActivityPub
10 import ExUnit.CaptureLog
14 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
18 test "the home timeline", %{conn: conn} do
20 following = insert(:user)
22 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
26 |> assign(:user, user)
27 |> get("/api/v1/timelines/home")
29 assert length(json_response(conn, 200)) == 0
31 {:ok, user} = User.follow(user, following)
35 |> assign(:user, user)
36 |> get("/api/v1/timelines/home")
38 assert [%{"content" => "test"}] = json_response(conn, 200)
41 test "the public timeline", %{conn: conn} do
42 following = insert(:user)
45 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
48 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
52 |> get("/api/v1/timelines/public", %{"local" => "False"})
54 assert length(json_response(conn, 200)) == 2
58 |> get("/api/v1/timelines/public", %{"local" => "True"})
60 assert [%{"content" => "test"}] = json_response(conn, 200)
64 |> get("/api/v1/timelines/public", %{"local" => "1"})
66 assert [%{"content" => "test"}] = json_response(conn, 200)
70 test "posting a status", %{conn: conn} do
73 idempotency_key = "Pikachu rocks!"
77 |> assign(:user, user)
78 |> put_req_header("idempotency-key", idempotency_key)
79 |> post("/api/v1/statuses", %{
81 "spoiler_text" => "2hu",
82 "sensitive" => "false"
85 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
87 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
89 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
90 json_response(conn_one, 200)
92 assert Repo.get(Activity, id)
96 |> assign(:user, user)
97 |> put_req_header("idempotency-key", idempotency_key)
98 |> post("/api/v1/statuses", %{
100 "spoiler_text" => "2hu",
101 "sensitive" => "false"
104 assert %{"id" => second_id} = json_response(conn_two, 200)
106 assert id == second_id
110 |> assign(:user, user)
111 |> post("/api/v1/statuses", %{
113 "spoiler_text" => "2hu",
114 "sensitive" => "false"
117 assert %{"id" => third_id} = json_response(conn_three, 200)
119 refute id == third_id
122 test "posting a sensitive status", %{conn: conn} do
127 |> assign(:user, user)
128 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
130 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
131 assert Repo.get(Activity, id)
134 test "posting a direct status", %{conn: conn} do
135 user1 = insert(:user)
136 user2 = insert(:user)
137 content = "direct cofe @#{user2.nickname}"
141 |> assign(:user, user1)
142 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
144 assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
145 assert activity = Repo.get(Activity, id)
146 assert activity.recipients == [user2.ap_id]
147 assert activity.data["to"] == [user2.ap_id]
148 assert activity.data["cc"] == []
151 test "direct timeline", %{conn: conn} do
152 user_one = insert(:user)
153 user_two = insert(:user)
155 {:ok, user_two} = User.follow(user_two, user_one)
158 CommonAPI.post(user_one, %{
159 "status" => "Hi @#{user_two.nickname}!",
160 "visibility" => "direct"
163 {:ok, _follower_only} =
164 CommonAPI.post(user_one, %{
165 "status" => "Hi @#{user_two.nickname}!",
166 "visibility" => "private"
169 # Only direct should be visible here
172 |> assign(:user, user_two)
173 |> get("api/v1/timelines/direct")
175 [status] = json_response(res_conn, 200)
177 assert %{"visibility" => "direct"} = status
178 assert status["url"] != direct.data["id"]
180 # Both should be visible here
183 |> assign(:user, user_two)
184 |> get("api/v1/timelines/home")
186 [_s1, _s2] = json_response(res_conn, 200)
189 Enum.each(1..20, fn _ ->
191 CommonAPI.post(user_one, %{
192 "status" => "Hi @#{user_two.nickname}!",
193 "visibility" => "direct"
199 |> assign(:user, user_two)
200 |> get("api/v1/timelines/direct")
202 statuses = json_response(res_conn, 200)
203 assert length(statuses) == 20
207 |> assign(:user, user_two)
208 |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
210 [status] = json_response(res_conn, 200)
212 assert status["url"] != direct.data["id"]
215 test "replying to a status", %{conn: conn} do
218 {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
222 |> assign(:user, user)
223 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
225 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
227 activity = Repo.get(Activity, id)
229 assert activity.data["context"] == replied_to.data["context"]
230 assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
233 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
238 |> assign(:user, user)
239 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
241 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
243 activity = Repo.get(Activity, id)
248 test "verify_credentials", %{conn: conn} do
253 |> assign(:user, user)
254 |> get("/api/v1/accounts/verify_credentials")
256 assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
257 assert id == to_string(user.id)
260 test "verify_credentials default scope unlisted", %{conn: conn} do
261 user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
265 |> assign(:user, user)
266 |> get("/api/v1/accounts/verify_credentials")
268 assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
269 assert id == to_string(user.id)
272 test "get a status", %{conn: conn} do
273 activity = insert(:note_activity)
277 |> get("/api/v1/statuses/#{activity.id}")
279 assert %{"id" => id} = json_response(conn, 200)
280 assert id == to_string(activity.id)
283 describe "deleting a status" do
284 test "when you created it", %{conn: conn} do
285 activity = insert(:note_activity)
286 author = User.get_by_ap_id(activity.data["actor"])
290 |> assign(:user, author)
291 |> delete("/api/v1/statuses/#{activity.id}")
293 assert %{} = json_response(conn, 200)
295 assert Repo.get(Activity, activity.id) == nil
298 test "when you didn't create it", %{conn: conn} do
299 activity = insert(:note_activity)
304 |> assign(:user, user)
305 |> delete("/api/v1/statuses/#{activity.id}")
307 assert %{"error" => _} = json_response(conn, 403)
309 assert Repo.get(Activity, activity.id) == activity
313 describe "filters" do
314 test "creating a filter", %{conn: conn} do
317 filter = %Pleroma.Filter{
324 |> assign(:user, user)
325 |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
327 assert response = json_response(conn, 200)
328 assert response["phrase"] == filter.phrase
329 assert response["context"] == filter.context
330 assert response["id"] != nil
331 assert response["id"] != ""
334 test "fetching a list of filters", %{conn: conn} do
337 query_one = %Pleroma.Filter{
344 query_two = %Pleroma.Filter{
351 {:ok, filter_one} = Pleroma.Filter.create(query_one)
352 {:ok, filter_two} = Pleroma.Filter.create(query_two)
356 |> assign(:user, user)
357 |> get("/api/v1/filters")
359 assert response = json_response(conn, 200)
362 test "get a filter", %{conn: conn} do
365 query = %Pleroma.Filter{
372 {:ok, filter} = Pleroma.Filter.create(query)
376 |> assign(:user, user)
377 |> get("/api/v1/filters/#{filter.filter_id}")
379 assert response = json_response(conn, 200)
382 test "update a filter", %{conn: conn} do
385 query = %Pleroma.Filter{
392 {:ok, filter} = Pleroma.Filter.create(query)
394 new = %Pleroma.Filter{
401 |> assign(:user, user)
402 |> put("/api/v1/filters/#{query.filter_id}", %{
407 assert response = json_response(conn, 200)
408 assert response["phrase"] == new.phrase
409 assert response["context"] == new.context
412 test "delete a filter", %{conn: conn} do
415 query = %Pleroma.Filter{
422 {:ok, filter} = Pleroma.Filter.create(query)
426 |> assign(:user, user)
427 |> delete("/api/v1/filters/#{filter.filter_id}")
429 assert response = json_response(conn, 200)
430 assert response == %{}
435 test "creating a list", %{conn: conn} do
440 |> assign(:user, user)
441 |> post("/api/v1/lists", %{"title" => "cuties"})
443 assert %{"title" => title} = json_response(conn, 200)
444 assert title == "cuties"
447 test "adding users to a list", %{conn: conn} do
449 other_user = insert(:user)
450 {:ok, list} = Pleroma.List.create("name", user)
454 |> assign(:user, user)
455 |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
457 assert %{} == json_response(conn, 200)
458 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
459 assert following == [other_user.follower_address]
462 test "removing users from a list", %{conn: conn} do
464 other_user = insert(:user)
465 third_user = insert(:user)
466 {:ok, list} = Pleroma.List.create("name", user)
467 {:ok, list} = Pleroma.List.follow(list, other_user)
468 {:ok, list} = Pleroma.List.follow(list, third_user)
472 |> assign(:user, user)
473 |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
475 assert %{} == json_response(conn, 200)
476 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
477 assert following == [third_user.follower_address]
480 test "listing users in a list", %{conn: conn} do
482 other_user = insert(:user)
483 {:ok, list} = Pleroma.List.create("name", user)
484 {:ok, list} = Pleroma.List.follow(list, other_user)
488 |> assign(:user, user)
489 |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
491 assert [%{"id" => id}] = json_response(conn, 200)
492 assert id == to_string(other_user.id)
495 test "retrieving a list", %{conn: conn} do
497 {:ok, list} = Pleroma.List.create("name", user)
501 |> assign(:user, user)
502 |> get("/api/v1/lists/#{list.id}")
504 assert %{"id" => id} = json_response(conn, 200)
505 assert id == to_string(list.id)
508 test "renaming a list", %{conn: conn} do
510 {:ok, list} = Pleroma.List.create("name", user)
514 |> assign(:user, user)
515 |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
517 assert %{"title" => name} = json_response(conn, 200)
518 assert name == "newname"
521 test "deleting a list", %{conn: conn} do
523 {:ok, list} = Pleroma.List.create("name", user)
527 |> assign(:user, user)
528 |> delete("/api/v1/lists/#{list.id}")
530 assert %{} = json_response(conn, 200)
531 assert is_nil(Repo.get(Pleroma.List, list.id))
534 test "list timeline", %{conn: conn} do
536 other_user = insert(:user)
537 {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
538 {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
539 {:ok, list} = Pleroma.List.create("name", user)
540 {:ok, list} = Pleroma.List.follow(list, other_user)
544 |> assign(:user, user)
545 |> get("/api/v1/timelines/list/#{list.id}")
547 assert [%{"id" => id}] = json_response(conn, 200)
549 assert id == to_string(activity_two.id)
552 test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
554 other_user = insert(:user)
555 {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
557 {:ok, activity_two} =
558 TwitterAPI.create_status(other_user, %{
559 "status" => "Marisa is cute.",
560 "visibility" => "private"
563 {:ok, list} = Pleroma.List.create("name", user)
564 {:ok, list} = Pleroma.List.follow(list, other_user)
568 |> assign(:user, user)
569 |> get("/api/v1/timelines/list/#{list.id}")
571 assert [%{"id" => id}] = json_response(conn, 200)
573 assert id == to_string(activity_one.id)
577 describe "notifications" do
578 test "list of notifications", %{conn: conn} do
580 other_user = insert(:user)
583 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
585 {:ok, [_notification]} = Notification.create_notifications(activity)
589 |> assign(:user, user)
590 |> get("/api/v1/notifications")
593 "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
595 assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
596 assert response == expected_response
599 test "getting a single notification", %{conn: conn} do
601 other_user = insert(:user)
604 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
606 {:ok, [notification]} = Notification.create_notifications(activity)
610 |> assign(:user, user)
611 |> get("/api/v1/notifications/#{notification.id}")
614 "hi <span><a data-user=\"#{user.id}\" href=\"#{user.ap_id}\">@<span>#{user.nickname}</span></a></span>"
616 assert %{"status" => %{"content" => response}} = json_response(conn, 200)
617 assert response == expected_response
620 test "dismissing a single notification", %{conn: conn} do
622 other_user = insert(:user)
625 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
627 {:ok, [notification]} = Notification.create_notifications(activity)
631 |> assign(:user, user)
632 |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
634 assert %{} = json_response(conn, 200)
637 test "clearing all notifications", %{conn: conn} do
639 other_user = insert(:user)
642 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
644 {:ok, [_notification]} = Notification.create_notifications(activity)
648 |> assign(:user, user)
649 |> post("/api/v1/notifications/clear")
651 assert %{} = json_response(conn, 200)
655 |> assign(:user, user)
656 |> get("/api/v1/notifications")
658 assert all = json_response(conn, 200)
663 describe "reblogging" do
664 test "reblogs and returns the reblogged status", %{conn: conn} do
665 activity = insert(:note_activity)
670 |> assign(:user, user)
671 |> post("/api/v1/statuses/#{activity.id}/reblog")
673 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
674 json_response(conn, 200)
676 assert to_string(activity.id) == id
680 describe "unreblogging" do
681 test "unreblogs and returns the unreblogged status", %{conn: conn} do
682 activity = insert(:note_activity)
685 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
689 |> assign(:user, user)
690 |> post("/api/v1/statuses/#{activity.id}/unreblog")
692 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
694 assert to_string(activity.id) == id
698 describe "favoriting" do
699 test "favs a status and returns it", %{conn: conn} do
700 activity = insert(:note_activity)
705 |> assign(:user, user)
706 |> post("/api/v1/statuses/#{activity.id}/favourite")
708 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
709 json_response(conn, 200)
711 assert to_string(activity.id) == id
714 test "returns 500 for a wrong id", %{conn: conn} do
719 |> assign(:user, user)
720 |> post("/api/v1/statuses/1/favourite")
721 |> json_response(500)
723 assert resp == "Something went wrong"
727 describe "unfavoriting" do
728 test "unfavorites a status and returns it", %{conn: conn} do
729 activity = insert(:note_activity)
732 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
736 |> assign(:user, user)
737 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
739 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
740 json_response(conn, 200)
742 assert to_string(activity.id) == id
746 describe "user timelines" do
747 test "gets a users statuses", %{conn: conn} do
748 user_one = insert(:user)
749 user_two = insert(:user)
750 user_three = insert(:user)
752 {:ok, user_three} = User.follow(user_three, user_one)
754 {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
756 {:ok, direct_activity} =
757 CommonAPI.post(user_one, %{
758 "status" => "Hi, @#{user_two.nickname}.",
759 "visibility" => "direct"
762 {:ok, private_activity} =
763 CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
767 |> get("/api/v1/accounts/#{user_one.id}/statuses")
769 assert [%{"id" => id}] = json_response(resp, 200)
770 assert id == to_string(activity.id)
774 |> assign(:user, user_two)
775 |> get("/api/v1/accounts/#{user_one.id}/statuses")
777 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
778 assert id_one == to_string(direct_activity.id)
779 assert id_two == to_string(activity.id)
783 |> assign(:user, user_three)
784 |> get("/api/v1/accounts/#{user_one.id}/statuses")
786 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
787 assert id_one == to_string(private_activity.id)
788 assert id_two == to_string(activity.id)
791 test "unimplemented pinned statuses feature", %{conn: conn} do
792 note = insert(:note_activity)
793 user = User.get_by_ap_id(note.data["actor"])
797 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
799 assert json_response(conn, 200) == []
802 test "gets an users media", %{conn: conn} do
803 note = insert(:note_activity)
804 user = User.get_by_ap_id(note.data["actor"])
807 content_type: "image/jpg",
808 path: Path.absname("test/fixtures/image.jpg"),
809 filename: "an_image.jpg"
813 TwitterAPI.upload(file, user, "json")
817 TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
821 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
823 assert [%{"id" => id}] = json_response(conn, 200)
824 assert id == to_string(image_post.id)
828 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
830 assert [%{"id" => id}] = json_response(conn, 200)
831 assert id == to_string(image_post.id)
835 describe "user relationships" do
836 test "returns the relationships for the current user", %{conn: conn} do
838 other_user = insert(:user)
839 {:ok, user} = User.follow(user, other_user)
843 |> assign(:user, user)
844 |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
846 assert [relationship] = json_response(conn, 200)
848 assert to_string(other_user.id) == relationship["id"]
852 describe "locked accounts" do
853 test "/api/v1/follow_requests works" do
854 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
855 other_user = insert(:user)
857 {:ok, activity} = ActivityPub.follow(other_user, user)
859 user = Repo.get(User, user.id)
860 other_user = Repo.get(User, other_user.id)
862 assert User.following?(other_user, user) == false
866 |> assign(:user, user)
867 |> get("/api/v1/follow_requests")
869 assert [relationship] = json_response(conn, 200)
870 assert to_string(other_user.id) == relationship["id"]
873 test "/api/v1/follow_requests/:id/authorize works" do
874 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
875 other_user = insert(:user)
877 {:ok, activity} = ActivityPub.follow(other_user, user)
879 user = Repo.get(User, user.id)
880 other_user = Repo.get(User, other_user.id)
882 assert User.following?(other_user, user) == false
886 |> assign(:user, user)
887 |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
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) == true
898 test "verify_credentials", %{conn: conn} do
899 user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
903 |> assign(:user, user)
904 |> get("/api/v1/accounts/verify_credentials")
906 assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
907 assert id == to_string(user.id)
910 test "/api/v1/follow_requests/:id/reject works" do
911 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
912 other_user = insert(:user)
914 {:ok, activity} = ActivityPub.follow(other_user, user)
918 |> assign(:user, user)
919 |> post("/api/v1/follow_requests/#{other_user.id}/reject")
921 assert relationship = json_response(conn, 200)
922 assert to_string(other_user.id) == relationship["id"]
924 user = Repo.get(User, user.id)
925 other_user = Repo.get(User, other_user.id)
927 assert User.following?(other_user, user) == false
931 test "account fetching", %{conn: conn} do
936 |> get("/api/v1/accounts/#{user.id}")
938 assert %{"id" => id} = json_response(conn, 200)
939 assert id == to_string(user.id)
943 |> get("/api/v1/accounts/-1")
945 assert %{"error" => "Can't find user"} = json_response(conn, 404)
948 test "media upload", %{conn: conn} do
950 content_type: "image/jpg",
951 path: Path.absname("test/fixtures/image.jpg"),
952 filename: "an_image.jpg"
955 desc = "Description of the image"
961 |> assign(:user, user)
962 |> post("/api/v1/media", %{"file" => file, "description" => desc})
964 assert media = json_response(conn, 200)
966 assert media["type"] == "image"
967 assert media["description"] == desc
970 object = Repo.get(Object, media["id"])
971 assert object.data["actor"] == User.ap_id(user)
974 test "hashtag timeline", %{conn: conn} do
975 following = insert(:user)
978 {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
981 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
985 |> get("/api/v1/timelines/tag/2hu")
987 assert [%{"id" => id}] = json_response(nconn, 200)
989 assert id == to_string(activity.id)
991 # works for different capitalization too
994 |> get("/api/v1/timelines/tag/2HU")
996 assert [%{"id" => id}] = json_response(nconn, 200)
998 assert id == to_string(activity.id)
1002 test "getting followers", %{conn: conn} do
1003 user = insert(:user)
1004 other_user = insert(:user)
1005 {:ok, user} = User.follow(user, other_user)
1009 |> get("/api/v1/accounts/#{other_user.id}/followers")
1011 assert [%{"id" => id}] = json_response(conn, 200)
1012 assert id == to_string(user.id)
1015 test "getting followers, hide_network", %{conn: conn} do
1016 user = insert(:user)
1017 other_user = insert(:user, %{info: %{hide_network: true}})
1018 {:ok, user} = User.follow(user, other_user)
1022 |> get("/api/v1/accounts/#{other_user.id}/followers")
1024 assert [] == json_response(conn, 200)
1027 test "getting followers, hide_network, same user requesting", %{conn: conn} do
1028 user = insert(:user)
1029 other_user = insert(:user, %{info: %{hide_network: true}})
1030 {:ok, user} = User.follow(user, other_user)
1034 |> assign(:user, other_user)
1035 |> get("/api/v1/accounts/#{other_user.id}/followers")
1037 refute [] == json_response(conn, 200)
1040 test "getting following", %{conn: conn} do
1041 user = insert(:user)
1042 other_user = insert(:user)
1043 {:ok, user} = User.follow(user, other_user)
1047 |> get("/api/v1/accounts/#{user.id}/following")
1049 assert [%{"id" => id}] = json_response(conn, 200)
1050 assert id == to_string(other_user.id)
1053 test "getting following, hide_network", %{conn: conn} do
1054 user = insert(:user, %{info: %{hide_network: true}})
1055 other_user = insert(:user)
1056 {:ok, user} = User.follow(user, other_user)
1060 |> get("/api/v1/accounts/#{user.id}/following")
1062 assert [] == json_response(conn, 200)
1065 test "getting following, hide_network, same user requesting", %{conn: conn} do
1066 user = insert(:user, %{info: %{hide_network: true}})
1067 other_user = insert(:user)
1068 {:ok, user} = User.follow(user, other_user)
1072 |> assign(:user, user)
1073 |> get("/api/v1/accounts/#{user.id}/following")
1075 refute [] == json_response(conn, 200)
1078 test "following / unfollowing a user", %{conn: conn} do
1079 user = insert(:user)
1080 other_user = insert(:user)
1084 |> assign(:user, user)
1085 |> post("/api/v1/accounts/#{other_user.id}/follow")
1087 assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1089 user = Repo.get(User, user.id)
1093 |> assign(:user, user)
1094 |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1096 assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1098 user = Repo.get(User, user.id)
1102 |> assign(:user, user)
1103 |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1105 assert %{"id" => id} = json_response(conn, 200)
1106 assert id == to_string(other_user.id)
1109 test "blocking / unblocking a user", %{conn: conn} do
1110 user = insert(:user)
1111 other_user = insert(:user)
1115 |> assign(:user, user)
1116 |> post("/api/v1/accounts/#{other_user.id}/block")
1118 assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1120 user = Repo.get(User, user.id)
1124 |> assign(:user, user)
1125 |> post("/api/v1/accounts/#{other_user.id}/unblock")
1127 assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1130 test "getting a list of blocks", %{conn: conn} do
1131 user = insert(:user)
1132 other_user = insert(:user)
1134 {:ok, user} = User.block(user, other_user)
1138 |> assign(:user, user)
1139 |> get("/api/v1/blocks")
1141 other_user_id = to_string(other_user.id)
1142 assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1145 test "blocking / unblocking a domain", %{conn: conn} do
1146 user = insert(:user)
1147 other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1151 |> assign(:user, user)
1152 |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1154 assert %{} = json_response(conn, 200)
1155 user = User.get_cached_by_ap_id(user.ap_id)
1156 assert User.blocks?(user, other_user)
1160 |> assign(:user, user)
1161 |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1163 assert %{} = json_response(conn, 200)
1164 user = User.get_cached_by_ap_id(user.ap_id)
1165 refute User.blocks?(user, other_user)
1168 test "getting a list of domain blocks", %{conn: conn} do
1169 user = insert(:user)
1171 {:ok, user} = User.block_domain(user, "bad.site")
1172 {:ok, user} = User.block_domain(user, "even.worse.site")
1176 |> assign(:user, user)
1177 |> get("/api/v1/domain_blocks")
1179 domain_blocks = json_response(conn, 200)
1181 assert "bad.site" in domain_blocks
1182 assert "even.worse.site" in domain_blocks
1185 test "unimplemented mute endpoints" do
1186 user = insert(:user)
1187 other_user = insert(:user)
1190 |> Enum.each(fn endpoint ->
1193 |> assign(:user, user)
1194 |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1196 assert %{"id" => id} = json_response(conn, 200)
1197 assert id == to_string(other_user.id)
1201 test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1202 user = insert(:user)
1204 ["blocks", "domain_blocks", "mutes", "follow_requests"]
1205 |> Enum.each(fn endpoint ->
1208 |> assign(:user, user)
1209 |> get("/api/v1/#{endpoint}")
1211 assert [] = json_response(conn, 200)
1215 test "account search", %{conn: conn} do
1216 user = insert(:user)
1217 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1218 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1222 |> assign(:user, user)
1223 |> get("/api/v1/accounts/search", %{"q" => "shp"})
1224 |> json_response(200)
1226 result_ids = for result <- results, do: result["acct"]
1228 assert user_two.nickname in result_ids
1229 assert user_three.nickname in result_ids
1233 |> assign(:user, user)
1234 |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1235 |> json_response(200)
1237 result_ids = for result <- results, do: result["acct"]
1239 assert user_three.nickname in result_ids
1242 test "search", %{conn: conn} do
1243 user = insert(:user)
1244 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1245 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1247 {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1250 CommonAPI.post(user, %{
1251 "status" => "This is about 2hu, but private",
1252 "visibility" => "private"
1255 {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1259 |> get("/api/v1/search", %{"q" => "2hu"})
1261 assert results = json_response(conn, 200)
1263 [account | _] = results["accounts"]
1264 assert account["id"] == to_string(user_three.id)
1266 assert results["hashtags"] == []
1268 [status] = results["statuses"]
1269 assert status["id"] == to_string(activity.id)
1272 test "search fetches remote statuses", %{conn: conn} do
1276 |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1278 assert results = json_response(conn, 200)
1280 [status] = results["statuses"]
1281 assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1285 test "search fetches remote accounts", %{conn: conn} do
1288 |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1290 assert results = json_response(conn, 200)
1291 [account] = results["accounts"]
1292 assert account["acct"] == "shp@social.heldscal.la"
1295 test "returns the favorites of a user", %{conn: conn} do
1296 user = insert(:user)
1297 other_user = insert(:user)
1299 {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1300 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1302 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1306 |> assign(:user, user)
1307 |> get("/api/v1/favourites")
1309 assert [status] = json_response(conn, 200)
1310 assert status["id"] == to_string(activity.id)
1313 describe "updating credentials" do
1314 test "updates the user's bio", %{conn: conn} do
1315 user = insert(:user)
1316 user2 = insert(:user)
1320 |> assign(:user, user)
1321 |> patch("/api/v1/accounts/update_credentials", %{
1322 "note" => "I drink #cofe with @#{user2.nickname}"
1325 assert user = json_response(conn, 200)
1327 assert user["note"] ==
1328 "I drink <a data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
1330 }\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1333 test "updates the user's locking status", %{conn: conn} do
1334 user = insert(:user)
1338 |> assign(:user, user)
1339 |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1341 assert user = json_response(conn, 200)
1342 assert user["locked"] == true
1345 test "updates the user's name", %{conn: conn} do
1346 user = insert(:user)
1350 |> assign(:user, user)
1351 |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1353 assert user = json_response(conn, 200)
1354 assert user["display_name"] == "markorepairs"
1357 test "updates the user's avatar", %{conn: conn} do
1358 user = insert(:user)
1360 new_avatar = %Plug.Upload{
1361 content_type: "image/jpg",
1362 path: Path.absname("test/fixtures/image.jpg"),
1363 filename: "an_image.jpg"
1368 |> assign(:user, user)
1369 |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1371 assert user_response = json_response(conn, 200)
1372 assert user_response["avatar"] != User.avatar_url(user)
1375 test "updates the user's banner", %{conn: conn} do
1376 user = insert(:user)
1378 new_header = %Plug.Upload{
1379 content_type: "image/jpg",
1380 path: Path.absname("test/fixtures/image.jpg"),
1381 filename: "an_image.jpg"
1386 |> assign(:user, user)
1387 |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1389 assert user_response = json_response(conn, 200)
1390 assert user_response["header"] != User.banner_url(user)
1394 test "get instance information", %{conn: conn} do
1395 insert(:user, %{local: true})
1396 user = insert(:user, %{local: true})
1397 insert(:user, %{local: false})
1399 {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1401 Pleroma.Stats.update_stats()
1405 |> get("/api/v1/instance")
1407 assert result = json_response(conn, 200)
1409 assert result["stats"]["user_count"] == 2
1410 assert result["stats"]["status_count"] == 1