1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
6 use Pleroma.Web.ConnCase
8 alias Pleroma.Web.TwitterAPI.TwitterAPI
9 alias Pleroma.{Repo, User, Object, Activity, Notification}
10 alias Pleroma.Web.{OStatus, CommonAPI}
11 alias Pleroma.Web.ActivityPub.ActivityPub
12 alias Pleroma.Web.MastodonAPI.FilterView
13 import Pleroma.Factory
14 import ExUnit.CaptureLog
18 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
22 test "the home timeline", %{conn: conn} do
24 following = insert(:user)
26 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
30 |> assign(:user, user)
31 |> get("/api/v1/timelines/home")
33 assert length(json_response(conn, 200)) == 0
35 {:ok, user} = User.follow(user, following)
39 |> assign(:user, user)
40 |> get("/api/v1/timelines/home")
42 assert [%{"content" => "test"}] = json_response(conn, 200)
45 test "the public timeline", %{conn: conn} do
46 following = insert(:user)
49 {:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})
52 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
56 |> get("/api/v1/timelines/public", %{"local" => "False"})
58 assert length(json_response(conn, 200)) == 2
62 |> get("/api/v1/timelines/public", %{"local" => "True"})
64 assert [%{"content" => "test"}] = json_response(conn, 200)
68 |> get("/api/v1/timelines/public", %{"local" => "1"})
70 assert [%{"content" => "test"}] = json_response(conn, 200)
74 test "posting a status", %{conn: conn} do
77 idempotency_key = "Pikachu rocks!"
81 |> assign(:user, user)
82 |> put_req_header("idempotency-key", idempotency_key)
83 |> post("/api/v1/statuses", %{
85 "spoiler_text" => "2hu",
86 "sensitive" => "false"
89 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
91 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
93 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
94 json_response(conn_one, 200)
96 assert Repo.get(Activity, id)
100 |> assign(:user, user)
101 |> put_req_header("idempotency-key", idempotency_key)
102 |> post("/api/v1/statuses", %{
104 "spoiler_text" => "2hu",
105 "sensitive" => "false"
108 assert %{"id" => second_id} = json_response(conn_two, 200)
110 assert id == second_id
114 |> assign(:user, user)
115 |> post("/api/v1/statuses", %{
117 "spoiler_text" => "2hu",
118 "sensitive" => "false"
121 assert %{"id" => third_id} = json_response(conn_three, 200)
123 refute id == third_id
126 test "posting a sensitive status", %{conn: conn} do
131 |> assign(:user, user)
132 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
134 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
135 assert Repo.get(Activity, id)
138 test "posting a direct status", %{conn: conn} do
139 user1 = insert(:user)
140 user2 = insert(:user)
141 content = "direct cofe @#{user2.nickname}"
145 |> assign(:user, user1)
146 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
148 assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
149 assert activity = Repo.get(Activity, id)
150 assert activity.recipients == [user2.ap_id]
151 assert activity.data["to"] == [user2.ap_id]
152 assert activity.data["cc"] == []
155 test "direct timeline", %{conn: conn} do
156 user_one = insert(:user)
157 user_two = insert(:user)
159 {:ok, user_two} = User.follow(user_two, user_one)
162 CommonAPI.post(user_one, %{
163 "status" => "Hi @#{user_two.nickname}!",
164 "visibility" => "direct"
167 {:ok, _follower_only} =
168 CommonAPI.post(user_one, %{
169 "status" => "Hi @#{user_two.nickname}!",
170 "visibility" => "private"
173 # Only direct should be visible here
176 |> assign(:user, user_two)
177 |> get("api/v1/timelines/direct")
179 [status] = json_response(res_conn, 200)
181 assert %{"visibility" => "direct"} = status
182 assert status["url"] != direct.data["id"]
184 # Both should be visible here
187 |> assign(:user, user_two)
188 |> get("api/v1/timelines/home")
190 [_s1, _s2] = json_response(res_conn, 200)
193 Enum.each(1..20, fn _ ->
195 CommonAPI.post(user_one, %{
196 "status" => "Hi @#{user_two.nickname}!",
197 "visibility" => "direct"
203 |> assign(:user, user_two)
204 |> get("api/v1/timelines/direct")
206 statuses = json_response(res_conn, 200)
207 assert length(statuses) == 20
211 |> assign(:user, user_two)
212 |> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})
214 [status] = json_response(res_conn, 200)
216 assert status["url"] != direct.data["id"]
219 test "replying to a status", %{conn: conn} do
222 {:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})
226 |> assign(:user, user)
227 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
229 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
231 activity = Repo.get(Activity, id)
233 assert activity.data["context"] == replied_to.data["context"]
234 assert activity.data["object"]["inReplyToStatusId"] == replied_to.id
237 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
242 |> assign(:user, user)
243 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
245 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
247 activity = Repo.get(Activity, id)
252 test "verify_credentials", %{conn: conn} do
257 |> assign(:user, user)
258 |> get("/api/v1/accounts/verify_credentials")
260 assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
261 assert id == to_string(user.id)
264 test "verify_credentials default scope unlisted", %{conn: conn} do
265 user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})
269 |> assign(:user, user)
270 |> get("/api/v1/accounts/verify_credentials")
272 assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
273 assert id == to_string(user.id)
276 test "get a status", %{conn: conn} do
277 activity = insert(:note_activity)
281 |> get("/api/v1/statuses/#{activity.id}")
283 assert %{"id" => id} = json_response(conn, 200)
284 assert id == to_string(activity.id)
287 describe "deleting a status" do
288 test "when you created it", %{conn: conn} do
289 activity = insert(:note_activity)
290 author = User.get_by_ap_id(activity.data["actor"])
294 |> assign(:user, author)
295 |> delete("/api/v1/statuses/#{activity.id}")
297 assert %{} = json_response(conn, 200)
299 refute Repo.get(Activity, activity.id)
302 test "when you didn't create it", %{conn: conn} do
303 activity = insert(:note_activity)
308 |> assign(:user, user)
309 |> delete("/api/v1/statuses/#{activity.id}")
311 assert %{"error" => _} = json_response(conn, 403)
313 assert Repo.get(Activity, activity.id) == activity
317 describe "filters" do
318 test "creating a filter", %{conn: conn} do
321 filter = %Pleroma.Filter{
328 |> assign(:user, user)
329 |> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})
331 assert response = json_response(conn, 200)
332 assert response["phrase"] == filter.phrase
333 assert response["context"] == filter.context
334 assert response["id"] != nil
335 assert response["id"] != ""
338 test "fetching a list of filters", %{conn: conn} do
341 query_one = %Pleroma.Filter{
348 query_two = %Pleroma.Filter{
355 {:ok, filter_one} = Pleroma.Filter.create(query_one)
356 {:ok, filter_two} = Pleroma.Filter.create(query_two)
360 |> assign(:user, user)
361 |> get("/api/v1/filters")
362 |> json_response(200)
368 filters: [filter_two, filter_one]
372 test "get a filter", %{conn: conn} do
375 query = %Pleroma.Filter{
382 {:ok, filter} = Pleroma.Filter.create(query)
386 |> assign(:user, user)
387 |> get("/api/v1/filters/#{filter.filter_id}")
389 assert _response = json_response(conn, 200)
392 test "update a filter", %{conn: conn} do
395 query = %Pleroma.Filter{
402 {:ok, _filter} = Pleroma.Filter.create(query)
404 new = %Pleroma.Filter{
411 |> assign(:user, user)
412 |> put("/api/v1/filters/#{query.filter_id}", %{
417 assert response = json_response(conn, 200)
418 assert response["phrase"] == new.phrase
419 assert response["context"] == new.context
422 test "delete a filter", %{conn: conn} do
425 query = %Pleroma.Filter{
432 {:ok, filter} = Pleroma.Filter.create(query)
436 |> assign(:user, user)
437 |> delete("/api/v1/filters/#{filter.filter_id}")
439 assert response = json_response(conn, 200)
440 assert response == %{}
445 test "creating a list", %{conn: conn} do
450 |> assign(:user, user)
451 |> post("/api/v1/lists", %{"title" => "cuties"})
453 assert %{"title" => title} = json_response(conn, 200)
454 assert title == "cuties"
457 test "adding users to a list", %{conn: conn} do
459 other_user = insert(:user)
460 {:ok, list} = Pleroma.List.create("name", user)
464 |> assign(:user, user)
465 |> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
467 assert %{} == json_response(conn, 200)
468 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
469 assert following == [other_user.follower_address]
472 test "removing users from a list", %{conn: conn} do
474 other_user = insert(:user)
475 third_user = insert(:user)
476 {:ok, list} = Pleroma.List.create("name", user)
477 {:ok, list} = Pleroma.List.follow(list, other_user)
478 {:ok, list} = Pleroma.List.follow(list, third_user)
482 |> assign(:user, user)
483 |> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
485 assert %{} == json_response(conn, 200)
486 %Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
487 assert following == [third_user.follower_address]
490 test "listing users in a list", %{conn: conn} do
492 other_user = insert(:user)
493 {:ok, list} = Pleroma.List.create("name", user)
494 {:ok, list} = Pleroma.List.follow(list, other_user)
498 |> assign(:user, user)
499 |> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})
501 assert [%{"id" => id}] = json_response(conn, 200)
502 assert id == to_string(other_user.id)
505 test "retrieving a list", %{conn: conn} do
507 {:ok, list} = Pleroma.List.create("name", user)
511 |> assign(:user, user)
512 |> get("/api/v1/lists/#{list.id}")
514 assert %{"id" => id} = json_response(conn, 200)
515 assert id == to_string(list.id)
518 test "renaming a list", %{conn: conn} do
520 {:ok, list} = Pleroma.List.create("name", user)
524 |> assign(:user, user)
525 |> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})
527 assert %{"title" => name} = json_response(conn, 200)
528 assert name == "newname"
531 test "deleting a list", %{conn: conn} do
533 {:ok, list} = Pleroma.List.create("name", user)
537 |> assign(:user, user)
538 |> delete("/api/v1/lists/#{list.id}")
540 assert %{} = json_response(conn, 200)
541 assert is_nil(Repo.get(Pleroma.List, list.id))
544 test "list timeline", %{conn: conn} do
546 other_user = insert(:user)
547 {:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
548 {:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
549 {:ok, list} = Pleroma.List.create("name", user)
550 {:ok, list} = Pleroma.List.follow(list, other_user)
554 |> assign(:user, user)
555 |> get("/api/v1/timelines/list/#{list.id}")
557 assert [%{"id" => id}] = json_response(conn, 200)
559 assert id == to_string(activity_two.id)
562 test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
564 other_user = insert(:user)
565 {:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
567 {:ok, _activity_two} =
568 TwitterAPI.create_status(other_user, %{
569 "status" => "Marisa is cute.",
570 "visibility" => "private"
573 {:ok, list} = Pleroma.List.create("name", user)
574 {:ok, list} = Pleroma.List.follow(list, other_user)
578 |> assign(:user, user)
579 |> get("/api/v1/timelines/list/#{list.id}")
581 assert [%{"id" => id}] = json_response(conn, 200)
583 assert id == to_string(activity_one.id)
587 describe "notifications" do
588 test "list of notifications", %{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 |> get("/api/v1/notifications")
603 "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
605 }\">@<span>#{user.nickname}</span></a></span>"
607 assert [%{"status" => %{"content" => response}} | _rest] = json_response(conn, 200)
608 assert response == expected_response
611 test "getting a single notification", %{conn: conn} do
613 other_user = insert(:user)
616 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
618 {:ok, [notification]} = Notification.create_notifications(activity)
622 |> assign(:user, user)
623 |> get("/api/v1/notifications/#{notification.id}")
626 "hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
628 }\">@<span>#{user.nickname}</span></a></span>"
630 assert %{"status" => %{"content" => response}} = json_response(conn, 200)
631 assert response == expected_response
634 test "dismissing a single notification", %{conn: conn} do
636 other_user = insert(:user)
639 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
641 {:ok, [notification]} = Notification.create_notifications(activity)
645 |> assign(:user, user)
646 |> post("/api/v1/notifications/dismiss", %{"id" => notification.id})
648 assert %{} = json_response(conn, 200)
651 test "clearing all notifications", %{conn: conn} do
653 other_user = insert(:user)
656 TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})
658 {:ok, [_notification]} = Notification.create_notifications(activity)
662 |> assign(:user, user)
663 |> post("/api/v1/notifications/clear")
665 assert %{} = json_response(conn, 200)
669 |> assign(:user, user)
670 |> get("/api/v1/notifications")
672 assert all = json_response(conn, 200)
677 describe "reblogging" do
678 test "reblogs and returns the reblogged status", %{conn: conn} do
679 activity = insert(:note_activity)
684 |> assign(:user, user)
685 |> post("/api/v1/statuses/#{activity.id}/reblog")
687 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
688 json_response(conn, 200)
690 assert to_string(activity.id) == id
694 describe "unreblogging" do
695 test "unreblogs and returns the unreblogged status", %{conn: conn} do
696 activity = insert(:note_activity)
699 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
703 |> assign(:user, user)
704 |> post("/api/v1/statuses/#{activity.id}/unreblog")
706 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
708 assert to_string(activity.id) == id
712 describe "favoriting" do
713 test "favs a status and returns it", %{conn: conn} do
714 activity = insert(:note_activity)
719 |> assign(:user, user)
720 |> post("/api/v1/statuses/#{activity.id}/favourite")
722 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
723 json_response(conn, 200)
725 assert to_string(activity.id) == id
728 test "returns 500 for a wrong id", %{conn: conn} do
733 |> assign(:user, user)
734 |> post("/api/v1/statuses/1/favourite")
735 |> json_response(500)
737 assert resp == "Something went wrong"
741 describe "unfavoriting" do
742 test "unfavorites a status and returns it", %{conn: conn} do
743 activity = insert(:note_activity)
746 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
750 |> assign(:user, user)
751 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
753 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
754 json_response(conn, 200)
756 assert to_string(activity.id) == id
760 describe "user timelines" do
761 test "gets a users statuses", %{conn: conn} do
762 user_one = insert(:user)
763 user_two = insert(:user)
764 user_three = insert(:user)
766 {:ok, user_three} = User.follow(user_three, user_one)
768 {:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})
770 {:ok, direct_activity} =
771 CommonAPI.post(user_one, %{
772 "status" => "Hi, @#{user_two.nickname}.",
773 "visibility" => "direct"
776 {:ok, private_activity} =
777 CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})
781 |> get("/api/v1/accounts/#{user_one.id}/statuses")
783 assert [%{"id" => id}] = json_response(resp, 200)
784 assert id == to_string(activity.id)
788 |> assign(:user, user_two)
789 |> get("/api/v1/accounts/#{user_one.id}/statuses")
791 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
792 assert id_one == to_string(direct_activity.id)
793 assert id_two == to_string(activity.id)
797 |> assign(:user, user_three)
798 |> get("/api/v1/accounts/#{user_one.id}/statuses")
800 assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
801 assert id_one == to_string(private_activity.id)
802 assert id_two == to_string(activity.id)
805 test "unimplemented pinned statuses feature", %{conn: conn} do
806 note = insert(:note_activity)
807 user = User.get_by_ap_id(note.data["actor"])
811 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
813 assert json_response(conn, 200) == []
816 test "gets an users media", %{conn: conn} do
817 note = insert(:note_activity)
818 user = User.get_by_ap_id(note.data["actor"])
821 content_type: "image/jpg",
822 path: Path.absname("test/fixtures/image.jpg"),
823 filename: "an_image.jpg"
827 TwitterAPI.upload(file, user, "json")
831 TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})
835 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})
837 assert [%{"id" => id}] = json_response(conn, 200)
838 assert id == to_string(image_post.id)
842 |> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})
844 assert [%{"id" => id}] = json_response(conn, 200)
845 assert id == to_string(image_post.id)
848 test "gets a user's statuses without reblogs", %{conn: conn} do
850 {:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
851 {:ok, _, _} = CommonAPI.repeat(post.id, user)
855 |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})
857 assert [%{"id" => id}] = json_response(conn, 200)
858 assert id == to_string(post.id)
862 |> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})
864 assert [%{"id" => id}] = json_response(conn, 200)
865 assert id == to_string(post.id)
869 describe "user relationships" do
870 test "returns the relationships for the current user", %{conn: conn} do
872 other_user = insert(:user)
873 {:ok, user} = User.follow(user, other_user)
877 |> assign(:user, user)
878 |> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})
880 assert [relationship] = json_response(conn, 200)
882 assert to_string(other_user.id) == relationship["id"]
886 describe "locked accounts" do
887 test "/api/v1/follow_requests works" do
888 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
889 other_user = insert(:user)
891 {:ok, _activity} = ActivityPub.follow(other_user, user)
893 user = Repo.get(User, user.id)
894 other_user = Repo.get(User, other_user.id)
896 assert User.following?(other_user, user) == false
900 |> assign(:user, user)
901 |> get("/api/v1/follow_requests")
903 assert [relationship] = json_response(conn, 200)
904 assert to_string(other_user.id) == relationship["id"]
907 test "/api/v1/follow_requests/:id/authorize works" do
908 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
909 other_user = insert(:user)
911 {:ok, _activity} = ActivityPub.follow(other_user, user)
913 user = Repo.get(User, user.id)
914 other_user = Repo.get(User, other_user.id)
916 assert User.following?(other_user, user) == false
920 |> assign(:user, user)
921 |> post("/api/v1/follow_requests/#{other_user.id}/authorize")
923 assert relationship = json_response(conn, 200)
924 assert to_string(other_user.id) == relationship["id"]
926 user = Repo.get(User, user.id)
927 other_user = Repo.get(User, other_user.id)
929 assert User.following?(other_user, user) == true
932 test "verify_credentials", %{conn: conn} do
933 user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})
937 |> assign(:user, user)
938 |> get("/api/v1/accounts/verify_credentials")
940 assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
941 assert id == to_string(user.id)
944 test "/api/v1/follow_requests/:id/reject works" do
945 user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
946 other_user = insert(:user)
948 {:ok, _activity} = ActivityPub.follow(other_user, user)
952 |> assign(:user, user)
953 |> post("/api/v1/follow_requests/#{other_user.id}/reject")
955 assert relationship = json_response(conn, 200)
956 assert to_string(other_user.id) == relationship["id"]
958 user = Repo.get(User, user.id)
959 other_user = Repo.get(User, other_user.id)
961 assert User.following?(other_user, user) == false
965 test "account fetching", %{conn: conn} do
970 |> get("/api/v1/accounts/#{user.id}")
972 assert %{"id" => id} = json_response(conn, 200)
973 assert id == to_string(user.id)
977 |> get("/api/v1/accounts/-1")
979 assert %{"error" => "Can't find user"} = json_response(conn, 404)
982 test "media upload", %{conn: conn} do
984 content_type: "image/jpg",
985 path: Path.absname("test/fixtures/image.jpg"),
986 filename: "an_image.jpg"
989 desc = "Description of the image"
995 |> assign(:user, user)
996 |> post("/api/v1/media", %{"file" => file, "description" => desc})
998 assert media = json_response(conn, 200)
1000 assert media["type"] == "image"
1001 assert media["description"] == desc
1004 object = Repo.get(Object, media["id"])
1005 assert object.data["actor"] == User.ap_id(user)
1008 test "hashtag timeline", %{conn: conn} do
1009 following = insert(:user)
1012 {:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})
1014 {:ok, [_activity]} =
1015 OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")
1019 |> get("/api/v1/timelines/tag/2hu")
1021 assert [%{"id" => id}] = json_response(nconn, 200)
1023 assert id == to_string(activity.id)
1025 # works for different capitalization too
1028 |> get("/api/v1/timelines/tag/2HU")
1030 assert [%{"id" => id}] = json_response(nconn, 200)
1032 assert id == to_string(activity.id)
1036 test "getting followers", %{conn: conn} do
1037 user = insert(:user)
1038 other_user = insert(:user)
1039 {:ok, user} = User.follow(user, other_user)
1043 |> get("/api/v1/accounts/#{other_user.id}/followers")
1045 assert [%{"id" => id}] = json_response(conn, 200)
1046 assert id == to_string(user.id)
1049 test "getting followers, hide_network", %{conn: conn} do
1050 user = insert(:user)
1051 other_user = insert(:user, %{info: %{hide_network: true}})
1052 {:ok, _user} = User.follow(user, other_user)
1056 |> get("/api/v1/accounts/#{other_user.id}/followers")
1058 assert [] == json_response(conn, 200)
1061 test "getting followers, hide_network, same user requesting", %{conn: conn} do
1062 user = insert(:user)
1063 other_user = insert(:user, %{info: %{hide_network: true}})
1064 {:ok, _user} = User.follow(user, other_user)
1068 |> assign(:user, other_user)
1069 |> get("/api/v1/accounts/#{other_user.id}/followers")
1071 refute [] == json_response(conn, 200)
1074 test "getting following", %{conn: conn} do
1075 user = insert(:user)
1076 other_user = insert(:user)
1077 {:ok, user} = User.follow(user, other_user)
1081 |> get("/api/v1/accounts/#{user.id}/following")
1083 assert [%{"id" => id}] = json_response(conn, 200)
1084 assert id == to_string(other_user.id)
1087 test "getting following, hide_network", %{conn: conn} do
1088 user = insert(:user, %{info: %{hide_network: true}})
1089 other_user = insert(:user)
1090 {:ok, user} = User.follow(user, other_user)
1094 |> get("/api/v1/accounts/#{user.id}/following")
1096 assert [] == json_response(conn, 200)
1099 test "getting following, hide_network, same user requesting", %{conn: conn} do
1100 user = insert(:user, %{info: %{hide_network: true}})
1101 other_user = insert(:user)
1102 {:ok, user} = User.follow(user, other_user)
1106 |> assign(:user, user)
1107 |> get("/api/v1/accounts/#{user.id}/following")
1109 refute [] == json_response(conn, 200)
1112 test "following / unfollowing a user", %{conn: conn} do
1113 user = insert(:user)
1114 other_user = insert(:user)
1118 |> assign(:user, user)
1119 |> post("/api/v1/accounts/#{other_user.id}/follow")
1121 assert %{"id" => _id, "following" => true} = json_response(conn, 200)
1123 user = Repo.get(User, user.id)
1127 |> assign(:user, user)
1128 |> post("/api/v1/accounts/#{other_user.id}/unfollow")
1130 assert %{"id" => _id, "following" => false} = json_response(conn, 200)
1132 user = Repo.get(User, user.id)
1136 |> assign(:user, user)
1137 |> post("/api/v1/follows", %{"uri" => other_user.nickname})
1139 assert %{"id" => id} = json_response(conn, 200)
1140 assert id == to_string(other_user.id)
1143 test "blocking / unblocking a user", %{conn: conn} do
1144 user = insert(:user)
1145 other_user = insert(:user)
1149 |> assign(:user, user)
1150 |> post("/api/v1/accounts/#{other_user.id}/block")
1152 assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)
1154 user = Repo.get(User, user.id)
1158 |> assign(:user, user)
1159 |> post("/api/v1/accounts/#{other_user.id}/unblock")
1161 assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
1164 test "getting a list of blocks", %{conn: conn} do
1165 user = insert(:user)
1166 other_user = insert(:user)
1168 {:ok, user} = User.block(user, other_user)
1172 |> assign(:user, user)
1173 |> get("/api/v1/blocks")
1175 other_user_id = to_string(other_user.id)
1176 assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
1179 test "blocking / unblocking a domain", %{conn: conn} do
1180 user = insert(:user)
1181 other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})
1185 |> assign(:user, user)
1186 |> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1188 assert %{} = json_response(conn, 200)
1189 user = User.get_cached_by_ap_id(user.ap_id)
1190 assert User.blocks?(user, other_user)
1194 |> assign(:user, user)
1195 |> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})
1197 assert %{} = json_response(conn, 200)
1198 user = User.get_cached_by_ap_id(user.ap_id)
1199 refute User.blocks?(user, other_user)
1202 test "getting a list of domain blocks", %{conn: conn} do
1203 user = insert(:user)
1205 {:ok, user} = User.block_domain(user, "bad.site")
1206 {:ok, user} = User.block_domain(user, "even.worse.site")
1210 |> assign(:user, user)
1211 |> get("/api/v1/domain_blocks")
1213 domain_blocks = json_response(conn, 200)
1215 assert "bad.site" in domain_blocks
1216 assert "even.worse.site" in domain_blocks
1219 test "unimplemented mute endpoints" do
1220 user = insert(:user)
1221 other_user = insert(:user)
1224 |> Enum.each(fn endpoint ->
1227 |> assign(:user, user)
1228 |> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
1230 assert %{"id" => id} = json_response(conn, 200)
1231 assert id == to_string(other_user.id)
1235 test "unimplemented mutes, follow_requests, blocks, domain blocks" do
1236 user = insert(:user)
1238 ["blocks", "domain_blocks", "mutes", "follow_requests"]
1239 |> Enum.each(fn endpoint ->
1242 |> assign(:user, user)
1243 |> get("/api/v1/#{endpoint}")
1245 assert [] = json_response(conn, 200)
1249 test "account search", %{conn: conn} do
1250 user = insert(:user)
1251 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1252 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1256 |> assign(:user, user)
1257 |> get("/api/v1/accounts/search", %{"q" => "shp"})
1258 |> json_response(200)
1260 result_ids = for result <- results, do: result["acct"]
1262 assert user_two.nickname in result_ids
1263 assert user_three.nickname in result_ids
1267 |> assign(:user, user)
1268 |> get("/api/v1/accounts/search", %{"q" => "2hu"})
1269 |> json_response(200)
1271 result_ids = for result <- results, do: result["acct"]
1273 assert user_three.nickname in result_ids
1276 test "search", %{conn: conn} do
1277 user = insert(:user)
1278 user_two = insert(:user, %{nickname: "shp@shitposter.club"})
1279 user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})
1281 {:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
1284 CommonAPI.post(user, %{
1285 "status" => "This is about 2hu, but private",
1286 "visibility" => "private"
1289 {:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})
1293 |> get("/api/v1/search", %{"q" => "2hu"})
1295 assert results = json_response(conn, 200)
1297 [account | _] = results["accounts"]
1298 assert account["id"] == to_string(user_three.id)
1300 assert results["hashtags"] == []
1302 [status] = results["statuses"]
1303 assert status["id"] == to_string(activity.id)
1306 test "search fetches remote statuses", %{conn: conn} do
1310 |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
1312 assert results = json_response(conn, 200)
1314 [status] = results["statuses"]
1315 assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1319 test "search doesn't show statuses that it shouldn't", %{conn: conn} do
1321 CommonAPI.post(insert(:user), %{
1322 "status" => "This is about 2hu, but private",
1323 "visibility" => "private"
1329 |> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
1331 assert results = json_response(conn, 200)
1333 [] = results["statuses"]
1337 test "search fetches remote accounts", %{conn: conn} do
1340 |> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
1342 assert results = json_response(conn, 200)
1343 [account] = results["accounts"]
1344 assert account["acct"] == "shp@social.heldscal.la"
1347 test "returns the favorites of a user", %{conn: conn} do
1348 user = insert(:user)
1349 other_user = insert(:user)
1351 {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1352 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1354 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1358 |> assign(:user, user)
1359 |> get("/api/v1/favourites")
1361 assert [status] = json_response(first_conn, 200)
1362 assert status["id"] == to_string(activity.id)
1364 assert [{"link", _link_header}] =
1365 Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1367 # Honours query params
1368 {:ok, second_activity} =
1369 CommonAPI.post(other_user, %{
1371 "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1374 {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1376 last_like = status["id"]
1380 |> assign(:user, user)
1381 |> get("/api/v1/favourites?since_id=#{last_like}")
1383 assert [second_status] = json_response(second_conn, 200)
1384 assert second_status["id"] == to_string(second_activity.id)
1388 |> assign(:user, user)
1389 |> get("/api/v1/favourites?limit=0")
1391 assert [] = json_response(third_conn, 200)
1394 describe "updating credentials" do
1395 test "updates the user's bio", %{conn: conn} do
1396 user = insert(:user)
1397 user2 = insert(:user)
1401 |> assign(:user, user)
1402 |> patch("/api/v1/accounts/update_credentials", %{
1403 "note" => "I drink #cofe with @#{user2.nickname}"
1406 assert user = json_response(conn, 200)
1408 assert user["note"] ==
1409 "I drink <a class=\"hashtag\" data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span class=\"h-card\"><a data-user=\"#{
1411 }\" class=\"u-url mention\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</span></a></span>"
1414 test "updates the user's locking status", %{conn: conn} do
1415 user = insert(:user)
1419 |> assign(:user, user)
1420 |> patch("/api/v1/accounts/update_credentials", %{locked: "true"})
1422 assert user = json_response(conn, 200)
1423 assert user["locked"] == true
1426 test "updates the user's name", %{conn: conn} do
1427 user = insert(:user)
1431 |> assign(:user, user)
1432 |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
1434 assert user = json_response(conn, 200)
1435 assert user["display_name"] == "markorepairs"
1438 test "updates the user's avatar", %{conn: conn} do
1439 user = insert(:user)
1441 new_avatar = %Plug.Upload{
1442 content_type: "image/jpg",
1443 path: Path.absname("test/fixtures/image.jpg"),
1444 filename: "an_image.jpg"
1449 |> assign(:user, user)
1450 |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
1452 assert user_response = json_response(conn, 200)
1453 assert user_response["avatar"] != User.avatar_url(user)
1456 test "updates the user's banner", %{conn: conn} do
1457 user = insert(:user)
1459 new_header = %Plug.Upload{
1460 content_type: "image/jpg",
1461 path: Path.absname("test/fixtures/image.jpg"),
1462 filename: "an_image.jpg"
1467 |> assign(:user, user)
1468 |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
1470 assert user_response = json_response(conn, 200)
1471 assert user_response["header"] != User.banner_url(user)
1475 test "get instance information", %{conn: conn} do
1476 user = insert(:user, %{local: true})
1478 user2 = insert(:user, %{local: true})
1479 {:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)
1481 insert(:user, %{local: false, nickname: "u@peer1.com"})
1482 insert(:user, %{local: false, nickname: "u@peer2.com"})
1484 {:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})
1486 Pleroma.Stats.update_stats()
1488 conn = get(conn, "/api/v1/instance")
1490 assert result = json_response(conn, 200)
1492 stats = result["stats"]
1495 assert stats["user_count"] == 1
1496 assert stats["status_count"] == 1
1497 assert stats["domain_count"] == 2
1500 test "get peers", %{conn: conn} do
1501 insert(:user, %{local: false, nickname: "u@peer1.com"})
1502 insert(:user, %{local: false, nickname: "u@peer2.com"})
1504 Pleroma.Stats.update_stats()
1506 conn = get(conn, "/api/v1/instance/peers")
1508 assert result = json_response(conn, 200)
1510 assert ["peer1.com", "peer2.com"] == Enum.sort(result)
1513 test "put settings", %{conn: conn} do
1514 user = insert(:user)
1518 |> assign(:user, user)
1519 |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
1521 assert _result = json_response(conn, 200)
1523 user = User.get_cached_by_ap_id(user.ap_id)
1524 assert user.info.settings == %{"programming" => "socks"}
1527 describe "pinned statuses" do
1529 Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
1531 user = insert(:user)
1532 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
1534 [user: user, activity: activity]
1537 test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
1538 {:ok, _} = CommonAPI.pin(activity.id, user)
1542 |> assign(:user, user)
1543 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1544 |> json_response(200)
1546 id_str = to_string(activity.id)
1548 assert [%{"id" => ^id_str, "pinned" => true}] = result
1551 test "pin status", %{conn: conn, user: user, activity: activity} do
1552 id_str = to_string(activity.id)
1554 assert %{"id" => ^id_str, "pinned" => true} =
1556 |> assign(:user, user)
1557 |> post("/api/v1/statuses/#{activity.id}/pin")
1558 |> json_response(200)
1560 assert [%{"id" => ^id_str, "pinned" => true}] =
1562 |> assign(:user, user)
1563 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1564 |> json_response(200)
1567 test "unpin status", %{conn: conn, user: user, activity: activity} do
1568 {:ok, _} = CommonAPI.pin(activity.id, user)
1570 id_str = to_string(activity.id)
1571 user = refresh_record(user)
1573 assert %{"id" => ^id_str, "pinned" => false} =
1575 |> assign(:user, user)
1576 |> post("/api/v1/statuses/#{activity.id}/unpin")
1577 |> json_response(200)
1581 |> assign(:user, user)
1582 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1583 |> json_response(200)
1586 test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1587 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1589 id_str_one = to_string(activity_one.id)
1591 assert %{"id" => ^id_str_one, "pinned" => true} =
1593 |> assign(:user, user)
1594 |> post("/api/v1/statuses/#{id_str_one}/pin")
1595 |> json_response(200)
1597 user = refresh_record(user)
1599 assert %{"error" => "You have already pinned the maximum number of statuses"} =
1601 |> assign(:user, user)
1602 |> post("/api/v1/statuses/#{activity_two.id}/pin")
1603 |> json_response(400)