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 "unreacting to an object" do
 943     test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
 944       Config.put([:instance, :federating], true)
 945       user = insert(:user)
 946       reactor = insert(:user)
 947       {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
 948       assert object = Object.normalize(activity)
 949
 950       {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
 951
 952       assert called(Federator.publish(reaction_activity))
 953
 954       {:ok, unreaction_activity, _object} =
 955         ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
 956
 957       assert called(Federator.publish(unreaction_activity))
 958     end
 959
 960     test "adds an undo activity to the db" do
 961       user = insert(:user)
 962       reactor = insert(:user)
 963       {:ok, activity} = CommonAPI.post(user, %{"status" => "YASSSS queen slay"})
 964       assert object = Object.normalize(activity)
 965
 966       {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "🔥")
 967
 968       {:ok, unreaction_activity, _object} =
 969         ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
 970
 971       assert unreaction_activity.actor == reactor.ap_id
 972       assert unreaction_activity.data["object"] == reaction_activity.data["id"]
 973
 974       object = Object.get_by_ap_id(object.data["id"])
 975       assert object.data["reaction_count"] == 0
 976       assert object.data["reactions"] == []
 977     end
 978
 979     test "reverts emoji unreact on error" do
 980       [user, reactor] = insert_list(2, :user)
 981       {:ok, activity} = CommonAPI.post(user, %{"status" => "Status"})
 982       object = Object.normalize(activity)
 983
 984       {:ok, reaction_activity, _object} = ActivityPub.react_with_emoji(reactor, object, "😀")
 985
 986       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
 987         assert {:error, :reverted} =
 988                  ActivityPub.unreact_with_emoji(reactor, reaction_activity.data["id"])
 989       end
 990
 991       object = Object.get_by_ap_id(object.data["id"])
 992
 993       assert object.data["reaction_count"] == 1
 994       assert object.data["reactions"] == [["😀", [reactor.ap_id]]]
 995     end
 996   end
 997
 998   describe "unliking" do
 999     test_with_mock "sends an activity to federation", Federator, [:passthrough], [] do
1000       Config.put([:instance, :federating], true)
1001
1002       note_activity = insert(:note_activity)
1003       object = Object.normalize(note_activity)
1004       user = insert(:user)
1005
1006       {:ok, object} = ActivityPub.unlike(user, object)
1007       refute called(Federator.publish())
1008
1009       {:ok, _like_activity} = CommonAPI.favorite(user, note_activity.id)
1010       object = Object.get_by_id(object.id)
1011       assert object.data["like_count"] == 1
1012
1013       {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1014       assert object.data["like_count"] == 0
1015
1016       assert called(Federator.publish(unlike_activity))
1017     end
1018
1019     test "reverts unliking on error" do
1020       note_activity = insert(:note_activity)
1021       user = insert(:user)
1022
1023       {:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)
1024       object = Object.normalize(note_activity)
1025       assert object.data["like_count"] == 1
1026
1027       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1028         assert {:error, :reverted} = ActivityPub.unlike(user, object)
1029       end
1030
1031       assert Object.get_by_ap_id(object.data["id"]) == object
1032       assert object.data["like_count"] == 1
1033       assert Activity.get_by_id(like_activity.id)
1034     end
1035
1036     test "unliking a previously liked object" do
1037       note_activity = insert(:note_activity)
1038       object = Object.normalize(note_activity)
1039       user = insert(:user)
1040
1041       # Unliking something that hasn't been liked does nothing
1042       {:ok, object} = ActivityPub.unlike(user, object)
1043       assert object.data["like_count"] == 0
1044
1045       {:ok, like_activity} = CommonAPI.favorite(user, note_activity.id)
1046
1047       object = Object.get_by_id(object.id)
1048       assert object.data["like_count"] == 1
1049
1050       {:ok, unlike_activity, _, object} = ActivityPub.unlike(user, object)
1051       assert object.data["like_count"] == 0
1052
1053       assert Activity.get_by_id(like_activity.id) == nil
1054       assert note_activity.actor in unlike_activity.recipients
1055     end
1056   end
1057
1058   describe "announcing an object" do
1059     test "adds an announce activity to the db" do
1060       note_activity = insert(:note_activity)
1061       object = Object.normalize(note_activity)
1062       user = insert(:user)
1063
1064       {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1065       assert object.data["announcement_count"] == 1
1066       assert object.data["announcements"] == [user.ap_id]
1067
1068       assert announce_activity.data["to"] == [
1069                User.ap_followers(user),
1070                note_activity.data["actor"]
1071              ]
1072
1073       assert announce_activity.data["object"] == object.data["id"]
1074       assert announce_activity.data["actor"] == user.ap_id
1075       assert announce_activity.data["context"] == object.data["context"]
1076     end
1077
1078     test "reverts annouce from object on error" do
1079       note_activity = insert(:note_activity)
1080       object = Object.normalize(note_activity)
1081       user = insert(:user)
1082
1083       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1084         assert {:error, :reverted} = ActivityPub.announce(user, object)
1085       end
1086
1087       reloaded_object = Object.get_by_ap_id(object.data["id"])
1088       assert reloaded_object == object
1089       refute reloaded_object.data["announcement_count"]
1090       refute reloaded_object.data["announcements"]
1091     end
1092   end
1093
1094   describe "announcing a private object" do
1095     test "adds an announce activity to the db if the audience is not widened" do
1096       user = insert(:user)
1097       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1098       object = Object.normalize(note_activity)
1099
1100       {:ok, announce_activity, object} = ActivityPub.announce(user, object, nil, true, false)
1101
1102       assert announce_activity.data["to"] == [User.ap_followers(user)]
1103
1104       assert announce_activity.data["object"] == object.data["id"]
1105       assert announce_activity.data["actor"] == user.ap_id
1106       assert announce_activity.data["context"] == object.data["context"]
1107     end
1108
1109     test "does not add an announce activity to the db if the audience is widened" do
1110       user = insert(:user)
1111       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1112       object = Object.normalize(note_activity)
1113
1114       assert {:error, _} = ActivityPub.announce(user, object, nil, true, true)
1115     end
1116
1117     test "does not add an announce activity to the db if the announcer is not the author" do
1118       user = insert(:user)
1119       announcer = insert(:user)
1120       {:ok, note_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
1121       object = Object.normalize(note_activity)
1122
1123       assert {:error, _} = ActivityPub.announce(announcer, object, nil, true, false)
1124     end
1125   end
1126
1127   describe "unannouncing an object" do
1128     test "unannouncing a previously announced object" do
1129       note_activity = insert(:note_activity)
1130       object = Object.normalize(note_activity)
1131       user = insert(:user)
1132
1133       # Unannouncing an object that is not announced does nothing
1134       {:ok, object} = ActivityPub.unannounce(user, object)
1135       refute object.data["announcement_count"]
1136
1137       {:ok, announce_activity, object} = ActivityPub.announce(user, object)
1138       assert object.data["announcement_count"] == 1
1139
1140       {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
1141       assert object.data["announcement_count"] == 0
1142
1143       assert unannounce_activity.data["to"] == [
1144                User.ap_followers(user),
1145                object.data["actor"]
1146              ]
1147
1148       assert unannounce_activity.data["type"] == "Undo"
1149       assert unannounce_activity.data["object"] == announce_activity.data
1150       assert unannounce_activity.data["actor"] == user.ap_id
1151       assert unannounce_activity.data["context"] == announce_activity.data["context"]
1152
1153       assert Activity.get_by_id(announce_activity.id) == nil
1154     end
1155
1156     test "reverts unannouncing on error" do
1157       note_activity = insert(:note_activity)
1158       object = Object.normalize(note_activity)
1159       user = insert(:user)
1160
1161       {:ok, _announce_activity, object} = ActivityPub.announce(user, object)
1162       assert object.data["announcement_count"] == 1
1163
1164       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1165         assert {:error, :reverted} = ActivityPub.unannounce(user, object)
1166       end
1167
1168       object = Object.get_by_ap_id(object.data["id"])
1169       assert object.data["announcement_count"] == 1
1170     end
1171   end
1172
1173   describe "uploading files" do
1174     test "copies the file to the configured folder" do
1175       file = %Plug.Upload{
1176         content_type: "image/jpg",
1177         path: Path.absname("test/fixtures/image.jpg"),
1178         filename: "an_image.jpg"
1179       }
1180
1181       {:ok, %Object{} = object} = ActivityPub.upload(file)
1182       assert object.data["name"] == "an_image.jpg"
1183     end
1184
1185     test "works with base64 encoded images" do
1186       file = %{
1187         "img" => data_uri()
1188       }
1189
1190       {:ok, %Object{}} = ActivityPub.upload(file)
1191     end
1192   end
1193
1194   describe "fetch the latest Follow" do
1195     test "fetches the latest Follow activity" do
1196       %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
1197       follower = Repo.get_by(User, ap_id: activity.data["actor"])
1198       followed = Repo.get_by(User, ap_id: activity.data["object"])
1199
1200       assert activity == Utils.fetch_latest_follow(follower, followed)
1201     end
1202   end
1203
1204   describe "following / unfollowing" do
1205     test "it reverts follow activity" do
1206       follower = insert(:user)
1207       followed = insert(:user)
1208
1209       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1210         assert {:error, :reverted} = ActivityPub.follow(follower, followed)
1211       end
1212
1213       assert Repo.aggregate(Activity, :count, :id) == 0
1214       assert Repo.aggregate(Object, :count, :id) == 0
1215     end
1216
1217     test "it reverts unfollow activity" do
1218       follower = insert(:user)
1219       followed = insert(:user)
1220
1221       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1222
1223       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1224         assert {:error, :reverted} = ActivityPub.unfollow(follower, followed)
1225       end
1226
1227       activity = Activity.get_by_id(follow_activity.id)
1228       assert activity.data["type"] == "Follow"
1229       assert activity.data["actor"] == follower.ap_id
1230
1231       assert activity.data["object"] == followed.ap_id
1232     end
1233
1234     test "creates a follow activity" do
1235       follower = insert(:user)
1236       followed = insert(:user)
1237
1238       {:ok, activity} = ActivityPub.follow(follower, followed)
1239       assert activity.data["type"] == "Follow"
1240       assert activity.data["actor"] == follower.ap_id
1241       assert activity.data["object"] == followed.ap_id
1242     end
1243
1244     test "creates an undo activity for the last follow" do
1245       follower = insert(:user)
1246       followed = insert(:user)
1247
1248       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1249       {:ok, activity} = ActivityPub.unfollow(follower, followed)
1250
1251       assert activity.data["type"] == "Undo"
1252       assert activity.data["actor"] == follower.ap_id
1253
1254       embedded_object = activity.data["object"]
1255       assert is_map(embedded_object)
1256       assert embedded_object["type"] == "Follow"
1257       assert embedded_object["object"] == followed.ap_id
1258       assert embedded_object["id"] == follow_activity.data["id"]
1259     end
1260
1261     test "creates an undo activity for a pending follow request" do
1262       follower = insert(:user)
1263       followed = insert(:user, %{locked: true})
1264
1265       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1266       {:ok, activity} = ActivityPub.unfollow(follower, followed)
1267
1268       assert activity.data["type"] == "Undo"
1269       assert activity.data["actor"] == follower.ap_id
1270
1271       embedded_object = activity.data["object"]
1272       assert is_map(embedded_object)
1273       assert embedded_object["type"] == "Follow"
1274       assert embedded_object["object"] == followed.ap_id
1275       assert embedded_object["id"] == follow_activity.data["id"]
1276     end
1277   end
1278
1279   describe "blocking / unblocking" do
1280     test "reverts block activity on error" do
1281       [blocker, blocked] = insert_list(2, :user)
1282
1283       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1284         assert {:error, :reverted} = ActivityPub.block(blocker, blocked)
1285       end
1286
1287       assert Repo.aggregate(Activity, :count, :id) == 0
1288       assert Repo.aggregate(Object, :count, :id) == 0
1289     end
1290
1291     test "creates a block activity" do
1292       blocker = insert(:user)
1293       blocked = insert(:user)
1294
1295       {:ok, activity} = ActivityPub.block(blocker, blocked)
1296
1297       assert activity.data["type"] == "Block"
1298       assert activity.data["actor"] == blocker.ap_id
1299       assert activity.data["object"] == blocked.ap_id
1300     end
1301
1302     test "reverts unblock activity on error" do
1303       [blocker, blocked] = insert_list(2, :user)
1304       {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1305
1306       with_mock(Utils, [:passthrough], maybe_federate: fn _ -> {:error, :reverted} end) do
1307         assert {:error, :reverted} = ActivityPub.unblock(blocker, blocked)
1308       end
1309
1310       assert block_activity.data["type"] == "Block"
1311       assert block_activity.data["actor"] == blocker.ap_id
1312
1313       assert Repo.aggregate(Activity, :count, :id) == 1
1314       assert Repo.aggregate(Object, :count, :id) == 1
1315     end
1316
1317     test "creates an undo activity for the last block" do
1318       blocker = insert(:user)
1319       blocked = insert(:user)
1320
1321       {:ok, block_activity} = ActivityPub.block(blocker, blocked)
1322       {:ok, activity} = ActivityPub.unblock(blocker, blocked)
1323
1324       assert activity.data["type"] == "Undo"
1325       assert activity.data["actor"] == blocker.ap_id
1326
1327       embedded_object = activity.data["object"]
1328       assert is_map(embedded_object)
1329       assert embedded_object["type"] == "Block"
1330       assert embedded_object["object"] == blocked.ap_id
1331       assert embedded_object["id"] == block_activity.data["id"]
1332     end
1333   end
1334
1335   describe "timeline post-processing" do
1336     test "it filters broken threads" do
1337       user1 = insert(:user)
1338       user2 = insert(:user)
1339       user3 = insert(:user)
1340
1341       {:ok, user1} = User.follow(user1, user3)
1342       assert User.following?(user1, user3)
1343
1344       {:ok, user2} = User.follow(user2, user3)
1345       assert User.following?(user2, user3)
1346
1347       {:ok, user3} = User.follow(user3, user2)
1348       assert User.following?(user3, user2)
1349
1350       {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
1351
1352       {:ok, private_activity_1} =
1353         CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
1354
1355       {:ok, private_activity_2} =
1356         CommonAPI.post(user2, %{
1357           "status" => "hi 3",
1358           "visibility" => "private",
1359           "in_reply_to_status_id" => private_activity_1.id
1360         })
1361
1362       {:ok, private_activity_3} =
1363         CommonAPI.post(user3, %{
1364           "status" => "hi 4",
1365           "visibility" => "private",
1366           "in_reply_to_status_id" => private_activity_2.id
1367         })
1368
1369       activities =
1370         ActivityPub.fetch_activities([user1.ap_id | User.following(user1)])
1371         |> Enum.map(fn a -> a.id end)
1372
1373       private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
1374
1375       assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
1376
1377       assert length(activities) == 3
1378
1379       activities =
1380         ActivityPub.fetch_activities([user1.ap_id | User.following(user1)], %{"user" => user1})
1381         |> Enum.map(fn a -> a.id end)
1382
1383       assert [public_activity.id, private_activity_1.id] == activities
1384       assert length(activities) == 2
1385     end
1386   end
1387
1388   describe "update" do
1389     setup do: clear_config([:instance, :max_pinned_statuses])
1390
1391     test "it creates an update activity with the new user data" do
1392       user = insert(:user)
1393       {:ok, user} = User.ensure_keys_present(user)
1394       user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1395
1396       {:ok, update} =
1397         ActivityPub.update(%{
1398           actor: user_data["id"],
1399           to: [user.follower_address],
1400           cc: [],
1401           object: user_data
1402         })
1403
1404       assert update.data["actor"] == user.ap_id
1405       assert update.data["to"] == [user.follower_address]
1406       assert embedded_object = update.data["object"]
1407       assert embedded_object["id"] == user_data["id"]
1408       assert embedded_object["type"] == user_data["type"]
1409     end
1410   end
1411
1412   test "returned pinned statuses" do
1413     Config.put([:instance, :max_pinned_statuses], 3)
1414     user = insert(:user)
1415
1416     {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1417     {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1418     {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1419
1420     CommonAPI.pin(activity_one.id, user)
1421     user = refresh_record(user)
1422
1423     CommonAPI.pin(activity_two.id, user)
1424     user = refresh_record(user)
1425
1426     CommonAPI.pin(activity_three.id, user)
1427     user = refresh_record(user)
1428
1429     activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1430
1431     assert 3 = length(activities)
1432   end
1433
1434   describe "flag/1" do
1435     setup do
1436       reporter = insert(:user)
1437       target_account = insert(:user)
1438       content = "foobar"
1439       {:ok, activity} = CommonAPI.post(target_account, %{"status" => content})
1440       context = Utils.generate_context_id()
1441
1442       reporter_ap_id = reporter.ap_id
1443       target_ap_id = target_account.ap_id
1444       activity_ap_id = activity.data["id"]
1445
1446       activity_with_object = Activity.get_by_ap_id_with_object(activity_ap_id)
1447
1448       {:ok,
1449        %{
1450          reporter: reporter,
1451          context: context,
1452          target_account: target_account,
1453          reported_activity: activity,
1454          content: content,
1455          activity_ap_id: activity_ap_id,
1456          activity_with_object: activity_with_object,
1457          reporter_ap_id: reporter_ap_id,
1458          target_ap_id: target_ap_id
1459        }}
1460     end
1461
1462     test "it can create a Flag activity",
1463          %{
1464            reporter: reporter,
1465            context: context,
1466            target_account: target_account,
1467            reported_activity: reported_activity,
1468            content: content,
1469            activity_ap_id: activity_ap_id,
1470            activity_with_object: activity_with_object,
1471            reporter_ap_id: reporter_ap_id,
1472            target_ap_id: target_ap_id
1473          } do
1474       assert {:ok, activity} =
1475                ActivityPub.flag(%{
1476                  actor: reporter,
1477                  context: context,
1478                  account: target_account,
1479                  statuses: [reported_activity],
1480                  content: content
1481                })
1482
1483       note_obj = %{
1484         "type" => "Note",
1485         "id" => activity_ap_id,
1486         "content" => content,
1487         "published" => activity_with_object.object.data["published"],
1488         "actor" => AccountView.render("show.json", %{user: target_account})
1489       }
1490
1491       assert %Activity{
1492                actor: ^reporter_ap_id,
1493                data: %{
1494                  "type" => "Flag",
1495                  "content" => ^content,
1496                  "context" => ^context,
1497                  "object" => [^target_ap_id, ^note_obj]
1498                }
1499              } = activity
1500     end
1501
1502     test_with_mock "strips status data from Flag, before federating it",
1503                    %{
1504                      reporter: reporter,
1505                      context: context,
1506                      target_account: target_account,
1507                      reported_activity: reported_activity,
1508                      content: content
1509                    },
1510                    Utils,
1511                    [:passthrough],
1512                    [] do
1513       {:ok, activity} =
1514         ActivityPub.flag(%{
1515           actor: reporter,
1516           context: context,
1517           account: target_account,
1518           statuses: [reported_activity],
1519           content: content
1520         })
1521
1522       new_data =
1523         put_in(activity.data, ["object"], [target_account.ap_id, reported_activity.data["id"]])
1524
1525       assert_called(Utils.maybe_federate(%{activity | data: new_data}))
1526     end
1527   end
1528
1529   test "fetch_activities/2 returns activities addressed to a list " do
1530     user = insert(:user)
1531     member = insert(:user)
1532     {:ok, list} = Pleroma.List.create("foo", user)
1533     {:ok, list} = Pleroma.List.follow(list, member)
1534
1535     {:ok, activity} =
1536       CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1537
1538     activity = Repo.preload(activity, :bookmark)
1539     activity = %Activity{activity | thread_muted?: !!activity.thread_muted?}
1540
1541     assert ActivityPub.fetch_activities([], %{"user" => user}) == [activity]
1542   end
1543
1544   def data_uri do
1545     File.read!("test/fixtures/avatar_data_uri")
1546   end
1547
1548   describe "fetch_activities_bounded" do
1549     test "fetches private posts for followed users" do
1550       user = insert(:user)
1551
1552       {:ok, activity} =
1553         CommonAPI.post(user, %{
1554           "status" => "thought I looked cute might delete later :3",
1555           "visibility" => "private"
1556         })
1557
1558       [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1559       assert result.id == activity.id
1560     end
1561
1562     test "fetches only public posts for other users" do
1563       user = insert(:user)
1564       {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1565
1566       {:ok, _private_activity} =
1567         CommonAPI.post(user, %{
1568           "status" => "why is tenshi eating a corndog so cute?",
1569           "visibility" => "private"
1570         })
1571
1572       [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1573       assert result.id == activity.id
1574     end
1575   end
1576
1577   describe "fetch_follow_information_for_user" do
1578     test "syncronizes following/followers counters" do
1579       user =
1580         insert(:user,
1581           local: false,
1582           follower_address: "http://localhost:4001/users/fuser2/followers",
1583           following_address: "http://localhost:4001/users/fuser2/following"
1584         )
1585
1586       {:ok, info} = ActivityPub.fetch_follow_information_for_user(user)
1587       assert info.follower_count == 527
1588       assert info.following_count == 267
1589     end
1590
1591     test "detects hidden followers" do
1592       mock(fn env ->
1593         case env.url do
1594           "http://localhost:4001/users/masto_closed/followers?page=1" ->
1595             %Tesla.Env{status: 403, body: ""}
1596
1597           _ ->
1598             apply(HttpRequestMock, :request, [env])
1599         end
1600       end)
1601
1602       user =
1603         insert(:user,
1604           local: false,
1605           follower_address: "http://localhost:4001/users/masto_closed/followers",
1606           following_address: "http://localhost:4001/users/masto_closed/following"
1607         )
1608
1609       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1610       assert follow_info.hide_followers == true
1611       assert follow_info.hide_follows == false
1612     end
1613
1614     test "detects hidden follows" do
1615       mock(fn env ->
1616         case env.url do
1617           "http://localhost:4001/users/masto_closed/following?page=1" ->
1618             %Tesla.Env{status: 403, body: ""}
1619
1620           _ ->
1621             apply(HttpRequestMock, :request, [env])
1622         end
1623       end)
1624
1625       user =
1626         insert(:user,
1627           local: false,
1628           follower_address: "http://localhost:4001/users/masto_closed/followers",
1629           following_address: "http://localhost:4001/users/masto_closed/following"
1630         )
1631
1632       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1633       assert follow_info.hide_followers == false
1634       assert follow_info.hide_follows == true
1635     end
1636
1637     test "detects hidden follows/followers for friendica" do
1638       user =
1639         insert(:user,
1640           local: false,
1641           follower_address: "http://localhost:8080/followers/fuser3",
1642           following_address: "http://localhost:8080/following/fuser3"
1643         )
1644
1645       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1646       assert follow_info.hide_followers == true
1647       assert follow_info.follower_count == 296
1648       assert follow_info.following_count == 32
1649       assert follow_info.hide_follows == true
1650     end
1651
1652     test "doesn't crash when follower and following counters are hidden" do
1653       mock(fn env ->
1654         case env.url do
1655           "http://localhost:4001/users/masto_hidden_counters/following" ->
1656             json(%{
1657               "@context" => "https://www.w3.org/ns/activitystreams",
1658               "id" => "http://localhost:4001/users/masto_hidden_counters/followers"
1659             })
1660
1661           "http://localhost:4001/users/masto_hidden_counters/following?page=1" ->
1662             %Tesla.Env{status: 403, body: ""}
1663
1664           "http://localhost:4001/users/masto_hidden_counters/followers" ->
1665             json(%{
1666               "@context" => "https://www.w3.org/ns/activitystreams",
1667               "id" => "http://localhost:4001/users/masto_hidden_counters/following"
1668             })
1669
1670           "http://localhost:4001/users/masto_hidden_counters/followers?page=1" ->
1671             %Tesla.Env{status: 403, body: ""}
1672         end
1673       end)
1674
1675       user =
1676         insert(:user,
1677           local: false,
1678           follower_address: "http://localhost:4001/users/masto_hidden_counters/followers",
1679           following_address: "http://localhost:4001/users/masto_hidden_counters/following"
1680         )
1681
1682       {:ok, follow_info} = ActivityPub.fetch_follow_information_for_user(user)
1683
1684       assert follow_info.hide_followers == true
1685       assert follow_info.follower_count == 0
1686       assert follow_info.hide_follows == true
1687       assert follow_info.following_count == 0
1688     end
1689   end
1690
1691   describe "fetch_favourites/3" do
1692     test "returns a favourite activities sorted by adds to favorite" do
1693       user = insert(:user)
1694       other_user = insert(:user)
1695       user1 = insert(:user)
1696       user2 = insert(:user)
1697       {:ok, a1} = CommonAPI.post(user1, %{"status" => "bla"})
1698       {:ok, _a2} = CommonAPI.post(user2, %{"status" => "traps are happy"})
1699       {:ok, a3} = CommonAPI.post(user2, %{"status" => "Trees Are "})
1700       {:ok, a4} = CommonAPI.post(user2, %{"status" => "Agent Smith "})
1701       {:ok, a5} = CommonAPI.post(user1, %{"status" => "Red or Blue "})
1702
1703       {:ok, _} = CommonAPI.favorite(user, a4.id)
1704       {:ok, _} = CommonAPI.favorite(other_user, a3.id)
1705       {:ok, _} = CommonAPI.favorite(user, a3.id)
1706       {:ok, _} = CommonAPI.favorite(other_user, a5.id)
1707       {:ok, _} = CommonAPI.favorite(user, a5.id)
1708       {:ok, _} = CommonAPI.favorite(other_user, a4.id)
1709       {:ok, _} = CommonAPI.favorite(user, a1.id)
1710       {:ok, _} = CommonAPI.favorite(other_user, a1.id)
1711       result = ActivityPub.fetch_favourites(user)
1712
1713       assert Enum.map(result, & &1.id) == [a1.id, a5.id, a3.id, a4.id]
1714
1715       result = ActivityPub.fetch_favourites(user, %{"limit" => 2})
1716       assert Enum.map(result, & &1.id) == [a1.id, a5.id]
1717     end
1718   end
1719
1720   describe "Move activity" do
1721     test "create" do
1722       %{ap_id: old_ap_id} = old_user = insert(:user)
1723       %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
1724       follower = insert(:user)
1725       follower_move_opted_out = insert(:user, allow_following_move: false)
1726
1727       User.follow(follower, old_user)
1728       User.follow(follower_move_opted_out, old_user)
1729
1730       assert User.following?(follower, old_user)
1731       assert User.following?(follower_move_opted_out, old_user)
1732
1733       assert {:ok, activity} = ActivityPub.move(old_user, new_user)
1734
1735       assert %Activity{
1736                actor: ^old_ap_id,
1737                data: %{
1738                  "actor" => ^old_ap_id,
1739                  "object" => ^old_ap_id,
1740                  "target" => ^new_ap_id,
1741                  "type" => "Move"
1742                },
1743                local: true
1744              } = activity
1745
1746       params = %{
1747         "op" => "move_following",
1748         "origin_id" => old_user.id,
1749         "target_id" => new_user.id
1750       }
1751
1752       assert_enqueued(worker: Pleroma.Workers.BackgroundWorker, args: params)
1753
1754       Pleroma.Workers.BackgroundWorker.perform(params, nil)
1755
1756       refute User.following?(follower, old_user)
1757       assert User.following?(follower, new_user)
1758
1759       assert User.following?(follower_move_opted_out, old_user)
1760       refute User.following?(follower_move_opted_out, new_user)
1761
1762       activity = %Activity{activity | object: nil}
1763
1764       assert [%Notification{activity: ^activity}] = Notification.for_user(follower)
1765
1766       assert [%Notification{activity: ^activity}] = Notification.for_user(follower_move_opted_out)
1767     end
1768
1769     test "old user must be in the new user's `also_known_as` list" do
1770       old_user = insert(:user)
1771       new_user = insert(:user)
1772
1773       assert {:error, "Target account must have the origin in `alsoKnownAs`"} =
1774                ActivityPub.move(old_user, new_user)
1775     end
1776   end
1777
1778   test "doesn't retrieve replies activities with exclude_replies" do
1779     user = insert(:user)
1780
1781     {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
1782
1783     {:ok, _reply} =
1784       CommonAPI.post(user, %{"status" => "yeah", "in_reply_to_status_id" => activity.id})
1785
1786     [result] = ActivityPub.fetch_public_activities(%{"exclude_replies" => "true"})
1787
1788     assert result.id == activity.id
1789
1790     assert length(ActivityPub.fetch_public_activities()) == 2
1791   end
1792
1793   describe "replies filtering with public messages" do
1794     setup :public_messages
1795
1796     test "public timeline", %{users: %{u1: user}} do
1797       activities_ids =
1798         %{}
1799         |> Map.put("type", ["Create", "Announce"])
1800         |> Map.put("local_only", false)
1801         |> Map.put("blocking_user", user)
1802         |> Map.put("muting_user", user)
1803         |> Map.put("reply_filtering_user", user)
1804         |> ActivityPub.fetch_public_activities()
1805         |> Enum.map(& &1.id)
1806
1807       assert length(activities_ids) == 16
1808     end
1809
1810     test "public timeline with reply_visibility `following`", %{
1811       users: %{u1: user},
1812       u1: u1,
1813       u2: u2,
1814       u3: u3,
1815       u4: u4,
1816       activities: activities
1817     } do
1818       activities_ids =
1819         %{}
1820         |> Map.put("type", ["Create", "Announce"])
1821         |> Map.put("local_only", false)
1822         |> Map.put("blocking_user", user)
1823         |> Map.put("muting_user", user)
1824         |> Map.put("reply_visibility", "following")
1825         |> Map.put("reply_filtering_user", user)
1826         |> ActivityPub.fetch_public_activities()
1827         |> Enum.map(& &1.id)
1828
1829       assert length(activities_ids) == 14
1830
1831       visible_ids =
1832         Map.values(u1) ++ Map.values(u2) ++ Map.values(u4) ++ Map.values(activities) ++ [u3[:r1]]
1833
1834       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1835     end
1836
1837     test "public timeline with reply_visibility `self`", %{
1838       users: %{u1: user},
1839       u1: u1,
1840       u2: u2,
1841       u3: u3,
1842       u4: u4,
1843       activities: activities
1844     } do
1845       activities_ids =
1846         %{}
1847         |> Map.put("type", ["Create", "Announce"])
1848         |> Map.put("local_only", false)
1849         |> Map.put("blocking_user", user)
1850         |> Map.put("muting_user", user)
1851         |> Map.put("reply_visibility", "self")
1852         |> Map.put("reply_filtering_user", user)
1853         |> ActivityPub.fetch_public_activities()
1854         |> Enum.map(& &1.id)
1855
1856       assert length(activities_ids) == 10
1857       visible_ids = Map.values(u1) ++ [u2[:r1], u3[:r1], u4[:r1]] ++ Map.values(activities)
1858       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1859     end
1860
1861     test "home timeline", %{
1862       users: %{u1: user},
1863       activities: activities,
1864       u1: u1,
1865       u2: u2,
1866       u3: u3,
1867       u4: u4
1868     } do
1869       params =
1870         %{}
1871         |> Map.put("type", ["Create", "Announce"])
1872         |> Map.put("blocking_user", user)
1873         |> Map.put("muting_user", user)
1874         |> Map.put("user", user)
1875         |> Map.put("reply_filtering_user", user)
1876
1877       activities_ids =
1878         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1879         |> Enum.map(& &1.id)
1880
1881       assert length(activities_ids) == 13
1882
1883       visible_ids =
1884         Map.values(u1) ++
1885           Map.values(u3) ++
1886           [
1887             activities[:a1],
1888             activities[:a2],
1889             activities[:a4],
1890             u2[:r1],
1891             u2[:r3],
1892             u4[:r1],
1893             u4[:r2]
1894           ]
1895
1896       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1897     end
1898
1899     test "home timeline with reply_visibility `following`", %{
1900       users: %{u1: user},
1901       activities: activities,
1902       u1: u1,
1903       u2: u2,
1904       u3: u3,
1905       u4: u4
1906     } do
1907       params =
1908         %{}
1909         |> Map.put("type", ["Create", "Announce"])
1910         |> Map.put("blocking_user", user)
1911         |> Map.put("muting_user", user)
1912         |> Map.put("user", user)
1913         |> Map.put("reply_visibility", "following")
1914         |> Map.put("reply_filtering_user", user)
1915
1916       activities_ids =
1917         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1918         |> Enum.map(& &1.id)
1919
1920       assert length(activities_ids) == 11
1921
1922       visible_ids =
1923         Map.values(u1) ++
1924           [
1925             activities[:a1],
1926             activities[:a2],
1927             activities[:a4],
1928             u2[:r1],
1929             u2[:r3],
1930             u3[:r1],
1931             u4[:r1],
1932             u4[:r2]
1933           ]
1934
1935       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1936     end
1937
1938     test "home timeline with reply_visibility `self`", %{
1939       users: %{u1: user},
1940       activities: activities,
1941       u1: u1,
1942       u2: u2,
1943       u3: u3,
1944       u4: u4
1945     } do
1946       params =
1947         %{}
1948         |> Map.put("type", ["Create", "Announce"])
1949         |> Map.put("blocking_user", user)
1950         |> Map.put("muting_user", user)
1951         |> Map.put("user", user)
1952         |> Map.put("reply_visibility", "self")
1953         |> Map.put("reply_filtering_user", user)
1954
1955       activities_ids =
1956         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
1957         |> Enum.map(& &1.id)
1958
1959       assert length(activities_ids) == 9
1960
1961       visible_ids =
1962         Map.values(u1) ++
1963           [
1964             activities[:a1],
1965             activities[:a2],
1966             activities[:a4],
1967             u2[:r1],
1968             u3[:r1],
1969             u4[:r1]
1970           ]
1971
1972       assert Enum.all?(visible_ids, &(&1 in activities_ids))
1973     end
1974   end
1975
1976   describe "replies filtering with private messages" do
1977     setup :private_messages
1978
1979     test "public timeline", %{users: %{u1: user}} do
1980       activities_ids =
1981         %{}
1982         |> Map.put("type", ["Create", "Announce"])
1983         |> Map.put("local_only", false)
1984         |> Map.put("blocking_user", user)
1985         |> Map.put("muting_user", user)
1986         |> Map.put("user", user)
1987         |> ActivityPub.fetch_public_activities()
1988         |> Enum.map(& &1.id)
1989
1990       assert activities_ids == []
1991     end
1992
1993     test "public timeline with default reply_visibility `following`", %{users: %{u1: user}} do
1994       activities_ids =
1995         %{}
1996         |> Map.put("type", ["Create", "Announce"])
1997         |> Map.put("local_only", false)
1998         |> Map.put("blocking_user", user)
1999         |> Map.put("muting_user", user)
2000         |> Map.put("reply_visibility", "following")
2001         |> Map.put("reply_filtering_user", user)
2002         |> Map.put("user", user)
2003         |> ActivityPub.fetch_public_activities()
2004         |> Enum.map(& &1.id)
2005
2006       assert activities_ids == []
2007     end
2008
2009     test "public timeline with default reply_visibility `self`", %{users: %{u1: user}} do
2010       activities_ids =
2011         %{}
2012         |> Map.put("type", ["Create", "Announce"])
2013         |> Map.put("local_only", false)
2014         |> Map.put("blocking_user", user)
2015         |> Map.put("muting_user", user)
2016         |> Map.put("reply_visibility", "self")
2017         |> Map.put("reply_filtering_user", user)
2018         |> Map.put("user", user)
2019         |> ActivityPub.fetch_public_activities()
2020         |> Enum.map(& &1.id)
2021
2022       assert activities_ids == []
2023     end
2024
2025     test "home timeline", %{users: %{u1: user}} do
2026       params =
2027         %{}
2028         |> Map.put("type", ["Create", "Announce"])
2029         |> Map.put("blocking_user", user)
2030         |> Map.put("muting_user", user)
2031         |> Map.put("user", user)
2032
2033       activities_ids =
2034         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2035         |> Enum.map(& &1.id)
2036
2037       assert length(activities_ids) == 12
2038     end
2039
2040     test "home timeline with default reply_visibility `following`", %{users: %{u1: user}} do
2041       params =
2042         %{}
2043         |> Map.put("type", ["Create", "Announce"])
2044         |> Map.put("blocking_user", user)
2045         |> Map.put("muting_user", user)
2046         |> Map.put("user", user)
2047         |> Map.put("reply_visibility", "following")
2048         |> Map.put("reply_filtering_user", user)
2049
2050       activities_ids =
2051         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2052         |> Enum.map(& &1.id)
2053
2054       assert length(activities_ids) == 12
2055     end
2056
2057     test "home timeline with default reply_visibility `self`", %{
2058       users: %{u1: user},
2059       activities: activities,
2060       u1: u1,
2061       u2: u2,
2062       u3: u3,
2063       u4: u4
2064     } do
2065       params =
2066         %{}
2067         |> Map.put("type", ["Create", "Announce"])
2068         |> Map.put("blocking_user", user)
2069         |> Map.put("muting_user", user)
2070         |> Map.put("user", user)
2071         |> Map.put("reply_visibility", "self")
2072         |> Map.put("reply_filtering_user", user)
2073
2074       activities_ids =
2075         ActivityPub.fetch_activities([user.ap_id | User.following(user)], params)
2076         |> Enum.map(& &1.id)
2077
2078       assert length(activities_ids) == 10
2079
2080       visible_ids =
2081         Map.values(u1) ++ Map.values(u4) ++ [u2[:r1], u3[:r1]] ++ Map.values(activities)
2082
2083       assert Enum.all?(visible_ids, &(&1 in activities_ids))
2084     end
2085   end
2086
2087   defp public_messages(_) do
2088     [u1, u2, u3, u4] = insert_list(4, :user)
2089     {:ok, u1} = User.follow(u1, u2)
2090     {:ok, u2} = User.follow(u2, u1)
2091     {:ok, u1} = User.follow(u1, u4)
2092     {:ok, u4} = User.follow(u4, u1)
2093
2094     {:ok, u2} = User.follow(u2, u3)
2095     {:ok, u3} = User.follow(u3, u2)
2096
2097     {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status"})
2098
2099     {:ok, r1_1} =
2100       CommonAPI.post(u2, %{
2101         "status" => "@#{u1.nickname} reply from u2 to u1",
2102         "in_reply_to_status_id" => a1.id
2103       })
2104
2105     {:ok, r1_2} =
2106       CommonAPI.post(u3, %{
2107         "status" => "@#{u1.nickname} reply from u3 to u1",
2108         "in_reply_to_status_id" => a1.id
2109       })
2110
2111     {:ok, r1_3} =
2112       CommonAPI.post(u4, %{
2113         "status" => "@#{u1.nickname} reply from u4 to u1",
2114         "in_reply_to_status_id" => a1.id
2115       })
2116
2117     {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status"})
2118
2119     {:ok, r2_1} =
2120       CommonAPI.post(u1, %{
2121         "status" => "@#{u2.nickname} reply from u1 to u2",
2122         "in_reply_to_status_id" => a2.id
2123       })
2124
2125     {:ok, r2_2} =
2126       CommonAPI.post(u3, %{
2127         "status" => "@#{u2.nickname} reply from u3 to u2",
2128         "in_reply_to_status_id" => a2.id
2129       })
2130
2131     {:ok, r2_3} =
2132       CommonAPI.post(u4, %{
2133         "status" => "@#{u2.nickname} reply from u4 to u2",
2134         "in_reply_to_status_id" => a2.id
2135       })
2136
2137     {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status"})
2138
2139     {:ok, r3_1} =
2140       CommonAPI.post(u1, %{
2141         "status" => "@#{u3.nickname} reply from u1 to u3",
2142         "in_reply_to_status_id" => a3.id
2143       })
2144
2145     {:ok, r3_2} =
2146       CommonAPI.post(u2, %{
2147         "status" => "@#{u3.nickname} reply from u2 to u3",
2148         "in_reply_to_status_id" => a3.id
2149       })
2150
2151     {:ok, r3_3} =
2152       CommonAPI.post(u4, %{
2153         "status" => "@#{u3.nickname} reply from u4 to u3",
2154         "in_reply_to_status_id" => a3.id
2155       })
2156
2157     {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status"})
2158
2159     {:ok, r4_1} =
2160       CommonAPI.post(u1, %{
2161         "status" => "@#{u4.nickname} reply from u1 to u4",
2162         "in_reply_to_status_id" => a4.id
2163       })
2164
2165     {:ok, r4_2} =
2166       CommonAPI.post(u2, %{
2167         "status" => "@#{u4.nickname} reply from u2 to u4",
2168         "in_reply_to_status_id" => a4.id
2169       })
2170
2171     {:ok, r4_3} =
2172       CommonAPI.post(u3, %{
2173         "status" => "@#{u4.nickname} reply from u3 to u4",
2174         "in_reply_to_status_id" => a4.id
2175       })
2176
2177     {:ok,
2178      users: %{u1: u1, u2: u2, u3: u3, u4: u4},
2179      activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
2180      u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
2181      u2: %{r1: r2_1.id, r2: r2_2.id, r3: r2_3.id},
2182      u3: %{r1: r3_1.id, r2: r3_2.id, r3: r3_3.id},
2183      u4: %{r1: r4_1.id, r2: r4_2.id, r3: r4_3.id}}
2184   end
2185
2186   defp private_messages(_) do
2187     [u1, u2, u3, u4] = insert_list(4, :user)
2188     {:ok, u1} = User.follow(u1, u2)
2189     {:ok, u2} = User.follow(u2, u1)
2190     {:ok, u1} = User.follow(u1, u3)
2191     {:ok, u3} = User.follow(u3, u1)
2192     {:ok, u1} = User.follow(u1, u4)
2193     {:ok, u4} = User.follow(u4, u1)
2194
2195     {:ok, u2} = User.follow(u2, u3)
2196     {:ok, u3} = User.follow(u3, u2)
2197
2198     {:ok, a1} = CommonAPI.post(u1, %{"status" => "Status", "visibility" => "private"})
2199
2200     {:ok, r1_1} =
2201       CommonAPI.post(u2, %{
2202         "status" => "@#{u1.nickname} reply from u2 to u1",
2203         "in_reply_to_status_id" => a1.id,
2204         "visibility" => "private"
2205       })
2206
2207     {:ok, r1_2} =
2208       CommonAPI.post(u3, %{
2209         "status" => "@#{u1.nickname} reply from u3 to u1",
2210         "in_reply_to_status_id" => a1.id,
2211         "visibility" => "private"
2212       })
2213
2214     {:ok, r1_3} =
2215       CommonAPI.post(u4, %{
2216         "status" => "@#{u1.nickname} reply from u4 to u1",
2217         "in_reply_to_status_id" => a1.id,
2218         "visibility" => "private"
2219       })
2220
2221     {:ok, a2} = CommonAPI.post(u2, %{"status" => "Status", "visibility" => "private"})
2222
2223     {:ok, r2_1} =
2224       CommonAPI.post(u1, %{
2225         "status" => "@#{u2.nickname} reply from u1 to u2",
2226         "in_reply_to_status_id" => a2.id,
2227         "visibility" => "private"
2228       })
2229
2230     {:ok, r2_2} =
2231       CommonAPI.post(u3, %{
2232         "status" => "@#{u2.nickname} reply from u3 to u2",
2233         "in_reply_to_status_id" => a2.id,
2234         "visibility" => "private"
2235       })
2236
2237     {:ok, a3} = CommonAPI.post(u3, %{"status" => "Status", "visibility" => "private"})
2238
2239     {:ok, r3_1} =
2240       CommonAPI.post(u1, %{
2241         "status" => "@#{u3.nickname} reply from u1 to u3",
2242         "in_reply_to_status_id" => a3.id,
2243         "visibility" => "private"
2244       })
2245
2246     {:ok, r3_2} =
2247       CommonAPI.post(u2, %{
2248         "status" => "@#{u3.nickname} reply from u2 to u3",
2249         "in_reply_to_status_id" => a3.id,
2250         "visibility" => "private"
2251       })
2252
2253     {:ok, a4} = CommonAPI.post(u4, %{"status" => "Status", "visibility" => "private"})
2254
2255     {:ok, r4_1} =
2256       CommonAPI.post(u1, %{
2257         "status" => "@#{u4.nickname} reply from u1 to u4",
2258         "in_reply_to_status_id" => a4.id,
2259         "visibility" => "private"
2260       })
2261
2262     {:ok,
2263      users: %{u1: u1, u2: u2, u3: u3, u4: u4},
2264      activities: %{a1: a1.id, a2: a2.id, a3: a3.id, a4: a4.id},
2265      u1: %{r1: r1_1.id, r2: r1_2.id, r3: r1_3.id},
2266      u2: %{r1: r2_1.id, r2: r2_2.id},
2267      u3: %{r1: r3_1.id, r2: r3_2.id},
2268      u4: %{r1: r4_1.id}}
2269   end
2270
2271   describe "maybe_update_follow_information/1" do
2272     setup do
2273       clear_config([:instance, :external_user_synchronization], true)
2274
2275       user = %{
2276         local: false,
2277         ap_id: "https://gensokyo.2hu/users/raymoo",
2278         following_address: "https://gensokyo.2hu/users/following",
2279         follower_address: "https://gensokyo.2hu/users/followers",
2280         type: "Person"
2281       }
2282
2283       %{user: user}
2284     end
2285
2286     test "logs an error when it can't fetch the info", %{user: user} do
2287       assert capture_log(fn ->
2288                ActivityPub.maybe_update_follow_information(user)
2289              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2290     end
2291
2292     test "just returns the input if the user type is Application", %{
2293       user: user
2294     } do
2295       user =
2296         user
2297         |> Map.put(:type, "Application")
2298
2299       refute capture_log(fn ->
2300                assert ^user = ActivityPub.maybe_update_follow_information(user)
2301              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2302     end
2303
2304     test "it just returns the input if the user has no following/follower addresses", %{
2305       user: user
2306     } do
2307       user =
2308         user
2309         |> Map.put(:following_address, nil)
2310         |> Map.put(:follower_address, nil)
2311
2312       refute capture_log(fn ->
2313                assert ^user = ActivityPub.maybe_update_follow_information(user)
2314              end) =~ "Follower/Following counter update for #{user.ap_id} failed"
2315     end
2316   end
2317 end