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 ExUnit.CaptureLog
  22   import Mock
  23   import Pleroma.Factory
  24   import Tesla.Mock
  25
  26   setup do
  27     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  28     :ok
  29   end
  30
  31   setup do: clear_config([:instance, :federating])
  32
  33   describe "streaming out participations" do
  34     test "it streams them out" do
  35       user = insert(:user)
  36       {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
  37
  38       {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
  39
  40       participations =
  41         conversation.participations
  42         |> Repo.preload(:user)
  43
  44       with_mock Pleroma.Web.Streamer,
  45         stream: fn _, _ -> nil end do
  46         ActivityPub.stream_out_participations(conversation.participations)
  47
  48         assert called(Pleroma.Web.Streamer.stream("participation", participations))
  49       end
  50     end
  51
  52     test "streams them out on activity creation" do
  53       user_one = insert(:user)
  54       user_two = insert(:user)
  55
  56       with_mock Pleroma.Web.Streamer,
  57         stream: fn _, _ -> nil end do
  58         {:ok, activity} =
  59           CommonAPI.post(user_one, %{
  60             "status" => "@#{user_two.nickname}",
  61             "visibility" => "direct"
  62           })
  63
  64         conversation =
  65           activity.data["context"]
  66           |> Pleroma.Conversation.get_for_ap_id()
  67           |> Repo.preload(participations: :user)
  68
  69         assert called(Pleroma.Web.Streamer.stream("participation", conversation.participations))
  70       end
  71     end
  72   end
  73
  74   describe "fetching restricted by visibility" do
  75     test "it restricts by the appropriate visibility" do
  76       user = insert(:user)
  77
  78       {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
  79
  80       {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
  81
  82       {:ok, unlisted_activity} =
  83         CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
  84
  85       {:ok, private_activity} =
  86         CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
  87
  88       activities =
  89         ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
  90
  91       assert activities == [direct_activity]
  92
  93       activities =
  94         ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
  95
  96       assert activities == [unlisted_activity]
  97
  98       activities =
  99         ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
 100
 101       assert activities == [private_activity]
 102
 103       activities =
 104         ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
 105
 106       assert activities == [public_activity]
 107
 108       activities =
 109         ActivityPub.fetch_activities([], %{
 110           :visibility => ~w[private public],
 111           "actor_id" => user.ap_id
 112         })
 113
 114       assert activities == [public_activity, private_activity]
 115     end
 116   end
 117
 118   describe "fetching excluded by visibility" do
 119     test "it excludes by the appropriate visibility" do
 120       user = insert(:user)
 121
 122       {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
 123
 124       {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
 125
 126       {:ok, unlisted_activity} =
 127         CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
 128
 129       {:ok, private_activity} =
 130         CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
 131
 132       activities =
 133         ActivityPub.fetch_activities([], %{
 134           "exclude_visibilities" => "direct",
 135           "actor_id" => user.ap_id
 136         })
 137
 138       assert public_activity in activities
 139       assert unlisted_activity in activities
 140       assert private_activity in activities
 141       refute direct_activity in activities
 142
 143       activities =
 144         ActivityPub.fetch_activities([], %{
 145           "exclude_visibilities" => "unlisted",
 146           "actor_id" => user.ap_id
 147         })
 148
 149       assert public_activity in activities
 150       refute unlisted_activity in activities
 151       assert private_activity in activities
 152       assert direct_activity in activities
 153
 154       activities =
 155         ActivityPub.fetch_activities([], %{
 156           "exclude_visibilities" => "private",
 157           "actor_id" => user.ap_id
 158         })
 159
 160       assert public_activity in activities
 161       assert unlisted_activity in activities
 162       refute private_activity in activities
 163       assert direct_activity in activities
 164
 165       activities =
 166         ActivityPub.fetch_activities([], %{
 167           "exclude_visibilities" => "public",
 168           "actor_id" => user.ap_id
 169         })
 170
 171       refute public_activity in activities
 172       assert unlisted_activity in activities
 173       assert private_activity in activities
 174       assert direct_activity in activities
 175     end
 176   end
 177
 178   describe "building a user from his ap id" do
 179     test "it returns a user" do
 180       user_id = "http://mastodon.example.org/users/admin"
 181       {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
 182       assert user.ap_id == user_id
 183       assert user.nickname == "admin@mastodon.example.org"
 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 "announcing an object" do
 943     test "adds an announce activity to the db" do
 944       note_activity = insert(:note_activity)
 945       object = Object.normalize(note_activity)
 946       user = insert(:user)
 947
 948       {:ok, announce_activity, object} = ActivityPub.announce(user, object)
 949       assert object.data["announcement_count"] == 1
 950       assert object.data["announcements"] == [user.ap_id]
 951
 952       assert announce_activity.data["to"] == [
 953                User.ap_followers(user),
 954                note_activity.data["actor"]
 955              ]
 956
 957       assert announce_activity.data["object"] == object.data["id"]
 958       assert announce_activity.data["actor"] == user.ap_id
 959       assert announce_activity.data["context"] == object.data["context"]
 960     end
 961
 962     test "reverts annouce from object on error" do
 963       note_activity = insert(:note_activity)
 964       object = Object.normalize(note_activity)
 965       user = insert(:user)
 966
 967       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
 968         assert {:error, :reverted} = ActivityPub.announce(user, object)
 969       end
 970
 971       reloaded_object = Object.get_by_ap_id(object.data["id"])
 972       assert reloaded_object == object
 973       refute reloaded_object.data["announcement_count"]
 974       refute reloaded_object.data["announcements"]
 975     end
 976   end
 977
 978   describe "announcing a private object" do
 979     test "adds an announce activity to the db if the audience is not widened" do
 980       user = insert(:user)
 981       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
 982       object = Object.normalize(note_activity)
 983
 984       {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
 985
 986       assert announce_activity.data["to"] == [User.ap_followers(user)]
 987
 988       assert announce_activity.data["object"] == object.data["id"]
 989       assert announce_activity.data["actor"] == user.ap_id
 990       assert announce_activity.data["context"] == object.data["context"]
 991     end
 992
 993     test "does not add an announce activity to the db if the audience is widened" do
 994       user = insert(:user)
 995       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
 996       object = Object.normalize(note_activity)
 997
 998       assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
 999     end
1000
1001     test "does not add an announce activity to the db if the announcer is not the author" do
1002       user = insert(:user)
1003       announcer = insert(:user)
1004       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1005       object = Object.normalize(note_activity)
1006
1007       assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
1008     end
1009   end
1010
1011   describe "uploading files" do
1012     test "copies the file to the configured folder" do
1013       file = %Plug.Upload{
1014         content_type: "image/jpg",
1015         path: Path.absname("test/fixtures/image.jpg"),
1016         filename: "an_image.jpg"
1017       }
1018
1019       {:ok, %Object{} = object} = ActivityPub.upload(file)
1020       assert object.data["name"] == "an_image.jpg"
1021     end
1022
1023     test "works with base64 encoded images" do
1024       file = %{
1025         "img" => data_uri()
1026       }
1027
1028       {:ok, %Object{}} = ActivityPub.upload(file)
1029     end
1030   end
1031
1032   describe "fetch the latest Follow" do
1033     test "fetches the latest Follow activity" do
1034       %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
1035       follower = Repo.get_by(User, ap_id: activity.data["actor"])
1036       followed = Repo.get_by(User, ap_id: activity.data["object"])
1037
1038       assert activity == Utils.fetch_latest_follow(follower, followed)
1039     end
1040   end
1041
1042   describe "following / unfollowing" do
1043     test "it reverts follow activity" do
1044       follower = insert(:user)
1045       followed = insert(:user)
1046
1047       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1048         assert {:error, :reverted} = ActivityPub.follow(follower, followed)
1049       end
1050
1051       assert Repo.aggregate(Activity, :count, :id) == 0
1052       assert Repo.aggregate(Object, :count, :id) == 0
1053     end
1054
1055     test "it reverts unfollow activity" do
1056       follower = insert(:user)
1057       followed = insert(:user)
1058
1059       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1060
1061       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1062         assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
1063       end
1064
1065       activity = Activity.get_by_id(follow_activity.id)
1066       assert activity.data["type"] == "Follow"
1067       assert activity.data["actor"] == follower.ap_id
1068
1069       assert activity.data["object"] == followed.ap_id
1070     end
1071
1072     test "creates a follow activity" do
1073       follower = insert(:user)
1074       followed = insert(:user)
1075
1076       {:ok, activity} = ActivityPub.follow(follower, followed)
1077       assert activity.data["type"] == "Follow"
1078       assert activity.data["actor"] == follower.ap_id
1079       assert activity.data["object"] == followed.ap_id
1080     end
1081
1082     test "creates an undo activity for the last follow" do
1083       follower = insert(:user)
1084       followed = insert(:user)
1085
1086       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1087       {:ok, activity} = ActivityPub.unfollow(follower, followed)
1088
1089       assert activity.data["type"] == "Undo"
1090       assert activity.data["actor"] == follower.ap_id
1091
1092       embedded_object = activity.data["object"]
1093       assert is_map(embedded_object)
1094       assert embedded_object["type"] == "Follow"
1095       assert embedded_object["object"] == followed.ap_id
1096       assert embedded_object["id"] == follow_activity.data["id"]
1097     end
1098
1099     test "creates an undo activity for a pending follow request" do
1100       follower = insert(:user)
1101       followed = insert(:user, %{locked: true})
1102
1103       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1104       {:ok, activity} = ActivityPub.unfollow(follower, followed)
1105
1106       assert activity.data["type"] == "Undo"
1107       assert activity.data["actor"] == follower.ap_id
1108
1109       embedded_object = activity.data["object"]
1110       assert is_map(embedded_object)
1111       assert embedded_object["type"] == "Follow"
1112       assert embedded_object["object"] == followed.ap_id
1113       assert embedded_object["id"] == follow_activity.data["id"]
1114     end
1115   end
1116
1117   describe "blocking" do
1118     test "reverts block activity on error" do
1119       [blocker, blocked] = insert_list(2, :user)
1120
1121       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1122         assert {:error, :reverted} = ActivityPub.block(blocker, blocked)
1123       end
1124
1125       assert Repo.aggregate(Activity, :count, :id) == 0
1126       assert Repo.aggregate(Object, :count, :id) == 0
1127     end
1128
1129     test "creates a block activity" do
1130       blocker = insert(:user)
1131       blocked = insert(:user)
1132
1133       {:ok, activity} = ActivityPub.block(blocker, blocked)
1134
1135       assert activity.data["type"] == "Block"
1136       assert activity.data["actor"] == blocker.ap_id
1137       assert activity.data["object"] == blocked.ap_id
1138     end
1139   end
1140
1141   describe "timeline post-processing" do
1142     test "it filters broken threads" do
1143       user1 = insert(:user)
1144       user2 = insert(:user)
1145       user3 = insert(:user)
1146
1147       {:ok, user1} = User.follow(user1, user3)
1148       assert User.following?(user1, user3)
1149
1150       {:ok, user2} = User.follow(user2, user3)
1151       assert User.following?(user2, user3)
1152
1153       {:ok, user3} = User.follow(user3, user2)
1154       assert User.following?(user3, user2)
1155
1156       {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
1157
1158       {:ok, private_activity_1} =
1159         CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
1160
1161       {:ok, private_activity_2} =
1162         CommonAPI.post(user2, %{
1163           "status" => "hi 3",
1164           "visibility" => "private",
1165           "in_reply_to_status_id" => private_activity_1.id
1166         })
1167
1168       {:ok, private_activity_3} =
1169         CommonAPI.post(user3, %{
1170           "status" => "hi 4",
1171           "visibility" => "private",
1172           "in_reply_to_status_id" => private_activity_2.id
1173         })
1174
1175       activities =
1176         ActivityPub.fetch_activities([user1.ap_id | User.following(user1)])
1177         |> Enum.map(fn a -> a.id end)
1178
1179       private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
1180
1181       assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
1182
1183       assert length(activities) == 3
1184
1185       activities =
1186         ActivityPub.fetch_activities([user1.ap_id | User.following(user1)], %{"user" => user1})
1187         |> Enum.map(fn a -> a.id end)
1188
1189       assert [public_activity.id, private_activity_1.id] == activities
1190       assert length(activities) == 2
1191     end
1192   end
1193
1194   describe "update" do
1195     setup do: clear_config([:instance, :max_pinned_statuses])
1196
1197     test "it creates an update activity with the new user data" do
1198       user = insert(:user)
1199       {:ok, user} = User.ensure_keys_present(user)
1200       user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1201
1202       {:ok, update} =
1203         ActivityPub.update(%{
1204           actor: user_data["id"],
1205           to: [user.follower_address],
1206           cc: [],
1207           object: user_data
1208         })
1209
1210       assert update.data["actor"] == user.ap_id
1211       assert update.data["to"] == [user.follower_address]
1212       assert embedded_object = update.data["object"]
1213       assert embedded_object["id"] == user_data["id"]
1214       assert embedded_object["type"] == user_data["type"]
1215     end
1216   end
1217
1218   test "returned pinned statuses" do
1219     Config.put([:instance, :max_pinned_statuses], 3)
1220     user = insert(:user)
1221
1222     {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1223     {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1224     {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1225
1226     CommonAPI.pin(activity_one.id, user)
1227     user = refresh_record(user)
1228
1229     CommonAPI.pin(activity_two.id, user)
1230     user = refresh_record(user)
1231
1232     CommonAPI.pin(activity_three.id, user)
1233     user = refresh_record(user)
1234
1235     activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1236
1237     assert 3 = length(activities)
1238   end
1239
1240   describe "flag/1" do
1241     setup do
1242       reporter = insert(:user)
1243       target_account = insert(:user)
1244       content = "foobar"
1245       {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
1246       context = Utils.generate_context_id()
1247
1248       reporter_ap_id = reporter.ap_id
1249       target_ap_id = target_account.ap_id
1250       activity_ap_id = activity.data["id"]
1251
1252       activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)
1253
1254       {:ok,
1255        %{
1256          reporter: reporter,
1257          context: context,
1258          target_account: target_account,
1259          reported_activity: activity,
1260          content: content,
1261          activity_ap_id: activity_ap_id,
1262          activity_with_object: activity_with_object,
1263          reporter_ap_id: reporter_ap_id,
1264          target_ap_id: target_ap_id
1265        }}
1266     end
1267
1268     test "it can create a Flag activity",
1269          %{
1270            reporter: reporter,
1271            context: context,
1272            target_account: target_account,
1273            reported_activity: reported_activity,
1274            content: content,
1275            activity_ap_id: activity_ap_id,
1276            activity_with_object: activity_with_object,
1277            reporter_ap_id: reporter_ap_id,
1278            target_ap_id: target_ap_id
1279          } do
1280       assert {:ok, activity} =
1281                ActivityPub.flag(%{
1282                  actor: reporter,
1283                  context: context,
1284                  account: target_account,
1285                  statuses: [reported_activity],
1286                  content: content
1287                })
1288
1289       note_obj = %{
1290         "type" => "Note",
1291         "id" => activity_ap_id,
1292         "content" => content,
1293         "published" => activity_with_object.object.data["published"],
1294         "actor" => AccountView.render("show.json", %{user: target_account})
1295       }
1296
1297       assert %Activity{
1298                actor: ^reporter_ap_id,
1299                data: %{
1300                  "type" => "Flag",
1301                  "content" => ^content,
1302                  "context" => ^context,
1303                  "object" => [^target_ap_id, ^note_obj]
1304                }
1305              } = activity
1306     end
1307
1308     test_with_mock "strips status data from Flag, before federating it",
1309                    %{
1310                      reporter: reporter,
1311                      context: context,
1312                      target_account: target_account,
1313                      reported_activity: reported_activity,
1314                      content: content
1315                    },
1316                    Utils,
1317                    [:passthrough],
1318                    [] do
1319       {:ok, activity} =
1320         ActivityPub.flag(%{
1321           actor: reporter,
1322           context: context,
1323           account: target_account,
1324           statuses: [reported_activity],
1325           content: content
1326         })
1327
1328       new_data =
1329         put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])
1330
1331       assert_called(Utils.maybe_federate(%{activity | data: new_data}))
1332     end
1333   end
1334
1335   test "fetch_activities/2 returns activities addressed to a list " do
1336     user = insert(:user)
1337     member = insert(:user)
1338     {:ok, list} = Pleroma.List.create("foo", user)
1339     {:ok, list} = Pleroma.List.follow(list, member)
1340
1341     {:ok, activity} =
1342       CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1343
1344     activity = Repo.preload(activity, :bookmark)
1345     activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
1346
1347     assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
1348   end
1349
1350   def data_uri do
1351     File.read!("test/fixtures/avatar_data_uri")
1352   end
1353
1354   describe "fetch_activities_bounded" do
1355     test "fetches private posts for followed users" do
1356       user = insert(:user)
1357
1358       {:ok, activity} =
1359         CommonAPI.post(user, %{
1360           "status" => "thought I looked cute might delete later :3",
1361           "visibility" => "private"
1362         })
1363
1364       [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1365       assert result.id == activity.id
1366     end
1367
1368     test "fetches only public posts for other users" do
1369       user = insert(:user)
1370       {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1371
1372       {:ok, _private_activity} =
1373         CommonAPI.post(user, %{
1374           "status" => "why is tenshi eating a corndog so cute?",
1375           "visibility" => "private"
1376         })
1377
1378       [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1379       assert result.id == activity.id
1380     end
1381   end
1382
1383   describe "fetch_follow_information_for_user" do
1384     test "syncronizes following/followers counters" do
1385       user =
1386         insert(:user,
1387           local: false,
1388           follower_address: "http://localhost:4001/users/fuser2/followers",
1389           following_address: "http://localhost:4001/users/fuser2/following"
1390         )
1391
1392       {:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
1393       assert info.follower_count == 527
1394       assert info.following_count == 267
1395     end
1396
1397     test "detects hidden followers" do
1398       mock(fn env ->
1399         case env.url do
1400           "http://localhost:4001/users/masto_closed/followers?page=1" ->
1401             %Tesla.Env{status: 403, body: ""}
1402
1403           _ ->
1404             apply(HttpRequestMock, :request, [env])
1405         end
1406       end)
1407
1408       user =
1409         insert(:user,
1410           local: false,
1411           follower_address: "http://localhost:4001/users/masto_closed/followers",
1412           following_address: "http://localhost:4001/users/masto_closed/following"
1413         )
1414
1415       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1416       assert follow_info.hide_followers == true
1417       assert follow_info.hide_follows == false
1418     end
1419
1420     test "detects hidden follows" do
1421       mock(fn env ->
1422         case env.url do
1423           "http://localhost:4001/users/masto_closed/following?page=1" ->
1424             %Tesla.Env{status: 403, body: ""}
1425
1426           _ ->
1427             apply(HttpRequestMock, :request, [env])
1428         end
1429       end)
1430
1431       user =
1432         insert(:user,
1433           local: false,
1434           follower_address: "http://localhost:4001/users/masto_closed/followers",
1435           following_address: "http://localhost:4001/users/masto_closed/following"
1436         )
1437
1438       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1439       assert follow_info.hide_followers == false
1440       assert follow_info.hide_follows == true
1441     end
1442
1443     test "detects hidden follows/followers for friendica" do
1444       user =
1445         insert(:user,
1446           local: false,
1447           follower_address: "http://localhost:8080/followers/fuser3",
1448           following_address: "http://localhost:8080/following/fuser3"
1449         )
1450
1451       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1452       assert follow_info.hide_followers == true
1453       assert follow_info.follower_count == 296
1454       assert follow_info.following_count == 32
1455       assert follow_info.hide_follows == true
1456     end
1457
1458     test "doesn't crash when follower and following counters are hidden" do
1459       mock(fn env ->
1460         case env.url do
1461           "http://localhost:4001/users/masto_hidden_counters/following" ->
1462             json(%{
1463               "@context" => "https://www.w3.org/ns/activitystreams",
1464               "id" => "http://localhost:4001/users/masto_hidden_counters/followers"
1465             })
1466
1467           "http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
1468             %Tesla.Env{status: 403, body: ""}
1469
1470           "http://localhost:4001/users/masto_hidden_counters/followers" ->
1471             json(%{
1472               "@context" => "https://www.w3.org/ns/activitystreams",
1473               "id" => "http://localhost:4001/users/masto_hidden_counters/following"
1474             })
1475
1476           "http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
1477             %Tesla.Env{status: 403, body: ""}
1478         end
1479       end)
1480
1481       user =
1482         insert(:user,
1483           local: false,
1484           follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
1485           following_address: "http://localhost:4001/users/masto_hidden_counters/following"
1486         )
1487
1488       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1489
1490       assert follow_info.hide_followers == true
1491       assert follow_info.follower_count == 0
1492       assert follow_info.hide_follows == true
1493       assert follow_info.following_count == 0
1494     end
1495   end
1496
1497   describe "fetch_favourites/3" do
1498     test "returns a favourite activities sorted by adds to favorite" do
1499       user = insert(:user)
1500       other_user = insert(:user)
1501       user1 = insert(:user)
1502       user2 = insert(:user)
1503       {:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
1504       {:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
1505       {:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
1506       {:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
1507       {:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})
1508
1509       {:ok, _} = CommonAPI.favorite(user, a4.id)
1510       {:ok, _} = CommonAPI.favorite(other_user, a3.id)
1511       {:ok, _} = CommonAPI.favorite(user, a3.id)
1512       {:ok, _} = CommonAPI.favorite(other_user, a5.id)
1513       {:ok, _} = CommonAPI.favorite(user, a5.id)
1514       {:ok, _} = CommonAPI.favorite(other_user, a4.id)
1515       {:ok, _} = CommonAPI.favorite(user, a1.id)
1516       {:ok, _} = CommonAPI.favorite(other_user, a1.id)
1517       result = ActivityPub.fetch_favourites(user)
1518
1519       assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]
1520
1521       result = ActivityPub.fetch_favourites(user, %{"limit" => 2})
1522       assert Enum.map(result, & &1.id) == [a1.id, a5.id]
1523     end
1524   end
1525
1526   describe "Move activity" do
1527     test "create" do
1528       %{ap_id: old_ap_id} = old_user = insert(:user)
1529       %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
1530       follower = insert(:user)
1531       follower_move_opted_out = insert(:user, allow_following_move: false)
1532
1533       User.follow(follower, old_user)
1534       User.follow(follower_move_opted_out, old_user)
1535
1536       assert User.following?(follower, old_user)
1537       assert User.following?(follower_move_opted_out, old_user)
1538
1539       assert {:ok, activity} = ActivityPub.move(old_user, new_user)
1540
1541       assert %Activity{
1542                actor: ^old_ap_id,
1543                data: %{
1544                  "actor" => ^old_ap_id,
1545                  "object" => ^old_ap_id,
1546                  "target" => ^new_ap_id,
1547                  "type" => "Move"
1548                },
1549                local: true
1550              } = activity
1551
1552       params = %{
1553         "op" => "move_following",
1554         "origin_id" => old_user.id,
1555         "target_id" => new_user.id
1556       }
1557
1558       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
1559
1560       Pleroma.Workers.BackgroundWorker.perform(params, nil)
1561
1562       refute User.following?(follower, old_user)
1563       assert User.following?(follower, new_user)
1564
1565       assert User.following?(follower_move_opted_out, old_user)
1566       refute User.following?(follower_move_opted_out, new_user)
1567
1568       activity = %Activity{activity | object: nil}
1569
1570       assert [%Notification{activity: ^activity}] = Notification.for_user(follower)
1571
1572       assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
1573     end
1574
1575     test "old user must be in the new user's `also_known_as` list" do
1576       old_user = insert(:user)
1577       new_user = insert(:user)
1578
1579       assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
1580                ActivityPub.move(old_user, new_user)
1581     end
1582   end
1583
1584   test "doesn't retrieve replies activities with exclude_replies" do
1585     user = insert(:user)
1586
1587     {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
1588
1589     {:ok, _reply} =
1590       CommonAPI.post(user, %{"status" => "yeah", "in_reply_to_status_id" => activity.id})
1591
1592     [result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"})
1593
1594     assert result.id == activity.id
1595
1596     assert length(ActivityPub.fetch_public_activities()) == 2
1597   end
1598
1599   describe "replies filtering with public messages" do
1600     setup :public_messages
1601
1602     test "public timeline", %{users: %{u1: user}} do
1603       activities_ids =
1604         %{}
1605         |> Map.put("type", ["Create", "Announce"])
1606         |> Map.put("local_only", false)
1607         |> Map.put("blocking_user", user)
1608         |> Map.put("muting_user", user)
1609         |> Map.put("reply_filtering_user", user)
1610         |> ActivityPub.fetch_public_activities()
1611         |> Enum.map(& &1.id)
1612
1613       assert length(activities_ids) == 16
1614     end
1615
1616     test "public timeline with reply_visibility `following`", %{
1617       users: %{u1: user},
1618       u1: u1,
1619       u2: u2,
1620       u3: u3,
1621       u4: u4,
1622       activities: activities
1623     } do
1624       activities_ids =
1625         %{}
1626         |> Map.put("type", ["Create", "Announce"])
1627         |> Map.put("local_only", false)
1628         |> Map.put("blocking_user", user)
1629         |> Map.put("muting_user", user)
1630         |> Map.put("reply_visibility", "following")
1631         |> Map.put("reply_filtering_user", user)
1632         |> ActivityPub.fetch_public_activities()
1633         |> Enum.map(& &1.id)
1634
1635       assert length(activities_ids) == 14
1636
1637       visible_ids =
1638         Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]
1639
1640       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1641     end
1642
1643     test "public timeline with reply_visibility `self`", %{
1644       users: %{u1: user},
1645       u1: u1,
1646       u2: u2,
1647       u3: u3,
1648       u4: u4,
1649       activities: activities
1650     } do
1651       activities_ids =
1652         %{}
1653         |> Map.put("type", ["Create", "Announce"])
1654         |> Map.put("local_only", false)
1655         |> Map.put("blocking_user", user)
1656         |> Map.put("muting_user", user)
1657         |> Map.put("reply_visibility", "self")
1658         |> Map.put("reply_filtering_user", user)
1659         |> ActivityPub.fetch_public_activities()
1660         |> Enum.map(& &1.id)
1661
1662       assert length(activities_ids) == 10
1663       visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
1664       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1665     end
1666
1667     test "home timeline", %{
1668       users: %{u1: user},
1669       activities: activities,
1670       u1: u1,
1671       u2: u2,
1672       u3: u3,
1673       u4: u4
1674     } do
1675       params =
1676         %{}
1677         |> Map.put("type", ["Create", "Announce"])
1678         |> Map.put("blocking_user", user)
1679         |> Map.put("muting_user", user)
1680         |> Map.put("user", user)
1681         |> Map.put("reply_filtering_user", user)
1682
1683       activities_ids =
1684         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1685         |> Enum.map(& &1.id)
1686
1687       assert length(activities_ids) == 13
1688
1689       visible_ids =
1690         Map.values(u1) ++
1691           Map.values(u3) ++
1692           [
1693             activities[:a1],
1694             activities[:a2],
1695             activities[:a4],
1696             u2[:r1],
1697             u2[:r3],
1698             u4[:r1],
1699             u4[:r2]
1700           ]
1701
1702       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1703     end
1704
1705     test "home timeline with reply_visibility `following`", %{
1706       users: %{u1: user},
1707       activities: activities,
1708       u1: u1,
1709       u2: u2,
1710       u3: u3,
1711       u4: u4
1712     } do
1713       params =
1714         %{}
1715         |> Map.put("type", ["Create", "Announce"])
1716         |> Map.put("blocking_user", user)
1717         |> Map.put("muting_user", user)
1718         |> Map.put("user", user)
1719         |> Map.put("reply_visibility", "following")
1720         |> Map.put("reply_filtering_user", user)
1721
1722       activities_ids =
1723         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1724         |> Enum.map(& &1.id)
1725
1726       assert length(activities_ids) == 11
1727
1728       visible_ids =
1729         Map.values(u1) ++
1730           [
1731             activities[:a1],
1732             activities[:a2],
1733             activities[:a4],
1734             u2[:r1],
1735             u2[:r3],
1736             u3[:r1],
1737             u4[:r1],
1738             u4[:r2]
1739           ]
1740
1741       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1742     end
1743
1744     test "home timeline with reply_visibility `self`", %{
1745       users: %{u1: user},
1746       activities: activities,
1747       u1: u1,
1748       u2: u2,
1749       u3: u3,
1750       u4: u4
1751     } do
1752       params =
1753         %{}
1754         |> Map.put("type", ["Create", "Announce"])
1755         |> Map.put("blocking_user", user)
1756         |> Map.put("muting_user", user)
1757         |> Map.put("user", user)
1758         |> Map.put("reply_visibility", "self")
1759         |> Map.put("reply_filtering_user", user)
1760
1761       activities_ids =
1762         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1763         |> Enum.map(& &1.id)
1764
1765       assert length(activities_ids) == 9
1766
1767       visible_ids =
1768         Map.values(u1) ++
1769           [
1770             activities[:a1],
1771             activities[:a2],
1772             activities[:a4],
1773             u2[:r1],
1774             u3[:r1],
1775             u4[:r1]
1776           ]
1777
1778       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1779     end
1780   end
1781
1782   describe "replies filtering with private messages" do
1783     setup :private_messages
1784
1785     test "public timeline", %{users: %{u1: user}} do
1786       activities_ids =
1787         %{}
1788         |> Map.put("type", ["Create", "Announce"])
1789         |> Map.put("local_only", false)
1790         |> Map.put("blocking_user", user)
1791         |> Map.put("muting_user", user)
1792         |> Map.put("user", user)
1793         |> ActivityPub.fetch_public_activities()
1794         |> Enum.map(& &1.id)
1795
1796       assert activities_ids == []
1797     end
1798
1799     test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
1800       activities_ids =
1801         %{}
1802         |> Map.put("type", ["Create", "Announce"])
1803         |> Map.put("local_only", false)
1804         |> Map.put("blocking_user", user)
1805         |> Map.put("muting_user", user)
1806         |> Map.put("reply_visibility", "following")
1807         |> Map.put("reply_filtering_user", user)
1808         |> Map.put("user", user)
1809         |> ActivityPub.fetch_public_activities()
1810         |> Enum.map(& &1.id)
1811
1812       assert activities_ids == []
1813     end
1814
1815     test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
1816       activities_ids =
1817         %{}
1818         |> Map.put("type", ["Create", "Announce"])
1819         |> Map.put("local_only", false)
1820         |> Map.put("blocking_user", user)
1821         |> Map.put("muting_user", user)
1822         |> Map.put("reply_visibility", "self")
1823         |> Map.put("reply_filtering_user", user)
1824         |> Map.put("user", user)
1825         |> ActivityPub.fetch_public_activities()
1826         |> Enum.map(& &1.id)
1827
1828       assert activities_ids == []
1829     end
1830
1831     test "home timeline", %{users: %{u1: user}} do
1832       params =
1833         %{}
1834         |> Map.put("type", ["Create", "Announce"])
1835         |> Map.put("blocking_user", user)
1836         |> Map.put("muting_user", user)
1837         |> Map.put("user", user)
1838
1839       activities_ids =
1840         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1841         |> Enum.map(& &1.id)
1842
1843       assert length(activities_ids) == 12
1844     end
1845
1846     test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
1847       params =
1848         %{}
1849         |> Map.put("type", ["Create", "Announce"])
1850         |> Map.put("blocking_user", user)
1851         |> Map.put("muting_user", user)
1852         |> Map.put("user", user)
1853         |> Map.put("reply_visibility", "following")
1854         |> Map.put("reply_filtering_user", user)
1855
1856       activities_ids =
1857         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1858         |> Enum.map(& &1.id)
1859
1860       assert length(activities_ids) == 12
1861     end
1862
1863     test "home timeline with default reply_visibility `self`", %{
1864       users: %{u1: user},
1865       activities: activities,
1866       u1: u1,
1867       u2: u2,
1868       u3: u3,
1869       u4: u4
1870     } do
1871       params =
1872         %{}
1873         |> Map.put("type", ["Create", "Announce"])
1874         |> Map.put("blocking_user", user)
1875         |> Map.put("muting_user", user)
1876         |> Map.put("user", user)
1877         |> Map.put("reply_visibility", "self")
1878         |> Map.put("reply_filtering_user", user)
1879
1880       activities_ids =
1881         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1882         |> Enum.map(& &1.id)
1883
1884       assert length(activities_ids) == 10
1885
1886       visible_ids =
1887         Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)
1888
1889       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1890     end
1891   end
1892
1893   defp public_messages(_) do
1894     [u1, u2, u3, u4] = insert_list(4, :user)
1895     {:ok, u1} = User.follow(u1, u2)
1896     {:ok, u2} = User.follow(u2, u1)
1897     {:ok, u1} = User.follow(u1, u4)
1898     {:ok, u4} = User.follow(u4, u1)
1899
1900     {:ok, u2} = User.follow(u2, u3)
1901     {:ok, u3} = User.follow(u3, u2)
1902
1903     {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status"})
1904
1905     {:ok, r1_1} =
1906       CommonAPI.post(u2, %{
1907         "status" => "@#{u1.nickname} reply from u2 to u1",
1908         "in_reply_to_status_id" => a1.id
1909       })
1910
1911     {:ok, r1_2} =
1912       CommonAPI.post(u3, %{
1913         "status" => "@#{u1.nickname} reply from u3 to u1",
1914         "in_reply_to_status_id" => a1.id
1915       })
1916
1917     {:ok, r1_3} =
1918       CommonAPI.post(u4, %{
1919         "status" => "@#{u1.nickname} reply from u4 to u1",
1920         "in_reply_to_status_id" => a1.id
1921       })
1922
1923     {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status"})
1924
1925     {:ok, r2_1} =
1926       CommonAPI.post(u1, %{
1927         "status" => "@#{u2.nickname} reply from u1 to u2",
1928         "in_reply_to_status_id" => a2.id
1929       })
1930
1931     {:ok, r2_2} =
1932       CommonAPI.post(u3, %{
1933         "status" => "@#{u2.nickname} reply from u3 to u2",
1934         "in_reply_to_status_id" => a2.id
1935       })
1936
1937     {:ok, r2_3} =
1938       CommonAPI.post(u4, %{
1939         "status" => "@#{u2.nickname} reply from u4 to u2",
1940         "in_reply_to_status_id" => a2.id
1941       })
1942
1943     {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status"})
1944
1945     {:ok, r3_1} =
1946       CommonAPI.post(u1, %{
1947         "status" => "@#{u3.nickname} reply from u1 to u3",
1948         "in_reply_to_status_id" => a3.id
1949       })
1950
1951     {:ok, r3_2} =
1952       CommonAPI.post(u2, %{
1953         "status" => "@#{u3.nickname} reply from u2 to u3",
1954         "in_reply_to_status_id" => a3.id
1955       })
1956
1957     {:ok, r3_3} =
1958       CommonAPI.post(u4, %{
1959         "status" => "@#{u3.nickname} reply from u4 to u3",
1960         "in_reply_to_status_id" => a3.id
1961       })
1962
1963     {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status"})
1964
1965     {:ok, r4_1} =
1966       CommonAPI.post(u1, %{
1967         "status" => "@#{u4.nickname} reply from u1 to u4",
1968         "in_reply_to_status_id" => a4.id
1969       })
1970
1971     {:ok, r4_2} =
1972       CommonAPI.post(u2, %{
1973         "status" => "@#{u4.nickname} reply from u2 to u4",
1974         "in_reply_to_status_id" => a4.id
1975       })
1976
1977     {:ok, r4_3} =
1978       CommonAPI.post(u3, %{
1979         "status" => "@#{u4.nickname} reply from u3 to u4",
1980         "in_reply_to_status_id" => a4.id
1981       })
1982
1983     {:ok,
1984      users: %{u1: u1, u2: u2, u3: u3, u4: u4},
1985      activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
1986      u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
1987      u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
1988      u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
1989      u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
1990   end
1991
1992   defp private_messages(_) do
1993     [u1, u2, u3, u4] = insert_list(4, :user)
1994     {:ok, u1} = User.follow(u1, u2)
1995     {:ok, u2} = User.follow(u2, u1)
1996     {:ok, u1} = User.follow(u1, u3)
1997     {:ok, u3} = User.follow(u3, u1)
1998     {:ok, u1} = User.follow(u1, u4)
1999     {:ok, u4} = User.follow(u4, u1)
2000
2001     {:ok, u2} = User.follow(u2, u3)
2002     {:ok, u3} = User.follow(u3, u2)
2003
2004     {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status", "visibility" => "private"})
2005
2006     {:ok, r1_1} =
2007       CommonAPI.post(u2, %{
2008         "status" => "@#{u1.nickname} reply from u2 to u1",
2009         "in_reply_to_status_id" => a1.id,
2010         "visibility" => "private"
2011       })
2012
2013     {:ok, r1_2} =
2014       CommonAPI.post(u3, %{
2015         "status" => "@#{u1.nickname} reply from u3 to u1",
2016         "in_reply_to_status_id" => a1.id,
2017         "visibility" => "private"
2018       })
2019
2020     {:ok, r1_3} =
2021       CommonAPI.post(u4, %{
2022         "status" => "@#{u1.nickname} reply from u4 to u1",
2023         "in_reply_to_status_id" => a1.id,
2024         "visibility" => "private"
2025       })
2026
2027     {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status", "visibility" => "private"})
2028
2029     {:ok, r2_1} =
2030       CommonAPI.post(u1, %{
2031         "status" => "@#{u2.nickname} reply from u1 to u2",
2032         "in_reply_to_status_id" => a2.id,
2033         "visibility" => "private"
2034       })
2035
2036     {:ok, r2_2} =
2037       CommonAPI.post(u3, %{
2038         "status" => "@#{u2.nickname} reply from u3 to u2",
2039         "in_reply_to_status_id" => a2.id,
2040         "visibility" => "private"
2041       })
2042
2043     {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status", "visibility" => "private"})
2044
2045     {:ok, r3_1} =
2046       CommonAPI.post(u1, %{
2047         "status" => "@#{u3.nickname} reply from u1 to u3",
2048         "in_reply_to_status_id" => a3.id,
2049         "visibility" => "private"
2050       })
2051
2052     {:ok, r3_2} =
2053       CommonAPI.post(u2, %{
2054         "status" => "@#{u3.nickname} reply from u2 to u3",
2055         "in_reply_to_status_id" => a3.id,
2056         "visibility" => "private"
2057       })
2058
2059     {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status", "visibility" => "private"})
2060
2061     {:ok, r4_1} =
2062       CommonAPI.post(u1, %{
2063         "status" => "@#{u4.nickname} reply from u1 to u4",
2064         "in_reply_to_status_id" => a4.id,
2065         "visibility" => "private"
2066       })
2067
2068     {:ok,
2069      users: %{u1: u1, u2: u2, u3: u3, u4: u4},
2070      activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
2071      u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
2072      u2: %{r1: r2_1.id, r2: r2_2.id},
2073      u3: %{r1: r3_1.id, r2: r3_2.id},
2074      u4: %{r1: r4_1.id}}
2075   end
2076
2077   describe "maybe_update_follow_information/1" do
2078     setup do
2079       clear_config([:instance, :external_user_synchronization], true)
2080
2081       user = %{
2082         local: false,
2083         ap_id: "https://gensokyo.2hu/users/raymoo",
2084         following_address: "https://gensokyo.2hu/users/following",
2085         follower_address: "https://gensokyo.2hu/users/followers",
2086         type: "Person"
2087       }
2088
2089       %{user: user}
2090     end
2091
2092     test "logs an error when it can't fetch the info", %{user: user} do
2093       assert capture_log(fn ->
2094                ActivityPub.maybe_update_follow_information(user)
2095              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2096     end
2097
2098     test "just returns the input if the user type is Application", %{
2099       user: user
2100     } do
2101       user =
2102         user
2103         |> Map.put(:type, "Application")
2104
2105       refute capture_log(fn ->
2106                assert ^user = ActivityPub.maybe_update_follow_information(user)
2107              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2108     end
2109
2110     test "it just returns the input if the user has no following/follower addresses", %{
2111       user: user
2112     } do
2113       user =
2114         user
2115         |> Map.put(:following_address, nil)
2116         |> Map.put(:follower_address, nil)
2117
2118       refute capture_log(fn ->
2119                assert ^user = ActivityPub.maybe_update_follow_information(user)
2120              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2121     end
2122   end
2123 end