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