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

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