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.ScheduledActivity
15 alias Pleroma.Web.ActivityPub.ActivityPub
16 alias Pleroma.Web.CommonAPI
18 import Pleroma.Factory
20 describe "posting statuses" do
26 |> assign(:user, user)
31 test "posting a status", %{conn: conn} do
32 idempotency_key = "Pikachu rocks!"
36 |> put_req_header("idempotency-key", idempotency_key)
37 |> post("/api/v1/statuses", %{
39 "spoiler_text" => "2hu",
40 "sensitive" => "false"
43 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
45 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
47 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
48 json_response(conn_one, 200)
50 assert Activity.get_by_id(id)
54 |> put_req_header("idempotency-key", idempotency_key)
55 |> post("/api/v1/statuses", %{
57 "spoiler_text" => "2hu",
58 "sensitive" => "false"
61 assert %{"id" => second_id} = json_response(conn_two, 200)
62 assert id == second_id
66 |> post("/api/v1/statuses", %{
68 "spoiler_text" => "2hu",
69 "sensitive" => "false"
72 assert %{"id" => third_id} = json_response(conn_three, 200)
75 # An activity that will expire:
81 |> post("api/v1/statuses", %{
83 "expires_in" => expires_in
86 assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
87 assert activity = Activity.get_by_id(fourth_id)
88 assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
90 estimated_expires_at =
91 NaiveDateTime.utc_now()
92 |> NaiveDateTime.add(expires_in)
93 |> NaiveDateTime.truncate(:second)
95 # This assert will fail if the test takes longer than a minute. I sure hope it never does:
96 assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60
98 assert fourth_response["pleroma"]["expires_at"] ==
99 NaiveDateTime.to_iso8601(expiration.scheduled_at)
102 test "posting an undefined status with an attachment", %{conn: conn} do
106 content_type: "image/jpg",
107 path: Path.absname("test/fixtures/image.jpg"),
108 filename: "an_image.jpg"
111 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
115 |> assign(:user, user)
116 |> post("/api/v1/statuses", %{
117 "media_ids" => [to_string(upload.id)]
120 assert json_response(conn, 200)
123 test "replying to a status", %{conn: conn} do
125 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
129 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
131 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
133 activity = Activity.get_by_id(id)
135 assert activity.data["context"] == replied_to.data["context"]
136 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
139 test "replying to a direct message with visibility other than direct", %{conn: conn} do
141 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
143 Enum.each(["public", "private", "unlisted"], fn visibility ->
146 |> post("/api/v1/statuses", %{
147 "status" => "@#{user.nickname} hey",
148 "in_reply_to_id" => replied_to.id,
149 "visibility" => visibility
152 assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
156 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
159 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
161 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
162 assert Activity.get_by_id(id)
165 test "posting a sensitive status", %{conn: conn} do
168 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
170 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
171 assert Activity.get_by_id(id)
174 test "posting a fake status", %{conn: conn} do
177 |> post("/api/v1/statuses", %{
179 "\"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"
182 real_status = json_response(real_conn, 200)
185 assert Object.get_by_ap_id(real_status["uri"])
189 |> Map.put("id", nil)
190 |> Map.put("url", nil)
191 |> Map.put("uri", nil)
192 |> Map.put("created_at", nil)
193 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
197 |> post("/api/v1/statuses", %{
199 "\"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",
203 fake_status = json_response(fake_conn, 200)
206 refute Object.get_by_ap_id(fake_status["uri"])
210 |> Map.put("id", nil)
211 |> Map.put("url", nil)
212 |> Map.put("uri", nil)
213 |> Map.put("created_at", nil)
214 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
216 assert real_status == fake_status
219 test "posting a status with OGP link preview", %{conn: conn} do
220 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
221 Config.put([:rich_media, :enabled], true)
225 |> post("/api/v1/statuses", %{
226 "status" => "https://example.com/ogp"
229 assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
230 assert Activity.get_by_id(id)
233 test "posting a direct status", %{conn: conn} do
234 user2 = insert(:user)
235 content = "direct cofe @#{user2.nickname}"
239 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
241 assert %{"id" => id} = response = json_response(conn, 200)
242 assert response["visibility"] == "direct"
243 assert response["pleroma"]["direct_conversation_id"]
244 assert activity = Activity.get_by_id(id)
245 assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
246 assert activity.data["to"] == [user2.ap_id]
247 assert activity.data["cc"] == []
251 describe "posting scheduled statuses" do
252 test "creates a scheduled activity", %{conn: conn} do
254 scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
258 |> assign(:user, user)
259 |> post("/api/v1/statuses", %{
260 "status" => "scheduled",
261 "scheduled_at" => scheduled_at
264 assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
265 assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
266 assert [] == Repo.all(Activity)
269 test "creates a scheduled activity with a media attachment", %{conn: conn} do
271 scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
274 content_type: "image/jpg",
275 path: Path.absname("test/fixtures/image.jpg"),
276 filename: "an_image.jpg"
279 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
283 |> assign(:user, user)
284 |> post("/api/v1/statuses", %{
285 "media_ids" => [to_string(upload.id)],
286 "status" => "scheduled",
287 "scheduled_at" => scheduled_at
290 assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
291 assert %{"type" => "image"} = media_attachment
294 test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
299 NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
303 |> assign(:user, user)
304 |> post("/api/v1/statuses", %{
305 "status" => "not scheduled",
306 "scheduled_at" => scheduled_at
309 assert %{"content" => "not scheduled"} = json_response(conn, 200)
310 assert [] == Repo.all(ScheduledActivity)
313 test "returns error when daily user limit is exceeded", %{conn: conn} do
317 NaiveDateTime.utc_now()
318 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
319 |> NaiveDateTime.to_iso8601()
321 attrs = %{params: %{}, scheduled_at: today}
322 {:ok, _} = ScheduledActivity.create(user, attrs)
323 {:ok, _} = ScheduledActivity.create(user, attrs)
327 |> assign(:user, user)
328 |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
330 assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
333 test "returns error when total user limit is exceeded", %{conn: conn} do
337 NaiveDateTime.utc_now()
338 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
339 |> NaiveDateTime.to_iso8601()
342 NaiveDateTime.utc_now()
343 |> NaiveDateTime.add(:timer.hours(36), :millisecond)
344 |> NaiveDateTime.to_iso8601()
346 attrs = %{params: %{}, scheduled_at: today}
347 {:ok, _} = ScheduledActivity.create(user, attrs)
348 {:ok, _} = ScheduledActivity.create(user, attrs)
349 {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
353 |> assign(:user, user)
354 |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
356 assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
360 describe "posting polls" do
361 test "posting a poll", %{conn: conn} do
363 time = NaiveDateTime.utc_now()
367 |> assign(:user, user)
368 |> post("/api/v1/statuses", %{
369 "status" => "Who is the #bestgrill?",
370 "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
373 response = json_response(conn, 200)
375 assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
376 title in ["Rei", "Asuka", "Misato"]
379 assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
380 refute response["poll"]["expred"]
383 test "option limit is enforced", %{conn: conn} do
385 limit = Config.get([:instance, :poll_limits, :max_options])
389 |> assign(:user, user)
390 |> post("/api/v1/statuses", %{
392 "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
395 %{"error" => error} = json_response(conn, 422)
396 assert error == "Poll can't contain more than #{limit} options"
399 test "option character limit is enforced", %{conn: conn} do
401 limit = Config.get([:instance, :poll_limits, :max_option_chars])
405 |> assign(:user, user)
406 |> post("/api/v1/statuses", %{
409 "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
414 %{"error" => error} = json_response(conn, 422)
415 assert error == "Poll options cannot be longer than #{limit} characters each"
418 test "minimal date limit is enforced", %{conn: conn} do
420 limit = Config.get([:instance, :poll_limits, :min_expiration])
424 |> assign(:user, user)
425 |> post("/api/v1/statuses", %{
426 "status" => "imagine arbitrary limits",
428 "options" => ["this post was made by pleroma gang"],
429 "expires_in" => limit - 1
433 %{"error" => error} = json_response(conn, 422)
434 assert error == "Expiration date is too soon"
437 test "maximum date limit is enforced", %{conn: conn} do
439 limit = Config.get([:instance, :poll_limits, :max_expiration])
443 |> assign(:user, user)
444 |> post("/api/v1/statuses", %{
445 "status" => "imagine arbitrary limits",
447 "options" => ["this post was made by pleroma gang"],
448 "expires_in" => limit + 1
452 %{"error" => error} = json_response(conn, 422)
453 assert error == "Expiration date is too far in the future"
457 test "get a status", %{conn: conn} do
458 activity = insert(:note_activity)
462 |> get("/api/v1/statuses/#{activity.id}")
464 assert %{"id" => id} = json_response(conn, 200)
465 assert id == to_string(activity.id)
468 test "get statuses by IDs", %{conn: conn} do
469 %{id: id1} = insert(:note_activity)
470 %{id: id2} = insert(:note_activity)
472 query_string = "ids[]=#{id1}&ids[]=#{id2}"
473 conn = get(conn, "/api/v1/statuses/?#{query_string}")
475 assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
478 describe "deleting a status" do
479 test "when you created it", %{conn: conn} do
480 activity = insert(:note_activity)
481 author = User.get_cached_by_ap_id(activity.data["actor"])
485 |> assign(:user, author)
486 |> delete("/api/v1/statuses/#{activity.id}")
488 assert %{} = json_response(conn, 200)
490 refute Activity.get_by_id(activity.id)
493 test "when you didn't create it", %{conn: conn} do
494 activity = insert(:note_activity)
499 |> assign(:user, user)
500 |> delete("/api/v1/statuses/#{activity.id}")
502 assert %{"error" => _} = json_response(conn, 403)
504 assert Activity.get_by_id(activity.id) == activity
507 test "when you're an admin or moderator", %{conn: conn} do
508 activity1 = insert(:note_activity)
509 activity2 = insert(:note_activity)
510 admin = insert(:user, info: %{is_admin: true})
511 moderator = insert(:user, info: %{is_moderator: true})
515 |> assign(:user, admin)
516 |> delete("/api/v1/statuses/#{activity1.id}")
518 assert %{} = json_response(res_conn, 200)
522 |> assign(:user, moderator)
523 |> delete("/api/v1/statuses/#{activity2.id}")
525 assert %{} = json_response(res_conn, 200)
527 refute Activity.get_by_id(activity1.id)
528 refute Activity.get_by_id(activity2.id)
532 describe "reblogging" do
533 test "reblogs and returns the reblogged status", %{conn: conn} do
534 activity = insert(:note_activity)
539 |> assign(:user, user)
540 |> post("/api/v1/statuses/#{activity.id}/reblog")
543 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
545 } = json_response(conn, 200)
547 assert to_string(activity.id) == id
550 test "reblogs privately and returns the reblogged status", %{conn: conn} do
551 activity = insert(:note_activity)
556 |> assign(:user, user)
557 |> post("/api/v1/statuses/#{activity.id}/reblog", %{"visibility" => "private"})
560 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 0},
562 "visibility" => "private"
563 } = json_response(conn, 200)
565 assert to_string(activity.id) == id
568 test "reblogged status for another user", %{conn: conn} do
569 activity = insert(:note_activity)
570 user1 = insert(:user)
571 user2 = insert(:user)
572 user3 = insert(:user)
573 CommonAPI.favorite(activity.id, user2)
574 {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
575 {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
576 {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
580 |> assign(:user, user3)
581 |> get("/api/v1/statuses/#{reblog_activity1.id}")
584 "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
585 "reblogged" => false,
586 "favourited" => false,
587 "bookmarked" => false
588 } = json_response(conn_res, 200)
592 |> assign(:user, user2)
593 |> get("/api/v1/statuses/#{reblog_activity1.id}")
596 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
598 "favourited" => true,
600 } = json_response(conn_res, 200)
602 assert to_string(activity.id) == id
605 test "returns 400 error when activity is not exist", %{conn: conn} do
610 |> assign(:user, user)
611 |> post("/api/v1/statuses/foo/reblog")
613 assert json_response(conn, 400) == %{"error" => "Could not repeat"}
617 describe "unreblogging" do
618 test "unreblogs and returns the unreblogged status", %{conn: conn} do
619 activity = insert(:note_activity)
622 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
626 |> assign(:user, user)
627 |> post("/api/v1/statuses/#{activity.id}/unreblog")
629 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
631 assert to_string(activity.id) == id
634 test "returns 400 error when activity is not exist", %{conn: conn} do
639 |> assign(:user, user)
640 |> post("/api/v1/statuses/foo/unreblog")
642 assert json_response(conn, 400) == %{"error" => "Could not unrepeat"}
646 describe "favoriting" do
647 test "favs a status and returns it", %{conn: conn} do
648 activity = insert(:note_activity)
653 |> assign(:user, user)
654 |> post("/api/v1/statuses/#{activity.id}/favourite")
656 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
657 json_response(conn, 200)
659 assert to_string(activity.id) == id
662 test "returns 400 error for a wrong id", %{conn: conn} do
667 |> assign(:user, user)
668 |> post("/api/v1/statuses/1/favourite")
670 assert json_response(conn, 400) == %{"error" => "Could not favorite"}
674 describe "unfavoriting" do
675 test "unfavorites a status and returns it", %{conn: conn} do
676 activity = insert(:note_activity)
679 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
683 |> assign(:user, user)
684 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
686 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
687 json_response(conn, 200)
689 assert to_string(activity.id) == id
692 test "returns 400 error for a wrong id", %{conn: conn} do
697 |> assign(:user, user)
698 |> post("/api/v1/statuses/1/unfavourite")
700 assert json_response(conn, 400) == %{"error" => "Could not unfavorite"}
704 describe "pinned statuses" do
707 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
709 [user: user, activity: activity]
712 clear_config([:instance, :max_pinned_statuses]) do
713 Config.put([:instance, :max_pinned_statuses], 1)
716 test "pin status", %{conn: conn, user: user, activity: activity} do
717 id_str = to_string(activity.id)
719 assert %{"id" => ^id_str, "pinned" => true} =
721 |> assign(:user, user)
722 |> post("/api/v1/statuses/#{activity.id}/pin")
723 |> json_response(200)
725 assert [%{"id" => ^id_str, "pinned" => true}] =
727 |> assign(:user, user)
728 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
729 |> json_response(200)
732 test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
733 {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
737 |> assign(:user, user)
738 |> post("/api/v1/statuses/#{dm.id}/pin")
740 assert json_response(conn, 400) == %{"error" => "Could not pin"}
743 test "unpin status", %{conn: conn, user: user, activity: activity} do
744 {:ok, _} = CommonAPI.pin(activity.id, user)
746 id_str = to_string(activity.id)
747 user = refresh_record(user)
749 assert %{"id" => ^id_str, "pinned" => false} =
751 |> assign(:user, user)
752 |> post("/api/v1/statuses/#{activity.id}/unpin")
753 |> json_response(200)
757 |> assign(:user, user)
758 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
759 |> json_response(200)
762 test "/unpin: returns 400 error when activity is not exist", %{conn: conn, user: user} do
765 |> assign(:user, user)
766 |> post("/api/v1/statuses/1/unpin")
768 assert json_response(conn, 400) == %{"error" => "Could not unpin"}
771 test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
772 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
774 id_str_one = to_string(activity_one.id)
776 assert %{"id" => ^id_str_one, "pinned" => true} =
778 |> assign(:user, user)
779 |> post("/api/v1/statuses/#{id_str_one}/pin")
780 |> json_response(200)
782 user = refresh_record(user)
784 assert %{"error" => "You have already pinned the maximum number of statuses"} =
786 |> assign(:user, user)
787 |> post("/api/v1/statuses/#{activity_two.id}/pin")
788 |> json_response(400)
794 Config.put([:rich_media, :enabled], true)
800 test "returns rich-media card", %{conn: conn, user: user} do
801 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
803 {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
806 "image" => "http://ia.media-imdb.com/images/rock.jpg",
807 "provider_name" => "example.com",
808 "provider_url" => "https://example.com",
809 "title" => "The Rock",
811 "url" => "https://example.com/ogp",
813 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
816 "image" => "http://ia.media-imdb.com/images/rock.jpg",
817 "title" => "The Rock",
818 "type" => "video.movie",
819 "url" => "https://example.com/ogp",
821 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
828 |> get("/api/v1/statuses/#{activity.id}/card")
829 |> json_response(200)
831 assert response == card_data
833 # works with private posts
835 CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
839 |> assign(:user, user)
840 |> get("/api/v1/statuses/#{activity.id}/card")
841 |> json_response(200)
843 assert response_two == card_data
846 test "replaces missing description with an empty string", %{conn: conn, user: user} do
847 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
850 CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
854 |> get("/api/v1/statuses/#{activity.id}/card")
855 |> json_response(:ok)
857 assert response == %{
859 "title" => "Pleroma",
862 "provider_name" => "example.com",
863 "provider_url" => "https://example.com",
864 "url" => "https://example.com/ogp-missing-data",
867 "title" => "Pleroma",
869 "url" => "https://example.com/ogp-missing-data"
878 for_user = insert(:user)
881 CommonAPI.post(user, %{
882 "status" => "heweoo?"
886 CommonAPI.post(user, %{
887 "status" => "heweoo!"
892 |> assign(:user, for_user)
893 |> post("/api/v1/statuses/#{activity1.id}/bookmark")
895 assert json_response(response1, 200)["bookmarked"] == true
899 |> assign(:user, for_user)
900 |> post("/api/v1/statuses/#{activity2.id}/bookmark")
902 assert json_response(response2, 200)["bookmarked"] == true
906 |> assign(:user, for_user)
907 |> get("/api/v1/bookmarks")
909 assert [json_response(response2, 200), json_response(response1, 200)] ==
910 json_response(bookmarks, 200)
914 |> assign(:user, for_user)
915 |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
917 assert json_response(response1, 200)["bookmarked"] == false
921 |> assign(:user, for_user)
922 |> get("/api/v1/bookmarks")
924 assert [json_response(response2, 200)] == json_response(bookmarks, 200)
927 describe "conversation muting" do
929 post_user = insert(:user)
932 {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
934 [user: user, activity: activity]
937 test "mute conversation", %{conn: conn, user: user, activity: activity} do
938 id_str = to_string(activity.id)
940 assert %{"id" => ^id_str, "muted" => true} =
942 |> assign(:user, user)
943 |> post("/api/v1/statuses/#{activity.id}/mute")
944 |> json_response(200)
947 test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
948 {:ok, _} = CommonAPI.add_mute(user, activity)
952 |> assign(:user, user)
953 |> post("/api/v1/statuses/#{activity.id}/mute")
955 assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
958 test "unmute conversation", %{conn: conn, user: user, activity: activity} do
959 {:ok, _} = CommonAPI.add_mute(user, activity)
961 id_str = to_string(activity.id)
962 user = refresh_record(user)
964 assert %{"id" => ^id_str, "muted" => false} =
966 |> assign(:user, user)
967 |> post("/api/v1/statuses/#{activity.id}/unmute")
968 |> json_response(200)
972 test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
973 user1 = insert(:user)
974 user2 = insert(:user)
975 user3 = insert(:user)
977 {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
979 # Reply to status from another user
982 |> assign(:user, user2)
983 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
985 assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
987 activity = Activity.get_by_id_with_object(id)
989 assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
990 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
992 # Reblog from the third user
995 |> assign(:user, user3)
996 |> post("/api/v1/statuses/#{activity.id}/reblog")
998 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
999 json_response(conn2, 200)
1001 assert to_string(activity.id) == id
1003 # Getting third user status
1006 |> assign(:user, user3)
1007 |> get("api/v1/timelines/home")
1009 [reblogged_activity] = json_response(conn3, 200)
1011 assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
1013 replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
1014 assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
1017 describe "GET /api/v1/statuses/:id/favourited_by" do
1019 user = insert(:user)
1020 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1024 |> assign(:user, user)
1026 [conn: conn, activity: activity, user: user]
1029 test "returns users who have favorited the status", %{conn: conn, activity: activity} do
1030 other_user = insert(:user)
1031 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1035 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1036 |> json_response(:ok)
1038 [%{"id" => id}] = response
1040 assert id == other_user.id
1043 test "returns empty array when status has not been favorited yet", %{
1049 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1050 |> json_response(:ok)
1052 assert Enum.empty?(response)
1055 test "does not return users who have favorited the status but are blocked", %{
1056 conn: %{assigns: %{user: user}} = conn,
1059 other_user = insert(:user)
1060 {:ok, user} = User.block(user, other_user)
1062 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1066 |> assign(:user, user)
1067 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1068 |> json_response(:ok)
1070 assert Enum.empty?(response)
1073 test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
1074 other_user = insert(:user)
1075 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1079 |> assign(:user, nil)
1080 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1081 |> json_response(:ok)
1083 [%{"id" => id}] = response
1084 assert id == other_user.id
1087 test "requires authentification for private posts", %{conn: conn, user: user} do
1088 other_user = insert(:user)
1091 CommonAPI.post(user, %{
1092 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1093 "visibility" => "direct"
1096 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1099 |> assign(:user, nil)
1100 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1101 |> json_response(404)
1105 |> assign(:user, other_user)
1106 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1107 |> json_response(200)
1109 [%{"id" => id}] = response
1110 assert id == other_user.id
1114 describe "GET /api/v1/statuses/:id/reblogged_by" do
1116 user = insert(:user)
1117 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1121 |> assign(:user, user)
1123 [conn: conn, activity: activity, user: user]
1126 test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
1127 other_user = insert(:user)
1128 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1132 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1133 |> json_response(:ok)
1135 [%{"id" => id}] = response
1137 assert id == other_user.id
1140 test "returns empty array when status has not been reblogged yet", %{
1146 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1147 |> json_response(:ok)
1149 assert Enum.empty?(response)
1152 test "does not return users who have reblogged the status but are blocked", %{
1153 conn: %{assigns: %{user: user}} = conn,
1156 other_user = insert(:user)
1157 {:ok, user} = User.block(user, other_user)
1159 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1163 |> assign(:user, user)
1164 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1165 |> json_response(:ok)
1167 assert Enum.empty?(response)
1170 test "does not fail on an unauthenticated request", %{conn: conn, activity: activity} do
1171 other_user = insert(:user)
1172 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1176 |> assign(:user, nil)
1177 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1178 |> json_response(:ok)
1180 [%{"id" => id}] = response
1181 assert id == other_user.id
1184 test "requires authentification for private posts", %{conn: conn, user: user} do
1185 other_user = insert(:user)
1188 CommonAPI.post(user, %{
1189 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1190 "visibility" => "direct"
1194 |> assign(:user, nil)
1195 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1196 |> json_response(404)
1200 |> assign(:user, other_user)
1201 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1202 |> json_response(200)
1204 assert [] == response
1209 user = insert(:user)
1211 {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
1212 {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
1213 {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
1214 {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
1215 {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
1219 |> assign(:user, nil)
1220 |> get("/api/v1/statuses/#{id3}/context")
1221 |> json_response(:ok)
1224 "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1225 "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]