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 alias Pleroma.Web.ActivityPub.ActivityPub
8 alias Pleroma.Web.ActivityPub.Utils
9 alias Pleroma.Web.CommonAPI
10 alias Pleroma.Activity
13 alias Pleroma.Instances
14 alias Pleroma.Builders.ActivityBuilder
16 import Pleroma.Factory
21 mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
25 describe "fetching restricted by visibility" do
26 test "it restricts by the appropriate visibility" do
29 {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
31 {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
33 {:ok, unlisted_activity} =
34 CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
36 {:ok, private_activity} =
37 CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
40 ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
42 assert activities == [direct_activity]
45 ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
47 assert activities == [unlisted_activity]
50 ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
52 assert activities == [private_activity]
55 ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
57 assert activities == [public_activity]
61 describe "building a user from his ap id" do
62 test "it returns a user" do
63 user_id = "http://mastodon.example.org/users/admin"
64 {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
65 assert user.ap_id == user_id
66 assert user.nickname == "admin@mastodon.example.org"
67 assert user.info.source_data
68 assert user.info.ap_enabled
69 assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
72 test "it fetches the appropriate tag-restricted posts" do
75 {:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
76 {:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
77 {:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})
79 fetch_one = ActivityPub.fetch_activities([], %{"tag" => "test"})
80 fetch_two = ActivityPub.fetch_activities([], %{"tag" => ["test", "essais"]})
83 ActivityPub.fetch_activities([], %{
84 "tag" => ["test", "essais"],
85 "tag_reject" => ["reject"]
89 ActivityPub.fetch_activities([], %{
91 "tag_all" => ["test", "reject"]
94 assert fetch_one == [status_one, status_three]
95 assert fetch_two == [status_one, status_two, status_three]
96 assert fetch_three == [status_one, status_two]
97 assert fetch_four == [status_three]
101 describe "insertion" do
102 test "drops activities beyond a certain limit" do
103 limit = Pleroma.Config.get([:instance, :remote_limit])
106 :crypto.strong_rand_bytes(limit + 1)
108 |> binary_part(0, limit + 1)
113 "content" => random_text
117 assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
120 test "doesn't drop activities with content being null" do
128 assert {:ok, _} = ActivityPub.insert(data)
131 test "returns the activity if one with the same id is already in" do
132 activity = insert(:note_activity)
133 {:ok, new_activity} = ActivityPub.insert(activity.data)
135 assert activity == new_activity
138 test "inserts a given map into the activity database, giving it an id if it has none." do
143 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
144 assert activity.data["ok"] == data["ok"]
145 assert is_binary(activity.data["id"])
152 "context" => "blabla"
155 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
156 assert activity.data["ok"] == data["ok"]
157 assert activity.data["id"] == given_id
158 assert activity.data["context"] == "blabla"
159 assert activity.data["context_id"]
162 test "adds a context when none is there" do
170 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
172 assert is_binary(activity.data["context"])
173 assert is_binary(activity.data["object"]["context"])
174 assert activity.data["context_id"]
175 assert activity.data["object"]["context_id"]
178 test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
186 {:ok, %Activity{} = activity} = ActivityPub.insert(data)
187 assert is_binary(activity.data["object"]["id"])
188 assert %Object{} = Object.get_by_ap_id(activity.data["object"]["id"])
192 describe "create activities" do
193 test "removes doubled 'to' recipients" do
197 ActivityPub.create(%{
198 to: ["user1", "user1", "user2"],
204 assert activity.data["to"] == ["user1", "user2"]
205 assert activity.actor == user.ap_id
206 assert activity.recipients == ["user1", "user2", user.ap_id]
209 test "increases user note count only for public activities" do
213 CommonAPI.post(Repo.get(User, user.id), %{"status" => "1", "visibility" => "public"})
216 CommonAPI.post(Repo.get(User, user.id), %{"status" => "2", "visibility" => "unlisted"})
219 CommonAPI.post(Repo.get(User, user.id), %{"status" => "2", "visibility" => "private"})
222 CommonAPI.post(Repo.get(User, user.id), %{"status" => "3", "visibility" => "direct"})
224 user = Repo.get(User, user.id)
225 assert user.info.note_count == 2
229 describe "fetch activities for recipients" do
230 test "retrieve the activities for certain recipients" do
231 {:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
232 {:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
233 {:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})
235 activities = ActivityPub.fetch_activities(["someone", "someone_else"])
236 assert length(activities) == 2
237 assert activities == [activity_one, activity_two]
241 describe "fetch activities in context" do
242 test "retrieves activities that have a given context" do
243 {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
244 {:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
245 {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
246 {:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
247 activity_five = insert(:note_activity)
250 {:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})
252 activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
253 assert activities == [activity_two, activity]
257 test "doesn't return blocked activities" do
258 activity_one = insert(:note_activity)
259 activity_two = insert(:note_activity)
260 activity_three = insert(:note_activity)
262 booster = insert(:user)
263 {:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})
265 activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
267 assert Enum.member?(activities, activity_two)
268 assert Enum.member?(activities, activity_three)
269 refute Enum.member?(activities, activity_one)
271 {:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
273 activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
275 assert Enum.member?(activities, activity_two)
276 assert Enum.member?(activities, activity_three)
277 assert Enum.member?(activities, activity_one)
279 {:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
280 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
281 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
282 activity_three = Repo.get(Activity, activity_three.id)
284 activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})
286 assert Enum.member?(activities, activity_two)
287 refute Enum.member?(activities, activity_three)
288 refute Enum.member?(activities, boost_activity)
289 assert Enum.member?(activities, activity_one)
291 activities = ActivityPub.fetch_activities([], %{"blocking_user" => nil})
293 assert Enum.member?(activities, activity_two)
294 assert Enum.member?(activities, activity_three)
295 assert Enum.member?(activities, boost_activity)
296 assert Enum.member?(activities, activity_one)
299 test "doesn't return muted activities" do
300 activity_one = insert(:note_activity)
301 activity_two = insert(:note_activity)
302 activity_three = insert(:note_activity)
304 booster = insert(:user)
305 {:ok, user} = User.mute(user, %User{ap_id: activity_one.data["actor"]})
307 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
309 assert Enum.member?(activities, activity_two)
310 assert Enum.member?(activities, activity_three)
311 refute Enum.member?(activities, activity_one)
313 # Calling with 'with_muted' will deliver muted activities, too.
314 activities = ActivityPub.fetch_activities([], %{"muting_user" => user, "with_muted" => true})
316 assert Enum.member?(activities, activity_two)
317 assert Enum.member?(activities, activity_three)
318 assert Enum.member?(activities, activity_one)
320 {:ok, user} = User.unmute(user, %User{ap_id: activity_one.data["actor"]})
322 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
324 assert Enum.member?(activities, activity_two)
325 assert Enum.member?(activities, activity_three)
326 assert Enum.member?(activities, activity_one)
328 {:ok, user} = User.mute(user, %User{ap_id: activity_three.data["actor"]})
329 {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
330 %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
331 activity_three = Repo.get(Activity, activity_three.id)
333 activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
335 assert Enum.member?(activities, activity_two)
336 refute Enum.member?(activities, activity_three)
337 refute Enum.member?(activities, boost_activity)
338 assert Enum.member?(activities, activity_one)
340 activities = ActivityPub.fetch_activities([], %{"muting_user" => nil})
342 assert Enum.member?(activities, activity_two)
343 assert Enum.member?(activities, activity_three)
344 assert Enum.member?(activities, boost_activity)
345 assert Enum.member?(activities, activity_one)
348 test "excludes reblogs on request" do
350 {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
351 {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
353 [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
355 assert activity == expected_activity
358 describe "public fetch activities" do
359 test "doesn't retrieve unlisted activities" do
362 {:ok, _unlisted_activity} =
363 CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
365 {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
367 [activity] = ActivityPub.fetch_public_activities()
369 assert activity == listed_activity
372 test "retrieves public activities" do
373 _activities = ActivityPub.fetch_public_activities()
375 %{public: public} = ActivityBuilder.public_and_non_public()
377 activities = ActivityPub.fetch_public_activities()
378 assert length(activities) == 1
379 assert Enum.at(activities, 0) == public
382 test "retrieves a maximum of 20 activities" do
383 activities = ActivityBuilder.insert_list(30)
384 last_expected = List.last(activities)
386 activities = ActivityPub.fetch_public_activities()
387 last = List.last(activities)
389 assert length(activities) == 20
390 assert last == last_expected
393 test "retrieves ids starting from a since_id" do
394 activities = ActivityBuilder.insert_list(30)
395 later_activities = ActivityBuilder.insert_list(10)
396 since_id = List.last(activities).id
397 last_expected = List.last(later_activities)
399 activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
400 last = List.last(activities)
402 assert length(activities) == 10
403 assert last == last_expected
406 test "retrieves ids up to max_id" do
407 _first_activities = ActivityBuilder.insert_list(10)
408 activities = ActivityBuilder.insert_list(20)
409 later_activities = ActivityBuilder.insert_list(10)
410 max_id = List.first(later_activities).id
411 last_expected = List.last(activities)
413 activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
414 last = List.last(activities)
416 assert length(activities) == 20
417 assert last == last_expected
421 describe "like an object" do
422 test "adds a like activity to the db" do
423 note_activity = insert(:note_activity)
424 object = Object.get_by_ap_id(note_activity.data["object"]["id"])
426 user_two = insert(:user)
428 {:ok, like_activity, object} = ActivityPub.like(user, object)
430 assert like_activity.data["actor"] == user.ap_id
431 assert like_activity.data["type"] == "Like"
432 assert like_activity.data["object"] == object.data["id"]
433 assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
434 assert like_activity.data["context"] == object.data["context"]
435 assert object.data["like_count"] == 1
436 assert object.data["likes"] == [user.ap_id]
438 # Just return the original activity if the user already liked it.
439 {:ok, same_like_activity, object} = ActivityPub.like(user, object)
441 assert like_activity == same_like_activity
442 assert object.data["likes"] == [user.ap_id]
444 [note_activity] = Activity.get_all_create_by_object_ap_id(object.data["id"])
445 assert note_activity.data["object"]["like_count"] == 1
447 {:ok, _like_activity, object} = ActivityPub.like(user_two, object)
448 assert object.data["like_count"] == 2
452 describe "unliking" do
453 test "unliking a previously liked object" do
454 note_activity = insert(:note_activity)
455 object = Object.get_by_ap_id(note_activity.data["object"]["id"])
458 # Unliking something that hasn't been liked does nothing
459 {:ok, object} = ActivityPub.unlike(user, object)
460 assert object.data["like_count"] == 0
462 {:ok, like_activity, object} = ActivityPub.like(user, object)
463 assert object.data["like_count"] == 1
465 {:ok, _, _, object} = ActivityPub.unlike(user, object)
466 assert object.data["like_count"] == 0
468 assert Repo.get(Activity, like_activity.id) == nil
472 describe "announcing an object" do
473 test "adds an announce activity to the db" do
474 note_activity = insert(:note_activity)
475 object = Object.get_by_ap_id(note_activity.data["object"]["id"])
478 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
479 assert object.data["announcement_count"] == 1
480 assert object.data["announcements"] == [user.ap_id]
482 assert announce_activity.data["to"] == [
483 User.ap_followers(user),
484 note_activity.data["actor"]
487 assert announce_activity.data["object"] == object.data["id"]
488 assert announce_activity.data["actor"] == user.ap_id
489 assert announce_activity.data["context"] == object.data["context"]
493 describe "unannouncing an object" do
494 test "unannouncing a previously announced object" do
495 note_activity = insert(:note_activity)
496 object = Object.get_by_ap_id(note_activity.data["object"]["id"])
499 # Unannouncing an object that is not announced does nothing
500 # {:ok, object} = ActivityPub.unannounce(user, object)
501 # assert object.data["announcement_count"] == 0
503 {:ok, announce_activity, object} = ActivityPub.announce(user, object)
504 assert object.data["announcement_count"] == 1
506 {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
507 assert object.data["announcement_count"] == 0
509 assert unannounce_activity.data["to"] == [
510 User.ap_followers(user),
511 announce_activity.data["actor"]
514 assert unannounce_activity.data["type"] == "Undo"
515 assert unannounce_activity.data["object"] == announce_activity.data
516 assert unannounce_activity.data["actor"] == user.ap_id
517 assert unannounce_activity.data["context"] == announce_activity.data["context"]
519 assert Repo.get(Activity, announce_activity.id) == nil
523 describe "uploading files" do
524 test "copies the file to the configured folder" do
526 content_type: "image/jpg",
527 path: Path.absname("test/fixtures/image.jpg"),
528 filename: "an_image.jpg"
531 {:ok, %Object{} = object} = ActivityPub.upload(file)
532 assert object.data["name"] == "an_image.jpg"
535 test "works with base64 encoded images" do
540 {:ok, %Object{}} = ActivityPub.upload(file)
544 describe "fetch the latest Follow" do
545 test "fetches the latest Follow activity" do
546 %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
547 follower = Repo.get_by(User, ap_id: activity.data["actor"])
548 followed = Repo.get_by(User, ap_id: activity.data["object"])
550 assert activity == Utils.fetch_latest_follow(follower, followed)
554 describe "fetching an object" do
555 test "it fetches an object" do
557 ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
559 assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
560 assert activity.data["id"]
562 {:ok, object_again} =
563 ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
565 assert [attachment] = object.data["attachment"]
566 assert is_list(attachment["url"])
568 assert object == object_again
571 test "it works with objects only available via Ostatus" do
572 {:ok, object} = ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
573 assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
574 assert activity.data["id"]
576 {:ok, object_again} =
577 ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
579 assert object == object_again
582 test "it correctly stitches up conversations between ostatus and ap" do
583 last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
584 {:ok, object} = ActivityPub.fetch_object_from_id(last)
586 object = Object.get_by_ap_id(object.data["inReplyTo"])
591 describe "following / unfollowing" do
592 test "creates a follow activity" do
593 follower = insert(:user)
594 followed = insert(:user)
596 {:ok, activity} = ActivityPub.follow(follower, followed)
597 assert activity.data["type"] == "Follow"
598 assert activity.data["actor"] == follower.ap_id
599 assert activity.data["object"] == followed.ap_id
602 test "creates an undo activity for the last follow" do
603 follower = insert(:user)
604 followed = insert(:user)
606 {:ok, follow_activity} = ActivityPub.follow(follower, followed)
607 {:ok, activity} = ActivityPub.unfollow(follower, followed)
609 assert activity.data["type"] == "Undo"
610 assert activity.data["actor"] == follower.ap_id
612 assert is_map(activity.data["object"])
613 assert activity.data["object"]["type"] == "Follow"
614 assert activity.data["object"]["object"] == followed.ap_id
615 assert activity.data["object"]["id"] == follow_activity.data["id"]
619 describe "blocking / unblocking" do
620 test "creates a block activity" do
621 blocker = insert(:user)
622 blocked = insert(:user)
624 {:ok, activity} = ActivityPub.block(blocker, blocked)
626 assert activity.data["type"] == "Block"
627 assert activity.data["actor"] == blocker.ap_id
628 assert activity.data["object"] == blocked.ap_id
631 test "creates an undo activity for the last block" do
632 blocker = insert(:user)
633 blocked = insert(:user)
635 {:ok, block_activity} = ActivityPub.block(blocker, blocked)
636 {:ok, activity} = ActivityPub.unblock(blocker, blocked)
638 assert activity.data["type"] == "Undo"
639 assert activity.data["actor"] == blocker.ap_id
641 assert is_map(activity.data["object"])
642 assert activity.data["object"]["type"] == "Block"
643 assert activity.data["object"]["object"] == blocked.ap_id
644 assert activity.data["object"]["id"] == block_activity.data["id"]
648 describe "deletion" do
649 test "it creates a delete activity and deletes the original object" do
650 note = insert(:note_activity)
651 object = Object.get_by_ap_id(note.data["object"]["id"])
652 {:ok, delete} = ActivityPub.delete(object)
654 assert delete.data["type"] == "Delete"
655 assert delete.data["actor"] == note.data["actor"]
656 assert delete.data["object"] == note.data["object"]["id"]
658 assert Repo.get(Activity, delete.id) != nil
660 assert Repo.get(Object, object.id).data["type"] == "Tombstone"
663 test "decrements user note count only for public activities" do
664 user = insert(:user, info: %{note_count: 10})
667 CommonAPI.post(Repo.get(User, user.id), %{"status" => "yeah", "visibility" => "public"})
670 CommonAPI.post(Repo.get(User, user.id), %{"status" => "yeah", "visibility" => "unlisted"})
673 CommonAPI.post(Repo.get(User, user.id), %{"status" => "yeah", "visibility" => "private"})
676 CommonAPI.post(Repo.get(User, user.id), %{"status" => "yeah", "visibility" => "direct"})
678 {:ok, _} = a1.data["object"]["id"] |> Object.get_by_ap_id() |> ActivityPub.delete()
679 {:ok, _} = a2.data["object"]["id"] |> Object.get_by_ap_id() |> ActivityPub.delete()
680 {:ok, _} = a3.data["object"]["id"] |> Object.get_by_ap_id() |> ActivityPub.delete()
681 {:ok, _} = a4.data["object"]["id"] |> Object.get_by_ap_id() |> ActivityPub.delete()
683 user = Repo.get(User, user.id)
684 assert user.info.note_count == 10
688 describe "timeline post-processing" do
689 test "it filters broken threads" do
690 user1 = insert(:user)
691 user2 = insert(:user)
692 user3 = insert(:user)
694 {:ok, user1} = User.follow(user1, user3)
695 assert User.following?(user1, user3)
697 {:ok, user2} = User.follow(user2, user3)
698 assert User.following?(user2, user3)
700 {:ok, user3} = User.follow(user3, user2)
701 assert User.following?(user3, user2)
703 {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
705 {:ok, private_activity_1} =
706 CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
708 {:ok, private_activity_2} =
709 CommonAPI.post(user2, %{
711 "visibility" => "private",
712 "in_reply_to_status_id" => private_activity_1.id
715 {:ok, private_activity_3} =
716 CommonAPI.post(user3, %{
718 "visibility" => "private",
719 "in_reply_to_status_id" => private_activity_2.id
722 activities = ActivityPub.fetch_activities([user1.ap_id | user1.following])
724 assert [public_activity, private_activity_1, private_activity_3] == activities
725 assert length(activities) == 3
727 activities = ActivityPub.contain_timeline(activities, user1)
729 assert [public_activity, private_activity_1] == activities
730 assert length(activities) == 2
734 test "it can fetch plume articles" do
736 ActivityPub.fetch_object_from_id(
737 "https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
744 test "it creates an update activity with the new user data" do
746 {:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
747 user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
750 ActivityPub.update(%{
751 actor: user_data["id"],
752 to: [user.follower_address],
757 assert update.data["actor"] == user.ap_id
758 assert update.data["to"] == [user.follower_address]
759 assert update.data["object"]["id"] == user_data["id"]
760 assert update.data["object"]["type"] == user_data["type"]
764 test "it can fetch peertube videos" do
766 ActivityPub.fetch_object_from_id(
767 "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
773 test "returned pinned statuses" do
774 Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
777 {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
778 {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
779 {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
781 CommonAPI.pin(activity_one.id, user)
782 user = refresh_record(user)
784 CommonAPI.pin(activity_two.id, user)
785 user = refresh_record(user)
787 CommonAPI.pin(activity_three.id, user)
788 user = refresh_record(user)
790 activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
792 assert 3 = length(activities)
795 test "it can create a Flag activity" do
796 reporter = insert(:user)
797 target_account = insert(:user)
798 {:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
799 context = Utils.generate_context_id()
802 reporter_ap_id = reporter.ap_id
803 target_ap_id = target_account.ap_id
804 activity_ap_id = activity.data["id"]
806 assert {:ok, activity} =
810 account: target_account,
811 statuses: [activity],
816 actor: ^reporter_ap_id,
819 "content" => ^content,
820 "context" => ^context,
821 "object" => [^target_ap_id, ^activity_ap_id]
826 describe "publish_one/1" do
827 test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
831 actor = insert(:user)
832 inbox = "http://200.site/users/nick1/inbox"
834 assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
836 assert called(Instances.set_reachable(inbox))
839 test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
843 actor = insert(:user)
844 inbox = "http://200.site/users/nick1/inbox"
847 ActivityPub.publish_one(%{
852 unreachable_since: NaiveDateTime.utc_now()
855 assert called(Instances.set_reachable(inbox))
858 test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
862 actor = insert(:user)
863 inbox = "http://200.site/users/nick1/inbox"
866 ActivityPub.publish_one(%{
871 unreachable_since: nil
874 refute called(Instances.set_reachable(inbox))
877 test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
881 actor = insert(:user)
882 inbox = "http://404.site/users/nick1/inbox"
885 ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
887 assert called(Instances.set_unreachable(inbox))
890 test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
894 actor = insert(:user)
895 inbox = "http://connrefused.site/users/nick1/inbox"
898 ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
900 assert called(Instances.set_unreachable(inbox))
903 test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
907 actor = insert(:user)
908 inbox = "http://200.site/users/nick1/inbox"
910 assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
912 refute called(Instances.set_unreachable(inbox))
915 test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
919 actor = insert(:user)
920 inbox = "http://connrefused.site/users/nick1/inbox"
923 ActivityPub.publish_one(%{
928 unreachable_since: NaiveDateTime.utc_now()
931 refute called(Instances.set_unreachable(inbox))
936 File.read!("test/fixtures/avatar_data_uri")