Merge branch 'develop' into issue/1276-2
[akkoma] / test / web / activity_pub / activity_pub_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.ActivityPub.ActivityPubTest do
6 use Pleroma.DataCase
7 use Oban.Testing, repo: Pleroma.Repo
8
9 alias Pleroma.Activity
10 alias Pleroma.Builders.ActivityBuilder
11 alias Pleroma.Config
12 alias Pleroma.Notification
13 alias Pleroma.Object
14 alias Pleroma.User
15 alias Pleroma.Web.ActivityPub.ActivityPub
16 alias Pleroma.Web.ActivityPub.Utils
17 alias Pleroma.Web.AdminAPI.AccountView
18 alias Pleroma.Web.CommonAPI
19 alias Pleroma.Web.Federator
20
21 import Pleroma.Factory
22 import Tesla.Mock
23 import Mock
24
25 setup do
26 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
27 :ok
28 end
29
30 setup do: clear_config([:instance, :federating])
31
32 describe "streaming out participations" do
33 test "it streams them out" do
34 user = insert(:user)
35 {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
36
37 {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
38
39 participations =
40 conversation.participations
41 |> Repo.preload(:user)
42
43 with_mock Pleroma.Web.Streamer,
44 stream: fn _, _ -> nil end do
45 ActivityPub.stream_out_participations(conversation.participations)
46
47 assert called(Pleroma.Web.Streamer.stream("participation", participations))
48 end
49 end
50
51 test "streams them out on activity creation" do
52 user_one = insert(:user)
53 user_two = insert(:user)
54
55 with_mock Pleroma.Web.Streamer,
56 stream: fn _, _ -> nil end do
57 {:ok, activity} =
58 CommonAPI.post(user_one, %{
59 "status" => "@#{user_two.nickname}",
60 "visibility" => "direct"
61 })
62
63 conversation =
64 activity.data["context"]
65 |> Pleroma.Conversation.get_for_ap_id()
66 |> Repo.preload(participations: :user)
67
68 assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
69 end
70 end
71 end
72
73 describe "fetching restricted by visibility" do
74 test "it restricts by the appropriate visibility" do
75 user = insert(:user)
76
77 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
78
79 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
80
81 {:ok, unlisted_activity} =
82 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
83
84 {:ok, private_activity} =
85 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
86
87 activities =
88 ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
89
90 assert activities == [direct_activity]
91
92 activities =
93 ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
94
95 assert activities == [unlisted_activity]
96
97 activities =
98 ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
99
100 assert activities == [private_activity]
101
102 activities =
103 ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
104
105 assert activities == [public_activity]
106
107 activities =
108 ActivityPub.fetch_activities([], %{
109 :visibility => ~w[private public],
110 "actor_id" => user.ap_id
111 })
112
113 assert activities == [public_activity, private_activity]
114 end
115 end
116
117 describe "fetching excluded by visibility" do
118 test "it excludes by the appropriate visibility" do
119 user = insert(:user)
120
121 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
122
123 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
124
125 {:ok, unlisted_activity} =
126 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
127
128 {:ok, private_activity} =
129 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
130
131 activities =
132 ActivityPub.fetch_activities([], %{
133 "exclude_visibilities" => "direct",
134 "actor_id" => user.ap_id
135 })
136
137 assert public_activity in activities
138 assert unlisted_activity in activities
139 assert private_activity in activities
140 refute direct_activity in activities
141
142 activities =
143 ActivityPub.fetch_activities([], %{
144 "exclude_visibilities" => "unlisted",
145 "actor_id" => user.ap_id
146 })
147
148 assert public_activity in activities
149 refute unlisted_activity in activities
150 assert private_activity in activities
151 assert direct_activity in activities
152
153 activities =
154 ActivityPub.fetch_activities([], %{
155 "exclude_visibilities" => "private",
156 "actor_id" => user.ap_id
157 })
158
159 assert public_activity in activities
160 assert unlisted_activity in activities
161 refute private_activity in activities
162 assert direct_activity in activities
163
164 activities =
165 ActivityPub.fetch_activities([], %{
166 "exclude_visibilities" => "public",
167 "actor_id" => user.ap_id
168 })
169
170 refute public_activity in activities
171 assert unlisted_activity in activities
172 assert private_activity in activities
173 assert direct_activity in activities
174 end
175 end
176
177 describe "building a user from his ap id" do
178 test "it returns a user" do
179 user_id = "http://mastodon.example.org/users/admin"
180 {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
181 assert user.ap_id == user_id
182 assert user.nickname == "admin@mastodon.example.org"
183 assert user.ap_enabled
184 assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
185 end
186
187 test "it returns a user that is invisible" do
188 user_id = "http://mastodon.example.org/users/relay"
189 {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
190 assert User.invisible?(user)
191 end
192
193 test "it fetches the appropriate tag-restricted posts" do
194 user = insert(:user)
195
196 {:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
197 {:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
198 {:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})
199
200 fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
201
202 fetch_two =
203 ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})
204
205 fetch_three =
206 ActivityPub.fetch_activities([], %{
207 "type" => "Create",
208 "tag" => ["test", "essais"],
209 "tag_reject" => ["reject"]
210 })
211
212 fetch_four =
213 ActivityPub.fetch_activities([], %{
214 "type" => "Create",
215 "tag" => ["test"],
216 "tag_all" => ["test", "reject"]
217 })
218
219 assert fetch_one == [status_one, status_three]
220 assert fetch_two == [status_one, status_two, status_three]
221 assert fetch_three == [status_one, status_two]
222 assert fetch_four == [status_three]
223 end
224 end
225
226 describe "insertion" do
227 test "drops activities beyond a certain limit" do
228 limit = Config.get([:instance, :remote_limit])
229
230 random_text =
231 :crypto.strong_rand_bytes(limit + 1)
232 |> Base.encode64()
233 |> binary_part(0, limit + 1)
234
235 data = %{
236 "ok" => true,
237 "object" => %{
238 "content" => random_text
239 }
240 }
241
242 assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
243 end
244
245 test "doesn't drop activities with content being null" do
246 user = insert(:user)
247
248 data = %{
249 "actor" => user.ap_id,
250 "to" => [],
251 "object" => %{
252 "actor" => user.ap_id,
253 "to" => [],
254 "type" => "Note",
255 "content" => nil
256 }
257 }
258
259 assert {:ok, _} = ActivityPub.insert(data)
260 end
261
262 test "returns the activity if one with the same id is already in" do
263 activity = insert(:note_activity)
264 {:ok, new_activity} = ActivityPub.insert(activity.data)
265
266 assert activity.id == new_activity.id
267 end
268
269 test "inserts a given map into the activity database, giving it an id if it has none." do
270 user = insert(:user)
271
272 data = %{
273 "actor" => user.ap_id,
274 "to" => [],
275 "object" => %{
276 "actor" => user.ap_id,
277 "to" => [],
278 "type" => "Note",
279 "content" => "hey"
280 }
281 }
282
283 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
284 assert activity.data["ok"] == data["ok"]
285 assert is_binary(activity.data["id"])
286
287 given_id = "bla"
288
289 data = %{
290 "id" => given_id,
291 "actor" => user.ap_id,
292 "to" => [],
293 "context" => "blabla",
294 "object" => %{
295 "actor" => user.ap_id,
296 "to" => [],
297 "type" => "Note",
298 "content" => "hey"
299 }
300 }
301
302 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
303 assert activity.data["ok"] == data["ok"]
304 assert activity.data["id"] == given_id
305 assert activity.data["context"] == "blabla"
306 assert activity.data["context_id"]
307 end
308
309 test "adds a context when none is there" do
310 user = insert(:user)
311
312 data = %{
313 "actor" => user.ap_id,
314 "to" => [],
315 "object" => %{
316 "actor" => user.ap_id,
317 "to" => [],
318 "type" => "Note",
319 "content" => "hey"
320 }
321 }
322
323 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
324 object = Pleroma.Object.normalize(activity)
325
326 assert is_binary(activity.data["context"])
327 assert is_binary(object.data["context"])
328 assert activity.data["context_id"]
329 assert object.data["context_id"]
330 end
331
332 test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
333 user = insert(:user)
334
335 data = %{
336 "actor" => user.ap_id,
337 "to" => [],
338 "object" => %{
339 "actor" => user.ap_id,
340 "to" => [],
341 "type" => "Note",
342 "content" => "hey"
343 }
344 }
345
346 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
347 assert object = Object.normalize(activity)
348 assert is_binary(object.data["id"])
349 end
350 end
351
352 describe "listen activities" do
353 test "does not increase user note count" do
354 user = insert(:user)
355
356 {:ok, activity} =
357 ActivityPub.listen(%{
358 to: ["https://www.w3.org/ns/activitystreams#Public"],
359 actor: user,
360 context: "",
361 object: %{
362 "actor" => user.ap_id,
363 "to" => ["https://www.w3.org/ns/activitystreams#Public"],
364 "artist" => "lain",
365 "title" => "lain radio episode 1",
366 "length" => 180_000,
367 "type" => "Audio"
368 }
369 })
370
371 assert activity.actor == user.ap_id
372
373 user = User.get_cached_by_id(user.id)
374 assert user.note_count == 0
375 end
376
377 test "can be fetched into a timeline" do
378 _listen_activity_1 = insert(:listen)
379 _listen_activity_2 = insert(:listen)
380 _listen_activity_3 = insert(:listen)
381
382 timeline = ActivityPub.fetch_activities([], %{"type" => ["Listen"]})
383
384 assert length(timeline) == 3
385 end
386 end
387
388 describe "create activities" do
389 test "it reverts create" do
390 user = insert(:user)
391
392 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
393 assert {:error, :reverted} =
394 ActivityPub.create(%{
395 to: ["user1", "user2"],
396 actor: user,
397 context: "",
398 object: %{
399 "to" => ["user1", "user2"],
400 "type" => "Note",
401 "content" => "testing"
402 }
403 })
404 end
405
406 assert Repo.aggregate(Activity, :count, :id) == 0
407 assert Repo.aggregate(Object, :count, :id) == 0
408 end
409
410 test "removes doubled 'to' recipients" do
411 user = insert(:user)
412
413 {:ok, activity} =
414 ActivityPub.create(%{
415 to: ["user1", "user1", "user2"],
416 actor: user,
417 context: "",
418 object: %{
419 "to" => ["user1", "user1", "user2"],
420 "type" => "Note",
421 "content" => "testing"
422 }
423 })
424
425 assert activity.data["to"] == ["user1", "user2"]
426 assert activity.actor == user.ap_id
427 assert activity.recipients == ["user1", "user2", user.ap_id]
428 end
429
430 test "increases user note count only for public activities" do
431 user = insert(:user)
432
433 {:ok, _} =
434 CommonAPI.post(User.get_cached_by_id(user.id), %{
435 "status" => "1",
436 "visibility" => "public"
437 })
438
439 {:ok, _} =
440 CommonAPI.post(User.get_cached_by_id(user.id), %{
441 "status" => "2",
442 "visibility" => "unlisted"
443 })
444
445 {:ok, _} =
446 CommonAPI.post(User.get_cached_by_id(user.id), %{
447 "status" => "2",
448 "visibility" => "private"
449 })
450
451 {:ok, _} =
452 CommonAPI.post(User.get_cached_by_id(user.id), %{
453 "status" => "3",
454 "visibility" => "direct"
455 })
456
457 user = User.get_cached_by_id(user.id)
458 assert user.note_count == 2
459 end
460
461 test "increases replies count" do
462 user = insert(:user)
463 user2 = insert(:user)
464
465 {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
466 ap_id = activity.data["id"]
467 reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
468
469 # public
470 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
471 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
472 assert object.data["repliesCount"] == 1
473
474 # unlisted
475 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
476 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
477 assert object.data["repliesCount"] == 2
478
479 # private
480 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
481 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
482 assert object.data["repliesCount"] == 2
483
484 # direct
485 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
486 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
487 assert object.data["repliesCount"] == 2
488 end
489 end
490
491 describe "fetch activities for recipients" do
492 test "retrieve the activities for certain recipients" do
493 {:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
494 {:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
495 {:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})
496
497 activities = ActivityPub.fetch_activities(["someone", "someone_else"])
498 assert length(activities) == 2
499 assert activities == [activity_one, activity_two]
500 end
501 end
502
503 describe "fetch activities in context" do
504 test "retrieves activities that have a given context" do
505 {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
506 {:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
507 {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
508 {:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
509 activity_five = insert(:note_activity)
510 user = insert(:user)
511
512 {:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})
513
514 activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
515 assert activities == [activity_two, activity]
516 end
517 end
518
519 test "doesn't return blocked activities" do
520 activity_one = insert(:note_activity)
521 activity_two = insert(:note_activity)
522 activity_three = insert(:note_activity)
523 user = insert(:user)
524 booster = insert(:user)
525 {:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})
526
527 activities =
528 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
529
530 assert Enum.member?(activities, activity_two)
531 assert Enum.member?(activities, activity_three)
532 refute Enum.member?(activities, activity_one)
533
534 {:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
535
536 activities =
537 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
538
539 assert Enum.member?(activities, activity_two)
540 assert Enum.member?(activities, activity_three)
541 assert Enum.member?(activities, activity_one)
542
543 {:ok, _user_relationship} = User.block(user, %{ap_id: activity_three.data["actor"]})
544 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
545 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
546 activity_three = Activity.get_by_id(activity_three.id)
547
548 activities =
549 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
550
551 assert Enum.member?(activities, activity_two)
552 refute Enum.member?(activities, activity_three)
553 refute Enum.member?(activities, boost_activity)
554 assert Enum.member?(activities, activity_one)
555
556 activities =
557 ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})
558
559 assert Enum.member?(activities, activity_two)
560 assert Enum.member?(activities, activity_three)
561 assert Enum.member?(activities, boost_activity)
562 assert Enum.member?(activities, activity_one)
563 end
564
565 test "doesn't return transitive interactions concerning blocked users" do
566 blocker = insert(:user)
567 blockee = insert(:user)
568 friend = insert(:user)
569
570 {:ok, _user_relationship} = User.block(blocker, blockee)
571
572 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
573
574 {:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
575
576 {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
577
578 {:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
579
580 activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
581
582 assert Enum.member?(activities, activity_one)
583 refute Enum.member?(activities, activity_two)
584 refute Enum.member?(activities, activity_three)
585 refute Enum.member?(activities, activity_four)
586 end
587
588 test "doesn't return announce activities concerning blocked users" do
589 blocker = insert(:user)
590 blockee = insert(:user)
591 friend = insert(:user)
592
593 {:ok, _user_relationship} = User.block(blocker, blockee)
594
595 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
596
597 {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
598
599 {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
600
601 activities =
602 ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
603 |> Enum.map(fn act -> act.id end)
604
605 assert Enum.member?(activities, activity_one.id)
606 refute Enum.member?(activities, activity_two.id)
607 refute Enum.member?(activities, activity_three.id)
608 end
609
610 test "doesn't return activities from blocked domains" do
611 domain = "dogwhistle.zone"
612 domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
613 note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
614 activity = insert(:note_activity, %{note: note})
615 user = insert(:user)
616 {:ok, user} = User.block_domain(user, domain)
617
618 activities =
619 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
620
621 refute activity in activities
622
623 followed_user = insert(:user)
624 ActivityPub.follow(user, followed_user)
625 {:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)
626
627 activities =
628 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
629
630 refute repeat_activity in activities
631 end
632
633 test "does return activities from followed users on blocked domains" do
634 domain = "meanies.social"
635 domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
636 blocker = insert(:user)
637
638 {:ok, blocker} = User.follow(blocker, domain_user)
639 {:ok, blocker} = User.block_domain(blocker, domain)
640
641 assert User.following?(blocker, domain_user)
642 assert User.blocks_domain?(blocker, domain_user)
643 refute User.blocks?(blocker, domain_user)
644
645 note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
646 activity = insert(:note_activity, %{note: note})
647
648 activities =
649 ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})
650
651 assert activity in activities
652
653 # And check that if the guy we DO follow boosts someone else from their domain,
654 # that should be hidden
655 another_user = insert(:user, %{ap_id: "https://#{domain}/@meanie2"})
656 bad_note = insert(:note, %{data: %{"actor" => another_user.ap_id}})
657 bad_activity = insert(:note_activity, %{note: bad_note})
658 {:ok, repeat_activity, _} = CommonAPI.repeat(bad_activity.id, domain_user)
659
660 activities =
661 ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})
662
663 refute repeat_activity in activities
664 end
665
666 test "doesn't return muted activities" do
667 activity_one = insert(:note_activity)
668 activity_two = insert(:note_activity)
669 activity_three = insert(:note_activity)
670 user = insert(:user)
671 booster = insert(:user)
672
673 activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
674 {:ok, _user_relationships} = User.mute(user, activity_one_actor)
675
676 activities =
677 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
678
679 assert Enum.member?(activities, activity_two)
680 assert Enum.member?(activities, activity_three)
681 refute Enum.member?(activities, activity_one)
682
683 # Calling with 'with_muted' will deliver muted activities, too.
684 activities =
685 ActivityPub.fetch_activities([], %{
686 "muting_user" => user,
687 "with_muted" => true,
688 "skip_preload" => true
689 })
690
691 assert Enum.member?(activities, activity_two)
692 assert Enum.member?(activities, activity_three)
693 assert Enum.member?(activities, activity_one)
694
695 {:ok, _user_mute} = User.unmute(user, activity_one_actor)
696
697 activities =
698 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
699
700 assert Enum.member?(activities, activity_two)
701 assert Enum.member?(activities, activity_three)
702 assert Enum.member?(activities, activity_one)
703
704 activity_three_actor = User.get_by_ap_id(activity_three.data["actor"])
705 {:ok, _user_relationships} = User.mute(user, activity_three_actor)
706 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
707 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
708 activity_three = Activity.get_by_id(activity_three.id)
709
710 activities =
711 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
712
713 assert Enum.member?(activities, activity_two)
714 refute Enum.member?(activities, activity_three)
715 refute Enum.member?(activities, boost_activity)
716 assert Enum.member?(activities, activity_one)
717
718 activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})
719
720 assert Enum.member?(activities, activity_two)
721 assert Enum.member?(activities, activity_three)
722 assert Enum.member?(activities, boost_activity)
723 assert Enum.member?(activities, activity_one)
724 end
725
726 test "doesn't return thread muted activities" do
727 user = insert(:user)
728 _activity_one = insert(:note_activity)
729 note_two = insert(:note, data: %{"context" => "suya.."})
730 activity_two = insert(:note_activity, note: note_two)
731
732 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
733
734 assert [_activity_one] = ActivityPub.fetch_activities([], %{"muting_user" => user})
735 end
736
737 test "returns thread muted activities when with_muted is set" do
738 user = insert(:user)
739 _activity_one = insert(:note_activity)
740 note_two = insert(:note, data: %{"context" => "suya.."})
741 activity_two = insert(:note_activity, note: note_two)
742
743 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
744
745 assert [_activity_two, _activity_one] =
746 ActivityPub.fetch_activities([], %{"muting_user" => user, "with_muted" => true})
747 end
748
749 test "does include announces on request" do
750 activity_three = insert(:note_activity)
751 user = insert(:user)
752 booster = insert(:user)
753
754 {:ok, user} = User.follow(user, booster)
755
756 {:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)
757
758 [announce_activity] = ActivityPub.fetch_activities([user.ap_id | User.following(user)])
759
760 assert announce_activity.id == announce.id
761 end
762
763 test "excludes reblogs on request" do
764 user = insert(:user)
765 {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
766 {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
767
768 [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
769
770 assert activity == expected_activity
771 end
772
773 describe "public fetch activities" do
774 test "doesn't retrieve unlisted activities" do
775 user = insert(:user)
776
777 {:ok, _unlisted_activity} =
778 CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
779
780 {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
781
782 [activity] = ActivityPub.fetch_public_activities()
783
784 assert activity == listed_activity
785 end
786
787 test "retrieves public activities" do
788 _activities = ActivityPub.fetch_public_activities()
789
790 %{public: public} = ActivityBuilder.public_and_non_public()
791
792 activities = ActivityPub.fetch_public_activities()
793 assert length(activities) == 1
794 assert Enum.at(activities, 0) == public
795 end
796
797 test "retrieves a maximum of 20 activities" do
798 ActivityBuilder.insert_list(10)
799 expected_activities = ActivityBuilder.insert_list(20)
800
801 activities = ActivityPub.fetch_public_activities()
802
803 assert collect_ids(activities) == collect_ids(expected_activities)
804 assert length(activities) == 20
805 end
806
807 test "retrieves ids starting from a since_id" do
808 activities = ActivityBuilder.insert_list(30)
809 expected_activities = ActivityBuilder.insert_list(10)
810 since_id = List.last(activities).id
811
812 activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
813
814 assert collect_ids(activities) == collect_ids(expected_activities)
815 assert length(activities) == 10
816 end
817
818 test "retrieves ids up to max_id" do
819 ActivityBuilder.insert_list(10)
820 expected_activities = ActivityBuilder.insert_list(20)
821
822 %{id: max_id} =
823 10
824 |> ActivityBuilder.insert_list()
825 |> List.first()
826
827 activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
828
829 assert length(activities) == 20
830 assert collect_ids(activities) == collect_ids(expected_activities)
831 end
832
833 test "paginates via offset/limit" do
834 _first_part_activities = ActivityBuilder.insert_list(10)
835 second_part_activities = ActivityBuilder.insert_list(10)
836
837 later_activities = ActivityBuilder.insert_list(10)
838
839 activities =
840 ActivityPub.fetch_public_activities(%{"page" => "2", "page_size" => "20"}, :offset)
841
842 assert length(activities) == 20
843
844 assert collect_ids(activities) ==
845 collect_ids(second_part_activities) ++ collect_ids(later_activities)
846 end
847
848 test "doesn't return reblogs for users for whom reblogs have been muted" do
849 activity = insert(:note_activity)
850 user = insert(:user)
851 booster = insert(:user)
852 {:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
853
854 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
855
856 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
857
858 refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
859 end
860
861 test "returns reblogs for users for whom reblogs have not been muted" do
862 activity = insert(:note_activity)
863 user = insert(:user)
864 booster = insert(:user)
865 {:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
866 {:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)
867
868 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
869
870 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
871
872 assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
873 end
874 end
875
876 describe "react to an object" do
877 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
878 Config.put([:instance, :federating], true)
879 user = insert(:user)
880 reactor = insert(:user)
881 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
882 assert object = Object.normalize(activity)
883
884 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
885
886 assert called(Federator.publish(reaction_activity))
887 end
888
889 test "adds an emoji reaction activity to the db" do
890 user = insert(:user)
891 reactor = insert(:user)
892 third_user = insert(:user)
893 fourth_user = insert(:user)
894 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
895 assert object = Object.normalize(activity)
896
897 {:ok, reaction_activity, object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
898
899 assert reaction_activity
900
901 assert reaction_activity.data["actor"] == reactor.ap_id
902 assert reaction_activity.data["type"] == "EmojiReact"
903 assert reaction_activity.data["content"] == "🔥"
904 assert reaction_activity.data["object"] == object.data["id"]
905 assert reaction_activity.data["to"] == [User.ap_followers(reactor), activity.data["actor"]]
906 assert reaction_activity.data["context"] == object.data["context"]
907 assert object.data["reaction_count"] == 1
908 assert object.data["reactions"] == [["🔥", [reactor.ap_id]]]
909
910 {:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(third_user, object, "☕")
911
912 assert object.data["reaction_count"] == 2
913 assert object.data["reactions"] == [["🔥", [reactor.ap_id]], ["☕", [third_user.ap_id]]]
914
915 {:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(fourth_user, object, "🔥")
916
917 assert object.data["reaction_count"] == 3
918
919 assert object.data["reactions"] == [
920 ["🔥", [fourth_user.ap_id, reactor.ap_id]],
921 ["☕", [third_user.ap_id]]
922 ]
923 end
924
925 test "reverts emoji reaction on error" do
926 [user, reactor] = insert_list(2, :user)
927
928 {:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
929 object = Object.normalize(activity)
930
931 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
932 assert {:error, :reverted} = ActivityPub.react_with_emoji(reactor, object, "😀")
933 end
934
935 object = Object.get_by_ap_id(object.data["id"])
936 refute object.data["reaction_count"]
937 refute object.data["reactions"]
938 end
939 end
940
941 describe "unreacting to an object" do
942 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
943 Config.put([:instance, :federating], true)
944 user = insert(:user)
945 reactor = insert(:user)
946 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
947 assert object = Object.normalize(activity)
948
949 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
950
951 assert called(Federator.publish(reaction_activity))
952
953 {:ok, unreaction_activity, _object} =
954 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
955
956 assert called(Federator.publish(unreaction_activity))
957 end
958
959 test "adds an undo activity to the db" do
960 user = insert(:user)
961 reactor = insert(:user)
962 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
963 assert object = Object.normalize(activity)
964
965 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
966
967 {:ok, unreaction_activity, _object} =
968 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
969
970 assert unreaction_activity.actor == reactor.ap_id
971 assert unreaction_activity.data["object"] == reaction_activity.data["id"]
972
973 object = Object.get_by_ap_id(object.data["id"])
974 assert object.data["reaction_count"] == 0
975 assert object.data["reactions"] == []
976 end
977
978 test "reverts emoji unreact on error" do
979 [user, reactor] = insert_list(2, :user)
980 {:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
981 object = Object.normalize(activity)
982
983 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "😀")
984
985 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
986 assert {:error, :reverted} =
987 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
988 end
989
990 object = Object.get_by_ap_id(object.data["id"])
991
992 assert object.data["reaction_count"] == 1
993 assert object.data["reactions"] == [["😀", [reactor.ap_id]]]
994 end
995 end
996
997 describe "unliking" do
998 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
999 Config.put([:instance, :federating], true)
1000
1001 note_activity = insert(:note_activity)
1002 object = Object.normalize(note_activity)
1003 user = insert(:user)
1004
1005 {:ok, object} = ActivityPub.unlike(user, object)
1006 refute called(Federator.publish())
1007
1008 {:ok, _like_activity} = CommonAPI.favorite(user, note_activity.id)
1009 object = Object.get_by_id(object.id)
1010 assert object.data["like_count"] == 1
1011
1012 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1013 assert object.data["like_count"] == 0
1014
1015 assert called(Federator.publish(unlike_activity))
1016 end
1017
1018 test "reverts unliking on error" do
1019 note_activity = insert(:note_activity)
1020 user = insert(:user)
1021
1022 {:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)
1023 object = Object.normalize(note_activity)
1024 assert object.data["like_count"] == 1
1025
1026 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1027 assert {:error, :reverted} = ActivityPub.unlike(user, object)
1028 end
1029
1030 assert Object.get_by_ap_id(object.data["id"]) == object
1031 assert object.data["like_count"] == 1
1032 assert Activity.get_by_id(like_activity.id)
1033 end
1034
1035 test "unliking a previously liked object" do
1036 note_activity = insert(:note_activity)
1037 object = Object.normalize(note_activity)
1038 user = insert(:user)
1039
1040 # Unliking something that hasn't been liked does nothing
1041 {:ok, object} = ActivityPub.unlike(user, object)
1042 assert object.data["like_count"] == 0
1043
1044 {:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)
1045
1046 object = Object.get_by_id(object.id)
1047 assert object.data["like_count"] == 1
1048
1049 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1050 assert object.data["like_count"] == 0
1051
1052 assert Activity.get_by_id(like_activity.id) == nil
1053 assert note_activity.actor in unlike_activity.recipients
1054 end
1055 end
1056
1057 describe "announcing an object" do
1058 test "adds an announce activity to the db" do
1059 note_activity = insert(:note_activity)
1060 object = Object.normalize(note_activity)
1061 user = insert(:user)
1062
1063 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1064 assert object.data["announcement_count"] == 1
1065 assert object.data["announcements"] == [user.ap_id]
1066
1067 assert announce_activity.data["to"] == [
1068 User.ap_followers(user),
1069 note_activity.data["actor"]
1070 ]
1071
1072 assert announce_activity.data["object"] == object.data["id"]
1073 assert announce_activity.data["actor"] == user.ap_id
1074 assert announce_activity.data["context"] == object.data["context"]
1075 end
1076
1077 test "reverts annouce from object on error" do
1078 note_activity = insert(:note_activity)
1079 object = Object.normalize(note_activity)
1080 user = insert(:user)
1081
1082 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1083 assert {:error, :reverted} = ActivityPub.announce(user, object)
1084 end
1085
1086 reloaded_object = Object.get_by_ap_id(object.data["id"])
1087 assert reloaded_object == object
1088 refute reloaded_object.data["announcement_count"]
1089 refute reloaded_object.data["announcements"]
1090 end
1091 end
1092
1093 describe "announcing a private object" do
1094 test "adds an announce activity to the db if the audience is not widened" do
1095 user = insert(:user)
1096 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1097 object = Object.normalize(note_activity)
1098
1099 {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
1100
1101 assert announce_activity.data["to"] == [User.ap_followers(user)]
1102
1103 assert announce_activity.data["object"] == object.data["id"]
1104 assert announce_activity.data["actor"] == user.ap_id
1105 assert announce_activity.data["context"] == object.data["context"]
1106 end
1107
1108 test "does not add an announce activity to the db if the audience is widened" do
1109 user = insert(:user)
1110 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1111 object = Object.normalize(note_activity)
1112
1113 assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
1114 end
1115
1116 test "does not add an announce activity to the db if the announcer is not the author" do
1117 user = insert(:user)
1118 announcer = insert(:user)
1119 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1120 object = Object.normalize(note_activity)
1121
1122 assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
1123 end
1124 end
1125
1126 describe "unannouncing an object" do
1127 test "unannouncing a previously announced object" do
1128 note_activity = insert(:note_activity)
1129 object = Object.normalize(note_activity)
1130 user = insert(:user)
1131
1132 # Unannouncing an object that is not announced does nothing
1133 {:ok, object} = ActivityPub.unannounce(user, object)
1134 refute object.data["announcement_count"]
1135
1136 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1137 assert object.data["announcement_count"] == 1
1138
1139 {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
1140 assert object.data["announcement_count"] == 0
1141
1142 assert unannounce_activity.data["to"] == [
1143 User.ap_followers(user),
1144 object.data["actor"]
1145 ]
1146
1147 assert unannounce_activity.data["type"] == "Undo"
1148 assert unannounce_activity.data["object"] == announce_activity.data
1149 assert unannounce_activity.data["actor"] == user.ap_id
1150 assert unannounce_activity.data["context"] == announce_activity.data["context"]
1151
1152 assert Activity.get_by_id(announce_activity.id) == nil
1153 end
1154
1155 test "reverts unannouncing on error" do
1156 note_activity = insert(:note_activity)
1157 object = Object.normalize(note_activity)
1158 user = insert(:user)
1159
1160 {:ok, _announce_activity, object} = ActivityPub.announce(user, object)
1161 assert object.data["announcement_count"] == 1
1162
1163 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1164 assert {:error, :reverted} = ActivityPub.unannounce(user, object)
1165 end
1166
1167 object = Object.get_by_ap_id(object.data["id"])
1168 assert object.data["announcement_count"] == 1
1169 end
1170 end
1171
1172 describe "uploading files" do
1173 test "copies the file to the configured folder" do
1174 file = %Plug.Upload{
1175 content_type: "image/jpg",
1176 path: Path.absname("test/fixtures/image.jpg"),
1177 filename: "an_image.jpg"
1178 }
1179
1180 {:ok, %Object{} = object} = ActivityPub.upload(file)
1181 assert object.data["name"] == "an_image.jpg"
1182 end
1183
1184 test "works with base64 encoded images" do
1185 file = %{
1186 "img" => data_uri()
1187 }
1188
1189 {:ok, %Object{}} = ActivityPub.upload(file)
1190 end
1191 end
1192
1193 describe "fetch the latest Follow" do
1194 test "fetches the latest Follow activity" do
1195 %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
1196 follower = Repo.get_by(User, ap_id: activity.data["actor"])
1197 followed = Repo.get_by(User, ap_id: activity.data["object"])
1198
1199 assert activity == Utils.fetch_latest_follow(follower, followed)
1200 end
1201 end
1202
1203 describe "following / unfollowing" do
1204 test "it reverts follow activity" do
1205 follower = insert(:user)
1206 followed = insert(:user)
1207
1208 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1209 assert {:error, :reverted} = ActivityPub.follow(follower, followed)
1210 end
1211
1212 assert Repo.aggregate(Activity, :count, :id) == 0
1213 assert Repo.aggregate(Object, :count, :id) == 0
1214 end
1215
1216 test "it reverts unfollow activity" do
1217 follower = insert(:user)
1218 followed = insert(:user)
1219
1220 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1221
1222 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1223 assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
1224 end
1225
1226 activity = Activity.get_by_id(follow_activity.id)
1227 assert activity.data["type"] == "Follow"
1228 assert activity.data["actor"] == follower.ap_id
1229
1230 assert activity.data["object"] == followed.ap_id
1231 end
1232
1233 test "creates a follow activity" do
1234 follower = insert(:user)
1235 followed = insert(:user)
1236
1237 {:ok, activity} = ActivityPub.follow(follower, followed)
1238 assert activity.data["type"] == "Follow"
1239 assert activity.data["actor"] == follower.ap_id
1240 assert activity.data["object"] == followed.ap_id
1241 end
1242
1243 test "creates an undo activity for the last follow" do
1244 follower = insert(:user)
1245 followed = insert(:user)
1246
1247 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1248 {:ok, activity} = ActivityPub.unfollow(follower, followed)
1249
1250 assert activity.data["type"] == "Undo"
1251 assert activity.data["actor"] == follower.ap_id
1252
1253 embedded_object = activity.data["object"]
1254 assert is_map(embedded_object)
1255 assert embedded_object["type"] == "Follow"
1256 assert embedded_object["object"] == followed.ap_id
1257 assert embedded_object["id"] == follow_activity.data["id"]
1258 end
1259
1260 test "creates an undo activity for a pending follow request" do
1261 follower = insert(:user)
1262 followed = insert(:user, %{locked: true})
1263
1264 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1265 {:ok, activity} = ActivityPub.unfollow(follower, followed)
1266
1267 assert activity.data["type"] == "Undo"
1268 assert activity.data["actor"] == follower.ap_id
1269
1270 embedded_object = activity.data["object"]
1271 assert is_map(embedded_object)
1272 assert embedded_object["type"] == "Follow"
1273 assert embedded_object["object"] == followed.ap_id
1274 assert embedded_object["id"] == follow_activity.data["id"]
1275 end
1276 end
1277
1278 describe "blocking / unblocking" do
1279 test "reverts block activity on error" do
1280 [blocker, blocked] = insert_list(2, :user)
1281
1282 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1283 assert {:error, :reverted} = ActivityPub.block(blocker, blocked)
1284 end
1285
1286 assert Repo.aggregate(Activity, :count, :id) == 0
1287 assert Repo.aggregate(Object, :count, :id) == 0
1288 end
1289
1290 test "creates a block activity" do
1291 blocker = insert(:user)
1292 blocked = insert(:user)
1293
1294 {:ok, activity} = ActivityPub.block(blocker, blocked)
1295
1296 assert activity.data["type"] == "Block"
1297 assert activity.data["actor"] == blocker.ap_id
1298 assert activity.data["object"] == blocked.ap_id
1299 end
1300
1301 test "reverts unblock activity on error" do
1302 [blocker, blocked] = insert_list(2, :user)
1303 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1304
1305 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1306 assert {:error, :reverted} = ActivityPub.unblock(blocker, blocked)
1307 end
1308
1309 assert block_activity.data["type"] == "Block"
1310 assert block_activity.data["actor"] == blocker.ap_id
1311
1312 assert Repo.aggregate(Activity, :count, :id) == 1
1313 assert Repo.aggregate(Object, :count, :id) == 1
1314 end
1315
1316 test "creates an undo activity for the last block" do
1317 blocker = insert(:user)
1318 blocked = insert(:user)
1319
1320 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1321 {:ok, activity} = ActivityPub.unblock(blocker, blocked)
1322
1323 assert activity.data["type"] == "Undo"
1324 assert activity.data["actor"] == blocker.ap_id
1325
1326 embedded_object = activity.data["object"]
1327 assert is_map(embedded_object)
1328 assert embedded_object["type"] == "Block"
1329 assert embedded_object["object"] == blocked.ap_id
1330 assert embedded_object["id"] == block_activity.data["id"]
1331 end
1332 end
1333
1334 describe "deletion" do
1335 setup do: clear_config([:instance, :rewrite_policy])
1336
1337 test "it reverts deletion on error" do
1338 note = insert(:note_activity)
1339 object = Object.normalize(note)
1340
1341 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1342 assert {:error, :reverted} = ActivityPub.delete(object)
1343 end
1344
1345 assert Repo.aggregate(Activity, :count, :id) == 1
1346 assert Repo.get(Object, object.id) == object
1347 assert Activity.get_by_id(note.id) == note
1348 end
1349
1350 test "it creates a delete activity and deletes the original object" do
1351 note = insert(:note_activity)
1352 object = Object.normalize(note)
1353 {:ok, delete} = ActivityPub.delete(object)
1354
1355 assert delete.data["type"] == "Delete"
1356 assert delete.data["actor"] == note.data["actor"]
1357 assert delete.data["object"] == object.data["id"]
1358
1359 assert Activity.get_by_id(delete.id) != nil
1360
1361 assert Repo.get(Object, object.id).data["type"] == "Tombstone"
1362 end
1363
1364 test "it doesn't fail when an activity was already deleted" do
1365 {:ok, delete} = insert(:note_activity) |> Object.normalize() |> ActivityPub.delete()
1366
1367 assert {:ok, ^delete} = delete |> Object.normalize() |> ActivityPub.delete()
1368 end
1369
1370 test "decrements user note count only for public activities" do
1371 user = insert(:user, note_count: 10)
1372
1373 {:ok, a1} =
1374 CommonAPI.post(User.get_cached_by_id(user.id), %{
1375 "status" => "yeah",
1376 "visibility" => "public"
1377 })
1378
1379 {:ok, a2} =
1380 CommonAPI.post(User.get_cached_by_id(user.id), %{
1381 "status" => "yeah",
1382 "visibility" => "unlisted"
1383 })
1384
1385 {:ok, a3} =
1386 CommonAPI.post(User.get_cached_by_id(user.id), %{
1387 "status" => "yeah",
1388 "visibility" => "private"
1389 })
1390
1391 {:ok, a4} =
1392 CommonAPI.post(User.get_cached_by_id(user.id), %{
1393 "status" => "yeah",
1394 "visibility" => "direct"
1395 })
1396
1397 {:ok, _} = Object.normalize(a1) |> ActivityPub.delete()
1398 {:ok, _} = Object.normalize(a2) |> ActivityPub.delete()
1399 {:ok, _} = Object.normalize(a3) |> ActivityPub.delete()
1400 {:ok, _} = Object.normalize(a4) |> ActivityPub.delete()
1401
1402 user = User.get_cached_by_id(user.id)
1403 assert user.note_count == 10
1404 end
1405
1406 test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
1407 user = insert(:user)
1408 note = insert(:note_activity)
1409 object = Object.normalize(note)
1410
1411 {:ok, object} =
1412 object
1413 |> Object.change(%{
1414 data: %{
1415 "actor" => object.data["actor"],
1416 "id" => object.data["id"],
1417 "to" => [user.ap_id],
1418 "type" => "Note"
1419 }
1420 })
1421 |> Object.update_and_set_cache()
1422
1423 {:ok, delete} = ActivityPub.delete(object)
1424
1425 assert user.ap_id in delete.data["to"]
1426 end
1427
1428 test "decreases reply count" do
1429 user = insert(:user)
1430 user2 = insert(:user)
1431
1432 {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
1433 reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
1434 ap_id = activity.data["id"]
1435
1436 {:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
1437 {:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
1438 {:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
1439 {:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
1440
1441 _ = CommonAPI.delete(direct_reply.id, user2)
1442 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1443 assert object.data["repliesCount"] == 2
1444
1445 _ = CommonAPI.delete(private_reply.id, user2)
1446 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1447 assert object.data["repliesCount"] == 2
1448
1449 _ = CommonAPI.delete(public_reply.id, user2)
1450 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1451 assert object.data["repliesCount"] == 1
1452
1453 _ = CommonAPI.delete(unlisted_reply.id, user2)
1454 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1455 assert object.data["repliesCount"] == 0
1456 end
1457
1458 test "it passes delete activity through MRF before deleting the object" do
1459 Pleroma.Config.put([:instance, :rewrite_policy], Pleroma.Web.ActivityPub.MRF.DropPolicy)
1460
1461 note = insert(:note_activity)
1462 object = Object.normalize(note)
1463
1464 {:error, {:reject, _}} = ActivityPub.delete(object)
1465
1466 assert Activity.get_by_id(note.id)
1467 assert Repo.get(Object, object.id).data["type"] == object.data["type"]
1468 end
1469 end
1470
1471 describe "timeline post-processing" do
1472 test "it filters broken threads" do
1473 user1 = insert(:user)
1474 user2 = insert(:user)
1475 user3 = insert(:user)
1476
1477 {:ok, user1} = User.follow(user1, user3)
1478 assert User.following?(user1, user3)
1479
1480 {:ok, user2} = User.follow(user2, user3)
1481 assert User.following?(user2, user3)
1482
1483 {:ok, user3} = User.follow(user3, user2)
1484 assert User.following?(user3, user2)
1485
1486 {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
1487
1488 {:ok, private_activity_1} =
1489 CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
1490
1491 {:ok, private_activity_2} =
1492 CommonAPI.post(user2, %{
1493 "status" => "hi 3",
1494 "visibility" => "private",
1495 "in_reply_to_status_id" => private_activity_1.id
1496 })
1497
1498 {:ok, private_activity_3} =
1499 CommonAPI.post(user3, %{
1500 "status" => "hi 4",
1501 "visibility" => "private",
1502 "in_reply_to_status_id" => private_activity_2.id
1503 })
1504
1505 activities =
1506 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)])
1507 |> Enum.map(fn a -> a.id end)
1508
1509 private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
1510
1511 assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
1512
1513 assert length(activities) == 3
1514
1515 activities =
1516 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)], %{"user" => user1})
1517 |> Enum.map(fn a -> a.id end)
1518
1519 assert [public_activity.id, private_activity_1.id] == activities
1520 assert length(activities) == 2
1521 end
1522 end
1523
1524 describe "update" do
1525 setup do: clear_config([:instance, :max_pinned_statuses])
1526
1527 test "it creates an update activity with the new user data" do
1528 user = insert(:user)
1529 {:ok, user} = User.ensure_keys_present(user)
1530 user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1531
1532 {:ok, update} =
1533 ActivityPub.update(%{
1534 actor: user_data["id"],
1535 to: [user.follower_address],
1536 cc: [],
1537 object: user_data
1538 })
1539
1540 assert update.data["actor"] == user.ap_id
1541 assert update.data["to"] == [user.follower_address]
1542 assert embedded_object = update.data["object"]
1543 assert embedded_object["id"] == user_data["id"]
1544 assert embedded_object["type"] == user_data["type"]
1545 end
1546 end
1547
1548 test "returned pinned statuses" do
1549 Config.put([:instance, :max_pinned_statuses], 3)
1550 user = insert(:user)
1551
1552 {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1553 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1554 {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1555
1556 CommonAPI.pin(activity_one.id, user)
1557 user = refresh_record(user)
1558
1559 CommonAPI.pin(activity_two.id, user)
1560 user = refresh_record(user)
1561
1562 CommonAPI.pin(activity_three.id, user)
1563 user = refresh_record(user)
1564
1565 activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1566
1567 assert 3 = length(activities)
1568 end
1569
1570 describe "flag/1" do
1571 setup do
1572 reporter = insert(:user)
1573 target_account = insert(:user)
1574 content = "foobar"
1575 {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
1576 context = Utils.generate_context_id()
1577
1578 reporter_ap_id = reporter.ap_id
1579 target_ap_id = target_account.ap_id
1580 activity_ap_id = activity.data["id"]
1581
1582 activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)
1583
1584 {:ok,
1585 %{
1586 reporter: reporter,
1587 context: context,
1588 target_account: target_account,
1589 reported_activity: activity,
1590 content: content,
1591 activity_ap_id: activity_ap_id,
1592 activity_with_object: activity_with_object,
1593 reporter_ap_id: reporter_ap_id,
1594 target_ap_id: target_ap_id
1595 }}
1596 end
1597
1598 test "it can create a Flag activity",
1599 %{
1600 reporter: reporter,
1601 context: context,
1602 target_account: target_account,
1603 reported_activity: reported_activity,
1604 content: content,
1605 activity_ap_id: activity_ap_id,
1606 activity_with_object: activity_with_object,
1607 reporter_ap_id: reporter_ap_id,
1608 target_ap_id: target_ap_id
1609 } do
1610 assert {:ok, activity} =
1611 ActivityPub.flag(%{
1612 actor: reporter,
1613 context: context,
1614 account: target_account,
1615 statuses: [reported_activity],
1616 content: content
1617 })
1618
1619 note_obj = %{
1620 "type" => "Note",
1621 "id" => activity_ap_id,
1622 "content" => content,
1623 "published" => activity_with_object.object.data["published"],
1624 "actor" => AccountView.render("show.json", %{user: target_account})
1625 }
1626
1627 assert %Activity{
1628 actor: ^reporter_ap_id,
1629 data: %{
1630 "type" => "Flag",
1631 "content" => ^content,
1632 "context" => ^context,
1633 "object" => [^target_ap_id, ^note_obj]
1634 }
1635 } = activity
1636 end
1637
1638 test_with_mock "strips status data from Flag, before federating it",
1639 %{
1640 reporter: reporter,
1641 context: context,
1642 target_account: target_account,
1643 reported_activity: reported_activity,
1644 content: content
1645 },
1646 Utils,
1647 [:passthrough],
1648 [] do
1649 {:ok, activity} =
1650 ActivityPub.flag(%{
1651 actor: reporter,
1652 context: context,
1653 account: target_account,
1654 statuses: [reported_activity],
1655 content: content
1656 })
1657
1658 new_data =
1659 put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])
1660
1661 assert_called(Utils.maybe_federate(%{activity | data: new_data}))
1662 end
1663 end
1664
1665 test "fetch_activities/2 returns activities addressed to a list " do
1666 user = insert(:user)
1667 member = insert(:user)
1668 {:ok, list} = Pleroma.List.create("foo", user)
1669 {:ok, list} = Pleroma.List.follow(list, member)
1670
1671 {:ok, activity} =
1672 CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1673
1674 activity = Repo.preload(activity, :bookmark)
1675 activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
1676
1677 assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
1678 end
1679
1680 def data_uri do
1681 File.read!("test/fixtures/avatar_data_uri")
1682 end
1683
1684 describe "fetch_activities_bounded" do
1685 test "fetches private posts for followed users" do
1686 user = insert(:user)
1687
1688 {:ok, activity} =
1689 CommonAPI.post(user, %{
1690 "status" => "thought I looked cute might delete later :3",
1691 "visibility" => "private"
1692 })
1693
1694 [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1695 assert result.id == activity.id
1696 end
1697
1698 test "fetches only public posts for other users" do
1699 user = insert(:user)
1700 {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1701
1702 {:ok, _private_activity} =
1703 CommonAPI.post(user, %{
1704 "status" => "why is tenshi eating a corndog so cute?",
1705 "visibility" => "private"
1706 })
1707
1708 [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1709 assert result.id == activity.id
1710 end
1711 end
1712
1713 describe "fetch_follow_information_for_user" do
1714 test "syncronizes following/followers counters" do
1715 user =
1716 insert(:user,
1717 local: false,
1718 follower_address: "http://localhost:4001/users/fuser2/followers",
1719 following_address: "http://localhost:4001/users/fuser2/following"
1720 )
1721
1722 {:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
1723 assert info.follower_count == 527
1724 assert info.following_count == 267
1725 end
1726
1727 test "detects hidden followers" do
1728 mock(fn env ->
1729 case env.url do
1730 "http://localhost:4001/users/masto_closed/followers?page=1" ->
1731 %Tesla.Env{status: 403, body: ""}
1732
1733 _ ->
1734 apply(HttpRequestMock, :request, [env])
1735 end
1736 end)
1737
1738 user =
1739 insert(:user,
1740 local: false,
1741 follower_address: "http://localhost:4001/users/masto_closed/followers",
1742 following_address: "http://localhost:4001/users/masto_closed/following"
1743 )
1744
1745 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1746 assert follow_info.hide_followers == true
1747 assert follow_info.hide_follows == false
1748 end
1749
1750 test "detects hidden follows" do
1751 mock(fn env ->
1752 case env.url do
1753 "http://localhost:4001/users/masto_closed/following?page=1" ->
1754 %Tesla.Env{status: 403, body: ""}
1755
1756 _ ->
1757 apply(HttpRequestMock, :request, [env])
1758 end
1759 end)
1760
1761 user =
1762 insert(:user,
1763 local: false,
1764 follower_address: "http://localhost:4001/users/masto_closed/followers",
1765 following_address: "http://localhost:4001/users/masto_closed/following"
1766 )
1767
1768 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1769 assert follow_info.hide_followers == false
1770 assert follow_info.hide_follows == true
1771 end
1772
1773 test "detects hidden follows/followers for friendica" do
1774 user =
1775 insert(:user,
1776 local: false,
1777 follower_address: "http://localhost:8080/followers/fuser3",
1778 following_address: "http://localhost:8080/following/fuser3"
1779 )
1780
1781 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1782 assert follow_info.hide_followers == true
1783 assert follow_info.follower_count == 296
1784 assert follow_info.following_count == 32
1785 assert follow_info.hide_follows == true
1786 end
1787
1788 test "doesn't crash when follower and following counters are hidden" do
1789 mock(fn env ->
1790 case env.url do
1791 "http://localhost:4001/users/masto_hidden_counters/following" ->
1792 json(%{
1793 "@context" => "https://www.w3.org/ns/activitystreams",
1794 "id" => "http://localhost:4001/users/masto_hidden_counters/followers"
1795 })
1796
1797 "http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
1798 %Tesla.Env{status: 403, body: ""}
1799
1800 "http://localhost:4001/users/masto_hidden_counters/followers" ->
1801 json(%{
1802 "@context" => "https://www.w3.org/ns/activitystreams",
1803 "id" => "http://localhost:4001/users/masto_hidden_counters/following"
1804 })
1805
1806 "http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
1807 %Tesla.Env{status: 403, body: ""}
1808 end
1809 end)
1810
1811 user =
1812 insert(:user,
1813 local: false,
1814 follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
1815 following_address: "http://localhost:4001/users/masto_hidden_counters/following"
1816 )
1817
1818 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1819
1820 assert follow_info.hide_followers == true
1821 assert follow_info.follower_count == 0
1822 assert follow_info.hide_follows == true
1823 assert follow_info.following_count == 0
1824 end
1825 end
1826
1827 describe "fetch_favourites/3" do
1828 test "returns a favourite activities sorted by adds to favorite" do
1829 user = insert(:user)
1830 other_user = insert(:user)
1831 user1 = insert(:user)
1832 user2 = insert(:user)
1833 {:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
1834 {:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
1835 {:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
1836 {:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
1837 {:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})
1838
1839 {:ok, _} = CommonAPI.favorite(user, a4.id)
1840 {:ok, _} = CommonAPI.favorite(other_user, a3.id)
1841 {:ok, _} = CommonAPI.favorite(user, a3.id)
1842 {:ok, _} = CommonAPI.favorite(other_user, a5.id)
1843 {:ok, _} = CommonAPI.favorite(user, a5.id)
1844 {:ok, _} = CommonAPI.favorite(other_user, a4.id)
1845 {:ok, _} = CommonAPI.favorite(user, a1.id)
1846 {:ok, _} = CommonAPI.favorite(other_user, a1.id)
1847 result = ActivityPub.fetch_favourites(user)
1848
1849 assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]
1850
1851 result = ActivityPub.fetch_favourites(user, %{"limit" => 2})
1852 assert Enum.map(result, & &1.id) == [a1.id, a5.id]
1853 end
1854 end
1855
1856 describe "Move activity" do
1857 test "create" do
1858 %{ap_id: old_ap_id} = old_user = insert(:user)
1859 %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
1860 follower = insert(:user)
1861 follower_move_opted_out = insert(:user, allow_following_move: false)
1862
1863 User.follow(follower, old_user)
1864 User.follow(follower_move_opted_out, old_user)
1865
1866 assert User.following?(follower, old_user)
1867 assert User.following?(follower_move_opted_out, old_user)
1868
1869 assert {:ok, activity} = ActivityPub.move(old_user, new_user)
1870
1871 assert %Activity{
1872 actor: ^old_ap_id,
1873 data: %{
1874 "actor" => ^old_ap_id,
1875 "object" => ^old_ap_id,
1876 "target" => ^new_ap_id,
1877 "type" => "Move"
1878 },
1879 local: true
1880 } = activity
1881
1882 params = %{
1883 "op" => "move_following",
1884 "origin_id" => old_user.id,
1885 "target_id" => new_user.id
1886 }
1887
1888 assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
1889
1890 Pleroma.Workers.BackgroundWorker.perform(params, nil)
1891
1892 refute User.following?(follower, old_user)
1893 assert User.following?(follower, new_user)
1894
1895 assert User.following?(follower_move_opted_out, old_user)
1896 refute User.following?(follower_move_opted_out, new_user)
1897
1898 activity = %Activity{activity | object: nil}
1899
1900 assert [%Notification{activity: ^activity}] = Notification.for_user(follower)
1901
1902 assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
1903 end
1904
1905 test "old user must be in the new user's `also_known_as` list" do
1906 old_user = insert(:user)
1907 new_user = insert(:user)
1908
1909 assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
1910 ActivityPub.move(old_user, new_user)
1911 end
1912 end
1913
1914 test "doesn't retrieve replies activities with exclude_replies" do
1915 user = insert(:user)
1916
1917 {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
1918
1919 {:ok, _reply} =
1920 CommonAPI.post(user, %{"status" => "yeah", "in_reply_to_status_id" => activity.id})
1921
1922 [result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"})
1923
1924 assert result.id == activity.id
1925
1926 assert length(ActivityPub.fetch_public_activities()) == 2
1927 end
1928
1929 describe "replies filtering with public messages" do
1930 setup :public_messages
1931
1932 test "public timeline", %{users: %{u1: user}} do
1933 activities_ids =
1934 %{}
1935 |> Map.put("type", ["Create", "Announce"])
1936 |> Map.put("local_only", false)
1937 |> Map.put("blocking_user", user)
1938 |> Map.put("muting_user", user)
1939 |> Map.put("reply_filtering_user", user)
1940 |> ActivityPub.fetch_public_activities()
1941 |> Enum.map(& &1.id)
1942
1943 assert length(activities_ids) == 16
1944 end
1945
1946 test "public timeline with reply_visibility `following`", %{
1947 users: %{u1: user},
1948 u1: u1,
1949 u2: u2,
1950 u3: u3,
1951 u4: u4,
1952 activities: activities
1953 } do
1954 activities_ids =
1955 %{}
1956 |> Map.put("type", ["Create", "Announce"])
1957 |> Map.put("local_only", false)
1958 |> Map.put("blocking_user", user)
1959 |> Map.put("muting_user", user)
1960 |> Map.put("reply_visibility", "following")
1961 |> Map.put("reply_filtering_user", user)
1962 |> ActivityPub.fetch_public_activities()
1963 |> Enum.map(& &1.id)
1964
1965 assert length(activities_ids) == 14
1966
1967 visible_ids =
1968 Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]
1969
1970 assert Enum.all?(visible_ids, &(&1 in activities_ids))
1971 end
1972
1973 test "public timeline with reply_visibility `self`", %{
1974 users: %{u1: user},
1975 u1: u1,
1976 u2: u2,
1977 u3: u3,
1978 u4: u4,
1979 activities: activities
1980 } do
1981 activities_ids =
1982 %{}
1983 |> Map.put("type", ["Create", "Announce"])
1984 |> Map.put("local_only", false)
1985 |> Map.put("blocking_user", user)
1986 |> Map.put("muting_user", user)
1987 |> Map.put("reply_visibility", "self")
1988 |> Map.put("reply_filtering_user", user)
1989 |> ActivityPub.fetch_public_activities()
1990 |> Enum.map(& &1.id)
1991
1992 assert length(activities_ids) == 10
1993 visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
1994 assert Enum.all?(visible_ids, &(&1 in activities_ids))
1995 end
1996
1997 test "home timeline", %{
1998 users: %{u1: user},
1999 activities: activities,
2000 u1: u1,
2001 u2: u2,
2002 u3: u3,
2003 u4: u4
2004 } do
2005 params =
2006 %{}
2007 |> Map.put("type", ["Create", "Announce"])
2008 |> Map.put("blocking_user", user)
2009 |> Map.put("muting_user", user)
2010 |> Map.put("user", user)
2011 |> Map.put("reply_filtering_user", user)
2012
2013 activities_ids =
2014 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2015 |> Enum.map(& &1.id)
2016
2017 assert length(activities_ids) == 13
2018
2019 visible_ids =
2020 Map.values(u1) ++
2021 Map.values(u3) ++
2022 [
2023 activities[:a1],
2024 activities[:a2],
2025 activities[:a4],
2026 u2[:r1],
2027 u2[:r3],
2028 u4[:r1],
2029 u4[:r2]
2030 ]
2031
2032 assert Enum.all?(visible_ids, &(&1 in activities_ids))
2033 end
2034
2035 test "home timeline with reply_visibility `following`", %{
2036 users: %{u1: user},
2037 activities: activities,
2038 u1: u1,
2039 u2: u2,
2040 u3: u3,
2041 u4: u4
2042 } do
2043 params =
2044 %{}
2045 |> Map.put("type", ["Create", "Announce"])
2046 |> Map.put("blocking_user", user)
2047 |> Map.put("muting_user", user)
2048 |> Map.put("user", user)
2049 |> Map.put("reply_visibility", "following")
2050 |> Map.put("reply_filtering_user", user)
2051
2052 activities_ids =
2053 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2054 |> Enum.map(& &1.id)
2055
2056 assert length(activities_ids) == 11
2057
2058 visible_ids =
2059 Map.values(u1) ++
2060 [
2061 activities[:a1],
2062 activities[:a2],
2063 activities[:a4],
2064 u2[:r1],
2065 u2[:r3],
2066 u3[:r1],
2067 u4[:r1],
2068 u4[:r2]
2069 ]
2070
2071 assert Enum.all?(visible_ids, &(&1 in activities_ids))
2072 end
2073
2074 test "home timeline with reply_visibility `self`", %{
2075 users: %{u1: user},
2076 activities: activities,
2077 u1: u1,
2078 u2: u2,
2079 u3: u3,
2080 u4: u4
2081 } do
2082 params =
2083 %{}
2084 |> Map.put("type", ["Create", "Announce"])
2085 |> Map.put("blocking_user", user)
2086 |> Map.put("muting_user", user)
2087 |> Map.put("user", user)
2088 |> Map.put("reply_visibility", "self")
2089 |> Map.put("reply_filtering_user", user)
2090
2091 activities_ids =
2092 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2093 |> Enum.map(& &1.id)
2094
2095 assert length(activities_ids) == 9
2096
2097 visible_ids =
2098 Map.values(u1) ++
2099 [
2100 activities[:a1],
2101 activities[:a2],
2102 activities[:a4],
2103 u2[:r1],
2104 u3[:r1],
2105 u4[:r1]
2106 ]
2107
2108 assert Enum.all?(visible_ids, &(&1 in activities_ids))
2109 end
2110 end
2111
2112 describe "replies filtering with private messages" do
2113 setup :private_messages
2114
2115 test "public timeline", %{users: %{u1: user}} do
2116 activities_ids =
2117 %{}
2118 |> Map.put("type", ["Create", "Announce"])
2119 |> Map.put("local_only", false)
2120 |> Map.put("blocking_user", user)
2121 |> Map.put("muting_user", user)
2122 |> Map.put("user", user)
2123 |> ActivityPub.fetch_public_activities()
2124 |> Enum.map(& &1.id)
2125
2126 assert activities_ids == []
2127 end
2128
2129 test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
2130 activities_ids =
2131 %{}
2132 |> Map.put("type", ["Create", "Announce"])
2133 |> Map.put("local_only", false)
2134 |> Map.put("blocking_user", user)
2135 |> Map.put("muting_user", user)
2136 |> Map.put("reply_visibility", "following")
2137 |> Map.put("reply_filtering_user", user)
2138 |> Map.put("user", user)
2139 |> ActivityPub.fetch_public_activities()
2140 |> Enum.map(& &1.id)
2141
2142 assert activities_ids == []
2143 end
2144
2145 test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
2146 activities_ids =
2147 %{}
2148 |> Map.put("type", ["Create", "Announce"])
2149 |> Map.put("local_only", false)
2150 |> Map.put("blocking_user", user)
2151 |> Map.put("muting_user", user)
2152 |> Map.put("reply_visibility", "self")
2153 |> Map.put("reply_filtering_user", user)
2154 |> Map.put("user", user)
2155 |> ActivityPub.fetch_public_activities()
2156 |> Enum.map(& &1.id)
2157
2158 assert activities_ids == []
2159 end
2160
2161 test "home timeline", %{users: %{u1: user}} do
2162 params =
2163 %{}
2164 |> Map.put("type", ["Create", "Announce"])
2165 |> Map.put("blocking_user", user)
2166 |> Map.put("muting_user", user)
2167 |> Map.put("user", user)
2168
2169 activities_ids =
2170 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2171 |> Enum.map(& &1.id)
2172
2173 assert length(activities_ids) == 12
2174 end
2175
2176 test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
2177 params =
2178 %{}
2179 |> Map.put("type", ["Create", "Announce"])
2180 |> Map.put("blocking_user", user)
2181 |> Map.put("muting_user", user)
2182 |> Map.put("user", user)
2183 |> Map.put("reply_visibility", "following")
2184 |> Map.put("reply_filtering_user", user)
2185
2186 activities_ids =
2187 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2188 |> Enum.map(& &1.id)
2189
2190 assert length(activities_ids) == 12
2191 end
2192
2193 test "home timeline with default reply_visibility `self`", %{
2194 users: %{u1: user},
2195 activities: activities,
2196 u1: u1,
2197 u2: u2,
2198 u3: u3,
2199 u4: u4
2200 } do
2201 params =
2202 %{}
2203 |> Map.put("type", ["Create", "Announce"])
2204 |> Map.put("blocking_user", user)
2205 |> Map.put("muting_user", user)
2206 |> Map.put("user", user)
2207 |> Map.put("reply_visibility", "self")
2208 |> Map.put("reply_filtering_user", user)
2209
2210 activities_ids =
2211 ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2212 |> Enum.map(& &1.id)
2213
2214 assert length(activities_ids) == 10
2215
2216 visible_ids =
2217 Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)
2218
2219 assert Enum.all?(visible_ids, &(&1 in activities_ids))
2220 end
2221 end
2222
2223 defp public_messages(_) do
2224 [u1, u2, u3, u4] = insert_list(4, :user)
2225 {:ok, u1} = User.follow(u1, u2)
2226 {:ok, u2} = User.follow(u2, u1)
2227 {:ok, u1} = User.follow(u1, u4)
2228 {:ok, u4} = User.follow(u4, u1)
2229
2230 {:ok, u2} = User.follow(u2, u3)
2231 {:ok, u3} = User.follow(u3, u2)
2232
2233 {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status"})
2234
2235 {:ok, r1_1} =
2236 CommonAPI.post(u2, %{
2237 "status" => "@#{u1.nickname} reply from u2 to u1",
2238 "in_reply_to_status_id" => a1.id
2239 })
2240
2241 {:ok, r1_2} =
2242 CommonAPI.post(u3, %{
2243 "status" => "@#{u1.nickname} reply from u3 to u1",
2244 "in_reply_to_status_id" => a1.id
2245 })
2246
2247 {:ok, r1_3} =
2248 CommonAPI.post(u4, %{
2249 "status" => "@#{u1.nickname} reply from u4 to u1",
2250 "in_reply_to_status_id" => a1.id
2251 })
2252
2253 {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status"})
2254
2255 {:ok, r2_1} =
2256 CommonAPI.post(u1, %{
2257 "status" => "@#{u2.nickname} reply from u1 to u2",
2258 "in_reply_to_status_id" => a2.id
2259 })
2260
2261 {:ok, r2_2} =
2262 CommonAPI.post(u3, %{
2263 "status" => "@#{u2.nickname} reply from u3 to u2",
2264 "in_reply_to_status_id" => a2.id
2265 })
2266
2267 {:ok, r2_3} =
2268 CommonAPI.post(u4, %{
2269 "status" => "@#{u2.nickname} reply from u4 to u2",
2270 "in_reply_to_status_id" => a2.id
2271 })
2272
2273 {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status"})
2274
2275 {:ok, r3_1} =
2276 CommonAPI.post(u1, %{
2277 "status" => "@#{u3.nickname} reply from u1 to u3",
2278 "in_reply_to_status_id" => a3.id
2279 })
2280
2281 {:ok, r3_2} =
2282 CommonAPI.post(u2, %{
2283 "status" => "@#{u3.nickname} reply from u2 to u3",
2284 "in_reply_to_status_id" => a3.id
2285 })
2286
2287 {:ok, r3_3} =
2288 CommonAPI.post(u4, %{
2289 "status" => "@#{u3.nickname} reply from u4 to u3",
2290 "in_reply_to_status_id" => a3.id
2291 })
2292
2293 {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status"})
2294
2295 {:ok, r4_1} =
2296 CommonAPI.post(u1, %{
2297 "status" => "@#{u4.nickname} reply from u1 to u4",
2298 "in_reply_to_status_id" => a4.id
2299 })
2300
2301 {:ok, r4_2} =
2302 CommonAPI.post(u2, %{
2303 "status" => "@#{u4.nickname} reply from u2 to u4",
2304 "in_reply_to_status_id" => a4.id
2305 })
2306
2307 {:ok, r4_3} =
2308 CommonAPI.post(u3, %{
2309 "status" => "@#{u4.nickname} reply from u3 to u4",
2310 "in_reply_to_status_id" => a4.id
2311 })
2312
2313 {:ok,
2314 users: %{u1: u1, u2: u2, u3: u3, u4: u4},
2315 activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
2316 u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
2317 u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
2318 u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
2319 u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
2320 end
2321
2322 defp private_messages(_) do
2323 [u1, u2, u3, u4] = insert_list(4, :user)
2324 {:ok, u1} = User.follow(u1, u2)
2325 {:ok, u2} = User.follow(u2, u1)
2326 {:ok, u1} = User.follow(u1, u3)
2327 {:ok, u3} = User.follow(u3, u1)
2328 {:ok, u1} = User.follow(u1, u4)
2329 {:ok, u4} = User.follow(u4, u1)
2330
2331 {:ok, u2} = User.follow(u2, u3)
2332 {:ok, u3} = User.follow(u3, u2)
2333
2334 {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status", "visibility" => "private"})
2335
2336 {:ok, r1_1} =
2337 CommonAPI.post(u2, %{
2338 "status" => "@#{u1.nickname} reply from u2 to u1",
2339 "in_reply_to_status_id" => a1.id,
2340 "visibility" => "private"
2341 })
2342
2343 {:ok, r1_2} =
2344 CommonAPI.post(u3, %{
2345 "status" => "@#{u1.nickname} reply from u3 to u1",
2346 "in_reply_to_status_id" => a1.id,
2347 "visibility" => "private"
2348 })
2349
2350 {:ok, r1_3} =
2351 CommonAPI.post(u4, %{
2352 "status" => "@#{u1.nickname} reply from u4 to u1",
2353 "in_reply_to_status_id" => a1.id,
2354 "visibility" => "private"
2355 })
2356
2357 {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status", "visibility" => "private"})
2358
2359 {:ok, r2_1} =
2360 CommonAPI.post(u1, %{
2361 "status" => "@#{u2.nickname} reply from u1 to u2",
2362 "in_reply_to_status_id" => a2.id,
2363 "visibility" => "private"
2364 })
2365
2366 {:ok, r2_2} =
2367 CommonAPI.post(u3, %{
2368 "status" => "@#{u2.nickname} reply from u3 to u2",
2369 "in_reply_to_status_id" => a2.id,
2370 "visibility" => "private"
2371 })
2372
2373 {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status", "visibility" => "private"})
2374
2375 {:ok, r3_1} =
2376 CommonAPI.post(u1, %{
2377 "status" => "@#{u3.nickname} reply from u1 to u3",
2378 "in_reply_to_status_id" => a3.id,
2379 "visibility" => "private"
2380 })
2381
2382 {:ok, r3_2} =
2383 CommonAPI.post(u2, %{
2384 "status" => "@#{u3.nickname} reply from u2 to u3",
2385 "in_reply_to_status_id" => a3.id,
2386 "visibility" => "private"
2387 })
2388
2389 {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status", "visibility" => "private"})
2390
2391 {:ok, r4_1} =
2392 CommonAPI.post(u1, %{
2393 "status" => "@#{u4.nickname} reply from u1 to u4",
2394 "in_reply_to_status_id" => a4.id,
2395 "visibility" => "private"
2396 })
2397
2398 {:ok,
2399 users: %{u1: u1, u2: u2, u3: u3, u4: u4},
2400 activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
2401 u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
2402 u2: %{r1: r2_1.id, r2: r2_2.id},
2403 u3: %{r1: r3_1.id, r2: r3_2.id},
2404 u4: %{r1: r4_1.id}}
2405 end
2406 end