1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
7 use Oban.Testing, repo: Pleroma.Repo
10 alias Pleroma.Builders.ActivityBuilder
12 alias Pleroma.Notification
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
21 import Pleroma.Factory
26 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
30 clear_config([:instance, :federating])
32 describe "streaming out participations" do
33 test "it streams them out" do
35 {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
37 {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
40 conversation.participations
41 |> Repo.preload(:user)
43 with_mock Pleroma.Web.Streamer,
44 stream: fn _, _ -> nil end do
45 ActivityPub.stream_out_participations(conversation.participations)
47 assert called(Pleroma.Web.Streamer.stream("participation", participations))
51 test "streams them out on activity creation" do
52 user_one = insert(:user)
53 user_two = insert(:user)
55 with_mock Pleroma.Web.Streamer,
56 stream: fn _, _ -> nil end do
58 CommonAPI.post(user_one, %{
59 "status" => "@#{user_two.nickname}",
60 "visibility" => "direct"
64 activity.data["context"]
65 |> Pleroma.Conversation.get_for_ap_id()
66 |> Repo.preload(participations: :user)
68 assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
73 describe "fetching restricted by visibility" do
74 test "it restricts by the appropriate visibility" do
77 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
79 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
81 {:ok, unlisted_activity} =
82 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
84 {:ok, private_activity} =
85 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
88 ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
90 assert activities == [direct_activity]
93 ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
95 assert activities == [unlisted_activity]
98 ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
100 assert activities == [private_activity]
103 ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
105 assert activities == [public_activity]
108 ActivityPub.fetch_activities([], %{
109 :visibility => ~w[private public],
110 "actor_id" => user.ap_id
113 assert activities == [public_activity, private_activity]
117 describe "fetching excluded by visibility" do
118 test "it excludes by the appropriate visibility" do
121 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
123 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
125 {:ok, unlisted_activity} =
126 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
128 {:ok, private_activity} =
129 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
132 ActivityPub.fetch_activities([], %{
133 "exclude_visibilities" => "direct",
134 "actor_id" => user.ap_id
137 assert public_activity in activities
138 assert unlisted_activity in activities
139 assert private_activity in activities
140 refute direct_activity in activities
143 ActivityPub.fetch_activities([], %{
144 "exclude_visibilities" => "unlisted",
145 "actor_id" => user.ap_id
148 assert public_activity in activities
149 refute unlisted_activity in activities
150 assert private_activity in activities
151 assert direct_activity in activities
154 ActivityPub.fetch_activities([], %{
155 "exclude_visibilities" => "private",
156 "actor_id" => user.ap_id
159 assert public_activity in activities
160 assert unlisted_activity in activities
161 refute private_activity in activities
162 assert direct_activity in activities
165 ActivityPub.fetch_activities([], %{
166 "exclude_visibilities" => "public",
167 "actor_id" => user.ap_id
170 refute public_activity in activities
171 assert unlisted_activity in activities
172 assert private_activity in activities
173 assert direct_activity in activities
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.source_data
184 assert user.ap_enabled
185 assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
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)
194 test "it fetches the appropriate tag-restricted posts" do
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"})
201 fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
204 ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})
207 ActivityPub.fetch_activities([], %{
209 "tag" => ["test", "essais"],
210 "tag_reject" => ["reject"]
214 ActivityPub.fetch_activities([], %{
217 "tag_all" => ["test", "reject"]
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]
227 describe "insertion" do
228 test "drops activities beyond a certain limit" do
229 limit = Config.get([:instance, :remote_limit])
232 :crypto.strong_rand_bytes(limit + 1)
234 |> binary_part(0, limit + 1)
239 "content" => random_text
243 assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
246 test "doesn't drop activities with content being null" do
250 "actor" => user.ap_id,
253 "actor" => user.ap_id,
260 assert {:ok, _} = ActivityPub.insert(data)
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)
267 assert activity.id == new_activity.id
270 test "inserts a given map into the activity database, giving it an id if it has none." do
274 "actor" => user.ap_id,
277 "actor" => user.ap_id,
284 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
285 assert activity.data["ok"] == data["ok"]
286 assert is_binary(activity.data["id"])
292 "actor" => user.ap_id,
294 "context" => "blabla",
296 "actor" => user.ap_id,
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"]
310 test "adds a context when none is there" do
314 "actor" => user.ap_id,
317 "actor" => user.ap_id,
324 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
325 object = Pleroma.Object.normalize(activity)
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"]
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
337 "actor" => user.ap_id,
340 "actor" => user.ap_id,
347 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
348 assert object = Object.normalize(activity)
349 assert is_binary(object.data["id"])
353 describe "listen activities" do
354 test "does not increase user note count" do
358 ActivityPub.listen(%{
359 to: ["https://www.w3.org/ns/activitystreams#Public"],
363 "actor" => user.ap_id,
364 "to" => ["https://www.w3.org/ns/activitystreams#Public"],
366 "title" => "lain radio episode 1",
372 assert activity.actor == user.ap_id
374 user = User.get_cached_by_id(user.id)
375 assert user.note_count == 0
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)
383 timeline = ActivityPub.fetch_activities([], %{"type" => ["Listen"]})
385 assert length(timeline) == 3
389 describe "create activities" do
390 test "it reverts create" do
393 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
394 assert {:error, :reverted} =
395 ActivityPub.create(%{
396 to: ["user1", "user2"],
400 "to" => ["user1", "user2"],
402 "content" => "testing"
407 assert Repo.aggregate(Activity, :count, :id) == 0
408 assert Repo.aggregate(Object, :count, :id) == 0
411 test "removes doubled 'to' recipients" do
415 ActivityPub.create(%{
416 to: ["user1", "user1", "user2"],
420 "to" => ["user1", "user1", "user2"],
422 "content" => "testing"
426 assert activity.data["to"] == ["user1", "user2"]
427 assert activity.actor == user.ap_id
428 assert activity.recipients == ["user1", "user2", user.ap_id]
431 test "increases user note count only for public activities" do
435 CommonAPI.post(User.get_cached_by_id(user.id), %{
437 "visibility" => "public"
441 CommonAPI.post(User.get_cached_by_id(user.id), %{
443 "visibility" => "unlisted"
447 CommonAPI.post(User.get_cached_by_id(user.id), %{
449 "visibility" => "private"
453 CommonAPI.post(User.get_cached_by_id(user.id), %{
455 "visibility" => "direct"
458 user = User.get_cached_by_id(user.id)
459 assert user.note_count == 2
462 test "increases replies count" do
464 user2 = insert(:user)
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}
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
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
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
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
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"]})
498 activities = ActivityPub.fetch_activities(["someone", "someone_else"])
499 assert length(activities) == 2
500 assert activities == [activity_one, activity_two]
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)
513 {:ok, _user_relationship} = User.block(user, %{ap_id: activity_five.data["actor"]})
515 activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
516 assert activities == [activity_two, activity]
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)
525 booster = insert(:user)
526 {:ok, _user_relationship} = User.block(user, %{ap_id: activity_one.data["actor"]})
529 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
531 assert Enum.member?(activities, activity_two)
532 assert Enum.member?(activities, activity_three)
533 refute Enum.member?(activities, activity_one)
535 {:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
538 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
540 assert Enum.member?(activities, activity_two)
541 assert Enum.member?(activities, activity_three)
542 assert Enum.member?(activities, activity_one)
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)
550 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
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)
558 ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})
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)
566 test "doesn't return transitive interactions concerning blocked users" do
567 blocker = insert(:user)
568 blockee = insert(:user)
569 friend = insert(:user)
571 {:ok, _user_relationship} = User.block(blocker, blockee)
573 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
575 {:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
577 {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
579 {:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
581 activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
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)
589 test "doesn't return announce activities concerning blocked users" do
590 blocker = insert(:user)
591 blockee = insert(:user)
592 friend = insert(:user)
594 {:ok, _user_relationship} = User.block(blocker, blockee)
596 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
598 {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
600 {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
603 ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
604 |> Enum.map(fn act -> act.id end)
606 assert Enum.member?(activities, activity_one.id)
607 refute Enum.member?(activities, activity_two.id)
608 refute Enum.member?(activities, activity_three.id)
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})
617 {:ok, user} = User.block_domain(user, domain)
620 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
622 refute activity in activities
624 followed_user = insert(:user)
625 ActivityPub.follow(user, followed_user)
626 {:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)
629 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
631 refute repeat_activity in activities
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)
639 {:ok, blocker} = User.follow(blocker, domain_user)
640 {:ok, blocker} = User.block_domain(blocker, domain)
642 assert User.following?(blocker, domain_user)
643 assert User.blocks_domain?(blocker, domain_user)
644 refute User.blocks?(blocker, domain_user)
646 note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
647 activity = insert(:note_activity, %{note: note})
650 ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})
652 assert activity in activities
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)
662 ActivityPub.fetch_activities([], %{"blocking_user" => blocker, "skip_preload" => true})
664 refute repeat_activity in activities
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)
672 booster = insert(:user)
674 activity_one_actor = User.get_by_ap_id(activity_one.data["actor"])
675 {:ok, _user_relationships} = User.mute(user, activity_one_actor)
678 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
680 assert Enum.member?(activities, activity_two)
681 assert Enum.member?(activities, activity_three)
682 refute Enum.member?(activities, activity_one)
684 # Calling with 'with_muted' will deliver muted activities, too.
686 ActivityPub.fetch_activities([], %{
687 "muting_user" => user,
688 "with_muted" => true,
689 "skip_preload" => true
692 assert Enum.member?(activities, activity_two)
693 assert Enum.member?(activities, activity_three)
694 assert Enum.member?(activities, activity_one)
696 {:ok, _user_mute} = User.unmute(user, activity_one_actor)
699 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
701 assert Enum.member?(activities, activity_two)
702 assert Enum.member?(activities, activity_three)
703 assert Enum.member?(activities, activity_one)
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)
712 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
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)
719 activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})
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)
727 test "doesn't return thread muted activities" do
729 _activity_one = insert(:note_activity)
730 note_two = insert(:note, data: %{"context" => "suya.."})
731 activity_two = insert(:note_activity, note: note_two)
733 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
735 assert [_activity_one] = ActivityPub.fetch_activities([], %{"muting_user" => user})
738 test "returns thread muted activities when with_muted is set" do
740 _activity_one = insert(:note_activity)
741 note_two = insert(:note, data: %{"context" => "suya.."})
742 activity_two = insert(:note_activity, note: note_two)
744 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
746 assert [_activity_two, _activity_one] =
747 ActivityPub.fetch_activities([], %{"muting_user" => user, "with_muted" => true})
750 test "does include announces on request" do
751 activity_three = insert(:note_activity)
753 booster = insert(:user)
755 {:ok, user} = User.follow(user, booster)
757 {:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)
759 [announce_activity] = ActivityPub.fetch_activities([user.ap_id | User.following(user)])
761 assert announce_activity.id == announce.id
764 test "excludes reblogs on request" do
766 {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
767 {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
769 [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
771 assert activity == expected_activity
774 describe "public fetch activities" do
775 test "doesn't retrieve unlisted activities" do
778 {:ok, _unlisted_activity} =
779 CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
781 {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
783 [activity] = ActivityPub.fetch_public_activities()
785 assert activity == listed_activity
788 test "retrieves public activities" do
789 _activities = ActivityPub.fetch_public_activities()
791 %{public: public} = ActivityBuilder.public_and_non_public()
793 activities = ActivityPub.fetch_public_activities()
794 assert length(activities) == 1
795 assert Enum.at(activities, 0) == public
798 test "retrieves a maximum of 20 activities" do
799 ActivityBuilder.insert_list(10)
800 expected_activities = ActivityBuilder.insert_list(20)
802 activities = ActivityPub.fetch_public_activities()
804 assert collect_ids(activities) == collect_ids(expected_activities)
805 assert length(activities) == 20
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
813 activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
815 assert collect_ids(activities) == collect_ids(expected_activities)
816 assert length(activities) == 10
819 test "retrieves ids up to max_id" do
820 ActivityBuilder.insert_list(10)
821 expected_activities = ActivityBuilder.insert_list(20)
825 |> ActivityBuilder.insert_list()
828 activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
830 assert length(activities) == 20
831 assert collect_ids(activities) == collect_ids(expected_activities)
834 test "paginates via offset/limit" do
835 _first_part_activities = ActivityBuilder.insert_list(10)
836 second_part_activities = ActivityBuilder.insert_list(10)
838 later_activities = ActivityBuilder.insert_list(10)
841 ActivityPub.fetch_public_activities(%{"page" => "2", "page_size" => "20"}, :offset)
843 assert length(activities) == 20
845 assert collect_ids(activities) ==
846 collect_ids(second_part_activities) ++ collect_ids(later_activities)
849 test "doesn't return reblogs for users for whom reblogs have been muted" do
850 activity = insert(:note_activity)
852 booster = insert(:user)
853 {:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
855 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
857 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
859 refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
862 test "returns reblogs for users for whom reblogs have not been muted" do
863 activity = insert(:note_activity)
865 booster = insert(:user)
866 {:ok, _reblog_mute} = CommonAPI.hide_reblogs(user, booster)
867 {:ok, _reblog_mute} = CommonAPI.show_reblogs(user, booster)
869 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
871 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
873 assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
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)
881 reactor = insert(:user)
882 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
883 assert object = Object.normalize(activity)
885 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
887 assert called(Federator.publish(reaction_activity))
890 test "adds an emoji reaction activity to the db" do
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)
898 {:ok, reaction_activity, object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
900 assert reaction_activity
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]]]
911 {:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(third_user, object, "☕")
913 assert object.data["reaction_count"] == 2
914 assert object.data["reactions"] == [["🔥", [reactor.ap_id]], ["☕", [third_user.ap_id]]]
916 {:ok, _reaction_activity, object} = ActivityPub.react_with_emoji(fourth_user, object, "🔥")
918 assert object.data["reaction_count"] == 3
920 assert object.data["reactions"] == [
921 ["🔥", [fourth_user.ap_id, reactor.ap_id]],
922 ["☕", [third_user.ap_id]]
926 test "reverts emoji reaction on error" do
927 [user, reactor] = insert_list(2, :user)
929 {:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
930 object = Object.normalize(activity)
932 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
933 assert {:error, :reverted} = ActivityPub.react_with_emoji(reactor, object, "😀")
936 object = Object.get_by_ap_id(object.data["id"])
937 refute object.data["reaction_count"]
938 refute object.data["reactions"]
942 describe "unreacting to an object" do
943 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
944 Config.put([:instance, :federating], true)
946 reactor = insert(:user)
947 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
948 assert object = Object.normalize(activity)
950 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
952 assert called(Federator.publish(reaction_activity))
954 {:ok, unreaction_activity, _object} =
955 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
957 assert called(Federator.publish(unreaction_activity))
960 test "adds an undo activity to the db" do
962 reactor = insert(:user)
963 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
964 assert object = Object.normalize(activity)
966 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
968 {:ok, unreaction_activity, _object} =
969 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
971 assert unreaction_activity.actor == reactor.ap_id
972 assert unreaction_activity.data["object"] == reaction_activity.data["id"]
974 object = Object.get_by_ap_id(object.data["id"])
975 assert object.data["reaction_count"] == 0
976 assert object.data["reactions"] == []
979 test "reverts emoji unreact on error" do
980 [user, reactor] = insert_list(2, :user)
981 {:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
982 object = Object.normalize(activity)
984 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "😀")
986 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
987 assert {:error, :reverted} =
988 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
991 object = Object.get_by_ap_id(object.data["id"])
993 assert object.data["reaction_count"] == 1
994 assert object.data["reactions"] == [["😀", [reactor.ap_id]]]
998 describe "like an object" do
999 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
1000 Config.put([:instance, :federating], true)
1001 note_activity = insert(:note_activity)
1002 assert object_activity = Object.normalize(note_activity)
1004 user = insert(:user)
1006 {:ok, like_activity, _object} = ActivityPub.like(user, object_activity)
1007 assert called(Federator.publish(like_activity))
1010 test "returns exist activity if object already liked" do
1011 note_activity = insert(:note_activity)
1012 assert object_activity = Object.normalize(note_activity)
1014 user = insert(:user)
1016 {:ok, like_activity, _object} = ActivityPub.like(user, object_activity)
1018 {:ok, like_activity_exist, _object} = ActivityPub.like(user, object_activity)
1019 assert like_activity == like_activity_exist
1022 test "reverts like activity on error" do
1023 note_activity = insert(:note_activity)
1024 object = Object.normalize(note_activity)
1025 user = insert(:user)
1027 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1028 assert {:error, :reverted} = ActivityPub.like(user, object)
1031 assert Repo.aggregate(Activity, :count, :id) == 1
1032 assert Repo.get(Object, object.id) == object
1035 test "adds a like activity to the db" do
1036 note_activity = insert(:note_activity)
1037 assert object = Object.normalize(note_activity)
1039 user = insert(:user)
1040 user_two = insert(:user)
1042 {:ok, like_activity, object} = ActivityPub.like(user, object)
1044 assert like_activity.data["actor"] == user.ap_id
1045 assert like_activity.data["type"] == "Like"
1046 assert like_activity.data["object"] == object.data["id"]
1047 assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
1048 assert like_activity.data["context"] == object.data["context"]
1049 assert object.data["like_count"] == 1
1050 assert object.data["likes"] == [user.ap_id]
1052 # Just return the original activity if the user already liked it.
1053 {:ok, same_like_activity, object} = ActivityPub.like(user, object)
1055 assert like_activity == same_like_activity
1056 assert object.data["likes"] == [user.ap_id]
1057 assert object.data["like_count"] == 1
1059 {:ok, _like_activity, object} = ActivityPub.like(user_two, object)
1060 assert object.data["like_count"] == 2
1064 describe "unliking" do
1065 test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
1066 Config.put([:instance, :federating], true)
1068 note_activity = insert(:note_activity)
1069 object = Object.normalize(note_activity)
1070 user = insert(:user)
1072 {:ok, object} = ActivityPub.unlike(user, object)
1073 refute called(Federator.publish())
1075 {:ok, _like_activity, object} = ActivityPub.like(user, object)
1076 assert object.data["like_count"] == 1
1078 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1079 assert object.data["like_count"] == 0
1081 assert called(Federator.publish(unlike_activity))
1084 test "reverts unliking on error" do
1085 note_activity = insert(:note_activity)
1086 object = Object.normalize(note_activity)
1087 user = insert(:user)
1089 {:ok, like_activity, object} = ActivityPub.like(user, object)
1090 assert object.data["like_count"] == 1
1092 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1093 assert {:error, :reverted} = ActivityPub.unlike(user, object)
1096 assert Object.get_by_ap_id(object.data["id"]) == object
1097 assert object.data["like_count"] == 1
1098 assert Activity.get_by_id(like_activity.id)
1101 test "unliking a previously liked object" do
1102 note_activity = insert(:note_activity)
1103 object = Object.normalize(note_activity)
1104 user = insert(:user)
1106 # Unliking something that hasn't been liked does nothing
1107 {:ok, object} = ActivityPub.unlike(user, object)
1108 assert object.data["like_count"] == 0
1110 {:ok, like_activity, object} = ActivityPub.like(user, object)
1111 assert object.data["like_count"] == 1
1113 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1114 assert object.data["like_count"] == 0
1116 assert Activity.get_by_id(like_activity.id) == nil
1117 assert note_activity.actor in unlike_activity.recipients
1121 describe "announcing an object" do
1122 test "adds an announce activity to the db" do
1123 note_activity = insert(:note_activity)
1124 object = Object.normalize(note_activity)
1125 user = insert(:user)
1127 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1128 assert object.data["announcement_count"] == 1
1129 assert object.data["announcements"] == [user.ap_id]
1131 assert announce_activity.data["to"] == [
1132 User.ap_followers(user),
1133 note_activity.data["actor"]
1136 assert announce_activity.data["object"] == object.data["id"]
1137 assert announce_activity.data["actor"] == user.ap_id
1138 assert announce_activity.data["context"] == object.data["context"]
1141 test "reverts annouce from object on error" do
1142 note_activity = insert(:note_activity)
1143 object = Object.normalize(note_activity)
1144 user = insert(:user)
1146 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1147 assert {:error, :reverted} = ActivityPub.announce(user, object)
1150 reloaded_object = Object.get_by_ap_id(object.data["id"])
1151 assert reloaded_object == object
1152 refute reloaded_object.data["announcement_count"]
1153 refute reloaded_object.data["announcements"]
1157 describe "announcing a private object" do
1158 test "adds an announce activity to the db if the audience is not widened" do
1159 user = insert(:user)
1160 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1161 object = Object.normalize(note_activity)
1163 {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
1165 assert announce_activity.data["to"] == [User.ap_followers(user)]
1167 assert announce_activity.data["object"] == object.data["id"]
1168 assert announce_activity.data["actor"] == user.ap_id
1169 assert announce_activity.data["context"] == object.data["context"]
1172 test "does not add an announce activity to the db if the audience is widened" do
1173 user = insert(:user)
1174 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1175 object = Object.normalize(note_activity)
1177 assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
1180 test "does not add an announce activity to the db if the announcer is not the author" do
1181 user = insert(:user)
1182 announcer = insert(:user)
1183 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1184 object = Object.normalize(note_activity)
1186 assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
1190 describe "unannouncing an object" do
1191 test "unannouncing a previously announced object" do
1192 note_activity = insert(:note_activity)
1193 object = Object.normalize(note_activity)
1194 user = insert(:user)
1196 # Unannouncing an object that is not announced does nothing
1197 {:ok, object} = ActivityPub.unannounce(user, object)
1198 refute object.data["announcement_count"]
1200 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1201 assert object.data["announcement_count"] == 1
1203 {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
1204 assert object.data["announcement_count"] == 0
1206 assert unannounce_activity.data["to"] == [
1207 User.ap_followers(user),
1208 object.data["actor"]
1211 assert unannounce_activity.data["type"] == "Undo"
1212 assert unannounce_activity.data["object"] == announce_activity.data
1213 assert unannounce_activity.data["actor"] == user.ap_id
1214 assert unannounce_activity.data["context"] == announce_activity.data["context"]
1216 assert Activity.get_by_id(announce_activity.id) == nil
1219 test "reverts unannouncing on error" do
1220 note_activity = insert(:note_activity)
1221 object = Object.normalize(note_activity)
1222 user = insert(:user)
1224 {:ok, _announce_activity, object} = ActivityPub.announce(user, object)
1225 assert object.data["announcement_count"] == 1
1227 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1228 assert {:error, :reverted} = ActivityPub.unannounce(user, object)
1231 object = Object.get_by_ap_id(object.data["id"])
1232 assert object.data["announcement_count"] == 1
1236 describe "uploading files" do
1237 test "copies the file to the configured folder" do
1238 file = %Plug.Upload{
1239 content_type: "image/jpg",
1240 path: Path.absname("test/fixtures/image.jpg"),
1241 filename: "an_image.jpg"
1244 {:ok, %Object{} = object} = ActivityPub.upload(file)
1245 assert object.data["name"] == "an_image.jpg"
1248 test "works with base64 encoded images" do
1253 {:ok, %Object{}} = ActivityPub.upload(file)
1257 describe "fetch the latest Follow" do
1258 test "fetches the latest Follow activity" do
1259 %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
1260 follower = Repo.get_by(User, ap_id: activity.data["actor"])
1261 followed = Repo.get_by(User, ap_id: activity.data["object"])
1263 assert activity == Utils.fetch_latest_follow(follower, followed)
1267 describe "following / unfollowing" do
1268 test "it reverts follow activity" do
1269 follower = insert(:user)
1270 followed = insert(:user)
1272 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1273 assert {:error, :reverted} = ActivityPub.follow(follower, followed)
1276 assert Repo.aggregate(Activity, :count, :id) == 0
1277 assert Repo.aggregate(Object, :count, :id) == 0
1280 test "it reverts unfollow activity" do
1281 follower = insert(:user)
1282 followed = insert(:user)
1284 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1286 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1287 assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
1290 activity = Activity.get_by_id(follow_activity.id)
1291 assert activity.data["type"] == "Follow"
1292 assert activity.data["actor"] == follower.ap_id
1294 assert activity.data["object"] == followed.ap_id
1297 test "creates a follow activity" do
1298 follower = insert(:user)
1299 followed = insert(:user)
1301 {:ok, activity} = ActivityPub.follow(follower, followed)
1302 assert activity.data["type"] == "Follow"
1303 assert activity.data["actor"] == follower.ap_id
1304 assert activity.data["object"] == followed.ap_id
1307 test "creates an undo activity for the last follow" do
1308 follower = insert(:user)
1309 followed = insert(:user)
1311 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1312 {:ok, activity} = ActivityPub.unfollow(follower, followed)
1314 assert activity.data["type"] == "Undo"
1315 assert activity.data["actor"] == follower.ap_id
1317 embedded_object = activity.data["object"]
1318 assert is_map(embedded_object)
1319 assert embedded_object["type"] == "Follow"
1320 assert embedded_object["object"] == followed.ap_id
1321 assert embedded_object["id"] == follow_activity.data["id"]
1324 test "creates an undo activity for a pending follow request" do
1325 follower = insert(:user)
1326 followed = insert(:user, %{locked: true})
1328 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1329 {:ok, activity} = ActivityPub.unfollow(follower, followed)
1331 assert activity.data["type"] == "Undo"
1332 assert activity.data["actor"] == follower.ap_id
1334 embedded_object = activity.data["object"]
1335 assert is_map(embedded_object)
1336 assert embedded_object["type"] == "Follow"
1337 assert embedded_object["object"] == followed.ap_id
1338 assert embedded_object["id"] == follow_activity.data["id"]
1342 describe "blocking / unblocking" do
1343 test "reverts block activity on error" do
1344 [blocker, blocked] = insert_list(2, :user)
1346 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1347 assert {:error, :reverted} = ActivityPub.block(blocker, blocked)
1350 assert Repo.aggregate(Activity, :count, :id) == 0
1351 assert Repo.aggregate(Object, :count, :id) == 0
1354 clear_config([:instance, :federating])
1356 test "creates a block activity" do
1357 Config.put([:instance, :federating], true)
1358 blocker = insert(:user)
1359 blocked = insert(:user)
1361 with_mock Pleroma.Web.Federator,
1362 publish: fn _ -> nil end do
1363 {:ok, activity} = ActivityPub.block(blocker, blocked)
1365 assert activity.data["type"] == "Block"
1366 assert activity.data["actor"] == blocker.ap_id
1367 assert activity.data["object"] == blocked.ap_id
1369 assert called(Pleroma.Web.Federator.publish(activity))
1373 clear_config([:instance, :federating])
1374 clear_config([:activitypub, :outgoing_blocks])
1376 test "works with outgoing blocks disabled, but doesn't federate" do
1377 Config.put([:instance, :federating], true)
1378 Config.put([:activitypub, :outgoing_blocks], false)
1379 blocker = insert(:user)
1380 blocked = insert(:user)
1382 with_mock Pleroma.Web.Federator,
1383 publish: fn _ -> nil end do
1384 {:ok, activity} = ActivityPub.block(blocker, blocked)
1386 assert activity.data["type"] == "Block"
1387 assert activity.data["actor"] == blocker.ap_id
1388 assert activity.data["object"] == blocked.ap_id
1390 refute called(Pleroma.Web.Federator.publish(:_))
1394 test "reverts unblock activity on error" do
1395 [blocker, blocked] = insert_list(2, :user)
1396 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1398 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1399 assert {:error, :reverted} = ActivityPub.unblock(blocker, blocked)
1402 assert block_activity.data["type"] == "Block"
1403 assert block_activity.data["actor"] == blocker.ap_id
1405 assert Repo.aggregate(Activity, :count, :id) == 1
1406 assert Repo.aggregate(Object, :count, :id) == 1
1409 test "creates an undo activity for the last block" do
1410 blocker = insert(:user)
1411 blocked = insert(:user)
1413 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1414 {:ok, activity} = ActivityPub.unblock(blocker, blocked)
1416 assert activity.data["type"] == "Undo"
1417 assert activity.data["actor"] == blocker.ap_id
1419 embedded_object = activity.data["object"]
1420 assert is_map(embedded_object)
1421 assert embedded_object["type"] == "Block"
1422 assert embedded_object["object"] == blocked.ap_id
1423 assert embedded_object["id"] == block_activity.data["id"]
1427 describe "deletion" do
1428 clear_config([:instance, :rewrite_policy])
1430 test "it reverts deletion on error" do
1431 note = insert(:note_activity)
1432 object = Object.normalize(note)
1434 with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1435 assert {:error, :reverted} = ActivityPub.delete(object)
1438 assert Repo.aggregate(Activity, :count, :id) == 1
1439 assert Repo.get(Object, object.id) == object
1440 assert Activity.get_by_id(note.id) == note
1443 test "it creates a delete activity and deletes the original object" do
1444 note = insert(:note_activity)
1445 object = Object.normalize(note)
1446 {:ok, delete} = ActivityPub.delete(object)
1448 assert delete.data["type"] == "Delete"
1449 assert delete.data["actor"] == note.data["actor"]
1450 assert delete.data["object"] == object.data["id"]
1452 assert Activity.get_by_id(delete.id) != nil
1454 assert Repo.get(Object, object.id).data["type"] == "Tombstone"
1457 test "it doesn't fail when an activity was already deleted" do
1458 {:ok, delete} = insert(:note_activity) |> Object.normalize() |> ActivityPub.delete()
1460 assert {:ok, ^delete} = delete |> Object.normalize() |> ActivityPub.delete()
1463 test "decrements user note count only for public activities" do
1464 user = insert(:user, note_count: 10)
1467 CommonAPI.post(User.get_cached_by_id(user.id), %{
1469 "visibility" => "public"
1473 CommonAPI.post(User.get_cached_by_id(user.id), %{
1475 "visibility" => "unlisted"
1479 CommonAPI.post(User.get_cached_by_id(user.id), %{
1481 "visibility" => "private"
1485 CommonAPI.post(User.get_cached_by_id(user.id), %{
1487 "visibility" => "direct"
1490 {:ok, _} = Object.normalize(a1) |> ActivityPub.delete()
1491 {:ok, _} = Object.normalize(a2) |> ActivityPub.delete()
1492 {:ok, _} = Object.normalize(a3) |> ActivityPub.delete()
1493 {:ok, _} = Object.normalize(a4) |> ActivityPub.delete()
1495 user = User.get_cached_by_id(user.id)
1496 assert user.note_count == 10
1499 test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
1500 user = insert(:user)
1501 note = insert(:note_activity)
1502 object = Object.normalize(note)
1508 "actor" => object.data["actor"],
1509 "id" => object.data["id"],
1510 "to" => [user.ap_id],
1514 |> Object.update_and_set_cache()
1516 {:ok, delete} = ActivityPub.delete(object)
1518 assert user.ap_id in delete.data["to"]
1521 test "decreases reply count" do
1522 user = insert(:user)
1523 user2 = insert(:user)
1525 {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
1526 reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
1527 ap_id = activity.data["id"]
1529 {:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
1530 {:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
1531 {:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
1532 {:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
1534 _ = CommonAPI.delete(direct_reply.id, user2)
1535 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1536 assert object.data["repliesCount"] == 2
1538 _ = CommonAPI.delete(private_reply.id, user2)
1539 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1540 assert object.data["repliesCount"] == 2
1542 _ = CommonAPI.delete(public_reply.id, user2)
1543 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1544 assert object.data["repliesCount"] == 1
1546 _ = CommonAPI.delete(unlisted_reply.id, user2)
1547 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1548 assert object.data["repliesCount"] == 0
1551 test "it passes delete activity through MRF before deleting the object" do
1552 Pleroma.Config.put([:instance, :rewrite_policy], Pleroma.Web.ActivityPub.MRF.DropPolicy)
1554 note = insert(:note_activity)
1555 object = Object.normalize(note)
1557 {:error, {:reject, _}} = ActivityPub.delete(object)
1559 assert Activity.get_by_id(note.id)
1560 assert Repo.get(Object, object.id).data["type"] == object.data["type"]
1564 describe "timeline post-processing" do
1565 test "it filters broken threads" do
1566 user1 = insert(:user)
1567 user2 = insert(:user)
1568 user3 = insert(:user)
1570 {:ok, user1} = User.follow(user1, user3)
1571 assert User.following?(user1, user3)
1573 {:ok, user2} = User.follow(user2, user3)
1574 assert User.following?(user2, user3)
1576 {:ok, user3} = User.follow(user3, user2)
1577 assert User.following?(user3, user2)
1579 {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
1581 {:ok, private_activity_1} =
1582 CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
1584 {:ok, private_activity_2} =
1585 CommonAPI.post(user2, %{
1587 "visibility" => "private",
1588 "in_reply_to_status_id" => private_activity_1.id
1591 {:ok, private_activity_3} =
1592 CommonAPI.post(user3, %{
1594 "visibility" => "private",
1595 "in_reply_to_status_id" => private_activity_2.id
1599 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)])
1600 |> Enum.map(fn a -> a.id end)
1602 private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
1604 assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
1606 assert length(activities) == 3
1609 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)], %{"user" => user1})
1610 |> Enum.map(fn a -> a.id end)
1612 assert [public_activity.id, private_activity_1.id] == activities
1613 assert length(activities) == 2
1617 describe "update" do
1618 clear_config([:instance, :max_pinned_statuses])
1620 test "it creates an update activity with the new user data" do
1621 user = insert(:user)
1622 {:ok, user} = User.ensure_keys_present(user)
1623 user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1626 ActivityPub.update(%{
1627 actor: user_data["id"],
1628 to: [user.follower_address],
1633 assert update.data["actor"] == user.ap_id
1634 assert update.data["to"] == [user.follower_address]
1635 assert embedded_object = update.data["object"]
1636 assert embedded_object["id"] == user_data["id"]
1637 assert embedded_object["type"] == user_data["type"]
1641 test "returned pinned statuses" do
1642 Config.put([:instance, :max_pinned_statuses], 3)
1643 user = insert(:user)
1645 {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1646 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1647 {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1649 CommonAPI.pin(activity_one.id, user)
1650 user = refresh_record(user)
1652 CommonAPI.pin(activity_two.id, user)
1653 user = refresh_record(user)
1655 CommonAPI.pin(activity_three.id, user)
1656 user = refresh_record(user)
1658 activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1660 assert 3 = length(activities)
1663 describe "flag/1" do
1665 reporter = insert(:user)
1666 target_account = insert(:user)
1668 {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
1669 context = Utils.generate_context_id()
1671 reporter_ap_id = reporter.ap_id
1672 target_ap_id = target_account.ap_id
1673 activity_ap_id = activity.data["id"]
1675 activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)
1681 target_account: target_account,
1682 reported_activity: activity,
1684 activity_ap_id: activity_ap_id,
1685 activity_with_object: activity_with_object,
1686 reporter_ap_id: reporter_ap_id,
1687 target_ap_id: target_ap_id
1691 test "it can create a Flag activity",
1695 target_account: target_account,
1696 reported_activity: reported_activity,
1698 activity_ap_id: activity_ap_id,
1699 activity_with_object: activity_with_object,
1700 reporter_ap_id: reporter_ap_id,
1701 target_ap_id: target_ap_id
1703 assert {:ok, activity} =
1707 account: target_account,
1708 statuses: [reported_activity],
1714 "id" => activity_ap_id,
1715 "content" => content,
1716 "published" => activity_with_object.object.data["published"],
1717 "actor" => AccountView.render("show.json", %{user: target_account})
1721 actor: ^reporter_ap_id,
1724 "content" => ^content,
1725 "context" => ^context,
1726 "object" => [^target_ap_id, ^note_obj]
1731 test_with_mock "strips status data from Flag, before federating it",
1735 target_account: target_account,
1736 reported_activity: reported_activity,
1746 account: target_account,
1747 statuses: [reported_activity],
1752 put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])
1754 assert_called(Utils.maybe_federate(%{activity | data: new_data}))
1758 test "fetch_activities/2 returns activities addressed to a list " do
1759 user = insert(:user)
1760 member = insert(:user)
1761 {:ok, list} = Pleroma.List.create("foo", user)
1762 {:ok, list} = Pleroma.List.follow(list, member)
1765 CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1767 activity = Repo.preload(activity, :bookmark)
1768 activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
1770 assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
1774 File.read!("test/fixtures/avatar_data_uri")
1777 describe "fetch_activities_bounded" do
1778 test "fetches private posts for followed users" do
1779 user = insert(:user)
1782 CommonAPI.post(user, %{
1783 "status" => "thought I looked cute might delete later :3",
1784 "visibility" => "private"
1787 [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1788 assert result.id == activity.id
1791 test "fetches only public posts for other users" do
1792 user = insert(:user)
1793 {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1795 {:ok, _private_activity} =
1796 CommonAPI.post(user, %{
1797 "status" => "why is tenshi eating a corndog so cute?",
1798 "visibility" => "private"
1801 [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1802 assert result.id == activity.id
1806 describe "fetch_follow_information_for_user" do
1807 test "syncronizes following/followers counters" do
1811 follower_address: "http://localhost:4001/users/fuser2/followers",
1812 following_address: "http://localhost:4001/users/fuser2/following"
1815 {:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
1816 assert info.follower_count == 527
1817 assert info.following_count == 267
1820 test "detects hidden followers" do
1823 "http://localhost:4001/users/masto_closed/followers?page=1" ->
1824 %Tesla.Env{status: 403, body: ""}
1827 apply(HttpRequestMock, :request, [env])
1834 follower_address: "http://localhost:4001/users/masto_closed/followers",
1835 following_address: "http://localhost:4001/users/masto_closed/following"
1838 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1839 assert follow_info.hide_followers == true
1840 assert follow_info.hide_follows == false
1843 test "detects hidden follows" do
1846 "http://localhost:4001/users/masto_closed/following?page=1" ->
1847 %Tesla.Env{status: 403, body: ""}
1850 apply(HttpRequestMock, :request, [env])
1857 follower_address: "http://localhost:4001/users/masto_closed/followers",
1858 following_address: "http://localhost:4001/users/masto_closed/following"
1861 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1862 assert follow_info.hide_followers == false
1863 assert follow_info.hide_follows == true
1866 test "detects hidden follows/followers for friendica" do
1870 follower_address: "http://localhost:8080/followers/fuser3",
1871 following_address: "http://localhost:8080/following/fuser3"
1874 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1875 assert follow_info.hide_followers == true
1876 assert follow_info.follower_count == 296
1877 assert follow_info.following_count == 32
1878 assert follow_info.hide_follows == true
1881 test "doesn't crash when follower and following counters are hidden" do
1884 "http://localhost:4001/users/masto_hidden_counters/following" ->
1886 "@context" => "https://www.w3.org/ns/activitystreams",
1887 "id" => "http://localhost:4001/users/masto_hidden_counters/followers"
1890 "http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
1891 %Tesla.Env{status: 403, body: ""}
1893 "http://localhost:4001/users/masto_hidden_counters/followers" ->
1895 "@context" => "https://www.w3.org/ns/activitystreams",
1896 "id" => "http://localhost:4001/users/masto_hidden_counters/following"
1899 "http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
1900 %Tesla.Env{status: 403, body: ""}
1907 follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
1908 following_address: "http://localhost:4001/users/masto_hidden_counters/following"
1911 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1913 assert follow_info.hide_followers == true
1914 assert follow_info.follower_count == 0
1915 assert follow_info.hide_follows == true
1916 assert follow_info.following_count == 0
1920 describe "fetch_favourites/3" do
1921 test "returns a favourite activities sorted by adds to favorite" do
1922 user = insert(:user)
1923 other_user = insert(:user)
1924 user1 = insert(:user)
1925 user2 = insert(:user)
1926 {:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
1927 {:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
1928 {:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
1929 {:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
1930 {:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})
1932 {:ok, _, _} = CommonAPI.favorite(a4.id, user)
1933 {:ok, _, _} = CommonAPI.favorite(a3.id, other_user)
1934 {:ok, _, _} = CommonAPI.favorite(a3.id, user)
1935 {:ok, _, _} = CommonAPI.favorite(a5.id, other_user)
1936 {:ok, _, _} = CommonAPI.favorite(a5.id, user)
1937 {:ok, _, _} = CommonAPI.favorite(a4.id, other_user)
1938 {:ok, _, _} = CommonAPI.favorite(a1.id, user)
1939 {:ok, _, _} = CommonAPI.favorite(a1.id, other_user)
1940 result = ActivityPub.fetch_favourites(user)
1942 assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]
1944 result = ActivityPub.fetch_favourites(user, %{"limit" => 2})
1945 assert Enum.map(result, & &1.id) == [a1.id, a5.id]
1949 describe "Move activity" do
1951 %{ap_id: old_ap_id} = old_user = insert(:user)
1952 %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
1953 follower = insert(:user)
1954 follower_move_opted_out = insert(:user, allow_following_move: false)
1956 User.follow(follower, old_user)
1957 User.follow(follower_move_opted_out, old_user)
1959 assert User.following?(follower, old_user)
1960 assert User.following?(follower_move_opted_out, old_user)
1962 assert {:ok, activity} = ActivityPub.move(old_user, new_user)
1967 "actor" => ^old_ap_id,
1968 "object" => ^old_ap_id,
1969 "target" => ^new_ap_id,
1976 "op" => "move_following",
1977 "origin_id" => old_user.id,
1978 "target_id" => new_user.id
1981 assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
1983 Pleroma.Workers.BackgroundWorker.perform(params, nil)
1985 refute User.following?(follower, old_user)
1986 assert User.following?(follower, new_user)
1988 assert User.following?(follower_move_opted_out, old_user)
1989 refute User.following?(follower_move_opted_out, new_user)
1991 activity = %Activity{activity | object: nil}
1993 assert [%Notification{activity: ^activity}] =
1994 Notification.for_user(follower, %{with_move: true})
1996 assert [%Notification{activity: ^activity}] =
1997 Notification.for_user(follower_move_opted_out, %{with_move: true})
2000 test "old user must be in the new user's `also_known_as` list" do
2001 old_user = insert(:user)
2002 new_user = insert(:user)
2004 assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
2005 ActivityPub.move(old_user, new_user)