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