1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 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
7 use Oban.Testing, repo: Pleroma.Repo
11 alias Pleroma.Conversation.Participation
14 alias Pleroma.ScheduledActivity
15 alias Pleroma.Tests.ObanHelpers
17 alias Pleroma.Web.ActivityPub.ActivityPub
18 alias Pleroma.Web.CommonAPI
20 import Pleroma.Factory
22 setup do: clear_config([:instance, :federating])
23 setup do: clear_config([:instance, :allow_relay])
24 setup do: clear_config([:rich_media, :enabled])
25 setup do: clear_config([:mrf, :policies])
26 setup do: clear_config([:mrf_keyword, :reject])
28 describe "posting statuses" do
29 setup do: oauth_access(["write:statuses"])
31 test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
32 Config.put([:instance, :federating], true)
33 Config.get([:instance, :allow_relay], true)
37 |> put_req_header("content-type", "application/json")
38 |> post("api/v1/statuses", %{
39 "content_type" => "text/plain",
40 "source" => "Pleroma FE",
41 "status" => "Hello world",
42 "visibility" => "public"
44 |> json_response_and_validate_schema(200)
46 assert response["reblogs_count"] == 0
47 ObanHelpers.perform_all()
51 |> get("api/v1/statuses/#{response["id"]}", %{})
52 |> json_response_and_validate_schema(200)
54 assert response["reblogs_count"] == 0
57 test "posting a status", %{conn: conn} do
58 idempotency_key = "Pikachu rocks!"
62 |> put_req_header("content-type", "application/json")
63 |> put_req_header("idempotency-key", idempotency_key)
64 |> post("/api/v1/statuses", %{
66 "spoiler_text" => "2hu",
70 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
72 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
74 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
75 json_response_and_validate_schema(conn_one, 200)
77 assert Activity.get_by_id(id)
81 |> put_req_header("content-type", "application/json")
82 |> put_req_header("idempotency-key", idempotency_key)
83 |> post("/api/v1/statuses", %{
85 "spoiler_text" => "2hu",
89 assert %{"id" => second_id} = json_response(conn_two, 200)
90 assert id == second_id
94 |> put_req_header("content-type", "application/json")
95 |> post("/api/v1/statuses", %{
97 "spoiler_text" => "2hu",
98 "sensitive" => "False"
101 assert %{"id" => third_id} = json_response_and_validate_schema(conn_three, 200)
102 refute id == third_id
104 # An activity that will expire:
106 expires_in = 2 * 60 * 60
108 expires_at = DateTime.add(DateTime.utc_now(), expires_in)
112 |> put_req_header("content-type", "application/json")
113 |> post("api/v1/statuses", %{
114 "status" => "oolong",
115 "expires_in" => expires_in
118 assert %{"id" => fourth_id} = json_response_and_validate_schema(conn_four, 200)
120 assert Activity.get_by_id(fourth_id)
123 worker: Pleroma.Workers.PurgeExpiredActivity,
124 args: %{activity_id: fourth_id},
125 scheduled_at: expires_at
129 test "it fails to create a status if `expires_in` is less or equal than an hour", %{
135 assert %{"error" => "Expiry date is too soon"} =
137 |> put_req_header("content-type", "application/json")
138 |> post("api/v1/statuses", %{
139 "status" => "oolong",
140 "expires_in" => expires_in
142 |> json_response_and_validate_schema(422)
147 assert %{"error" => "Expiry date is too soon"} =
149 |> put_req_header("content-type", "application/json")
150 |> post("api/v1/statuses", %{
151 "status" => "oolong",
152 "expires_in" => expires_in
154 |> json_response_and_validate_schema(422)
157 test "Get MRF reason when posting a status is rejected by one", %{conn: conn} do
158 Config.put([:mrf_keyword, :reject], ["GNO"])
159 Config.put([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.KeywordPolicy])
161 assert %{"error" => "[KeywordPolicy] Matches with rejected keyword"} =
163 |> put_req_header("content-type", "application/json")
164 |> post("api/v1/statuses", %{"status" => "GNO/Linux"})
165 |> json_response_and_validate_schema(422)
168 test "posting an undefined status with an attachment", %{user: user, conn: conn} do
170 content_type: "image/jpeg",
171 path: Path.absname("test/fixtures/image.jpg"),
172 filename: "an_image.jpg"
175 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
179 |> put_req_header("content-type", "application/json")
180 |> post("/api/v1/statuses", %{
181 "media_ids" => [to_string(upload.id)]
184 assert json_response_and_validate_schema(conn, 200)
187 test "replying to a status", %{user: user, conn: conn} do
188 {:ok, replied_to} = CommonAPI.post(user, %{status: "cofe"})
192 |> put_req_header("content-type", "application/json")
193 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
195 assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
197 activity = Activity.get_by_id(id)
199 assert activity.data["context"] == replied_to.data["context"]
200 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
203 test "replying to a direct message with visibility other than direct", %{
207 {:ok, replied_to} = CommonAPI.post(user, %{status: "suya..", visibility: "direct"})
209 Enum.each(["public", "private", "unlisted"], fn visibility ->
212 |> put_req_header("content-type", "application/json")
213 |> post("/api/v1/statuses", %{
214 "status" => "@#{user.nickname} hey",
215 "in_reply_to_id" => replied_to.id,
216 "visibility" => visibility
219 assert json_response_and_validate_schema(conn, 422) == %{
220 "error" => "The message visibility must be direct"
225 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
228 |> put_req_header("content-type", "application/json")
229 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
231 assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn, 200)
232 assert Activity.get_by_id(id)
235 test "posting a sensitive status", %{conn: conn} do
238 |> put_req_header("content-type", "application/json")
239 |> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
241 assert %{"content" => "cofe", "id" => id, "sensitive" => true} =
242 json_response_and_validate_schema(conn, 200)
244 assert Activity.get_by_id(id)
247 test "posting a fake status", %{conn: conn} do
250 |> put_req_header("content-type", "application/json")
251 |> post("/api/v1/statuses", %{
253 "\"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"
256 real_status = json_response_and_validate_schema(real_conn, 200)
259 assert Object.get_by_ap_id(real_status["uri"])
263 |> Map.put("id", nil)
264 |> Map.put("url", nil)
265 |> Map.put("uri", nil)
266 |> Map.put("created_at", nil)
267 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
271 |> put_req_header("content-type", "application/json")
272 |> post("/api/v1/statuses", %{
274 "\"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",
278 fake_status = json_response_and_validate_schema(fake_conn, 200)
281 refute Object.get_by_ap_id(fake_status["uri"])
285 |> Map.put("id", nil)
286 |> Map.put("url", nil)
287 |> Map.put("uri", nil)
288 |> Map.put("created_at", nil)
289 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
291 assert real_status == fake_status
294 test "fake statuses' preview card is not cached", %{conn: conn} do
295 clear_config([:rich_media, :enabled], true)
300 url: "https://example.com/twitter-card"
302 %Tesla.Env{status: 200, body: File.read!("test/fixtures/rich_media/twitter_card.html")}
305 apply(HttpRequestMock, :request, [env])
310 |> put_req_header("content-type", "application/json")
311 |> post("/api/v1/statuses", %{
312 "status" => "https://example.com/ogp",
318 |> put_req_header("content-type", "application/json")
319 |> post("/api/v1/statuses", %{
320 "status" => "https://example.com/twitter-card",
324 assert %{"card" => %{"title" => "The Rock"}} = json_response_and_validate_schema(conn1, 200)
326 assert %{"card" => %{"title" => "Small Island Developing States Photo Submission"}} =
327 json_response_and_validate_schema(conn2, 200)
330 test "posting a status with OGP link preview", %{conn: conn} do
331 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
332 clear_config([:rich_media, :enabled], true)
336 |> put_req_header("content-type", "application/json")
337 |> post("/api/v1/statuses", %{
338 "status" => "https://example.com/ogp"
341 assert %{"id" => id, "card" => %{"title" => "The Rock"}} =
342 json_response_and_validate_schema(conn, 200)
344 assert Activity.get_by_id(id)
347 test "posting a direct status", %{conn: conn} do
348 user2 = insert(:user)
349 content = "direct cofe @#{user2.nickname}"
353 |> put_req_header("content-type", "application/json")
354 |> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})
356 assert %{"id" => id} = response = json_response_and_validate_schema(conn, 200)
357 assert response["visibility"] == "direct"
358 assert response["pleroma"]["direct_conversation_id"]
359 assert activity = Activity.get_by_id(id)
360 assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
361 assert activity.data["to"] == [user2.ap_id]
362 assert activity.data["cc"] == []
366 describe "posting scheduled statuses" do
367 setup do: oauth_access(["write:statuses"])
369 test "creates a scheduled activity", %{conn: conn} do
371 NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
372 |> NaiveDateTime.to_iso8601()
377 |> put_req_header("content-type", "application/json")
378 |> post("/api/v1/statuses", %{
379 "status" => "scheduled",
380 "scheduled_at" => scheduled_at
383 assert %{"scheduled_at" => expected_scheduled_at} =
384 json_response_and_validate_schema(conn, 200)
386 assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
387 assert [] == Repo.all(Activity)
390 test "ignores nil values", %{conn: conn} do
393 |> put_req_header("content-type", "application/json")
394 |> post("/api/v1/statuses", %{
395 "status" => "not scheduled",
396 "scheduled_at" => nil
399 assert result = json_response_and_validate_schema(conn, 200)
400 assert Activity.get_by_id(result["id"])
403 test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
405 NaiveDateTime.utc_now()
406 |> NaiveDateTime.add(:timer.minutes(120), :millisecond)
407 |> NaiveDateTime.to_iso8601()
411 content_type: "image/jpeg",
412 path: Path.absname("test/fixtures/image.jpg"),
413 filename: "an_image.jpg"
416 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
420 |> put_req_header("content-type", "application/json")
421 |> post("/api/v1/statuses", %{
422 "media_ids" => [to_string(upload.id)],
423 "status" => "scheduled",
424 "scheduled_at" => scheduled_at
427 assert %{"media_attachments" => [media_attachment]} =
428 json_response_and_validate_schema(conn, 200)
430 assert %{"type" => "image"} = media_attachment
433 test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
436 NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
437 |> NaiveDateTime.to_iso8601()
442 |> put_req_header("content-type", "application/json")
443 |> post("/api/v1/statuses", %{
444 "status" => "not scheduled",
445 "scheduled_at" => scheduled_at
448 assert %{"content" => "not scheduled"} = json_response_and_validate_schema(conn, 200)
449 assert [] == Repo.all(ScheduledActivity)
452 test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
454 NaiveDateTime.utc_now()
455 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
456 |> NaiveDateTime.to_iso8601()
460 attrs = %{params: %{}, scheduled_at: today}
461 {:ok, _} = ScheduledActivity.create(user, attrs)
462 {:ok, _} = ScheduledActivity.create(user, attrs)
466 |> put_req_header("content-type", "application/json")
467 |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
469 assert %{"error" => "daily limit exceeded"} == json_response_and_validate_schema(conn, 422)
472 test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
474 NaiveDateTime.utc_now()
475 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
476 |> NaiveDateTime.to_iso8601()
480 NaiveDateTime.utc_now()
481 |> NaiveDateTime.add(:timer.hours(36), :millisecond)
482 |> NaiveDateTime.to_iso8601()
485 attrs = %{params: %{}, scheduled_at: today}
486 {:ok, _} = ScheduledActivity.create(user, attrs)
487 {:ok, _} = ScheduledActivity.create(user, attrs)
488 {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
492 |> put_req_header("content-type", "application/json")
493 |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
495 assert %{"error" => "total limit exceeded"} == json_response_and_validate_schema(conn, 422)
499 describe "posting polls" do
500 setup do: oauth_access(["write:statuses"])
502 test "posting a poll", %{conn: conn} do
503 time = NaiveDateTime.utc_now()
507 |> put_req_header("content-type", "application/json")
508 |> post("/api/v1/statuses", %{
509 "status" => "Who is the #bestgrill?",
511 "options" => ["Rei", "Asuka", "Misato"],
516 response = json_response_and_validate_schema(conn, 200)
518 assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
519 title in ["Rei", "Asuka", "Misato"]
522 assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
523 refute response["poll"]["expred"]
525 question = Object.get_by_id(response["poll"]["id"])
527 # closed contains utc timezone
528 assert question.data["closed"] =~ "Z"
531 test "option limit is enforced", %{conn: conn} do
532 limit = Config.get([:instance, :poll_limits, :max_options])
536 |> put_req_header("content-type", "application/json")
537 |> post("/api/v1/statuses", %{
539 "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
542 %{"error" => error} = json_response_and_validate_schema(conn, 422)
543 assert error == "Poll can't contain more than #{limit} options"
546 test "option character limit is enforced", %{conn: conn} do
547 limit = Config.get([:instance, :poll_limits, :max_option_chars])
551 |> put_req_header("content-type", "application/json")
552 |> post("/api/v1/statuses", %{
555 "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
560 %{"error" => error} = json_response_and_validate_schema(conn, 422)
561 assert error == "Poll options cannot be longer than #{limit} characters each"
564 test "minimal date limit is enforced", %{conn: conn} do
565 limit = Config.get([:instance, :poll_limits, :min_expiration])
569 |> put_req_header("content-type", "application/json")
570 |> post("/api/v1/statuses", %{
571 "status" => "imagine arbitrary limits",
573 "options" => ["this post was made by pleroma gang"],
574 "expires_in" => limit - 1
578 %{"error" => error} = json_response_and_validate_schema(conn, 422)
579 assert error == "Expiration date is too soon"
582 test "maximum date limit is enforced", %{conn: conn} do
583 limit = Config.get([:instance, :poll_limits, :max_expiration])
587 |> put_req_header("content-type", "application/json")
588 |> post("/api/v1/statuses", %{
589 "status" => "imagine arbitrary limits",
591 "options" => ["this post was made by pleroma gang"],
592 "expires_in" => limit + 1
596 %{"error" => error} = json_response_and_validate_schema(conn, 422)
597 assert error == "Expiration date is too far in the future"
601 test "get a status" do
602 %{conn: conn} = oauth_access(["read:statuses"])
603 activity = insert(:note_activity)
605 conn = get(conn, "/api/v1/statuses/#{activity.id}")
607 assert %{"id" => id} = json_response_and_validate_schema(conn, 200)
608 assert id == to_string(activity.id)
611 defp local_and_remote_activities do
612 local = insert(:note_activity)
613 remote = insert(:note_activity, local: false)
614 {:ok, local: local, remote: remote}
617 describe "status with restrict unauthenticated activities for local and remote" do
618 setup do: local_and_remote_activities()
620 setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
622 setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
624 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
625 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
627 assert json_response_and_validate_schema(res_conn, :not_found) == %{
628 "error" => "Record not found"
631 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
633 assert json_response_and_validate_schema(res_conn, :not_found) == %{
634 "error" => "Record not found"
638 test "if user is authenticated", %{local: local, remote: remote} do
639 %{conn: conn} = oauth_access(["read"])
640 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
641 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
643 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
644 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
648 describe "status with restrict unauthenticated activities for local" do
649 setup do: local_and_remote_activities()
651 setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
653 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
654 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
656 assert json_response_and_validate_schema(res_conn, :not_found) == %{
657 "error" => "Record not found"
660 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
661 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
664 test "if user is authenticated", %{local: local, remote: remote} do
665 %{conn: conn} = oauth_access(["read"])
666 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
667 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
669 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
670 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
674 describe "status with restrict unauthenticated activities for remote" do
675 setup do: local_and_remote_activities()
677 setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
679 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
680 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
681 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
683 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
685 assert json_response_and_validate_schema(res_conn, :not_found) == %{
686 "error" => "Record not found"
690 test "if user is authenticated", %{local: local, remote: remote} do
691 %{conn: conn} = oauth_access(["read"])
692 res_conn = get(conn, "/api/v1/statuses/#{local.id}")
693 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
695 res_conn = get(conn, "/api/v1/statuses/#{remote.id}")
696 assert %{"id" => _} = json_response_and_validate_schema(res_conn, 200)
700 test "getting a status that doesn't exist returns 404" do
701 %{conn: conn} = oauth_access(["read:statuses"])
702 activity = insert(:note_activity)
704 conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")
706 assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
709 test "get a direct status" do
710 %{user: user, conn: conn} = oauth_access(["read:statuses"])
711 other_user = insert(:user)
714 CommonAPI.post(user, %{status: "@#{other_user.nickname}", visibility: "direct"})
718 |> assign(:user, user)
719 |> get("/api/v1/statuses/#{activity.id}")
721 [participation] = Participation.for_user(user)
723 res = json_response_and_validate_schema(conn, 200)
724 assert res["pleroma"]["direct_conversation_id"] == participation.id
727 test "get statuses by IDs" do
728 %{conn: conn} = oauth_access(["read:statuses"])
729 %{id: id1} = insert(:note_activity)
730 %{id: id2} = insert(:note_activity)
732 query_string = "ids[]=#{id1}&ids[]=#{id2}"
733 conn = get(conn, "/api/v1/statuses/?#{query_string}")
735 assert [%{"id" => ^id1}, %{"id" => ^id2}] =
736 Enum.sort_by(json_response_and_validate_schema(conn, :ok), & &1["id"])
739 describe "getting statuses by ids with restricted unauthenticated for local and remote" do
740 setup do: local_and_remote_activities()
742 setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
744 setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
746 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
747 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
749 assert json_response_and_validate_schema(res_conn, 200) == []
752 test "if user is authenticated", %{local: local, remote: remote} do
753 %{conn: conn} = oauth_access(["read"])
755 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
757 assert length(json_response_and_validate_schema(res_conn, 200)) == 2
761 describe "getting statuses by ids with restricted unauthenticated for local" do
762 setup do: local_and_remote_activities()
764 setup do: clear_config([:restrict_unauthenticated, :activities, :local], true)
766 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
767 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
769 remote_id = remote.id
770 assert [%{"id" => ^remote_id}] = json_response_and_validate_schema(res_conn, 200)
773 test "if user is authenticated", %{local: local, remote: remote} do
774 %{conn: conn} = oauth_access(["read"])
776 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
778 assert length(json_response_and_validate_schema(res_conn, 200)) == 2
782 describe "getting statuses by ids with restricted unauthenticated for remote" do
783 setup do: local_and_remote_activities()
785 setup do: clear_config([:restrict_unauthenticated, :activities, :remote], true)
787 test "if user is unauthenticated", %{conn: conn, local: local, remote: remote} do
788 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
791 assert [%{"id" => ^local_id}] = json_response_and_validate_schema(res_conn, 200)
794 test "if user is authenticated", %{local: local, remote: remote} do
795 %{conn: conn} = oauth_access(["read"])
797 res_conn = get(conn, "/api/v1/statuses?ids[]=#{local.id}&ids[]=#{remote.id}")
799 assert length(json_response_and_validate_schema(res_conn, 200)) == 2
803 describe "deleting a status" do
804 test "when you created it" do
805 %{user: author, conn: conn} = oauth_access(["write:statuses"])
806 activity = insert(:note_activity, user: author)
807 object = Object.normalize(activity)
809 content = object.data["content"]
810 source = object.data["source"]
814 |> assign(:user, author)
815 |> delete("/api/v1/statuses/#{activity.id}")
816 |> json_response_and_validate_schema(200)
818 assert match?(%{"content" => ^content, "text" => ^source}, result)
820 refute Activity.get_by_id(activity.id)
823 test "when it doesn't exist" do
824 %{user: author, conn: conn} = oauth_access(["write:statuses"])
825 activity = insert(:note_activity, user: author)
829 |> assign(:user, author)
830 |> delete("/api/v1/statuses/#{String.downcase(activity.id)}")
832 assert %{"error" => "Record not found"} == json_response_and_validate_schema(conn, 404)
835 test "when you didn't create it" do
836 %{conn: conn} = oauth_access(["write:statuses"])
837 activity = insert(:note_activity)
839 conn = delete(conn, "/api/v1/statuses/#{activity.id}")
841 assert %{"error" => "Record not found"} == json_response_and_validate_schema(conn, 404)
843 assert Activity.get_by_id(activity.id) == activity
846 test "when you're an admin or moderator", %{conn: conn} do
847 activity1 = insert(:note_activity)
848 activity2 = insert(:note_activity)
849 admin = insert(:user, is_admin: true)
850 moderator = insert(:user, is_moderator: true)
854 |> assign(:user, admin)
855 |> assign(:token, insert(:oauth_token, user: admin, scopes: ["write:statuses"]))
856 |> delete("/api/v1/statuses/#{activity1.id}")
858 assert %{} = json_response_and_validate_schema(res_conn, 200)
862 |> assign(:user, moderator)
863 |> assign(:token, insert(:oauth_token, user: moderator, scopes: ["write:statuses"]))
864 |> delete("/api/v1/statuses/#{activity2.id}")
866 assert %{} = json_response_and_validate_schema(res_conn, 200)
868 refute Activity.get_by_id(activity1.id)
869 refute Activity.get_by_id(activity2.id)
873 describe "reblogging" do
874 setup do: oauth_access(["write:statuses"])
876 test "reblogs and returns the reblogged status", %{conn: conn} do
877 activity = insert(:note_activity)
881 |> put_req_header("content-type", "application/json")
882 |> post("/api/v1/statuses/#{activity.id}/reblog")
885 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
887 } = json_response_and_validate_schema(conn, 200)
889 assert to_string(activity.id) == id
892 test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
893 activity = insert(:note_activity)
897 |> put_req_header("content-type", "application/json")
898 |> post("/api/v1/statuses/#{String.downcase(activity.id)}/reblog")
900 assert %{"error" => "Record not found"} = json_response_and_validate_schema(conn, 404)
903 test "reblogs privately and returns the reblogged status", %{conn: conn} do
904 activity = insert(:note_activity)
908 |> put_req_header("content-type", "application/json")
910 "/api/v1/statuses/#{activity.id}/reblog",
911 %{"visibility" => "private"}
915 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
917 "visibility" => "private"
918 } = json_response_and_validate_schema(conn, 200)
920 assert to_string(activity.id) == id
923 test "reblogged status for another user" do
924 activity = insert(:note_activity)
925 user1 = insert(:user)
926 user2 = insert(:user)
927 user3 = insert(:user)
928 {:ok, _} = CommonAPI.favorite(user2, activity.id)
929 {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
930 {:ok, reblog_activity1} = CommonAPI.repeat(activity.id, user1)
931 {:ok, _} = CommonAPI.repeat(activity.id, user2)
935 |> assign(:user, user3)
936 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
937 |> get("/api/v1/statuses/#{reblog_activity1.id}")
940 "reblog" => %{"id" => _id, "reblogged" => false, "reblogs_count" => 2},
941 "reblogged" => false,
942 "favourited" => false,
943 "bookmarked" => false
944 } = json_response_and_validate_schema(conn_res, 200)
948 |> assign(:user, user2)
949 |> assign(:token, insert(:oauth_token, user: user2, scopes: ["read:statuses"]))
950 |> get("/api/v1/statuses/#{reblog_activity1.id}")
953 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
955 "favourited" => true,
957 } = json_response_and_validate_schema(conn_res, 200)
959 assert to_string(activity.id) == id
963 describe "unreblogging" do
964 setup do: oauth_access(["write:statuses"])
966 test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} do
967 activity = insert(:note_activity)
969 {:ok, _} = CommonAPI.repeat(activity.id, user)
973 |> put_req_header("content-type", "application/json")
974 |> post("/api/v1/statuses/#{activity.id}/unreblog")
976 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} =
977 json_response_and_validate_schema(conn, 200)
979 assert to_string(activity.id) == id
982 test "returns 404 error when activity does not exist", %{conn: conn} do
985 |> put_req_header("content-type", "application/json")
986 |> post("/api/v1/statuses/foo/unreblog")
988 assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
992 describe "favoriting" do
993 setup do: oauth_access(["write:favourites"])
995 test "favs a status and returns it", %{conn: conn} do
996 activity = insert(:note_activity)
1000 |> put_req_header("content-type", "application/json")
1001 |> post("/api/v1/statuses/#{activity.id}/favourite")
1003 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
1004 json_response_and_validate_schema(conn, 200)
1006 assert to_string(activity.id) == id
1009 test "favoriting twice will just return 200", %{conn: conn} do
1010 activity = insert(:note_activity)
1013 |> put_req_header("content-type", "application/json")
1014 |> post("/api/v1/statuses/#{activity.id}/favourite")
1017 |> put_req_header("content-type", "application/json")
1018 |> post("/api/v1/statuses/#{activity.id}/favourite")
1019 |> json_response_and_validate_schema(200)
1022 test "returns 404 error for a wrong id", %{conn: conn} do
1025 |> put_req_header("content-type", "application/json")
1026 |> post("/api/v1/statuses/1/favourite")
1028 assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
1032 describe "unfavoriting" do
1033 setup do: oauth_access(["write:favourites"])
1035 test "unfavorites a status and returns it", %{user: user, conn: conn} do
1036 activity = insert(:note_activity)
1038 {:ok, _} = CommonAPI.favorite(user, activity.id)
1042 |> put_req_header("content-type", "application/json")
1043 |> post("/api/v1/statuses/#{activity.id}/unfavourite")
1045 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
1046 json_response_and_validate_schema(conn, 200)
1048 assert to_string(activity.id) == id
1051 test "returns 404 error for a wrong id", %{conn: conn} do
1054 |> put_req_header("content-type", "application/json")
1055 |> post("/api/v1/statuses/1/unfavourite")
1057 assert json_response_and_validate_schema(conn, 404) == %{"error" => "Record not found"}
1061 describe "pinned statuses" do
1062 setup do: oauth_access(["write:accounts"])
1064 setup %{user: user} do
1065 {:ok, activity} = CommonAPI.post(user, %{status: "HI!!!"})
1067 %{activity: activity}
1070 setup do: clear_config([:instance, :max_pinned_statuses], 1)
1072 test "pin status", %{conn: conn, user: user, activity: activity} do
1073 id_str = to_string(activity.id)
1075 assert %{"id" => ^id_str, "pinned" => true} =
1077 |> put_req_header("content-type", "application/json")
1078 |> post("/api/v1/statuses/#{activity.id}/pin")
1079 |> json_response_and_validate_schema(200)
1081 assert [%{"id" => ^id_str, "pinned" => true}] =
1083 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1084 |> json_response_and_validate_schema(200)
1087 test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
1088 {:ok, dm} = CommonAPI.post(user, %{status: "test", visibility: "direct"})
1092 |> put_req_header("content-type", "application/json")
1093 |> post("/api/v1/statuses/#{dm.id}/pin")
1095 assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not pin"}
1098 test "unpin status", %{conn: conn, user: user, activity: activity} do
1099 {:ok, _} = CommonAPI.pin(activity.id, user)
1100 user = refresh_record(user)
1102 id_str = to_string(activity.id)
1104 assert %{"id" => ^id_str, "pinned" => false} =
1106 |> assign(:user, user)
1107 |> post("/api/v1/statuses/#{activity.id}/unpin")
1108 |> json_response_and_validate_schema(200)
1112 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
1113 |> json_response_and_validate_schema(200)
1116 test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
1119 |> put_req_header("content-type", "application/json")
1120 |> post("/api/v1/statuses/1/unpin")
1122 assert json_response_and_validate_schema(conn, 400) == %{"error" => "Could not unpin"}
1125 test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
1126 {:ok, activity_two} = CommonAPI.post(user, %{status: "HI!!!"})
1128 id_str_one = to_string(activity_one.id)
1130 assert %{"id" => ^id_str_one, "pinned" => true} =
1132 |> put_req_header("content-type", "application/json")
1133 |> post("/api/v1/statuses/#{id_str_one}/pin")
1134 |> json_response_and_validate_schema(200)
1136 user = refresh_record(user)
1138 assert %{"error" => "You have already pinned the maximum number of statuses"} =
1140 |> assign(:user, user)
1141 |> post("/api/v1/statuses/#{activity_two.id}/pin")
1142 |> json_response_and_validate_schema(400)
1145 test "on pin removes deletion job, on unpin reschedule deletion" do
1146 %{conn: conn} = oauth_access(["write:accounts", "write:statuses"])
1147 expires_in = 2 * 60 * 60
1149 expires_at = DateTime.add(DateTime.utc_now(), expires_in)
1151 assert %{"id" => id} =
1153 |> put_req_header("content-type", "application/json")
1154 |> post("api/v1/statuses", %{
1155 "status" => "oolong",
1156 "expires_in" => expires_in
1158 |> json_response_and_validate_schema(200)
1161 worker: Pleroma.Workers.PurgeExpiredActivity,
1162 args: %{activity_id: id},
1163 scheduled_at: expires_at
1166 assert %{"id" => ^id, "pinned" => true} =
1168 |> put_req_header("content-type", "application/json")
1169 |> post("/api/v1/statuses/#{id}/pin")
1170 |> json_response_and_validate_schema(200)
1173 worker: Pleroma.Workers.PurgeExpiredActivity,
1174 args: %{activity_id: id},
1175 scheduled_at: expires_at
1178 assert %{"id" => ^id, "pinned" => false} =
1180 |> put_req_header("content-type", "application/json")
1181 |> post("/api/v1/statuses/#{id}/unpin")
1182 |> json_response_and_validate_schema(200)
1185 worker: Pleroma.Workers.PurgeExpiredActivity,
1186 args: %{activity_id: id},
1187 scheduled_at: expires_at
1194 Config.put([:rich_media, :enabled], true)
1196 oauth_access(["read:statuses"])
1199 test "returns rich-media card", %{conn: conn, user: user} do
1200 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
1202 {:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp"})
1205 "image" => "http://ia.media-imdb.com/images/rock.jpg",
1206 "provider_name" => "example.com",
1207 "provider_url" => "https://example.com",
1208 "title" => "The Rock",
1210 "url" => "https://example.com/ogp",
1212 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
1215 "image" => "http://ia.media-imdb.com/images/rock.jpg",
1216 "title" => "The Rock",
1217 "type" => "video.movie",
1218 "url" => "https://example.com/ogp",
1220 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
1227 |> get("/api/v1/statuses/#{activity.id}/card")
1228 |> json_response_and_validate_schema(200)
1230 assert response == card_data
1232 # works with private posts
1234 CommonAPI.post(user, %{status: "https://example.com/ogp", visibility: "direct"})
1238 |> get("/api/v1/statuses/#{activity.id}/card")
1239 |> json_response_and_validate_schema(200)
1241 assert response_two == card_data
1244 test "replaces missing description with an empty string", %{conn: conn, user: user} do
1245 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
1247 {:ok, activity} = CommonAPI.post(user, %{status: "https://example.com/ogp-missing-data"})
1251 |> get("/api/v1/statuses/#{activity.id}/card")
1252 |> json_response_and_validate_schema(:ok)
1254 assert response == %{
1256 "title" => "Pleroma",
1257 "description" => "",
1259 "provider_name" => "example.com",
1260 "provider_url" => "https://example.com",
1261 "url" => "https://example.com/ogp-missing-data",
1264 "title" => "Pleroma",
1265 "type" => "website",
1266 "url" => "https://example.com/ogp-missing-data"
1274 bookmarks_uri = "/api/v1/bookmarks"
1276 %{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
1277 author = insert(:user)
1279 {:ok, activity1} = CommonAPI.post(author, %{status: "heweoo?"})
1280 {:ok, activity2} = CommonAPI.post(author, %{status: "heweoo!"})
1284 |> put_req_header("content-type", "application/json")
1285 |> post("/api/v1/statuses/#{activity1.id}/bookmark")
1287 assert json_response_and_validate_schema(response1, 200)["bookmarked"] == true
1291 |> put_req_header("content-type", "application/json")
1292 |> post("/api/v1/statuses/#{activity2.id}/bookmark")
1294 assert json_response_and_validate_schema(response2, 200)["bookmarked"] == true
1296 bookmarks = get(conn, bookmarks_uri)
1299 json_response_and_validate_schema(response2, 200),
1300 json_response_and_validate_schema(response1, 200)
1302 json_response_and_validate_schema(bookmarks, 200)
1306 |> put_req_header("content-type", "application/json")
1307 |> post("/api/v1/statuses/#{activity1.id}/unbookmark")
1309 assert json_response_and_validate_schema(response1, 200)["bookmarked"] == false
1311 bookmarks = get(conn, bookmarks_uri)
1313 assert [json_response_and_validate_schema(response2, 200)] ==
1314 json_response_and_validate_schema(bookmarks, 200)
1317 describe "conversation muting" do
1318 setup do: oauth_access(["write:mutes"])
1321 post_user = insert(:user)
1322 {:ok, activity} = CommonAPI.post(post_user, %{status: "HIE"})
1323 %{activity: activity}
1326 test "mute conversation", %{conn: conn, activity: activity} do
1327 id_str = to_string(activity.id)
1329 assert %{"id" => ^id_str, "muted" => true} =
1331 |> put_req_header("content-type", "application/json")
1332 |> post("/api/v1/statuses/#{activity.id}/mute")
1333 |> json_response_and_validate_schema(200)
1336 test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
1337 {:ok, _} = CommonAPI.add_mute(user, activity)
1341 |> put_req_header("content-type", "application/json")
1342 |> post("/api/v1/statuses/#{activity.id}/mute")
1344 assert json_response_and_validate_schema(conn, 400) == %{
1345 "error" => "conversation is already muted"
1349 test "unmute conversation", %{conn: conn, user: user, activity: activity} do
1350 {:ok, _} = CommonAPI.add_mute(user, activity)
1352 id_str = to_string(activity.id)
1354 assert %{"id" => ^id_str, "muted" => false} =
1356 # |> assign(:user, user)
1357 |> post("/api/v1/statuses/#{activity.id}/unmute")
1358 |> json_response_and_validate_schema(200)
1362 test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
1363 user1 = insert(:user)
1364 user2 = insert(:user)
1365 user3 = insert(:user)
1367 {:ok, replied_to} = CommonAPI.post(user1, %{status: "cofe"})
1369 # Reply to status from another user
1372 |> assign(:user, user2)
1373 |> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
1374 |> put_req_header("content-type", "application/json")
1375 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
1377 assert %{"content" => "xD", "id" => id} = json_response_and_validate_schema(conn1, 200)
1379 activity = Activity.get_by_id_with_object(id)
1381 assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
1382 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
1384 # Reblog from the third user
1387 |> assign(:user, user3)
1388 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
1389 |> put_req_header("content-type", "application/json")
1390 |> post("/api/v1/statuses/#{activity.id}/reblog")
1392 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
1393 json_response_and_validate_schema(conn2, 200)
1395 assert to_string(activity.id) == id
1397 # Getting third user status
1400 |> assign(:user, user3)
1401 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
1402 |> get("api/v1/timelines/home")
1404 [reblogged_activity] = json_response(conn3, 200)
1406 assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
1408 replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
1409 assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
1412 describe "GET /api/v1/statuses/:id/favourited_by" do
1413 setup do: oauth_access(["read:accounts"])
1415 setup %{user: user} do
1416 {:ok, activity} = CommonAPI.post(user, %{status: "test"})
1418 %{activity: activity}
1421 test "returns users who have favorited the status", %{conn: conn, activity: activity} do
1422 other_user = insert(:user)
1423 {:ok, _} = CommonAPI.favorite(other_user, activity.id)
1427 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1428 |> json_response_and_validate_schema(:ok)
1430 [%{"id" => id}] = response
1432 assert id == other_user.id
1435 test "returns empty array when status has not been favorited yet", %{
1441 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1442 |> json_response_and_validate_schema(:ok)
1444 assert Enum.empty?(response)
1447 test "does not return users who have favorited the status but are blocked", %{
1448 conn: %{assigns: %{user: user}} = conn,
1451 other_user = insert(:user)
1452 {:ok, _user_relationship} = User.block(user, other_user)
1454 {:ok, _} = CommonAPI.favorite(other_user, activity.id)
1458 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1459 |> json_response_and_validate_schema(:ok)
1461 assert Enum.empty?(response)
1464 test "does not fail on an unauthenticated request", %{activity: activity} do
1465 other_user = insert(:user)
1466 {:ok, _} = CommonAPI.favorite(other_user, activity.id)
1470 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1471 |> json_response_and_validate_schema(:ok)
1473 [%{"id" => id}] = response
1474 assert id == other_user.id
1477 test "requires authentication for private posts", %{user: user} do
1478 other_user = insert(:user)
1481 CommonAPI.post(user, %{
1482 status: "@#{other_user.nickname} wanna get some #cofe together?",
1483 visibility: "direct"
1486 {:ok, _} = CommonAPI.favorite(other_user, activity.id)
1488 favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"
1491 |> get(favourited_by_url)
1492 |> json_response_and_validate_schema(404)
1496 |> assign(:user, other_user)
1497 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1500 |> assign(:token, nil)
1501 |> get(favourited_by_url)
1502 |> json_response_and_validate_schema(404)
1506 |> get(favourited_by_url)
1507 |> json_response_and_validate_schema(200)
1509 [%{"id" => id}] = response
1510 assert id == other_user.id
1513 test "returns empty array when :show_reactions is disabled", %{conn: conn, activity: activity} do
1514 clear_config([:instance, :show_reactions], false)
1516 other_user = insert(:user)
1517 {:ok, _} = CommonAPI.favorite(other_user, activity.id)
1521 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1522 |> json_response_and_validate_schema(:ok)
1524 assert Enum.empty?(response)
1528 describe "GET /api/v1/statuses/:id/reblogged_by" do
1529 setup do: oauth_access(["read:accounts"])
1531 setup %{user: user} do
1532 {:ok, activity} = CommonAPI.post(user, %{status: "test"})
1534 %{activity: activity}
1537 test "returns users who have reblogged the status", %{conn: conn, activity: activity} do
1538 other_user = insert(:user)
1539 {:ok, _} = CommonAPI.repeat(activity.id, other_user)
1543 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1544 |> json_response_and_validate_schema(:ok)
1546 [%{"id" => id}] = response
1548 assert id == other_user.id
1551 test "returns empty array when status has not been reblogged yet", %{
1557 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1558 |> json_response_and_validate_schema(:ok)
1560 assert Enum.empty?(response)
1563 test "does not return users who have reblogged the status but are blocked", %{
1564 conn: %{assigns: %{user: user}} = conn,
1567 other_user = insert(:user)
1568 {:ok, _user_relationship} = User.block(user, other_user)
1570 {:ok, _} = CommonAPI.repeat(activity.id, other_user)
1574 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1575 |> json_response_and_validate_schema(:ok)
1577 assert Enum.empty?(response)
1580 test "does not return users who have reblogged the status privately", %{
1583 other_user = insert(:user)
1584 {:ok, activity} = CommonAPI.post(other_user, %{status: "my secret post"})
1586 {:ok, _} = CommonAPI.repeat(activity.id, other_user, %{visibility: "private"})
1590 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1591 |> json_response_and_validate_schema(:ok)
1593 assert Enum.empty?(response)
1596 test "does not fail on an unauthenticated request", %{activity: activity} do
1597 other_user = insert(:user)
1598 {:ok, _} = CommonAPI.repeat(activity.id, other_user)
1602 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1603 |> json_response_and_validate_schema(:ok)
1605 [%{"id" => id}] = response
1606 assert id == other_user.id
1609 test "requires authentication for private posts", %{user: user} do
1610 other_user = insert(:user)
1613 CommonAPI.post(user, %{
1614 status: "@#{other_user.nickname} wanna get some #cofe together?",
1615 visibility: "direct"
1619 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1620 |> json_response_and_validate_schema(404)
1624 |> assign(:user, other_user)
1625 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1626 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1627 |> json_response_and_validate_schema(200)
1629 assert [] == response
1634 user = insert(:user)
1636 {:ok, %{id: id1}} = CommonAPI.post(user, %{status: "1"})
1637 {:ok, %{id: id2}} = CommonAPI.post(user, %{status: "2", in_reply_to_status_id: id1})
1638 {:ok, %{id: id3}} = CommonAPI.post(user, %{status: "3", in_reply_to_status_id: id2})
1639 {:ok, %{id: id4}} = CommonAPI.post(user, %{status: "4", in_reply_to_status_id: id3})
1640 {:ok, %{id: id5}} = CommonAPI.post(user, %{status: "5", in_reply_to_status_id: id4})
1644 |> get("/api/v1/statuses/#{id3}/context")
1645 |> json_response_and_validate_schema(:ok)
1648 "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1649 "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
1653 test "favorites paginate correctly" do
1654 %{user: user, conn: conn} = oauth_access(["read:favourites"])
1655 other_user = insert(:user)
1656 {:ok, first_post} = CommonAPI.post(other_user, %{status: "bla"})
1657 {:ok, second_post} = CommonAPI.post(other_user, %{status: "bla"})
1658 {:ok, third_post} = CommonAPI.post(other_user, %{status: "bla"})
1660 {:ok, _first_favorite} = CommonAPI.favorite(user, third_post.id)
1661 {:ok, _second_favorite} = CommonAPI.favorite(user, first_post.id)
1662 {:ok, third_favorite} = CommonAPI.favorite(user, second_post.id)
1666 |> get("/api/v1/favourites?limit=1")
1668 assert [%{"id" => post_id}] = json_response_and_validate_schema(result, 200)
1669 assert post_id == second_post.id
1671 # Using the header for pagination works correctly
1672 [next, _] = get_resp_header(result, "link") |> hd() |> String.split(", ")
1673 [_, max_id] = Regex.run(~r/max_id=([^&]+)/, next)
1675 assert max_id == third_favorite.id
1679 |> get("/api/v1/favourites?max_id=#{max_id}")
1681 assert [%{"id" => first_post_id}, %{"id" => third_post_id}] =
1682 json_response_and_validate_schema(result, 200)
1684 assert first_post_id == first_post.id
1685 assert third_post_id == third_post.id
1688 test "returns the favorites of a user" do
1689 %{user: user, conn: conn} = oauth_access(["read:favourites"])
1690 other_user = insert(:user)
1692 {:ok, _} = CommonAPI.post(other_user, %{status: "bla"})
1693 {:ok, activity} = CommonAPI.post(other_user, %{status: "trees are happy"})
1695 {:ok, last_like} = CommonAPI.favorite(user, activity.id)
1697 first_conn = get(conn, "/api/v1/favourites")
1699 assert [status] = json_response_and_validate_schema(first_conn, 200)
1700 assert status["id"] == to_string(activity.id)
1702 assert [{"link", _link_header}] =
1703 Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1705 # Honours query params
1706 {:ok, second_activity} =
1707 CommonAPI.post(other_user, %{
1708 status: "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1711 {:ok, _} = CommonAPI.favorite(user, second_activity.id)
1713 second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like.id}")
1715 assert [second_status] = json_response_and_validate_schema(second_conn, 200)
1716 assert second_status["id"] == to_string(second_activity.id)
1718 third_conn = get(conn, "/api/v1/favourites?limit=0")
1720 assert [] = json_response_and_validate_schema(third_conn, 200)
1723 test "expires_at is nil for another user" do
1724 %{conn: conn, user: user} = oauth_access(["read:statuses"])
1725 expires_at = DateTime.add(DateTime.utc_now(), 1_000_000)
1726 {:ok, activity} = CommonAPI.post(user, %{status: "foobar", expires_in: 1_000_000})
1728 assert %{"pleroma" => %{"expires_at" => a_expires_at}} =
1730 |> get("/api/v1/statuses/#{activity.id}")
1731 |> json_response_and_validate_schema(:ok)
1733 {:ok, a_expires_at, 0} = DateTime.from_iso8601(a_expires_at)
1734 assert DateTime.diff(expires_at, a_expires_at) == 0
1736 %{conn: conn} = oauth_access(["read:statuses"])
1738 assert %{"pleroma" => %{"expires_at" => nil}} =
1740 |> get("/api/v1/statuses/#{activity.id}")
1741 |> json_response_and_validate_schema(:ok)