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.StatusControllerTest do
6 use Pleroma.Web.ConnCase
9 alias Pleroma.ActivityExpiration
13 alias Pleroma.Web.CommonAPI
15 import Pleroma.Factory
17 describe "posting statuses" do
23 |> assign(:user, user)
28 test "posting a status", %{conn: conn} do
29 idempotency_key = "Pikachu rocks!"
33 |> put_req_header("idempotency-key", idempotency_key)
34 |> post("/api/v1/statuses", %{
36 "spoiler_text" => "2hu",
37 "sensitive" => "false"
40 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
42 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
44 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
45 json_response(conn_one, 200)
47 assert Activity.get_by_id(id)
51 |> put_req_header("idempotency-key", idempotency_key)
52 |> post("/api/v1/statuses", %{
54 "spoiler_text" => "2hu",
55 "sensitive" => "false"
58 assert %{"id" => second_id} = json_response(conn_two, 200)
59 assert id == second_id
63 |> post("/api/v1/statuses", %{
65 "spoiler_text" => "2hu",
66 "sensitive" => "false"
69 assert %{"id" => third_id} = json_response(conn_three, 200)
72 # An activity that will expire:
78 |> post("api/v1/statuses", %{
80 "expires_in" => expires_in
83 assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
84 assert activity = Activity.get_by_id(fourth_id)
85 assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
87 estimated_expires_at =
88 NaiveDateTime.utc_now()
89 |> NaiveDateTime.add(expires_in)
90 |> NaiveDateTime.truncate(:second)
92 # This assert will fail if the test takes longer than a minute. I sure hope it never does:
93 assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60
95 assert fourth_response["pleroma"]["expires_at"] ==
96 NaiveDateTime.to_iso8601(expiration.scheduled_at)
99 test "replying to a status", %{conn: conn} do
101 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
105 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
107 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
109 activity = Activity.get_by_id(id)
111 assert activity.data["context"] == replied_to.data["context"]
112 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
115 test "replying to a direct message with visibility other than direct", %{conn: conn} do
117 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
119 Enum.each(["public", "private", "unlisted"], fn visibility ->
122 |> post("/api/v1/statuses", %{
123 "status" => "@#{user.nickname} hey",
124 "in_reply_to_id" => replied_to.id,
125 "visibility" => visibility
128 assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
132 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
135 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
137 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
138 assert Activity.get_by_id(id)
141 test "posting a sensitive status", %{conn: conn} do
144 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
146 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
147 assert Activity.get_by_id(id)
150 test "posting a fake status", %{conn: conn} do
153 |> post("/api/v1/statuses", %{
155 "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
158 real_status = json_response(real_conn, 200)
161 assert Object.get_by_ap_id(real_status["uri"])
165 |> Map.put("id", nil)
166 |> Map.put("url", nil)
167 |> Map.put("uri", nil)
168 |> Map.put("created_at", nil)
169 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
173 |> post("/api/v1/statuses", %{
175 "\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
179 fake_status = json_response(fake_conn, 200)
182 refute Object.get_by_ap_id(fake_status["uri"])
186 |> Map.put("id", nil)
187 |> Map.put("url", nil)
188 |> Map.put("uri", nil)
189 |> Map.put("created_at", nil)
190 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
192 assert real_status == fake_status
195 test "posting a status with OGP link preview", %{conn: conn} do
196 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
197 Config.put([:rich_media, :enabled], true)
201 |> post("/api/v1/statuses", %{
202 "status" => "https://example.com/ogp"
205 assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
206 assert Activity.get_by_id(id)
209 test "posting a direct status", %{conn: conn} do
210 user2 = insert(:user)
211 content = "direct cofe @#{user2.nickname}"
215 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
217 assert %{"id" => id} = response = json_response(conn, 200)
218 assert response["visibility"] == "direct"
219 assert response["pleroma"]["direct_conversation_id"]
220 assert activity = Activity.get_by_id(id)
221 assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
222 assert activity.data["to"] == [user2.ap_id]
223 assert activity.data["cc"] == []
227 describe "posting polls" do
228 test "posting a poll", %{conn: conn} do
230 time = NaiveDateTime.utc_now()
234 |> assign(:user, user)
235 |> post("/api/v1/statuses", %{
236 "status" => "Who is the #bestgrill?",
237 "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
240 response = json_response(conn, 200)
242 assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
243 title in ["Rei", "Asuka", "Misato"]
246 assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
247 refute response["poll"]["expred"]
250 test "option limit is enforced", %{conn: conn} do
252 limit = Config.get([:instance, :poll_limits, :max_options])
256 |> assign(:user, user)
257 |> post("/api/v1/statuses", %{
259 "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
262 %{"error" => error} = json_response(conn, 422)
263 assert error == "Poll can't contain more than #{limit} options"
266 test "option character limit is enforced", %{conn: conn} do
268 limit = Config.get([:instance, :poll_limits, :max_option_chars])
272 |> assign(:user, user)
273 |> post("/api/v1/statuses", %{
276 "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
281 %{"error" => error} = json_response(conn, 422)
282 assert error == "Poll options cannot be longer than #{limit} characters each"
285 test "minimal date limit is enforced", %{conn: conn} do
287 limit = Config.get([:instance, :poll_limits, :min_expiration])
291 |> assign(:user, user)
292 |> post("/api/v1/statuses", %{
293 "status" => "imagine arbitrary limits",
295 "options" => ["this post was made by pleroma gang"],
296 "expires_in" => limit - 1
300 %{"error" => error} = json_response(conn, 422)
301 assert error == "Expiration date is too soon"
304 test "maximum date limit is enforced", %{conn: conn} do
306 limit = Config.get([:instance, :poll_limits, :max_expiration])
310 |> assign(:user, user)
311 |> post("/api/v1/statuses", %{
312 "status" => "imagine arbitrary limits",
314 "options" => ["this post was made by pleroma gang"],
315 "expires_in" => limit + 1
319 %{"error" => error} = json_response(conn, 422)
320 assert error == "Expiration date is too far in the future"
324 test "get a status", %{conn: conn} do
325 activity = insert(:note_activity)
329 |> get("/api/v1/statuses/#{activity.id}")
331 assert %{"id" => id} = json_response(conn, 200)
332 assert id == to_string(activity.id)
335 test "get statuses by IDs", %{conn: conn} do
336 %{id: id1} = insert(:note_activity)
337 %{id: id2} = insert(:note_activity)
339 query_string = "ids[]=#{id1}&ids[]=#{id2}"
340 conn = get(conn, "/api/v1/statuses/?#{query_string}")
342 assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
345 describe "deleting a status" do
346 test "when you created it", %{conn: conn} do
347 activity = insert(:note_activity)
348 author = User.get_cached_by_ap_id(activity.data["actor"])
352 |> assign(:user, author)
353 |> delete("/api/v1/statuses/#{activity.id}")
355 assert %{} = json_response(conn, 200)
357 refute Activity.get_by_id(activity.id)
360 test "when you didn't create it", %{conn: conn} do
361 activity = insert(:note_activity)
366 |> assign(:user, user)
367 |> delete("/api/v1/statuses/#{activity.id}")
369 assert %{"error" => _} = json_response(conn, 403)
371 assert Activity.get_by_id(activity.id) == activity
374 test "when you're an admin or moderator", %{conn: conn} do
375 activity1 = insert(:note_activity)
376 activity2 = insert(:note_activity)
377 admin = insert(:user, info: %{is_admin: true})
378 moderator = insert(:user, info: %{is_moderator: true})
382 |> assign(:user, admin)
383 |> delete("/api/v1/statuses/#{activity1.id}")
385 assert %{} = json_response(res_conn, 200)
389 |> assign(:user, moderator)
390 |> delete("/api/v1/statuses/#{activity2.id}")
392 assert %{} = json_response(res_conn, 200)
394 refute Activity.get_by_id(activity1.id)
395 refute Activity.get_by_id(activity2.id)
399 describe "reblogging" do
400 test "reblogs and returns the reblogged status", %{conn: conn} do
401 activity = insert(:note_activity)
406 |> assign(:user, user)
407 |> post("/api/v1/statuses/#{activity.id}/reblog")
410 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
412 } = json_response(conn, 200)
414 assert to_string(activity.id) == id
417 test "reblogged status for another user", %{conn: conn} do
418 activity = insert(:note_activity)
419 user1 = insert(:user)
420 user2 = insert(:user)
421 user3 = insert(:user)
422 CommonAPI.favorite(activity.id, user2)
423 {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
424 {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
425 {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
429 |> assign(:user, user3)
430 |> get("/api/v1/statuses/#{reblog_activity1.id}")
433 "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
434 "reblogged" => false,
435 "favourited" => false,
436 "bookmarked" => false
437 } = json_response(conn_res, 200)
441 |> assign(:user, user2)
442 |> get("/api/v1/statuses/#{reblog_activity1.id}")
445 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
447 "favourited" => true,
449 } = json_response(conn_res, 200)
451 assert to_string(activity.id) == id
454 test "returns 400 error when activity is not exist", %{conn: conn} do
459 |> assign(:user, user)
460 |> post("/api/v1/statuses/foo/reblog")
462 assert json_response(conn, 400) == %{"error" => "Could not repeat"}
466 describe "unreblogging" do
467 test "unreblogs and returns the unreblogged status", %{conn: conn} do
468 activity = insert(:note_activity)
471 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
475 |> assign(:user, user)
476 |> post("/api/v1/statuses/#{activity.id}/unreblog")
478 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
480 assert to_string(activity.id) == id
483 test "returns 400 error when activity is not exist", %{conn: conn} do
488 |> assign(:user, user)
489 |> post("/api/v1/statuses/foo/unreblog")
491 assert json_response(conn, 400) == %{"error" => "Could not unrepeat"}
495 describe "favoriting" do
496 test "favs a status and returns it", %{conn: conn} do
497 activity = insert(:note_activity)
502 |> assign(:user, user)
503 |> post("/api/v1/statuses/#{activity.id}/favourite")
505 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
506 json_response(conn, 200)
508 assert to_string(activity.id) == id
511 test "returns 400 error for a wrong id", %{conn: conn} do
516 |> assign(:user, user)
517 |> post("/api/v1/statuses/1/favourite")
519 assert json_response(conn, 400) == %{"error" => "Could not favorite"}
523 describe "unfavoriting" do
524 test "unfavorites a status and returns it", %{conn: conn} do
525 activity = insert(:note_activity)
528 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
532 |> assign(:user, user)
533 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
535 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
536 json_response(conn, 200)
538 assert to_string(activity.id) == id
541 test "returns 400 error for a wrong id", %{conn: conn} do
546 |> assign(:user, user)
547 |> post("/api/v1/statuses/1/unfavourite")
549 assert json_response(conn, 400) == %{"error" => "Could not unfavorite"}
553 describe "pinned statuses" do
556 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
558 [user: user, activity: activity]
561 clear_config([:instance, :max_pinned_statuses]) do
562 Config.put([:instance, :max_pinned_statuses], 1)
565 test "pin status", %{conn: conn, user: user, activity: activity} do
566 id_str = to_string(activity.id)
568 assert %{"id" => ^id_str, "pinned" => true} =
570 |> assign(:user, user)
571 |> post("/api/v1/statuses/#{activity.id}/pin")
572 |> json_response(200)
574 assert [%{"id" => ^id_str, "pinned" => true}] =
576 |> assign(:user, user)
577 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
578 |> json_response(200)
581 test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
582 {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
586 |> assign(:user, user)
587 |> post("/api/v1/statuses/#{dm.id}/pin")
589 assert json_response(conn, 400) == %{"error" => "Could not pin"}
592 test "unpin status", %{conn: conn, user: user, activity: activity} do
593 {:ok, _} = CommonAPI.pin(activity.id, user)
595 id_str = to_string(activity.id)
596 user = refresh_record(user)
598 assert %{"id" => ^id_str, "pinned" => false} =
600 |> assign(:user, user)
601 |> post("/api/v1/statuses/#{activity.id}/unpin")
602 |> json_response(200)
606 |> assign(:user, user)
607 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
608 |> json_response(200)
611 test "/unpin: returns 400 error when activity is not exist", %{conn: conn, user: user} do
614 |> assign(:user, user)
615 |> post("/api/v1/statuses/1/unpin")
617 assert json_response(conn, 400) == %{"error" => "Could not unpin"}
620 test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
621 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
623 id_str_one = to_string(activity_one.id)
625 assert %{"id" => ^id_str_one, "pinned" => true} =
627 |> assign(:user, user)
628 |> post("/api/v1/statuses/#{id_str_one}/pin")
629 |> json_response(200)
631 user = refresh_record(user)
633 assert %{"error" => "You have already pinned the maximum number of statuses"} =
635 |> assign(:user, user)
636 |> post("/api/v1/statuses/#{activity_two.id}/pin")
637 |> json_response(400)
643 Config.put([:rich_media, :enabled], true)
649 test "returns rich-media card", %{conn: conn, user: user} do
650 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
652 {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
655 "image" => "http://ia.media-imdb.com/images/rock.jpg",
656 "provider_name" => "example.com",
657 "provider_url" => "https://example.com",
658 "title" => "The Rock",
660 "url" => "https://example.com/ogp",
662 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
665 "image" => "http://ia.media-imdb.com/images/rock.jpg",
666 "title" => "The Rock",
667 "type" => "video.movie",
668 "url" => "https://example.com/ogp",
670 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
677 |> get("/api/v1/statuses/#{activity.id}/card")
678 |> json_response(200)
680 assert response == card_data
682 # works with private posts
684 CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
688 |> assign(:user, user)
689 |> get("/api/v1/statuses/#{activity.id}/card")
690 |> json_response(200)
692 assert response_two == card_data
695 test "replaces missing description with an empty string", %{conn: conn, user: user} do
696 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
699 CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
703 |> get("/api/v1/statuses/#{activity.id}/card")
704 |> json_response(:ok)
706 assert response == %{
708 "title" => "Pleroma",
711 "provider_name" => "example.com",
712 "provider_url" => "https://example.com",
713 "url" => "https://example.com/ogp-missing-data",
716 "title" => "Pleroma",
718 "url" => "https://example.com/ogp-missing-data"
727 for_user = insert(:user)
730 CommonAPI.post(user, %{
731 "status" => "heweoo?"
735 CommonAPI.post(user, %{
736 "status" => "heweoo!"
741 |> assign(:user, for_user)
742 |> post("/api/v1/statuses/#{activity1.id}/bookmark")
744 assert json_response(response1, 200)["bookmarked"] == true
748 |> assign(:user, for_user)
749 |> post("/api/v1/statuses/#{activity2.id}/bookmark")
751 assert json_response(response2, 200)["bookmarked"] == true
755 |> assign(:user, for_user)
756 |> get("/api/v1/bookmarks")
758 assert [json_response(response2, 200), json_response(response1, 200)] ==
759 json_response(bookmarks, 200)
763 |> assign(:user, for_user)
764 |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
766 assert json_response(response1, 200)["bookmarked"] == false
770 |> assign(:user, for_user)
771 |> get("/api/v1/bookmarks")
773 assert [json_response(response2, 200)] == json_response(bookmarks, 200)
776 describe "conversation muting" do
778 post_user = insert(:user)
781 {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
783 [user: user, activity: activity]
786 test "mute conversation", %{conn: conn, user: user, activity: activity} do
787 id_str = to_string(activity.id)
789 assert %{"id" => ^id_str, "muted" => true} =
791 |> assign(:user, user)
792 |> post("/api/v1/statuses/#{activity.id}/mute")
793 |> json_response(200)
796 test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
797 {:ok, _} = CommonAPI.add_mute(user, activity)
801 |> assign(:user, user)
802 |> post("/api/v1/statuses/#{activity.id}/mute")
804 assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
807 test "unmute conversation", %{conn: conn, user: user, activity: activity} do
808 {:ok, _} = CommonAPI.add_mute(user, activity)
810 id_str = to_string(activity.id)
811 user = refresh_record(user)
813 assert %{"id" => ^id_str, "muted" => false} =
815 |> assign(:user, user)
816 |> post("/api/v1/statuses/#{activity.id}/unmute")
817 |> json_response(200)
821 test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
822 user1 = insert(:user)
823 user2 = insert(:user)
824 user3 = insert(:user)
826 {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
828 # Reply to status from another user
831 |> assign(:user, user2)
832 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
834 assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
836 activity = Activity.get_by_id_with_object(id)
838 assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
839 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
841 # Reblog from the third user
844 |> assign(:user, user3)
845 |> post("/api/v1/statuses/#{activity.id}/reblog")
847 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
848 json_response(conn2, 200)
850 assert to_string(activity.id) == id
852 # Getting third user status
855 |> assign(:user, user3)
856 |> get("api/v1/timelines/home")
858 [reblogged_activity] = json_response(conn3, 200)
860 assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
862 replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
863 assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
866 describe "GET /api/v1/statuses/:id/favourited_by" do
869 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
873 |> assign(:user, user)
875 [conn: conn, activity: activity, user: user]
878 test "returns users who have favorited the status", %{conn: conn, activity: activity} do
879 other_user = insert(:user)
880 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
884 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
885 |> json_response(:ok)
887 [%{"id" => id}] = response
889 assert id == other_user.id
892 test "returns empty array when status has not been favorited yet", %{
898 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
899 |> json_response(:ok)
901 assert Enum.empty?(response)
904 test "does not return users who have favorited the status but are blocked", %{
905 conn: %{assigns: %{user: user}} = conn,
908 other_user = insert(:user)
909 {:ok, user} = User.block(user, other_user)
911 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
915 |> assign(:user, user)
916 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
917 |> json_response(:ok)
919 assert Enum.empty?(response)
922 test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
923 other_user = insert(:user)
924 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
928 |> assign(:user, nil)
929 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
930 |> json_response(:ok)
932 [%{"id" => id}] = response
933 assert id == other_user.id
936 test "requires authentification for private posts", %{conn: conn, user: user} do
937 other_user = insert(:user)
940 CommonAPI.post(user, %{
941 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
942 "visibility" => "direct"
945 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
948 |> assign(:user, nil)
949 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
950 |> json_response(404)
954 |> assign(:user, other_user)
955 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
956 |> json_response(200)
958 [%{"id" => id}] = response
959 assert id == other_user.id
963 describe "GET /api/v1/statuses/:id/reblogged_by" do
966 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
970 |> assign(:user, user)
972 [conn: conn, activity: activity, user: user]
975 test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
976 other_user = insert(:user)
977 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
981 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
982 |> json_response(:ok)
984 [%{"id" => id}] = response
986 assert id == other_user.id
989 test "returns empty array when status has not been reblogged yet", %{
995 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
996 |> json_response(:ok)
998 assert Enum.empty?(response)
1001 test "does not return users who have reblogged the status but are blocked", %{
1002 conn: %{assigns: %{user: user}} = conn,
1005 other_user = insert(:user)
1006 {:ok, user} = User.block(user, other_user)
1008 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1012 |> assign(:user, user)
1013 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1014 |> json_response(:ok)
1016 assert Enum.empty?(response)
1019 test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
1020 other_user = insert(:user)
1021 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1025 |> assign(:user, nil)
1026 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1027 |> json_response(:ok)
1029 [%{"id" => id}] = response
1030 assert id == other_user.id
1033 test "requires authentification for private posts", %{conn: conn, user: user} do
1034 other_user = insert(:user)
1037 CommonAPI.post(user, %{
1038 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1039 "visibility" => "direct"
1043 |> assign(:user, nil)
1044 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1045 |> json_response(404)
1049 |> assign(:user, other_user)
1050 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1051 |> json_response(200)
1053 assert [] == response
1058 user = insert(:user)
1060 {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
1061 {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
1062 {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
1063 {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
1064 {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
1068 |> assign(:user, nil)
1069 |> get("/api/v1/statuses/#{id3}/context")
1070 |> json_response(:ok)
1073 "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1074 "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]