projects / akkoma / blob
? search:


5259abdcd7ba0adb40a9ddd0334d2c93f879acdd
[akkoma] / test / web / mastodon_api / controllers / status_controller_test.exs
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
6 use Pleroma.Web.ConnCase
7
8 alias Pleroma.Activity
9 alias Pleroma.ActivityExpiration
10 alias Pleroma.Config
11 alias Pleroma.Conversation.Participation
12 alias Pleroma.Object
13 alias Pleroma.Repo
14 alias Pleroma.ScheduledActivity
15 alias Pleroma.Tests.ObanHelpers
16 alias Pleroma.User
17 alias Pleroma.Web.ActivityPub.ActivityPub
18 alias Pleroma.Web.CommonAPI
19
20 import Pleroma.Factory
21
22 clear_config([:instance, :federating])
23 clear_config([:instance, :allow_relay])
24 clear_config([:rich_media, :enabled])
25
26 describe "posting statuses" do
27 setup do: oauth_access(["write:statuses"])
28
29 test "posting a status does not increment reblog_count when relaying", %{conn: conn} do
30 Pleroma.Config.put([:instance, :federating], true)
31 Pleroma.Config.get([:instance, :allow_relay], true)
32
33 response =
34 conn
35 |> post("api/v1/statuses", %{
36 "content_type" => "text/plain",
37 "source" => "Pleroma FE",
38 "status" => "Hello world",
39 "visibility" => "public"
40 })
41 |> json_response(200)
42
43 assert response["reblogs_count"] == 0
44 ObanHelpers.perform_all()
45
46 response =
47 conn
48 |> get("api/v1/statuses/#{response["id"]}", %{})
49 |> json_response(200)
50
51 assert response["reblogs_count"] == 0
52 end
53
54 test "posting a status", %{conn: conn} do
55 idempotency_key = "Pikachu rocks!"
56
57 conn_one =
58 conn
59 |> put_req_header("idempotency-key", idempotency_key)
60 |> post("/api/v1/statuses", %{
61 "status" => "cofe",
62 "spoiler_text" => "2hu",
63 "sensitive" => "false"
64 })
65
66 {:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
67 # Six hours
68 assert ttl > :timer.seconds(6 * 60 * 60 - 1)
69
70 assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
71 json_response(conn_one, 200)
72
73 assert Activity.get_by_id(id)
74
75 conn_two =
76 conn
77 |> put_req_header("idempotency-key", idempotency_key)
78 |> post("/api/v1/statuses", %{
79 "status" => "cofe",
80 "spoiler_text" => "2hu",
81 "sensitive" => "false"
82 })
83
84 assert %{"id" => second_id} = json_response(conn_two, 200)
85 assert id == second_id
86
87 conn_three =
88 conn
89 |> post("/api/v1/statuses", %{
90 "status" => "cofe",
91 "spoiler_text" => "2hu",
92 "sensitive" => "false"
93 })
94
95 assert %{"id" => third_id} = json_response(conn_three, 200)
96 refute id == third_id
97
98 # An activity that will expire:
99 # 2 hours
100 expires_in = 120 * 60
101
102 conn_four =
103 conn
104 |> post("api/v1/statuses", %{
105 "status" => "oolong",
106 "expires_in" => expires_in
107 })
108
109 assert fourth_response = %{"id" => fourth_id} = json_response(conn_four, 200)
110 assert activity = Activity.get_by_id(fourth_id)
111 assert expiration = ActivityExpiration.get_by_activity_id(fourth_id)
112
113 estimated_expires_at =
114 NaiveDateTime.utc_now()
115 |> NaiveDateTime.add(expires_in)
116 |> NaiveDateTime.truncate(:second)
117
118 # This assert will fail if the test takes longer than a minute. I sure hope it never does:
119 assert abs(NaiveDateTime.diff(expiration.scheduled_at, estimated_expires_at, :second)) < 60
120
121 assert fourth_response["pleroma"]["expires_at"] ==
122 NaiveDateTime.to_iso8601(expiration.scheduled_at)
123 end
124
125 test "it fails to create a status if `expires_in` is less or equal than an hour", %{
126 conn: conn
127 } do
128 # 1 hour
129 expires_in = 60 * 60
130
131 assert %{"error" => "Expiry date is too soon"} =
132 conn
133 |> post("api/v1/statuses", %{
134 "status" => "oolong",
135 "expires_in" => expires_in
136 })
137 |> json_response(422)
138
139 # 30 minutes
140 expires_in = 30 * 60
141
142 assert %{"error" => "Expiry date is too soon"} =
143 conn
144 |> post("api/v1/statuses", %{
145 "status" => "oolong",
146 "expires_in" => expires_in
147 })
148 |> json_response(422)
149 end
150
151 test "posting an undefined status with an attachment", %{user: user, conn: conn} do
152 file = %Plug.Upload{
153 content_type: "image/jpg",
154 path: Path.absname("test/fixtures/image.jpg"),
155 filename: "an_image.jpg"
156 }
157
158 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
159
160 conn =
161 post(conn, "/api/v1/statuses", %{
162 "media_ids" => [to_string(upload.id)]
163 })
164
165 assert json_response(conn, 200)
166 end
167
168 test "replying to a status", %{user: user, conn: conn} do
169 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "cofe"})
170
171 conn =
172 conn
173 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
174
175 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
176
177 activity = Activity.get_by_id(id)
178
179 assert activity.data["context"] == replied_to.data["context"]
180 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
181 end
182
183 test "replying to a direct message with visibility other than direct", %{
184 user: user,
185 conn: conn
186 } do
187 {:ok, replied_to} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})
188
189 Enum.each(["public", "private", "unlisted"], fn visibility ->
190 conn =
191 conn
192 |> post("/api/v1/statuses", %{
193 "status" => "@#{user.nickname} hey",
194 "in_reply_to_id" => replied_to.id,
195 "visibility" => visibility
196 })
197
198 assert json_response(conn, 422) == %{"error" => "The message visibility must be direct"}
199 end)
200 end
201
202 test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
203 conn = post(conn, "/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})
204
205 assert %{"content" => "xD", "id" => id} = json_response(conn, 200)
206 assert Activity.get_by_id(id)
207 end
208
209 test "posting a sensitive status", %{conn: conn} do
210 conn = post(conn, "/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})
211
212 assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
213 assert Activity.get_by_id(id)
214 end
215
216 test "posting a fake status", %{conn: conn} do
217 real_conn =
218 post(conn, "/api/v1/statuses", %{
219 "status" =>
220 "\"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"
221 })
222
223 real_status = json_response(real_conn, 200)
224
225 assert real_status
226 assert Object.get_by_ap_id(real_status["uri"])
227
228 real_status =
229 real_status
230 |> Map.put("id", nil)
231 |> Map.put("url", nil)
232 |> Map.put("uri", nil)
233 |> Map.put("created_at", nil)
234 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
235
236 fake_conn =
237 post(conn, "/api/v1/statuses", %{
238 "status" =>
239 "\"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",
240 "preview" => true
241 })
242
243 fake_status = json_response(fake_conn, 200)
244
245 assert fake_status
246 refute Object.get_by_ap_id(fake_status["uri"])
247
248 fake_status =
249 fake_status
250 |> Map.put("id", nil)
251 |> Map.put("url", nil)
252 |> Map.put("uri", nil)
253 |> Map.put("created_at", nil)
254 |> Kernel.put_in(["pleroma", "conversation_id"], nil)
255
256 assert real_status == fake_status
257 end
258
259 test "posting a status with OGP link preview", %{conn: conn} do
260 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
261 Config.put([:rich_media, :enabled], true)
262
263 conn =
264 post(conn, "/api/v1/statuses", %{
265 "status" => "https://example.com/ogp"
266 })
267
268 assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
269 assert Activity.get_by_id(id)
270 end
271
272 test "posting a direct status", %{conn: conn} do
273 user2 = insert(:user)
274 content = "direct cofe @#{user2.nickname}"
275
276 conn = post(conn, "api/v1/statuses", %{"status" => content, "visibility" => "direct"})
277
278 assert %{"id" => id} = response = json_response(conn, 200)
279 assert response["visibility"] == "direct"
280 assert response["pleroma"]["direct_conversation_id"]
281 assert activity = Activity.get_by_id(id)
282 assert activity.recipients == [user2.ap_id, conn.assigns[:user].ap_id]
283 assert activity.data["to"] == [user2.ap_id]
284 assert activity.data["cc"] == []
285 end
286 end
287
288 describe "posting scheduled statuses" do
289 setup do: oauth_access(["write:statuses"])
290
291 test "creates a scheduled activity", %{conn: conn} do
292 scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
293
294 conn =
295 post(conn, "/api/v1/statuses", %{
296 "status" => "scheduled",
297 "scheduled_at" => scheduled_at
298 })
299
300 assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
301 assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
302 assert [] == Repo.all(Activity)
303 end
304
305 test "creates a scheduled activity with a media attachment", %{user: user, conn: conn} do
306 scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
307
308 file = %Plug.Upload{
309 content_type: "image/jpg",
310 path: Path.absname("test/fixtures/image.jpg"),
311 filename: "an_image.jpg"
312 }
313
314 {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
315
316 conn =
317 post(conn, "/api/v1/statuses", %{
318 "media_ids" => [to_string(upload.id)],
319 "status" => "scheduled",
320 "scheduled_at" => scheduled_at
321 })
322
323 assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
324 assert %{"type" => "image"} = media_attachment
325 end
326
327 test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
328 %{conn: conn} do
329 scheduled_at =
330 NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
331
332 conn =
333 post(conn, "/api/v1/statuses", %{
334 "status" => "not scheduled",
335 "scheduled_at" => scheduled_at
336 })
337
338 assert %{"content" => "not scheduled"} = json_response(conn, 200)
339 assert [] == Repo.all(ScheduledActivity)
340 end
341
342 test "returns error when daily user limit is exceeded", %{user: user, conn: conn} do
343 today =
344 NaiveDateTime.utc_now()
345 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
346 |> NaiveDateTime.to_iso8601()
347
348 attrs = %{params: %{}, scheduled_at: today}
349 {:ok, _} = ScheduledActivity.create(user, attrs)
350 {:ok, _} = ScheduledActivity.create(user, attrs)
351
352 conn = post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
353
354 assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
355 end
356
357 test "returns error when total user limit is exceeded", %{user: user, conn: conn} do
358 today =
359 NaiveDateTime.utc_now()
360 |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
361 |> NaiveDateTime.to_iso8601()
362
363 tomorrow =
364 NaiveDateTime.utc_now()
365 |> NaiveDateTime.add(:timer.hours(36), :millisecond)
366 |> NaiveDateTime.to_iso8601()
367
368 attrs = %{params: %{}, scheduled_at: today}
369 {:ok, _} = ScheduledActivity.create(user, attrs)
370 {:ok, _} = ScheduledActivity.create(user, attrs)
371 {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
372
373 conn =
374 post(conn, "/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
375
376 assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
377 end
378 end
379
380 describe "posting polls" do
381 setup do: oauth_access(["write:statuses"])
382
383 test "posting a poll", %{conn: conn} do
384 time = NaiveDateTime.utc_now()
385
386 conn =
387 post(conn, "/api/v1/statuses", %{
388 "status" => "Who is the #bestgrill?",
389 "poll" => %{"options" => ["Rei", "Asuka", "Misato"], "expires_in" => 420}
390 })
391
392 response = json_response(conn, 200)
393
394 assert Enum.all?(response["poll"]["options"], fn %{"title" => title} ->
395 title in ["Rei", "Asuka", "Misato"]
396 end)
397
398 assert NaiveDateTime.diff(NaiveDateTime.from_iso8601!(response["poll"]["expires_at"]), time) in 420..430
399 refute response["poll"]["expred"]
400
401 question = Object.get_by_id(response["poll"]["id"])
402
403 # closed contains utc timezone
404 assert question.data["closed"] =~ "Z"
405 end
406
407 test "option limit is enforced", %{conn: conn} do
408 limit = Config.get([:instance, :poll_limits, :max_options])
409
410 conn =
411 post(conn, "/api/v1/statuses", %{
412 "status" => "desu~",
413 "poll" => %{"options" => Enum.map(0..limit, fn _ -> "desu" end), "expires_in" => 1}
414 })
415
416 %{"error" => error} = json_response(conn, 422)
417 assert error == "Poll can't contain more than #{limit} options"
418 end
419
420 test "option character limit is enforced", %{conn: conn} do
421 limit = Config.get([:instance, :poll_limits, :max_option_chars])
422
423 conn =
424 post(conn, "/api/v1/statuses", %{
425 "status" => "...",
426 "poll" => %{
427 "options" => [Enum.reduce(0..limit, "", fn _, acc -> acc <> "." end)],
428 "expires_in" => 1
429 }
430 })
431
432 %{"error" => error} = json_response(conn, 422)
433 assert error == "Poll options cannot be longer than #{limit} characters each"
434 end
435
436 test "minimal date limit is enforced", %{conn: conn} do
437 limit = Config.get([:instance, :poll_limits, :min_expiration])
438
439 conn =
440 post(conn, "/api/v1/statuses", %{
441 "status" => "imagine arbitrary limits",
442 "poll" => %{
443 "options" => ["this post was made by pleroma gang"],
444 "expires_in" => limit - 1
445 }
446 })
447
448 %{"error" => error} = json_response(conn, 422)
449 assert error == "Expiration date is too soon"
450 end
451
452 test "maximum date limit is enforced", %{conn: conn} do
453 limit = Config.get([:instance, :poll_limits, :max_expiration])
454
455 conn =
456 post(conn, "/api/v1/statuses", %{
457 "status" => "imagine arbitrary limits",
458 "poll" => %{
459 "options" => ["this post was made by pleroma gang"],
460 "expires_in" => limit + 1
461 }
462 })
463
464 %{"error" => error} = json_response(conn, 422)
465 assert error == "Expiration date is too far in the future"
466 end
467 end
468
469 test "get a status" do
470 %{conn: conn} = oauth_access(["read:statuses"])
471 activity = insert(:note_activity)
472
473 conn = get(conn, "/api/v1/statuses/#{activity.id}")
474
475 assert %{"id" => id} = json_response(conn, 200)
476 assert id == to_string(activity.id)
477 end
478
479 test "getting a status that doesn't exist returns 404" do
480 %{conn: conn} = oauth_access(["read:statuses"])
481 activity = insert(:note_activity)
482
483 conn = get(conn, "/api/v1/statuses/#{String.downcase(activity.id)}")
484
485 assert json_response(conn, 404) == %{"error" => "Record not found"}
486 end
487
488 test "get a direct status" do
489 %{user: user, conn: conn} = oauth_access(["read:statuses"])
490 other_user = insert(:user)
491
492 {:ok, activity} =
493 CommonAPI.post(user, %{"status" => "@#{other_user.nickname}", "visibility" => "direct"})
494
495 conn =
496 conn
497 |> assign(:user, user)
498 |> get("/api/v1/statuses/#{activity.id}")
499
500 [participation] = Participation.for_user(user)
501
502 res = json_response(conn, 200)
503 assert res["pleroma"]["direct_conversation_id"] == participation.id
504 end
505
506 test "get statuses by IDs" do
507 %{conn: conn} = oauth_access(["read:statuses"])
508 %{id: id1} = insert(:note_activity)
509 %{id: id2} = insert(:note_activity)
510
511 query_string = "ids[]=#{id1}&ids[]=#{id2}"
512 conn = get(conn, "/api/v1/statuses/?#{query_string}")
513
514 assert [%{"id" => ^id1}, %{"id" => ^id2}] = Enum.sort_by(json_response(conn, :ok), & &1["id"])
515 end
516
517 describe "deleting a status" do
518 test "when you created it" do
519 %{user: author, conn: conn} = oauth_access(["write:statuses"])
520 activity = insert(:note_activity, user: author)
521
522 conn =
523 conn
524 |> assign(:user, author)
525 |> delete("/api/v1/statuses/#{activity.id}")
526
527 assert %{} = json_response(conn, 200)
528
529 refute Activity.get_by_id(activity.id)
530 end
531
532 test "when it doesn't exist" do
533 %{user: author, conn: conn} = oauth_access(["write:statuses"])
534 activity = insert(:note_activity, user: author)
535
536 conn =
537 conn
538 |> assign(:user, author)
539 |> delete("/api/v1/statuses/#{String.downcase(activity.id)}")
540
541 assert %{"error" => "Record not found"} == json_response(conn, 404)
542 end
543
544 test "when you didn't create it" do
545 %{conn: conn} = oauth_access(["write:statuses"])
546 activity = insert(:note_activity)
547
548 conn = delete(conn, "/api/v1/statuses/#{activity.id}")
549
550 assert %{"error" => _} = json_response(conn, 403)
551
552 assert Activity.get_by_id(activity.id) == activity
553 end
554
555 test "when you're an admin or moderator", %{conn: conn} do
556 activity1 = insert(:note_activity)
557 activity2 = insert(:note_activity)
558 admin = insert(:user, is_admin: true)
559 moderator = insert(:user, is_moderator: true)
560
561 res_conn =
562 conn
563 |> assign(:user, admin)
564 |> assign(:token, insert(:oauth_token, user: admin, scopes: ["write:statuses"]))
565 |> delete("/api/v1/statuses/#{activity1.id}")
566
567 assert %{} = json_response(res_conn, 200)
568
569 res_conn =
570 conn
571 |> assign(:user, moderator)
572 |> assign(:token, insert(:oauth_token, user: moderator, scopes: ["write:statuses"]))
573 |> delete("/api/v1/statuses/#{activity2.id}")
574
575 assert %{} = json_response(res_conn, 200)
576
577 refute Activity.get_by_id(activity1.id)
578 refute Activity.get_by_id(activity2.id)
579 end
580 end
581
582 describe "reblogging" do
583 setup do: oauth_access(["write:statuses"])
584
585 test "reblogs and returns the reblogged status", %{conn: conn} do
586 activity = insert(:note_activity)
587
588 conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog")
589
590 assert %{
591 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
592 "reblogged" => true
593 } = json_response(conn, 200)
594
595 assert to_string(activity.id) == id
596 end
597
598 test "returns 404 if the reblogged status doesn't exist", %{conn: conn} do
599 activity = insert(:note_activity)
600
601 conn = post(conn, "/api/v1/statuses/#{String.downcase(activity.id)}/reblog")
602
603 assert %{"error" => "Record not found"} = json_response(conn, 404)
604 end
605
606 test "reblogs privately and returns the reblogged status", %{conn: conn} do
607 activity = insert(:note_activity)
608
609 conn = post(conn, "/api/v1/statuses/#{activity.id}/reblog", %{"visibility" => "private"})
610
611 assert %{
612 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
613 "reblogged" => true,
614 "visibility" => "private"
615 } = json_response(conn, 200)
616
617 assert to_string(activity.id) == id
618 end
619
620 test "reblogged status for another user" do
621 activity = insert(:note_activity)
622 user1 = insert(:user)
623 user2 = insert(:user)
624 user3 = insert(:user)
625 CommonAPI.favorite(activity.id, user2)
626 {:ok, _bookmark} = Pleroma.Bookmark.create(user2.id, activity.id)
627 {:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
628 {:ok, _, _object} = CommonAPI.repeat(activity.id, user2)
629
630 conn_res =
631 build_conn()
632 |> assign(:user, user3)
633 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
634 |> get("/api/v1/statuses/#{reblog_activity1.id}")
635
636 assert %{
637 "reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
638 "reblogged" => false,
639 "favourited" => false,
640 "bookmarked" => false
641 } = json_response(conn_res, 200)
642
643 conn_res =
644 build_conn()
645 |> assign(:user, user2)
646 |> assign(:token, insert(:oauth_token, user: user2, scopes: ["read:statuses"]))
647 |> get("/api/v1/statuses/#{reblog_activity1.id}")
648
649 assert %{
650 "reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
651 "reblogged" => true,
652 "favourited" => true,
653 "bookmarked" => true
654 } = json_response(conn_res, 200)
655
656 assert to_string(activity.id) == id
657 end
658 end
659
660 describe "unreblogging" do
661 setup do: oauth_access(["write:statuses"])
662
663 test "unreblogs and returns the unreblogged status", %{user: user, conn: conn} do
664 activity = insert(:note_activity)
665
666 {:ok, _, _} = CommonAPI.repeat(activity.id, user)
667
668 conn = post(conn, "/api/v1/statuses/#{activity.id}/unreblog")
669
670 assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)
671
672 assert to_string(activity.id) == id
673 end
674
675 test "returns 404 error when activity does not exist", %{conn: conn} do
676 conn = post(conn, "/api/v1/statuses/foo/unreblog")
677
678 assert json_response(conn, 404) == %{"error" => "Record not found"}
679 end
680 end
681
682 describe "favoriting" do
683 setup do: oauth_access(["write:favourites"])
684
685 test "favs a status and returns it", %{conn: conn} do
686 activity = insert(:note_activity)
687
688 conn = post(conn, "/api/v1/statuses/#{activity.id}/favourite")
689
690 assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
691 json_response(conn, 200)
692
693 assert to_string(activity.id) == id
694 end
695
696 test "favoriting twice will just return 200", %{conn: conn} do
697 activity = insert(:note_activity)
698
699 post(conn, "/api/v1/statuses/#{activity.id}/favourite")
700 assert post(conn, "/api/v1/statuses/#{activity.id}/favourite") |> json_response(200)
701 end
702
703 test "returns 404 error for a wrong id", %{conn: conn} do
704 conn = post(conn, "/api/v1/statuses/1/favourite")
705
706 assert json_response(conn, 404) == %{"error" => "Record not found"}
707 end
708 end
709
710 describe "unfavoriting" do
711 setup do: oauth_access(["write:favourites"])
712
713 test "unfavorites a status and returns it", %{user: user, conn: conn} do
714 activity = insert(:note_activity)
715
716 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
717
718 conn = post(conn, "/api/v1/statuses/#{activity.id}/unfavourite")
719
720 assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
721 json_response(conn, 200)
722
723 assert to_string(activity.id) == id
724 end
725
726 test "returns 404 error for a wrong id", %{conn: conn} do
727 conn = post(conn, "/api/v1/statuses/1/unfavourite")
728
729 assert json_response(conn, 404) == %{"error" => "Record not found"}
730 end
731 end
732
733 describe "pinned statuses" do
734 setup do: oauth_access(["write:accounts"])
735
736 setup %{user: user} do
737 {:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})
738
739 %{activity: activity}
740 end
741
742 clear_config([:instance, :max_pinned_statuses], 1)
743
744 test "pin status", %{conn: conn, user: user, activity: activity} do
745 id_str = to_string(activity.id)
746
747 assert %{"id" => ^id_str, "pinned" => true} =
748 conn
749 |> post("/api/v1/statuses/#{activity.id}/pin")
750 |> json_response(200)
751
752 assert [%{"id" => ^id_str, "pinned" => true}] =
753 conn
754 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
755 |> json_response(200)
756 end
757
758 test "/pin: returns 400 error when activity is not public", %{conn: conn, user: user} do
759 {:ok, dm} = CommonAPI.post(user, %{"status" => "test", "visibility" => "direct"})
760
761 conn = post(conn, "/api/v1/statuses/#{dm.id}/pin")
762
763 assert json_response(conn, 400) == %{"error" => "Could not pin"}
764 end
765
766 test "unpin status", %{conn: conn, user: user, activity: activity} do
767 {:ok, _} = CommonAPI.pin(activity.id, user)
768 user = refresh_record(user)
769
770 id_str = to_string(activity.id)
771
772 assert %{"id" => ^id_str, "pinned" => false} =
773 conn
774 |> assign(:user, user)
775 |> post("/api/v1/statuses/#{activity.id}/unpin")
776 |> json_response(200)
777
778 assert [] =
779 conn
780 |> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
781 |> json_response(200)
782 end
783
784 test "/unpin: returns 400 error when activity is not exist", %{conn: conn} do
785 conn = post(conn, "/api/v1/statuses/1/unpin")
786
787 assert json_response(conn, 400) == %{"error" => "Could not unpin"}
788 end
789
790 test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
791 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
792
793 id_str_one = to_string(activity_one.id)
794
795 assert %{"id" => ^id_str_one, "pinned" => true} =
796 conn
797 |> post("/api/v1/statuses/#{id_str_one}/pin")
798 |> json_response(200)
799
800 user = refresh_record(user)
801
802 assert %{"error" => "You have already pinned the maximum number of statuses"} =
803 conn
804 |> assign(:user, user)
805 |> post("/api/v1/statuses/#{activity_two.id}/pin")
806 |> json_response(400)
807 end
808 end
809
810 describe "cards" do
811 setup do
812 Config.put([:rich_media, :enabled], true)
813
814 oauth_access(["read:statuses"])
815 end
816
817 test "returns rich-media card", %{conn: conn, user: user} do
818 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
819
820 {:ok, activity} = CommonAPI.post(user, %{"status" => "https://example.com/ogp"})
821
822 card_data = %{
823 "image" => "http://ia.media-imdb.com/images/rock.jpg",
824 "provider_name" => "example.com",
825 "provider_url" => "https://example.com",
826 "title" => "The Rock",
827 "type" => "link",
828 "url" => "https://example.com/ogp",
829 "description" =>
830 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer.",
831 "pleroma" => %{
832 "opengraph" => %{
833 "image" => "http://ia.media-imdb.com/images/rock.jpg",
834 "title" => "The Rock",
835 "type" => "video.movie",
836 "url" => "https://example.com/ogp",
837 "description" =>
838 "Directed by Michael Bay. With Sean Connery, Nicolas Cage, Ed Harris, John Spencer."
839 }
840 }
841 }
842
843 response =
844 conn
845 |> get("/api/v1/statuses/#{activity.id}/card")
846 |> json_response(200)
847
848 assert response == card_data
849
850 # works with private posts
851 {:ok, activity} =
852 CommonAPI.post(user, %{"status" => "https://example.com/ogp", "visibility" => "direct"})
853
854 response_two =
855 conn
856 |> get("/api/v1/statuses/#{activity.id}/card")
857 |> json_response(200)
858
859 assert response_two == card_data
860 end
861
862 test "replaces missing description with an empty string", %{conn: conn, user: user} do
863 Tesla.Mock.mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
864
865 {:ok, activity} =
866 CommonAPI.post(user, %{"status" => "https://example.com/ogp-missing-data"})
867
868 response =
869 conn
870 |> get("/api/v1/statuses/#{activity.id}/card")
871 |> json_response(:ok)
872
873 assert response == %{
874 "type" => "link",
875 "title" => "Pleroma",
876 "description" => "",
877 "image" => nil,
878 "provider_name" => "example.com",
879 "provider_url" => "https://example.com",
880 "url" => "https://example.com/ogp-missing-data",
881 "pleroma" => %{
882 "opengraph" => %{
883 "title" => "Pleroma",
884 "type" => "website",
885 "url" => "https://example.com/ogp-missing-data"
886 }
887 }
888 }
889 end
890 end
891
892 test "bookmarks" do
893 %{conn: conn} = oauth_access(["write:bookmarks", "read:bookmarks"])
894 author = insert(:user)
895
896 {:ok, activity1} =
897 CommonAPI.post(author, %{
898 "status" => "heweoo?"
899 })
900
901 {:ok, activity2} =
902 CommonAPI.post(author, %{
903 "status" => "heweoo!"
904 })
905
906 response1 = post(conn, "/api/v1/statuses/#{activity1.id}/bookmark")
907
908 assert json_response(response1, 200)["bookmarked"] == true
909
910 response2 = post(conn, "/api/v1/statuses/#{activity2.id}/bookmark")
911
912 assert json_response(response2, 200)["bookmarked"] == true
913
914 bookmarks = get(conn, "/api/v1/bookmarks")
915
916 assert [json_response(response2, 200), json_response(response1, 200)] ==
917 json_response(bookmarks, 200)
918
919 response1 = post(conn, "/api/v1/statuses/#{activity1.id}/unbookmark")
920
921 assert json_response(response1, 200)["bookmarked"] == false
922
923 bookmarks = get(conn, "/api/v1/bookmarks")
924
925 assert [json_response(response2, 200)] == json_response(bookmarks, 200)
926 end
927
928 describe "conversation muting" do
929 setup do: oauth_access(["write:mutes"])
930
931 setup do
932 post_user = insert(:user)
933 {:ok, activity} = CommonAPI.post(post_user, %{"status" => "HIE"})
934 %{activity: activity}
935 end
936
937 test "mute conversation", %{conn: conn, activity: activity} do
938 id_str = to_string(activity.id)
939
940 assert %{"id" => ^id_str, "muted" => true} =
941 conn
942 |> post("/api/v1/statuses/#{activity.id}/mute")
943 |> json_response(200)
944 end
945
946 test "cannot mute already muted conversation", %{conn: conn, user: user, activity: activity} do
947 {:ok, _} = CommonAPI.add_mute(user, activity)
948
949 conn = post(conn, "/api/v1/statuses/#{activity.id}/mute")
950
951 assert json_response(conn, 400) == %{"error" => "conversation is already muted"}
952 end
953
954 test "unmute conversation", %{conn: conn, user: user, activity: activity} do
955 {:ok, _} = CommonAPI.add_mute(user, activity)
956
957 id_str = to_string(activity.id)
958
959 assert %{"id" => ^id_str, "muted" => false} =
960 conn
961 # |> assign(:user, user)
962 |> post("/api/v1/statuses/#{activity.id}/unmute")
963 |> json_response(200)
964 end
965 end
966
967 test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
968 user1 = insert(:user)
969 user2 = insert(:user)
970 user3 = insert(:user)
971
972 {:ok, replied_to} = CommonAPI.post(user1, %{"status" => "cofe"})
973
974 # Reply to status from another user
975 conn1 =
976 conn
977 |> assign(:user, user2)
978 |> assign(:token, insert(:oauth_token, user: user2, scopes: ["write:statuses"]))
979 |> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})
980
981 assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)
982
983 activity = Activity.get_by_id_with_object(id)
984
985 assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
986 assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
987
988 # Reblog from the third user
989 conn2 =
990 conn
991 |> assign(:user, user3)
992 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["write:statuses"]))
993 |> post("/api/v1/statuses/#{activity.id}/reblog")
994
995 assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
996 json_response(conn2, 200)
997
998 assert to_string(activity.id) == id
999
1000 # Getting third user status
1001 conn3 =
1002 conn
1003 |> assign(:user, user3)
1004 |> assign(:token, insert(:oauth_token, user: user3, scopes: ["read:statuses"]))
1005 |> get("api/v1/timelines/home")
1006
1007 [reblogged_activity] = json_response(conn3, 200)
1008
1009 assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id
1010
1011 replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
1012 assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
1013 end
1014
1015 describe "GET /api/v1/statuses/:id/favourited_by" do
1016 setup do: oauth_access(["read:accounts"])
1017
1018 setup %{user: user} do
1019 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1020
1021 %{activity: activity}
1022 end
1023
1024 test "returns users who have favorited the status", %{conn: conn, activity: activity} do
1025 other_user = insert(:user)
1026 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1027
1028 response =
1029 conn
1030 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1031 |> json_response(:ok)
1032
1033 [%{"id" => id}] = response
1034
1035 assert id == other_user.id
1036 end
1037
1038 test "returns empty array when status has not been favorited yet", %{
1039 conn: conn,
1040 activity: activity
1041 } do
1042 response =
1043 conn
1044 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1045 |> json_response(:ok)
1046
1047 assert Enum.empty?(response)
1048 end
1049
1050 test "does not return users who have favorited the status but are blocked", %{
1051 conn: %{assigns: %{user: user}} = conn,
1052 activity: activity
1053 } do
1054 other_user = insert(:user)
1055 {:ok, _user_relationship} = User.block(user, other_user)
1056
1057 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1058
1059 response =
1060 conn
1061 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1062 |> json_response(:ok)
1063
1064 assert Enum.empty?(response)
1065 end
1066
1067 test "does not fail on an unauthenticated request", %{activity: activity} do
1068 other_user = insert(:user)
1069 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1070
1071 response =
1072 build_conn()
1073 |> get("/api/v1/statuses/#{activity.id}/favourited_by")
1074 |> json_response(:ok)
1075
1076 [%{"id" => id}] = response
1077 assert id == other_user.id
1078 end
1079
1080 test "requires authentication for private posts", %{user: user} do
1081 other_user = insert(:user)
1082
1083 {:ok, activity} =
1084 CommonAPI.post(user, %{
1085 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1086 "visibility" => "direct"
1087 })
1088
1089 {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
1090
1091 favourited_by_url = "/api/v1/statuses/#{activity.id}/favourited_by"
1092
1093 build_conn()
1094 |> get(favourited_by_url)
1095 |> json_response(404)
1096
1097 conn =
1098 build_conn()
1099 |> assign(:user, other_user)
1100 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1101
1102 conn
1103 |> assign(:token, nil)
1104 |> get(favourited_by_url)
1105 |> json_response(404)
1106
1107 response =
1108 conn
1109 |> get(favourited_by_url)
1110 |> json_response(200)
1111
1112 [%{"id" => id}] = response
1113 assert id == other_user.id
1114 end
1115 end
1116
1117 describe "GET /api/v1/statuses/:id/reblogged_by" do
1118 setup do: oauth_access(["read:accounts"])
1119
1120 setup %{user: user} do
1121 {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1122
1123 %{activity: activity}
1124 end
1125
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)
1129
1130 response =
1131 conn
1132 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1133 |> json_response(:ok)
1134
1135 [%{"id" => id}] = response
1136
1137 assert id == other_user.id
1138 end
1139
1140 test "returns empty array when status has not been reblogged yet", %{
1141 conn: conn,
1142 activity: activity
1143 } do
1144 response =
1145 conn
1146 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1147 |> json_response(:ok)
1148
1149 assert Enum.empty?(response)
1150 end
1151
1152 test "does not return users who have reblogged the status but are blocked", %{
1153 conn: %{assigns: %{user: user}} = conn,
1154 activity: activity
1155 } do
1156 other_user = insert(:user)
1157 {:ok, _user_relationship} = User.block(user, other_user)
1158
1159 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1160
1161 response =
1162 conn
1163 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1164 |> json_response(:ok)
1165
1166 assert Enum.empty?(response)
1167 end
1168
1169 test "does not return users who have reblogged the status privately", %{
1170 conn: conn,
1171 activity: activity
1172 } do
1173 other_user = insert(:user)
1174
1175 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user, %{"visibility" => "private"})
1176
1177 response =
1178 conn
1179 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1180 |> json_response(:ok)
1181
1182 assert Enum.empty?(response)
1183 end
1184
1185 test "does not fail on an unauthenticated request", %{activity: activity} do
1186 other_user = insert(:user)
1187 {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
1188
1189 response =
1190 build_conn()
1191 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1192 |> json_response(:ok)
1193
1194 [%{"id" => id}] = response
1195 assert id == other_user.id
1196 end
1197
1198 test "requires authentication for private posts", %{user: user} do
1199 other_user = insert(:user)
1200
1201 {:ok, activity} =
1202 CommonAPI.post(user, %{
1203 "status" => "@#{other_user.nickname} wanna get some #cofe together?",
1204 "visibility" => "direct"
1205 })
1206
1207 build_conn()
1208 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1209 |> json_response(404)
1210
1211 response =
1212 build_conn()
1213 |> assign(:user, other_user)
1214 |> assign(:token, insert(:oauth_token, user: other_user, scopes: ["read:accounts"]))
1215 |> get("/api/v1/statuses/#{activity.id}/reblogged_by")
1216 |> json_response(200)
1217
1218 assert [] == response
1219 end
1220 end
1221
1222 test "context" do
1223 user = insert(:user)
1224
1225 {:ok, %{id: id1}} = CommonAPI.post(user, %{"status" => "1"})
1226 {:ok, %{id: id2}} = CommonAPI.post(user, %{"status" => "2", "in_reply_to_status_id" => id1})
1227 {:ok, %{id: id3}} = CommonAPI.post(user, %{"status" => "3", "in_reply_to_status_id" => id2})
1228 {:ok, %{id: id4}} = CommonAPI.post(user, %{"status" => "4", "in_reply_to_status_id" => id3})
1229 {:ok, %{id: id5}} = CommonAPI.post(user, %{"status" => "5", "in_reply_to_status_id" => id4})
1230
1231 response =
1232 build_conn()
1233 |> get("/api/v1/statuses/#{id3}/context")
1234 |> json_response(:ok)
1235
1236 assert %{
1237 "ancestors" => [%{"id" => ^id1}, %{"id" => ^id2}],
1238 "descendants" => [%{"id" => ^id4}, %{"id" => ^id5}]
1239 } = response
1240 end
1241
1242 test "returns the favorites of a user" do
1243 %{user: user, conn: conn} = oauth_access(["read:favourites"])
1244 other_user = insert(:user)
1245
1246 {:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
1247 {:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})
1248
1249 {:ok, _, _} = CommonAPI.favorite(activity.id, user)
1250
1251 first_conn = get(conn, "/api/v1/favourites")
1252
1253 assert [status] = json_response(first_conn, 200)
1254 assert status["id"] == to_string(activity.id)
1255
1256 assert [{"link", _link_header}] =
1257 Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)
1258
1259 # Honours query params
1260 {:ok, second_activity} =
1261 CommonAPI.post(other_user, %{
1262 "status" =>
1263 "Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
1264 })
1265
1266 {:ok, _, _} = CommonAPI.favorite(second_activity.id, user)
1267
1268 last_like = status["id"]
1269
1270 second_conn = get(conn, "/api/v1/favourites?since_id=#{last_like}")
1271
1272 assert [second_status] = json_response(second_conn, 200)
1273 assert second_status["id"] == to_string(second_activity.id)
1274
1275 third_conn = get(conn, "/api/v1/favourites?limit=0")
1276
1277 assert [] = json_response(third_conn, 200)
1278 end
1279
1280 test "expires_at is nil for another user" do
1281 %{conn: conn, user: user} = oauth_access(["read:statuses"])
1282 {:ok, activity} = CommonAPI.post(user, %{"status" => "foobar", "expires_in" => 1_000_000})
1283
1284 expires_at =
1285 activity.id
1286 |> ActivityExpiration.get_by_activity_id()
1287 |> Map.get(:scheduled_at)
1288 |> NaiveDateTime.to_iso8601()
1289
1290 assert %{"pleroma" => %{"expires_at" => ^expires_at}} =
1291 conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
1292
1293 %{conn: conn} = oauth_access(["read:statuses"])
1294
1295 assert %{"pleroma" => %{"expires_at" => nil}} =
1296 conn |> get("/api/v1/statuses/#{activity.id}") |> json_response(:ok)
1297 end
1298 end
Fork of https://akkoma.dev/AkkomaGang/akkoma.git