git.squeep.com Git - akkoma/blob - test/web/activity_pub/activity_pub_test.exs

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