1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 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
11 alias Pleroma.Notification
14 alias Pleroma.Web.ActivityPub.ActivityPub
15 alias Pleroma.Web.ActivityPub.Utils
16 alias Pleroma.Web.AdminAPI.AccountView
17 alias Pleroma.Web.CommonAPI
19 import Pleroma.Factory
24 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
28 clear_config([:instance, :federating])
30 describe "streaming out participations" do
31 test "it streams them out" do
33 {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
35 {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
38 conversation.participations
39 |> Repo.preload(:user)
41 with_mock Pleroma.Web.Streamer,
42 stream: fn _, _ -> nil end do
43 ActivityPub.stream_out_participations(conversation.participations)
45 assert called(Pleroma.Web.Streamer.stream("participation", participations))
49 test "streams them out on activity creation" do
50 user_one = insert(:user)
51 user_two = insert(:user)
53 with_mock Pleroma.Web.Streamer,
54 stream: fn _, _ -> nil end do
56 CommonAPI.post(user_one, %{
57 "status" => "@#{user_two.nickname}",
58 "visibility" => "direct"
62 activity.data["context"]
63 |> Pleroma.Conversation.get_for_ap_id()
64 |> Repo.preload(participations: :user)
66 assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
71 describe "fetching restricted by visibility" do
72 test "it restricts by the appropriate visibility" do
75 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
77 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
79 {:ok, unlisted_activity} =
80 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
82 {:ok, private_activity} =
83 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
86 ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
88 assert activities == [direct_activity]
91 ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
93 assert activities == [unlisted_activity]
96 ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
98 assert activities == [private_activity]
101 ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
103 assert activities == [public_activity]
106 ActivityPub.fetch_activities([], %{
107 :visibility => ~w[private public],
108 "actor_id" => user.ap_id
111 assert activities == [public_activity, private_activity]
115 describe "fetching excluded by visibility" do
116 test "it excludes by the appropriate visibility" do
119 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
121 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
123 {:ok, unlisted_activity} =
124 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
126 {:ok, private_activity} =
127 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
130 ActivityPub.fetch_activities([], %{
131 "exclude_visibilities" => "direct",
132 "actor_id" => user.ap_id
135 assert public_activity in activities
136 assert unlisted_activity in activities
137 assert private_activity in activities
138 refute direct_activity in activities
141 ActivityPub.fetch_activities([], %{
142 "exclude_visibilities" => "unlisted",
143 "actor_id" => user.ap_id
146 assert public_activity in activities
147 refute unlisted_activity in activities
148 assert private_activity in activities
149 assert direct_activity in activities
152 ActivityPub.fetch_activities([], %{
153 "exclude_visibilities" => "private",
154 "actor_id" => user.ap_id
157 assert public_activity in activities
158 assert unlisted_activity in activities
159 refute private_activity in activities
160 assert direct_activity in activities
163 ActivityPub.fetch_activities([], %{
164 "exclude_visibilities" => "public",
165 "actor_id" => user.ap_id
168 refute public_activity in activities
169 assert unlisted_activity in activities
170 assert private_activity in activities
171 assert direct_activity in activities
175 describe "building a user from his ap id" do
176 test "it returns a user" do
177 user_id = "http://mastodon.example.org/users/admin"
178 {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
179 assert user.ap_id == user_id
180 assert user.nickname == "admin@mastodon.example.org"
181 assert user.source_data
182 assert user.ap_enabled
183 assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
186 test "it returns a user that is invisible" do
187 user_id = "http://mastodon.example.org/users/relay"
188 {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
189 assert User.invisible?(user)
192 test "it fetches the appropriate tag-restricted posts" do
195 {:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
196 {:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
197 {:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})
199 fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
202 ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})
205 ActivityPub.fetch_activities([], %{
207 "tag" => ["test", "essais"],
208 "tag_reject" => ["reject"]
212 ActivityPub.fetch_activities([], %{
215 "tag_all" => ["test", "reject"]
218 assert fetch_one == [status_one, status_three]
219 assert fetch_two == [status_one, status_two, status_three]
220 assert fetch_three == [status_one, status_two]
221 assert fetch_four == [status_three]
225 describe "insertion" do
226 test "drops activities beyond a certain limit" do
227 limit = Pleroma.Config.get([:instance, :remote_limit])
230 :crypto.strong_rand_bytes(limit + 1)
232 |> binary_part(0, limit + 1)
237 "content" => random_text
241 assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
244 test "doesn't drop activities with content being null" do
248 "actor" => user.ap_id,
251 "actor" => user.ap_id,
258 assert {:ok, _} = ActivityPub.insert(data)
261 test "returns the activity if one with the same id is already in" do
262 activity = insert(:note_activity)
263 {:ok, new_activity} = ActivityPub.insert(activity.data)
265 assert activity.id == new_activity.id
268 test "inserts a given map into the activity database, giving it an id if it has none." do
272 "actor" => user.ap_id,
275 "actor" => user.ap_id,
282 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
283 assert activity.data["ok"] == data["ok"]
284 assert is_binary(activity.data["id"])
290 "actor" => user.ap_id,
292 "context" => "blabla",
294 "actor" => user.ap_id,
301 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
302 assert activity.data["ok"] == data["ok"]
303 assert activity.data["id"] == given_id
304 assert activity.data["context"] == "blabla"
305 assert activity.data["context_id"]
308 test "adds a context when none is there" do
312 "actor" => user.ap_id,
315 "actor" => user.ap_id,
322 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
323 object = Pleroma.Object.normalize(activity)
325 assert is_binary(activity.data["context"])
326 assert is_binary(object.data["context"])
327 assert activity.data["context_id"]
328 assert object.data["context_id"]
331 test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
335 "actor" => user.ap_id,
338 "actor" => user.ap_id,
345 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
346 assert object = Object.normalize(activity)
347 assert is_binary(object.data["id"])
351 describe "listen activities" do
352 test "does not increase user note count" do
356 ActivityPub.listen(%{
357 to: ["https://www.w3.org/ns/activitystreams#Public"],
361 "actor" => user.ap_id,
362 "to" => ["https://www.w3.org/ns/activitystreams#Public"],
364 "title" => "lain radio episode 1",
370 assert activity.actor == user.ap_id
372 user = User.get_cached_by_id(user.id)
373 assert user.note_count == 0
376 test "can be fetched into a timeline" do
377 _listen_activity_1 = insert(:listen)
378 _listen_activity_2 = insert(:listen)
379 _listen_activity_3 = insert(:listen)
381 timeline = ActivityPub.fetch_activities([], %{"type" => ["Listen"]})
383 assert length(timeline) == 3
387 describe "create activities" do
388 test "removes doubled 'to' recipients" do
392 ActivityPub.create(%{
393 to: ["user1", "user1", "user2"],
397 "to" => ["user1", "user1", "user2"],
399 "content" => "testing"
403 assert activity.data["to"] == ["user1", "user2"]
404 assert activity.actor == user.ap_id
405 assert activity.recipients == ["user1", "user2", user.ap_id]
408 test "increases user note count only for public activities" do
412 CommonAPI.post(User.get_cached_by_id(user.id), %{
414 "visibility" => "public"
418 CommonAPI.post(User.get_cached_by_id(user.id), %{
420 "visibility" => "unlisted"
424 CommonAPI.post(User.get_cached_by_id(user.id), %{
426 "visibility" => "private"
430 CommonAPI.post(User.get_cached_by_id(user.id), %{
432 "visibility" => "direct"
435 user = User.get_cached_by_id(user.id)
436 assert user.note_count == 2
439 test "increases replies count" do
441 user2 = insert(:user)
443 {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
444 ap_id = activity.data["id"]
445 reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
448 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
449 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
450 assert object.data["repliesCount"] == 1
453 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
454 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
455 assert object.data["repliesCount"] == 2
458 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
459 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
460 assert object.data["repliesCount"] == 2
463 {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
464 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
465 assert object.data["repliesCount"] == 2
469 describe "fetch activities for recipients" do
470 test "retrieve the activities for certain recipients" do
471 {:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
472 {:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
473 {:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})
475 activities = ActivityPub.fetch_activities(["someone", "someone_else"])
476 assert length(activities) == 2
477 assert activities == [activity_one, activity_two]
481 describe "fetch activities in context" do
482 test "retrieves activities that have a given context" do
483 {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
484 {:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
485 {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
486 {:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
487 activity_five = insert(:note_activity)
490 {:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})
492 activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
493 assert activities == [activity_two, activity]
497 test "doesn't return blocked activities" do
498 activity_one = insert(:note_activity)
499 activity_two = insert(:note_activity)
500 activity_three = insert(:note_activity)
502 booster = insert(:user)
503 {:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})
506 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
508 assert Enum.member?(activities, activity_two)
509 assert Enum.member?(activities, activity_three)
510 refute Enum.member?(activities, activity_one)
512 {:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
515 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
517 assert Enum.member?(activities, activity_two)
518 assert Enum.member?(activities, activity_three)
519 assert Enum.member?(activities, activity_one)
521 {:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
522 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
523 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
524 activity_three = Activity.get_by_id(activity_three.id)
527 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
529 assert Enum.member?(activities, activity_two)
530 refute Enum.member?(activities, activity_three)
531 refute Enum.member?(activities, boost_activity)
532 assert Enum.member?(activities, activity_one)
535 ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})
537 assert Enum.member?(activities, activity_two)
538 assert Enum.member?(activities, activity_three)
539 assert Enum.member?(activities, boost_activity)
540 assert Enum.member?(activities, activity_one)
543 test "doesn't return transitive interactions concerning blocked users" do
544 blocker = insert(:user)
545 blockee = insert(:user)
546 friend = insert(:user)
548 {:ok, blocker} = User.block(blocker, blockee)
550 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
552 {:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
554 {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
556 {:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
558 activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
560 assert Enum.member?(activities, activity_one)
561 refute Enum.member?(activities, activity_two)
562 refute Enum.member?(activities, activity_three)
563 refute Enum.member?(activities, activity_four)
566 test "doesn't return announce activities concerning blocked users" do
567 blocker = insert(:user)
568 blockee = insert(:user)
569 friend = insert(:user)
571 {:ok, blocker} = User.block(blocker, blockee)
573 {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
575 {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
577 {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
580 ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
581 |> Enum.map(fn act -> act.id end)
583 assert Enum.member?(activities, activity_one.id)
584 refute Enum.member?(activities, activity_two.id)
585 refute Enum.member?(activities, activity_three.id)
588 test "doesn't return activities from blocked domains" do
589 domain = "dogwhistle.zone"
590 domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
591 note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
592 activity = insert(:note_activity, %{note: note})
594 {:ok, user} = User.block_domain(user, domain)
597 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
599 refute activity in activities
601 followed_user = insert(:user)
602 ActivityPub.follow(user, followed_user)
603 {:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)
606 ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
608 refute repeat_activity in activities
611 test "doesn't return muted activities" do
612 activity_one = insert(:note_activity)
613 activity_two = insert(:note_activity)
614 activity_three = insert(:note_activity)
616 booster = insert(:user)
617 {:ok, user} = User.mute(user, %User{ap_id: activity_one.data["actor"]})
620 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
622 assert Enum.member?(activities, activity_two)
623 assert Enum.member?(activities, activity_three)
624 refute Enum.member?(activities, activity_one)
626 # Calling with 'with_muted' will deliver muted activities, too.
628 ActivityPub.fetch_activities([], %{
629 "muting_user" => user,
630 "with_muted" => true,
631 "skip_preload" => true
634 assert Enum.member?(activities, activity_two)
635 assert Enum.member?(activities, activity_three)
636 assert Enum.member?(activities, activity_one)
638 {:ok, user} = User.unmute(user, %User{ap_id: activity_one.data["actor"]})
641 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
643 assert Enum.member?(activities, activity_two)
644 assert Enum.member?(activities, activity_three)
645 assert Enum.member?(activities, activity_one)
647 {:ok, user} = User.mute(user, %User{ap_id: activity_three.data["actor"]})
648 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
649 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
650 activity_three = Activity.get_by_id(activity_three.id)
653 ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
655 assert Enum.member?(activities, activity_two)
656 refute Enum.member?(activities, activity_three)
657 refute Enum.member?(activities, boost_activity)
658 assert Enum.member?(activities, activity_one)
660 activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})
662 assert Enum.member?(activities, activity_two)
663 assert Enum.member?(activities, activity_three)
664 assert Enum.member?(activities, boost_activity)
665 assert Enum.member?(activities, activity_one)
668 test "doesn't return thread muted activities" do
670 _activity_one = insert(:note_activity)
671 note_two = insert(:note, data: %{"context" => "suya.."})
672 activity_two = insert(:note_activity, note: note_two)
674 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
676 assert [_activity_one] = ActivityPub.fetch_activities([], %{"muting_user" => user})
679 test "returns thread muted activities when with_muted is set" do
681 _activity_one = insert(:note_activity)
682 note_two = insert(:note, data: %{"context" => "suya.."})
683 activity_two = insert(:note_activity, note: note_two)
685 {:ok, _activity_two} = CommonAPI.add_mute(user, activity_two)
687 assert [_activity_two, _activity_one] =
688 ActivityPub.fetch_activities([], %{"muting_user" => user, "with_muted" => true})
691 test "does include announces on request" do
692 activity_three = insert(:note_activity)
694 booster = insert(:user)
696 {:ok, user} = User.follow(user, booster)
698 {:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)
700 [announce_activity] = ActivityPub.fetch_activities([user.ap_id | User.following(user)])
702 assert announce_activity.id == announce.id
705 test "excludes reblogs on request" do
707 {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
708 {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
710 [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
712 assert activity == expected_activity
715 describe "public fetch activities" do
716 test "doesn't retrieve unlisted activities" do
719 {:ok, _unlisted_activity} =
720 CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
722 {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
724 [activity] = ActivityPub.fetch_public_activities()
726 assert activity == listed_activity
729 test "retrieves public activities" do
730 _activities = ActivityPub.fetch_public_activities()
732 %{public: public} = ActivityBuilder.public_and_non_public()
734 activities = ActivityPub.fetch_public_activities()
735 assert length(activities) == 1
736 assert Enum.at(activities, 0) == public
739 test "retrieves a maximum of 20 activities" do
740 ActivityBuilder.insert_list(10)
741 expected_activities = ActivityBuilder.insert_list(20)
743 activities = ActivityPub.fetch_public_activities()
745 assert collect_ids(activities) == collect_ids(expected_activities)
746 assert length(activities) == 20
749 test "retrieves ids starting from a since_id" do
750 activities = ActivityBuilder.insert_list(30)
751 expected_activities = ActivityBuilder.insert_list(10)
752 since_id = List.last(activities).id
754 activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
756 assert collect_ids(activities) == collect_ids(expected_activities)
757 assert length(activities) == 10
760 test "retrieves ids up to max_id" do
761 ActivityBuilder.insert_list(10)
762 expected_activities = ActivityBuilder.insert_list(20)
766 |> ActivityBuilder.insert_list()
769 activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
771 assert length(activities) == 20
772 assert collect_ids(activities) == collect_ids(expected_activities)
775 test "paginates via offset/limit" do
776 _first_part_activities = ActivityBuilder.insert_list(10)
777 second_part_activities = ActivityBuilder.insert_list(10)
779 later_activities = ActivityBuilder.insert_list(10)
782 ActivityPub.fetch_public_activities(%{"page" => "2", "page_size" => "20"}, :offset)
784 assert length(activities) == 20
786 assert collect_ids(activities) ==
787 collect_ids(second_part_activities) ++ collect_ids(later_activities)
790 test "doesn't return reblogs for users for whom reblogs have been muted" do
791 activity = insert(:note_activity)
793 booster = insert(:user)
794 {:ok, user} = CommonAPI.hide_reblogs(user, booster)
796 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
798 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
800 refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
803 test "returns reblogs for users for whom reblogs have not been muted" do
804 activity = insert(:note_activity)
806 booster = insert(:user)
807 {:ok, user} = CommonAPI.hide_reblogs(user, booster)
808 {:ok, user} = CommonAPI.show_reblogs(user, booster)
810 {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
812 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
814 assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
818 describe "react to an object" do
819 test_with_mock "sends an activity to federation", Pleroma.Web.Federator, [:passthrough], [] do
820 Pleroma.Config.put([:instance, :federating], true)
822 reactor = insert(:user)
823 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
824 assert object = Object.normalize(activity)
826 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
828 assert called(Pleroma.Web.Federator.publish(reaction_activity))
831 test "adds an emoji reaction activity to the db" do
833 reactor = insert(:user)
834 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
835 assert object = Object.normalize(activity)
837 {:ok, reaction_activity, object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
839 assert reaction_activity
841 assert reaction_activity.data["actor"] == reactor.ap_id
842 assert reaction_activity.data["type"] == "EmojiReaction"
843 assert reaction_activity.data["content"] == "🔥"
844 assert reaction_activity.data["object"] == object.data["id"]
845 assert reaction_activity.data["to"] == [User.ap_followers(reactor), activity.data["actor"]]
846 assert reaction_activity.data["context"] == object.data["context"]
847 assert object.data["reaction_count"] == 1
848 assert object.data["reactions"]["🔥"] == [reactor.ap_id]
852 describe "unreacting to an object" do
853 test_with_mock "sends an activity to federation", Pleroma.Web.Federator, [:passthrough], [] do
854 Pleroma.Config.put([:instance, :federating], true)
856 reactor = insert(:user)
857 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
858 assert object = Object.normalize(activity)
860 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
862 assert called(Pleroma.Web.Federator.publish(reaction_activity))
864 {:ok, unreaction_activity, _object} =
865 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
867 assert called(Pleroma.Web.Federator.publish(unreaction_activity))
870 test "adds an undo activity to the db" do
872 reactor = insert(:user)
873 {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
874 assert object = Object.normalize(activity)
876 {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
878 {:ok, unreaction_activity, _object} =
879 ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
881 assert unreaction_activity.actor == reactor.ap_id
882 assert unreaction_activity.data["object"] == reaction_activity.data["id"]
884 object = Object.get_by_ap_id(object.data["id"])
885 assert object.data["reaction_count"] == 0
886 assert object.data["reactions"] == %{}
890 describe "like an object" do
891 test_with_mock "sends an activity to federation", Pleroma.Web.Federator, [:passthrough], [] do
892 Pleroma.Config.put([:instance, :federating], true)
893 note_activity = insert(:note_activity)
894 assert object_activity = Object.normalize(note_activity)
898 {:ok, like_activity, _object} = ActivityPub.like(user, object_activity)
899 assert called(Pleroma.Web.Federator.publish(like_activity))
902 test "returns exist activity if object already liked" do
903 note_activity = insert(:note_activity)
904 assert object_activity = Object.normalize(note_activity)
908 {:ok, like_activity, _object} = ActivityPub.like(user, object_activity)
910 {:ok, like_activity_exist, _object} = ActivityPub.like(user, object_activity)
911 assert like_activity == like_activity_exist
914 test "adds a like activity to the db" do
915 note_activity = insert(:note_activity)
916 assert object = Object.normalize(note_activity)
919 user_two = insert(:user)
921 {:ok, like_activity, object} = ActivityPub.like(user, object)
923 assert like_activity.data["actor"] == user.ap_id
924 assert like_activity.data["type"] == "Like"
925 assert like_activity.data["object"] == object.data["id"]
926 assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
927 assert like_activity.data["context"] == object.data["context"]
928 assert object.data["like_count"] == 1
929 assert object.data["likes"] == [user.ap_id]
931 # Just return the original activity if the user already liked it.
932 {:ok, same_like_activity, object} = ActivityPub.like(user, object)
934 assert like_activity == same_like_activity
935 assert object.data["likes"] == [user.ap_id]
936 assert object.data["like_count"] == 1
938 {:ok, _like_activity, object} = ActivityPub.like(user_two, object)
939 assert object.data["like_count"] == 2
943 describe "unliking" do
944 test_with_mock "sends an activity to federation", Pleroma.Web.Federator, [:passthrough], [] do
945 Pleroma.Config.put([:instance, :federating], true)
947 note_activity = insert(:note_activity)
948 object = Object.normalize(note_activity)
951 {:ok, object} = ActivityPub.unlike(user, object)
952 refute called(Pleroma.Web.Federator.publish())
954 {:ok, _like_activity, object} = ActivityPub.like(user, object)
955 assert object.data["like_count"] == 1
957 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
958 assert object.data["like_count"] == 0
960 assert called(Pleroma.Web.Federator.publish(unlike_activity))
963 test "unliking a previously liked object" do
964 note_activity = insert(:note_activity)
965 object = Object.normalize(note_activity)
968 # Unliking something that hasn't been liked does nothing
969 {:ok, object} = ActivityPub.unlike(user, object)
970 assert object.data["like_count"] == 0
972 {:ok, like_activity, object} = ActivityPub.like(user, object)
973 assert object.data["like_count"] == 1
975 {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
976 assert object.data["like_count"] == 0
978 assert Activity.get_by_id(like_activity.id) == nil
979 assert note_activity.actor in unlike_activity.recipients
983 describe "announcing an object" do
984 test "adds an announce activity to the db" do
985 note_activity = insert(:note_activity)
986 object = Object.normalize(note_activity)
989 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
990 assert object.data["announcement_count"] == 1
991 assert object.data["announcements"] == [user.ap_id]
993 assert announce_activity.data["to"] == [
994 User.ap_followers(user),
995 note_activity.data["actor"]
998 assert announce_activity.data["object"] == object.data["id"]
999 assert announce_activity.data["actor"] == user.ap_id
1000 assert announce_activity.data["context"] == object.data["context"]
1004 describe "announcing a private object" do
1005 test "adds an announce activity to the db if the audience is not widened" do
1006 user = insert(:user)
1007 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1008 object = Object.normalize(note_activity)
1010 {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
1012 assert announce_activity.data["to"] == [User.ap_followers(user)]
1014 assert announce_activity.data["object"] == object.data["id"]
1015 assert announce_activity.data["actor"] == user.ap_id
1016 assert announce_activity.data["context"] == object.data["context"]
1019 test "does not add an announce activity to the db if the audience is widened" do
1020 user = insert(:user)
1021 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1022 object = Object.normalize(note_activity)
1024 assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
1027 test "does not add an announce activity to the db if the announcer is not the author" do
1028 user = insert(:user)
1029 announcer = insert(:user)
1030 {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1031 object = Object.normalize(note_activity)
1033 assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
1037 describe "unannouncing an object" do
1038 test "unannouncing a previously announced object" do
1039 note_activity = insert(:note_activity)
1040 object = Object.normalize(note_activity)
1041 user = insert(:user)
1043 # Unannouncing an object that is not announced does nothing
1044 # {:ok, object} = ActivityPub.unannounce(user, object)
1045 # assert object.data["announcement_count"] == 0
1047 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1048 assert object.data["announcement_count"] == 1
1050 {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
1051 assert object.data["announcement_count"] == 0
1053 assert unannounce_activity.data["to"] == [
1054 User.ap_followers(user),
1055 object.data["actor"]
1058 assert unannounce_activity.data["type"] == "Undo"
1059 assert unannounce_activity.data["object"] == announce_activity.data
1060 assert unannounce_activity.data["actor"] == user.ap_id
1061 assert unannounce_activity.data["context"] == announce_activity.data["context"]
1063 assert Activity.get_by_id(announce_activity.id) == nil
1067 describe "uploading files" do
1068 test "copies the file to the configured folder" do
1069 file = %Plug.Upload{
1070 content_type: "image/jpg",
1071 path: Path.absname("test/fixtures/image.jpg"),
1072 filename: "an_image.jpg"
1075 {:ok, %Object{} = object} = ActivityPub.upload(file)
1076 assert object.data["name"] == "an_image.jpg"
1079 test "works with base64 encoded images" do
1084 {:ok, %Object{}} = ActivityPub.upload(file)
1088 describe "fetch the latest Follow" do
1089 test "fetches the latest Follow activity" do
1090 %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
1091 follower = Repo.get_by(User, ap_id: activity.data["actor"])
1092 followed = Repo.get_by(User, ap_id: activity.data["object"])
1094 assert activity == Utils.fetch_latest_follow(follower, followed)
1098 describe "following / unfollowing" do
1099 test "creates a follow activity" do
1100 follower = insert(:user)
1101 followed = insert(:user)
1103 {:ok, activity} = ActivityPub.follow(follower, followed)
1104 assert activity.data["type"] == "Follow"
1105 assert activity.data["actor"] == follower.ap_id
1106 assert activity.data["object"] == followed.ap_id
1109 test "creates an undo activity for the last follow" do
1110 follower = insert(:user)
1111 followed = insert(:user)
1113 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1114 {:ok, activity} = ActivityPub.unfollow(follower, followed)
1116 assert activity.data["type"] == "Undo"
1117 assert activity.data["actor"] == follower.ap_id
1119 embedded_object = activity.data["object"]
1120 assert is_map(embedded_object)
1121 assert embedded_object["type"] == "Follow"
1122 assert embedded_object["object"] == followed.ap_id
1123 assert embedded_object["id"] == follow_activity.data["id"]
1127 describe "blocking / unblocking" do
1128 test "creates a block activity" do
1129 blocker = insert(:user)
1130 blocked = insert(:user)
1132 {:ok, activity} = ActivityPub.block(blocker, blocked)
1134 assert activity.data["type"] == "Block"
1135 assert activity.data["actor"] == blocker.ap_id
1136 assert activity.data["object"] == blocked.ap_id
1139 test "creates an undo activity for the last block" do
1140 blocker = insert(:user)
1141 blocked = insert(:user)
1143 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1144 {:ok, activity} = ActivityPub.unblock(blocker, blocked)
1146 assert activity.data["type"] == "Undo"
1147 assert activity.data["actor"] == blocker.ap_id
1149 embedded_object = activity.data["object"]
1150 assert is_map(embedded_object)
1151 assert embedded_object["type"] == "Block"
1152 assert embedded_object["object"] == blocked.ap_id
1153 assert embedded_object["id"] == block_activity.data["id"]
1157 describe "deletion" do
1158 test "it creates a delete activity and deletes the original object" do
1159 note = insert(:note_activity)
1160 object = Object.normalize(note)
1161 {:ok, delete} = ActivityPub.delete(object)
1163 assert delete.data["type"] == "Delete"
1164 assert delete.data["actor"] == note.data["actor"]
1165 assert delete.data["object"] == object.data["id"]
1167 assert Activity.get_by_id(delete.id) != nil
1169 assert Repo.get(Object, object.id).data["type"] == "Tombstone"
1172 test "decrements user note count only for public activities" do
1173 user = insert(:user, note_count: 10)
1176 CommonAPI.post(User.get_cached_by_id(user.id), %{
1178 "visibility" => "public"
1182 CommonAPI.post(User.get_cached_by_id(user.id), %{
1184 "visibility" => "unlisted"
1188 CommonAPI.post(User.get_cached_by_id(user.id), %{
1190 "visibility" => "private"
1194 CommonAPI.post(User.get_cached_by_id(user.id), %{
1196 "visibility" => "direct"
1199 {:ok, _} = Object.normalize(a1) |> ActivityPub.delete()
1200 {:ok, _} = Object.normalize(a2) |> ActivityPub.delete()
1201 {:ok, _} = Object.normalize(a3) |> ActivityPub.delete()
1202 {:ok, _} = Object.normalize(a4) |> ActivityPub.delete()
1204 user = User.get_cached_by_id(user.id)
1205 assert user.note_count == 10
1208 test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
1209 user = insert(:user)
1210 note = insert(:note_activity)
1211 object = Object.normalize(note)
1217 "actor" => object.data["actor"],
1218 "id" => object.data["id"],
1219 "to" => [user.ap_id],
1223 |> Object.update_and_set_cache()
1225 {:ok, delete} = ActivityPub.delete(object)
1227 assert user.ap_id in delete.data["to"]
1230 test "decreases reply count" do
1231 user = insert(:user)
1232 user2 = insert(:user)
1234 {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
1235 reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
1236 ap_id = activity.data["id"]
1238 {:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
1239 {:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
1240 {:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
1241 {:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
1243 _ = CommonAPI.delete(direct_reply.id, user2)
1244 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1245 assert object.data["repliesCount"] == 2
1247 _ = CommonAPI.delete(private_reply.id, user2)
1248 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1249 assert object.data["repliesCount"] == 2
1251 _ = CommonAPI.delete(public_reply.id, user2)
1252 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1253 assert object.data["repliesCount"] == 1
1255 _ = CommonAPI.delete(unlisted_reply.id, user2)
1256 assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
1257 assert object.data["repliesCount"] == 0
1261 describe "timeline post-processing" do
1262 test "it filters broken threads" do
1263 user1 = insert(:user)
1264 user2 = insert(:user)
1265 user3 = insert(:user)
1267 {:ok, user1} = User.follow(user1, user3)
1268 assert User.following?(user1, user3)
1270 {:ok, user2} = User.follow(user2, user3)
1271 assert User.following?(user2, user3)
1273 {:ok, user3} = User.follow(user3, user2)
1274 assert User.following?(user3, user2)
1276 {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
1278 {:ok, private_activity_1} =
1279 CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
1281 {:ok, private_activity_2} =
1282 CommonAPI.post(user2, %{
1284 "visibility" => "private",
1285 "in_reply_to_status_id" => private_activity_1.id
1288 {:ok, private_activity_3} =
1289 CommonAPI.post(user3, %{
1291 "visibility" => "private",
1292 "in_reply_to_status_id" => private_activity_2.id
1296 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)])
1297 |> Enum.map(fn a -> a.id end)
1299 private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
1301 assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
1303 assert length(activities) == 3
1306 ActivityPub.fetch_activities([user1.ap_id | User.following(user1)], %{"user" => user1})
1307 |> Enum.map(fn a -> a.id end)
1309 assert [public_activity.id, private_activity_1.id] == activities
1310 assert length(activities) == 2
1314 describe "update" do
1315 test "it creates an update activity with the new user data" do
1316 user = insert(:user)
1317 {:ok, user} = User.ensure_keys_present(user)
1318 user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1321 ActivityPub.update(%{
1322 actor: user_data["id"],
1323 to: [user.follower_address],
1328 assert update.data["actor"] == user.ap_id
1329 assert update.data["to"] == [user.follower_address]
1330 assert embedded_object = update.data["object"]
1331 assert embedded_object["id"] == user_data["id"]
1332 assert embedded_object["type"] == user_data["type"]
1336 test "returned pinned statuses" do
1337 Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
1338 user = insert(:user)
1340 {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1341 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1342 {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1344 CommonAPI.pin(activity_one.id, user)
1345 user = refresh_record(user)
1347 CommonAPI.pin(activity_two.id, user)
1348 user = refresh_record(user)
1350 CommonAPI.pin(activity_three.id, user)
1351 user = refresh_record(user)
1353 activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1355 assert 3 = length(activities)
1358 describe "flag/1" do
1360 reporter = insert(:user)
1361 target_account = insert(:user)
1363 {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
1364 context = Utils.generate_context_id()
1366 reporter_ap_id = reporter.ap_id
1367 target_ap_id = target_account.ap_id
1368 activity_ap_id = activity.data["id"]
1370 activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)
1376 target_account: target_account,
1377 reported_activity: activity,
1379 activity_ap_id: activity_ap_id,
1380 activity_with_object: activity_with_object,
1381 reporter_ap_id: reporter_ap_id,
1382 target_ap_id: target_ap_id
1386 test "it can create a Flag activity",
1390 target_account: target_account,
1391 reported_activity: reported_activity,
1393 activity_ap_id: activity_ap_id,
1394 activity_with_object: activity_with_object,
1395 reporter_ap_id: reporter_ap_id,
1396 target_ap_id: target_ap_id
1398 assert {:ok, activity} =
1402 account: target_account,
1403 statuses: [reported_activity],
1409 "id" => activity_ap_id,
1410 "content" => content,
1411 "published" => activity_with_object.object.data["published"],
1412 "actor" => AccountView.render("show.json", %{user: target_account})
1416 actor: ^reporter_ap_id,
1419 "content" => ^content,
1420 "context" => ^context,
1421 "object" => [^target_ap_id, ^note_obj]
1426 test_with_mock "strips status data from Flag, before federating it",
1430 target_account: target_account,
1431 reported_activity: reported_activity,
1441 account: target_account,
1442 statuses: [reported_activity],
1447 put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])
1449 assert_called(Utils.maybe_federate(%{activity | data: new_data}))
1453 test "fetch_activities/2 returns activities addressed to a list " do
1454 user = insert(:user)
1455 member = insert(:user)
1456 {:ok, list} = Pleroma.List.create("foo", user)
1457 {:ok, list} = Pleroma.List.follow(list, member)
1460 CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1462 activity = Repo.preload(activity, :bookmark)
1463 activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
1465 assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
1469 File.read!("test/fixtures/avatar_data_uri")
1472 describe "fetch_activities_bounded" do
1473 test "fetches private posts for followed users" do
1474 user = insert(:user)
1477 CommonAPI.post(user, %{
1478 "status" => "thought I looked cute might delete later :3",
1479 "visibility" => "private"
1482 [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1483 assert result.id == activity.id
1486 test "fetches only public posts for other users" do
1487 user = insert(:user)
1488 {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1490 {:ok, _private_activity} =
1491 CommonAPI.post(user, %{
1492 "status" => "why is tenshi eating a corndog so cute?",
1493 "visibility" => "private"
1496 [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1497 assert result.id == activity.id
1501 describe "fetch_follow_information_for_user" do
1502 test "syncronizes following/followers counters" do
1506 follower_address: "http://localhost:4001/users/fuser2/followers",
1507 following_address: "http://localhost:4001/users/fuser2/following"
1510 {:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
1511 assert info.follower_count == 527
1512 assert info.following_count == 267
1515 test "detects hidden followers" do
1518 "http://localhost:4001/users/masto_closed/followers?page=1" ->
1519 %Tesla.Env{status: 403, body: ""}
1522 apply(HttpRequestMock, :request, [env])
1529 follower_address: "http://localhost:4001/users/masto_closed/followers",
1530 following_address: "http://localhost:4001/users/masto_closed/following"
1533 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1534 assert follow_info.hide_followers == true
1535 assert follow_info.hide_follows == false
1538 test "detects hidden follows" do
1541 "http://localhost:4001/users/masto_closed/following?page=1" ->
1542 %Tesla.Env{status: 403, body: ""}
1545 apply(HttpRequestMock, :request, [env])
1552 follower_address: "http://localhost:4001/users/masto_closed/followers",
1553 following_address: "http://localhost:4001/users/masto_closed/following"
1556 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1557 assert follow_info.hide_followers == false
1558 assert follow_info.hide_follows == true
1561 test "detects hidden follows/followers for friendica" do
1565 follower_address: "http://localhost:8080/followers/fuser3",
1566 following_address: "http://localhost:8080/following/fuser3"
1569 {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1570 assert follow_info.hide_followers == true
1571 assert follow_info.follower_count == 296
1572 assert follow_info.following_count == 32
1573 assert follow_info.hide_follows == true
1577 describe "Move activity" do
1579 %{ap_id: old_ap_id} = old_user = insert(:user)
1580 %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
1581 follower = insert(:user)
1582 follower_move_opted_out = insert(:user, allow_following_move: false)
1584 User.follow(follower, old_user)
1585 User.follow(follower_move_opted_out, old_user)
1587 assert User.following?(follower, old_user)
1588 assert User.following?(follower_move_opted_out, old_user)
1590 assert {:ok, activity} = ActivityPub.move(old_user, new_user)
1595 "actor" => ^old_ap_id,
1596 "object" => ^old_ap_id,
1597 "target" => ^new_ap_id,
1604 "op" => "move_following",
1605 "origin_id" => old_user.id,
1606 "target_id" => new_user.id
1609 assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
1611 Pleroma.Workers.BackgroundWorker.perform(params, nil)
1613 refute User.following?(follower, old_user)
1614 assert User.following?(follower, new_user)
1616 assert User.following?(follower_move_opted_out, old_user)
1617 refute User.following?(follower_move_opted_out, new_user)
1619 activity = %Activity{activity | object: nil}
1621 assert [%Notification{activity: ^activity}] =
1622 Notification.for_user_since(follower, ~N[2019-04-13 11:22:33])
1624 assert [%Notification{activity: ^activity}] =
1625 Notification.for_user_since(follower_move_opted_out, ~N[2019-04-13 11:22:33])
1628 test "old user must be in the new user's `also_known_as` list" do
1629 old_user = insert(:user)
1630 new_user = insert(:user)
1632 assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
1633 ActivityPub.move(old_user, new_user)