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   alias Pleroma.Activity
   8   alias Pleroma.Builders.ActivityBuilder
   9   alias Pleroma.Instances
  10   alias Pleroma.Object
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.ActivityPub.Publisher
  14   alias Pleroma.Web.ActivityPub.Utils
  15   alias Pleroma.Web.CommonAPI
  16
  17   import Pleroma.Factory
  18   import Tesla.Mock
  19   import Mock
  20
  21   setup do
  22     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  23     :ok
  24   end
  25
  26   describe "streaming out participations" do
  27     test "it streams them out" do
  28       user = insert(:user)
  29       {:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
  30
  31       {:ok, conversation} = Pleroma.Conversation.create_or_bump_for(activity)
  32
  33       participations =
  34         conversation.participations
  35         |> Repo.preload(:user)
  36
  37       with_mock Pleroma.Web.Streamer,
  38         stream: fn _, _ -> nil end do
  39         ActivityPub.stream_out_participations(conversation.participations)
  40
  41         Enum.each(participations, fn participation ->
  42           assert called(Pleroma.Web.Streamer.stream("participation", participation))
  43         end)
  44       end
  45     end
  46   end
  47
  48   describe "fetching restricted by visibility" do
  49     test "it restricts by the appropriate visibility" do
  50       user = insert(:user)
  51
  52       {:ok, public_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "public"})
  53
  54       {:ok, direct_activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
  55
  56       {:ok, unlisted_activity} =
  57         CommonAPI.post(user, %{"status" => ".", "visibility" => "unlisted"})
  58
  59       {:ok, private_activity} =
  60         CommonAPI.post(user, %{"status" => ".", "visibility" => "private"})
  61
  62       activities =
  63         ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})
  64
  65       assert activities == [direct_activity]
  66
  67       activities =
  68         ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})
  69
  70       assert activities == [unlisted_activity]
  71
  72       activities =
  73         ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})
  74
  75       assert activities == [private_activity]
  76
  77       activities =
  78         ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})
  79
  80       assert activities == [public_activity]
  81
  82       activities =
  83         ActivityPub.fetch_activities([], %{
  84           :visibility => ~w[private public],
  85           "actor_id" => user.ap_id
  86         })
  87
  88       assert activities == [public_activity, private_activity]
  89     end
  90   end
  91
  92   describe "building a user from his ap id" do
  93     test "it returns a user" do
  94       user_id = "http://mastodon.example.org/users/admin"
  95       {:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
  96       assert user.ap_id == user_id
  97       assert user.nickname == "admin@mastodon.example.org"
  98       assert user.info.source_data
  99       assert user.info.ap_enabled
 100       assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
 101     end
 102
 103     test "it fetches the appropriate tag-restricted posts" do
 104       user = insert(:user)
 105
 106       {:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
 107       {:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
 108       {:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})
 109
 110       fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
 111
 112       fetch_two =
 113         ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})
 114
 115       fetch_three =
 116         ActivityPub.fetch_activities([], %{
 117           "type" => "Create",
 118           "tag" => ["test", "essais"],
 119           "tag_reject" => ["reject"]
 120         })
 121
 122       fetch_four =
 123         ActivityPub.fetch_activities([], %{
 124           "type" => "Create",
 125           "tag" => ["test"],
 126           "tag_all" => ["test", "reject"]
 127         })
 128
 129       assert fetch_one == [status_one, status_three]
 130       assert fetch_two == [status_one, status_two, status_three]
 131       assert fetch_three == [status_one, status_two]
 132       assert fetch_four == [status_three]
 133     end
 134   end
 135
 136   describe "insertion" do
 137     test "drops activities beyond a certain limit" do
 138       limit = Pleroma.Config.get([:instance, :remote_limit])
 139
 140       random_text =
 141         :crypto.strong_rand_bytes(limit + 1)
 142         |> Base.encode64()
 143         |> binary_part(0, limit + 1)
 144
 145       data = %{
 146         "ok" => true,
 147         "object" => %{
 148           "content" => random_text
 149         }
 150       }
 151
 152       assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
 153     end
 154
 155     test "doesn't drop activities with content being null" do
 156       user = insert(:user)
 157
 158       data = %{
 159         "actor" => user.ap_id,
 160         "to" => [],
 161         "object" => %{
 162           "actor" => user.ap_id,
 163           "to" => [],
 164           "type" => "Note",
 165           "content" => nil
 166         }
 167       }
 168
 169       assert {:ok, _} = ActivityPub.insert(data)
 170     end
 171
 172     test "returns the activity if one with the same id is already in" do
 173       activity = insert(:note_activity)
 174       {:ok, new_activity} = ActivityPub.insert(activity.data)
 175
 176       assert activity.id == new_activity.id
 177     end
 178
 179     test "inserts a given map into the activity database, giving it an id if it has none." do
 180       user = insert(:user)
 181
 182       data = %{
 183         "actor" => user.ap_id,
 184         "to" => [],
 185         "object" => %{
 186           "actor" => user.ap_id,
 187           "to" => [],
 188           "type" => "Note",
 189           "content" => "hey"
 190         }
 191       }
 192
 193       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
 194       assert activity.data["ok"] == data["ok"]
 195       assert is_binary(activity.data["id"])
 196
 197       given_id = "bla"
 198
 199       data = %{
 200         "id" => given_id,
 201         "actor" => user.ap_id,
 202         "to" => [],
 203         "context" => "blabla",
 204         "object" => %{
 205           "actor" => user.ap_id,
 206           "to" => [],
 207           "type" => "Note",
 208           "content" => "hey"
 209         }
 210       }
 211
 212       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
 213       assert activity.data["ok"] == data["ok"]
 214       assert activity.data["id"] == given_id
 215       assert activity.data["context"] == "blabla"
 216       assert activity.data["context_id"]
 217     end
 218
 219     test "adds a context when none is there" do
 220       user = insert(:user)
 221
 222       data = %{
 223         "actor" => user.ap_id,
 224         "to" => [],
 225         "object" => %{
 226           "actor" => user.ap_id,
 227           "to" => [],
 228           "type" => "Note",
 229           "content" => "hey"
 230         }
 231       }
 232
 233       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
 234       object = Pleroma.Object.normalize(activity)
 235
 236       assert is_binary(activity.data["context"])
 237       assert is_binary(object.data["context"])
 238       assert activity.data["context_id"]
 239       assert object.data["context_id"]
 240     end
 241
 242     test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
 243       user = insert(:user)
 244
 245       data = %{
 246         "actor" => user.ap_id,
 247         "to" => [],
 248         "object" => %{
 249           "actor" => user.ap_id,
 250           "to" => [],
 251           "type" => "Note",
 252           "content" => "hey"
 253         }
 254       }
 255
 256       {:ok, %Activity{} = activity} = ActivityPub.insert(data)
 257       assert object = Object.normalize(activity)
 258       assert is_binary(object.data["id"])
 259     end
 260   end
 261
 262   describe "create activities" do
 263     test "removes doubled 'to' recipients" do
 264       user = insert(:user)
 265
 266       {:ok, activity} =
 267         ActivityPub.create(%{
 268           to: ["user1", "user1", "user2"],
 269           actor: user,
 270           context: "",
 271           object: %{
 272             "to" => ["user1", "user1", "user2"],
 273             "type" => "Note",
 274             "content" => "testing"
 275           }
 276         })
 277
 278       assert activity.data["to"] == ["user1", "user2"]
 279       assert activity.actor == user.ap_id
 280       assert activity.recipients == ["user1", "user2", user.ap_id]
 281     end
 282
 283     test "increases user note count only for public activities" do
 284       user = insert(:user)
 285
 286       {:ok, _} =
 287         CommonAPI.post(User.get_cached_by_id(user.id), %{
 288           "status" => "1",
 289           "visibility" => "public"
 290         })
 291
 292       {:ok, _} =
 293         CommonAPI.post(User.get_cached_by_id(user.id), %{
 294           "status" => "2",
 295           "visibility" => "unlisted"
 296         })
 297
 298       {:ok, _} =
 299         CommonAPI.post(User.get_cached_by_id(user.id), %{
 300           "status" => "2",
 301           "visibility" => "private"
 302         })
 303
 304       {:ok, _} =
 305         CommonAPI.post(User.get_cached_by_id(user.id), %{
 306           "status" => "3",
 307           "visibility" => "direct"
 308         })
 309
 310       user = User.get_cached_by_id(user.id)
 311       assert user.info.note_count == 2
 312     end
 313
 314     test "increases replies count" do
 315       user = insert(:user)
 316       user2 = insert(:user)
 317
 318       {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
 319       ap_id = activity.data["id"]
 320       reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
 321
 322       # public
 323       {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
 324       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 325       assert object.data["repliesCount"] == 1
 326
 327       # unlisted
 328       {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
 329       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 330       assert object.data["repliesCount"] == 2
 331
 332       # private
 333       {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
 334       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 335       assert object.data["repliesCount"] == 2
 336
 337       # direct
 338       {:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
 339       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 340       assert object.data["repliesCount"] == 2
 341     end
 342   end
 343
 344   describe "fetch activities for recipients" do
 345     test "retrieve the activities for certain recipients" do
 346       {:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
 347       {:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
 348       {:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})
 349
 350       activities = ActivityPub.fetch_activities(["someone", "someone_else"])
 351       assert length(activities) == 2
 352       assert activities == [activity_one, activity_two]
 353     end
 354   end
 355
 356   describe "fetch activities in context" do
 357     test "retrieves activities that have a given context" do
 358       {:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 359       {:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
 360       {:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
 361       {:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
 362       activity_five = insert(:note_activity)
 363       user = insert(:user)
 364
 365       {:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})
 366
 367       activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
 368       assert activities == [activity_two, activity]
 369     end
 370   end
 371
 372   test "doesn't return blocked activities" do
 373     activity_one = insert(:note_activity)
 374     activity_two = insert(:note_activity)
 375     activity_three = insert(:note_activity)
 376     user = insert(:user)
 377     booster = insert(:user)
 378     {:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})
 379
 380     activities =
 381       ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
 382
 383     assert Enum.member?(activities, activity_two)
 384     assert Enum.member?(activities, activity_three)
 385     refute Enum.member?(activities, activity_one)
 386
 387     {:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
 388
 389     activities =
 390       ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
 391
 392     assert Enum.member?(activities, activity_two)
 393     assert Enum.member?(activities, activity_three)
 394     assert Enum.member?(activities, activity_one)
 395
 396     {:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
 397     {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
 398     %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
 399     activity_three = Activity.get_by_id(activity_three.id)
 400
 401     activities =
 402       ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
 403
 404     assert Enum.member?(activities, activity_two)
 405     refute Enum.member?(activities, activity_three)
 406     refute Enum.member?(activities, boost_activity)
 407     assert Enum.member?(activities, activity_one)
 408
 409     activities =
 410       ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})
 411
 412     assert Enum.member?(activities, activity_two)
 413     assert Enum.member?(activities, activity_three)
 414     assert Enum.member?(activities, boost_activity)
 415     assert Enum.member?(activities, activity_one)
 416   end
 417
 418   test "doesn't return transitive interactions concerning blocked users" do
 419     blocker = insert(:user)
 420     blockee = insert(:user)
 421     friend = insert(:user)
 422
 423     {:ok, blocker} = User.block(blocker, blockee)
 424
 425     {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
 426
 427     {:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
 428
 429     {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
 430
 431     {:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
 432
 433     activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
 434
 435     assert Enum.member?(activities, activity_one)
 436     refute Enum.member?(activities, activity_two)
 437     refute Enum.member?(activities, activity_three)
 438     refute Enum.member?(activities, activity_four)
 439   end
 440
 441   test "doesn't return announce activities concerning blocked users" do
 442     blocker = insert(:user)
 443     blockee = insert(:user)
 444     friend = insert(:user)
 445
 446     {:ok, blocker} = User.block(blocker, blockee)
 447
 448     {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
 449
 450     {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
 451
 452     {:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)
 453
 454     activities =
 455       ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
 456       |> Enum.map(fn act -> act.id end)
 457
 458     assert Enum.member?(activities, activity_one.id)
 459     refute Enum.member?(activities, activity_two.id)
 460     refute Enum.member?(activities, activity_three.id)
 461   end
 462
 463   test "doesn't return activities from blocked domains" do
 464     domain = "dogwhistle.zone"
 465     domain_user = insert(:user, %{ap_id: "https://#{domain}/@pundit"})
 466     note = insert(:note, %{data: %{"actor" => domain_user.ap_id}})
 467     activity = insert(:note_activity, %{note: note})
 468     user = insert(:user)
 469     {:ok, user} = User.block_domain(user, domain)
 470
 471     activities =
 472       ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
 473
 474     refute activity in activities
 475
 476     followed_user = insert(:user)
 477     ActivityPub.follow(user, followed_user)
 478     {:ok, repeat_activity, _} = CommonAPI.repeat(activity.id, followed_user)
 479
 480     activities =
 481       ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
 482
 483     refute repeat_activity in activities
 484   end
 485
 486   test "doesn't return muted activities" do
 487     activity_one = insert(:note_activity)
 488     activity_two = insert(:note_activity)
 489     activity_three = insert(:note_activity)
 490     user = insert(:user)
 491     booster = insert(:user)
 492     {:ok, user} = User.mute(user, %User{ap_id: activity_one.data["actor"]})
 493
 494     activities =
 495       ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
 496
 497     assert Enum.member?(activities, activity_two)
 498     assert Enum.member?(activities, activity_three)
 499     refute Enum.member?(activities, activity_one)
 500
 501     # Calling with 'with_muted' will deliver muted activities, too.
 502     activities =
 503       ActivityPub.fetch_activities([], %{
 504         "muting_user" => user,
 505         "with_muted" => true,
 506         "skip_preload" => true
 507       })
 508
 509     assert Enum.member?(activities, activity_two)
 510     assert Enum.member?(activities, activity_three)
 511     assert Enum.member?(activities, activity_one)
 512
 513     {:ok, user} = User.unmute(user, %User{ap_id: activity_one.data["actor"]})
 514
 515     activities =
 516       ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
 517
 518     assert Enum.member?(activities, activity_two)
 519     assert Enum.member?(activities, activity_three)
 520     assert Enum.member?(activities, activity_one)
 521
 522     {:ok, user} = User.mute(user, %User{ap_id: activity_three.data["actor"]})
 523     {:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
 524     %Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
 525     activity_three = Activity.get_by_id(activity_three.id)
 526
 527     activities =
 528       ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})
 529
 530     assert Enum.member?(activities, activity_two)
 531     refute Enum.member?(activities, activity_three)
 532     refute Enum.member?(activities, boost_activity)
 533     assert Enum.member?(activities, activity_one)
 534
 535     activities = ActivityPub.fetch_activities([], %{"muting_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 "does include announces on request" do
 544     activity_three = insert(:note_activity)
 545     user = insert(:user)
 546     booster = insert(:user)
 547
 548     {:ok, user} = User.follow(user, booster)
 549
 550     {:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)
 551
 552     [announce_activity] = ActivityPub.fetch_activities([user.ap_id | user.following])
 553
 554     assert announce_activity.id == announce.id
 555   end
 556
 557   test "excludes reblogs on request" do
 558     user = insert(:user)
 559     {:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
 560     {:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})
 561
 562     [activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})
 563
 564     assert activity == expected_activity
 565   end
 566
 567   describe "public fetch activities" do
 568     test "doesn't retrieve unlisted activities" do
 569       user = insert(:user)
 570
 571       {:ok, _unlisted_activity} =
 572         CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})
 573
 574       {:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})
 575
 576       [activity] = ActivityPub.fetch_public_activities()
 577
 578       assert activity == listed_activity
 579     end
 580
 581     test "retrieves public activities" do
 582       _activities = ActivityPub.fetch_public_activities()
 583
 584       %{public: public} = ActivityBuilder.public_and_non_public()
 585
 586       activities = ActivityPub.fetch_public_activities()
 587       assert length(activities) == 1
 588       assert Enum.at(activities, 0) == public
 589     end
 590
 591     test "retrieves a maximum of 20 activities" do
 592       activities = ActivityBuilder.insert_list(30)
 593       last_expected = List.last(activities)
 594
 595       activities = ActivityPub.fetch_public_activities()
 596       last = List.last(activities)
 597
 598       assert length(activities) == 20
 599       assert last == last_expected
 600     end
 601
 602     test "retrieves ids starting from a since_id" do
 603       activities = ActivityBuilder.insert_list(30)
 604       later_activities = ActivityBuilder.insert_list(10)
 605       since_id = List.last(activities).id
 606       last_expected = List.last(later_activities)
 607
 608       activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
 609       last = List.last(activities)
 610
 611       assert length(activities) == 10
 612       assert last == last_expected
 613     end
 614
 615     test "retrieves ids up to max_id" do
 616       _first_activities = ActivityBuilder.insert_list(10)
 617       activities = ActivityBuilder.insert_list(20)
 618       later_activities = ActivityBuilder.insert_list(10)
 619       max_id = List.first(later_activities).id
 620       last_expected = List.last(activities)
 621
 622       activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
 623       last = List.last(activities)
 624
 625       assert length(activities) == 20
 626       assert last == last_expected
 627     end
 628
 629     test "doesn't return reblogs for users for whom reblogs have been muted" do
 630       activity = insert(:note_activity)
 631       user = insert(:user)
 632       booster = insert(:user)
 633       {:ok, user} = CommonAPI.hide_reblogs(user, booster)
 634
 635       {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
 636
 637       activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
 638
 639       refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
 640     end
 641
 642     test "returns reblogs for users for whom reblogs have not been muted" do
 643       activity = insert(:note_activity)
 644       user = insert(:user)
 645       booster = insert(:user)
 646       {:ok, user} = CommonAPI.hide_reblogs(user, booster)
 647       {:ok, user} = CommonAPI.show_reblogs(user, booster)
 648
 649       {:ok, activity, _} = CommonAPI.repeat(activity.id, booster)
 650
 651       activities = ActivityPub.fetch_activities([], %{"muting_user" => user})
 652
 653       assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
 654     end
 655   end
 656
 657   describe "like an object" do
 658     test "adds a like activity to the db" do
 659       note_activity = insert(:note_activity)
 660       assert object = Object.normalize(note_activity)
 661
 662       user = insert(:user)
 663       user_two = insert(:user)
 664
 665       {:ok, like_activity, object} = ActivityPub.like(user, object)
 666
 667       assert like_activity.data["actor"] == user.ap_id
 668       assert like_activity.data["type"] == "Like"
 669       # assert like_activity.data["object"] == object.data["id"]
 670       assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
 671       assert like_activity.data["context"] == object.data["context"]
 672       assert object.data["like_count"] == 1
 673       assert object.data["likes"] == [user.ap_id]
 674
 675       # Just return the original activity if the user already liked it.
 676       {:ok, same_like_activity, object} = ActivityPub.like(user, object)
 677
 678       assert like_activity == same_like_activity
 679       assert object.data["likes"] == [user.ap_id]
 680       assert object.data["like_count"] == 1
 681
 682       {:ok, _like_activity, object} = ActivityPub.like(user_two, object)
 683       assert object.data["like_count"] == 2
 684     end
 685   end
 686
 687   describe "unliking" do
 688     test "unliking a previously liked object" do
 689       note_activity = insert(:note_activity)
 690       object = Object.normalize(note_activity)
 691       user = insert(:user)
 692
 693       # Unliking something that hasn't been liked does nothing
 694       {:ok, object} = ActivityPub.unlike(user, object)
 695       assert object.data["like_count"] == 0
 696
 697       {:ok, like_activity, object} = ActivityPub.like(user, object)
 698       assert object.data["like_count"] == 1
 699
 700       {:ok, _, _, object} = ActivityPub.unlike(user, object)
 701       assert object.data["like_count"] == 0
 702
 703       assert Activity.get_by_id(like_activity.id) == nil
 704     end
 705   end
 706
 707   describe "announcing an object" do
 708     test "adds an announce activity to the db" do
 709       note_activity = insert(:note_activity)
 710       object = Object.normalize(note_activity)
 711       user = insert(:user)
 712
 713       {:ok, announce_activity, object} = ActivityPub.announce(user, object)
 714       assert object.data["announcement_count"] == 1
 715       assert object.data["announcements"] == [user.ap_id]
 716
 717       assert announce_activity.data["to"] == [
 718                User.ap_followers(user),
 719                note_activity.data["actor"]
 720              ]
 721
 722       assert announce_activity.data["object"] == object.data["id"]
 723       assert announce_activity.data["actor"] == user.ap_id
 724       assert announce_activity.data["context"] == object.data["context"]
 725     end
 726   end
 727
 728   describe "unannouncing an object" do
 729     test "unannouncing a previously announced object" do
 730       note_activity = insert(:note_activity)
 731       object = Object.normalize(note_activity)
 732       user = insert(:user)
 733
 734       # Unannouncing an object that is not announced does nothing
 735       # {:ok, object} = ActivityPub.unannounce(user, object)
 736       # assert object.data["announcement_count"] == 0
 737
 738       {:ok, announce_activity, object} = ActivityPub.announce(user, object)
 739       assert object.data["announcement_count"] == 1
 740
 741       {:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
 742       assert object.data["announcement_count"] == 0
 743
 744       assert unannounce_activity.data["to"] == [
 745                User.ap_followers(user),
 746                announce_activity.data["actor"]
 747              ]
 748
 749       assert unannounce_activity.data["type"] == "Undo"
 750       assert unannounce_activity.data["object"] == announce_activity.data
 751       assert unannounce_activity.data["actor"] == user.ap_id
 752       assert unannounce_activity.data["context"] == announce_activity.data["context"]
 753
 754       assert Activity.get_by_id(announce_activity.id) == nil
 755     end
 756   end
 757
 758   describe "uploading files" do
 759     test "copies the file to the configured folder" do
 760       file = %Plug.Upload{
 761         content_type: "image/jpg",
 762         path: Path.absname("test/fixtures/image.jpg"),
 763         filename: "an_image.jpg"
 764       }
 765
 766       {:ok, %Object{} = object} = ActivityPub.upload(file)
 767       assert object.data["name"] == "an_image.jpg"
 768     end
 769
 770     test "works with base64 encoded images" do
 771       file = %{
 772         "img" => data_uri()
 773       }
 774
 775       {:ok, %Object{}} = ActivityPub.upload(file)
 776     end
 777   end
 778
 779   describe "fetch the latest Follow" do
 780     test "fetches the latest Follow activity" do
 781       %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
 782       follower = Repo.get_by(User, ap_id: activity.data["actor"])
 783       followed = Repo.get_by(User, ap_id: activity.data["object"])
 784
 785       assert activity == Utils.fetch_latest_follow(follower, followed)
 786     end
 787   end
 788
 789   describe "following / unfollowing" do
 790     test "creates a follow activity" do
 791       follower = insert(:user)
 792       followed = insert(:user)
 793
 794       {:ok, activity} = ActivityPub.follow(follower, followed)
 795       assert activity.data["type"] == "Follow"
 796       assert activity.data["actor"] == follower.ap_id
 797       assert activity.data["object"] == followed.ap_id
 798     end
 799
 800     test "creates an undo activity for the last follow" do
 801       follower = insert(:user)
 802       followed = insert(:user)
 803
 804       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 805       {:ok, activity} = ActivityPub.unfollow(follower, followed)
 806
 807       assert activity.data["type"] == "Undo"
 808       assert activity.data["actor"] == follower.ap_id
 809
 810       embedded_object = activity.data["object"]
 811       assert is_map(embedded_object)
 812       assert embedded_object["type"] == "Follow"
 813       assert embedded_object["object"] == followed.ap_id
 814       assert embedded_object["id"] == follow_activity.data["id"]
 815     end
 816   end
 817
 818   describe "blocking / unblocking" do
 819     test "creates a block activity" do
 820       blocker = insert(:user)
 821       blocked = insert(:user)
 822
 823       {:ok, activity} = ActivityPub.block(blocker, blocked)
 824
 825       assert activity.data["type"] == "Block"
 826       assert activity.data["actor"] == blocker.ap_id
 827       assert activity.data["object"] == blocked.ap_id
 828     end
 829
 830     test "creates an undo activity for the last block" do
 831       blocker = insert(:user)
 832       blocked = insert(:user)
 833
 834       {:ok, block_activity} = ActivityPub.block(blocker, blocked)
 835       {:ok, activity} = ActivityPub.unblock(blocker, blocked)
 836
 837       assert activity.data["type"] == "Undo"
 838       assert activity.data["actor"] == blocker.ap_id
 839
 840       embedded_object = activity.data["object"]
 841       assert is_map(embedded_object)
 842       assert embedded_object["type"] == "Block"
 843       assert embedded_object["object"] == blocked.ap_id
 844       assert embedded_object["id"] == block_activity.data["id"]
 845     end
 846   end
 847
 848   describe "deletion" do
 849     test "it creates a delete activity and deletes the original object" do
 850       note = insert(:note_activity)
 851       object = Object.normalize(note)
 852       {:ok, delete} = ActivityPub.delete(object)
 853
 854       assert delete.data["type"] == "Delete"
 855       assert delete.data["actor"] == note.data["actor"]
 856       assert delete.data["object"] == object.data["id"]
 857
 858       assert Activity.get_by_id(delete.id) != nil
 859
 860       assert Repo.get(Object, object.id).data["type"] == "Tombstone"
 861     end
 862
 863     test "decrements user note count only for public activities" do
 864       user = insert(:user, info: %{note_count: 10})
 865
 866       {:ok, a1} =
 867         CommonAPI.post(User.get_cached_by_id(user.id), %{
 868           "status" => "yeah",
 869           "visibility" => "public"
 870         })
 871
 872       {:ok, a2} =
 873         CommonAPI.post(User.get_cached_by_id(user.id), %{
 874           "status" => "yeah",
 875           "visibility" => "unlisted"
 876         })
 877
 878       {:ok, a3} =
 879         CommonAPI.post(User.get_cached_by_id(user.id), %{
 880           "status" => "yeah",
 881           "visibility" => "private"
 882         })
 883
 884       {:ok, a4} =
 885         CommonAPI.post(User.get_cached_by_id(user.id), %{
 886           "status" => "yeah",
 887           "visibility" => "direct"
 888         })
 889
 890       {:ok, _} = Object.normalize(a1) |> ActivityPub.delete()
 891       {:ok, _} = Object.normalize(a2) |> ActivityPub.delete()
 892       {:ok, _} = Object.normalize(a3) |> ActivityPub.delete()
 893       {:ok, _} = Object.normalize(a4) |> ActivityPub.delete()
 894
 895       user = User.get_cached_by_id(user.id)
 896       assert user.info.note_count == 10
 897     end
 898
 899     test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
 900       user = insert(:user)
 901       note = insert(:note_activity)
 902       object = Object.normalize(note)
 903
 904       {:ok, object} =
 905         object
 906         |> Object.change(%{
 907           data: %{
 908             "actor" => object.data["actor"],
 909             "id" => object.data["id"],
 910             "to" => [user.ap_id],
 911             "type" => "Note"
 912           }
 913         })
 914         |> Object.update_and_set_cache()
 915
 916       {:ok, delete} = ActivityPub.delete(object)
 917
 918       assert user.ap_id in delete.data["to"]
 919     end
 920
 921     test "decreases reply count" do
 922       user = insert(:user)
 923       user2 = insert(:user)
 924
 925       {:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
 926       reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
 927       ap_id = activity.data["id"]
 928
 929       {:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
 930       {:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
 931       {:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
 932       {:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
 933
 934       _ = CommonAPI.delete(direct_reply.id, user2)
 935       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 936       assert object.data["repliesCount"] == 2
 937
 938       _ = CommonAPI.delete(private_reply.id, user2)
 939       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 940       assert object.data["repliesCount"] == 2
 941
 942       _ = CommonAPI.delete(public_reply.id, user2)
 943       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 944       assert object.data["repliesCount"] == 1
 945
 946       _ = CommonAPI.delete(unlisted_reply.id, user2)
 947       assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
 948       assert object.data["repliesCount"] == 0
 949     end
 950   end
 951
 952   describe "timeline post-processing" do
 953     test "it filters broken threads" do
 954       user1 = insert(:user)
 955       user2 = insert(:user)
 956       user3 = insert(:user)
 957
 958       {:ok, user1} = User.follow(user1, user3)
 959       assert User.following?(user1, user3)
 960
 961       {:ok, user2} = User.follow(user2, user3)
 962       assert User.following?(user2, user3)
 963
 964       {:ok, user3} = User.follow(user3, user2)
 965       assert User.following?(user3, user2)
 966
 967       {:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})
 968
 969       {:ok, private_activity_1} =
 970         CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})
 971
 972       {:ok, private_activity_2} =
 973         CommonAPI.post(user2, %{
 974           "status" => "hi 3",
 975           "visibility" => "private",
 976           "in_reply_to_status_id" => private_activity_1.id
 977         })
 978
 979       {:ok, private_activity_3} =
 980         CommonAPI.post(user3, %{
 981           "status" => "hi 4",
 982           "visibility" => "private",
 983           "in_reply_to_status_id" => private_activity_2.id
 984         })
 985
 986       activities =
 987         ActivityPub.fetch_activities([user1.ap_id | user1.following])
 988         |> Enum.map(fn a -> a.id end)
 989
 990       private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
 991
 992       assert [public_activity.id, private_activity_1.id, private_activity_3.id] == activities
 993
 994       assert length(activities) == 3
 995
 996       activities =
 997         ActivityPub.fetch_activities([user1.ap_id | user1.following], %{"user" => user1})
 998         |> Enum.map(fn a -> a.id end)
 999
1000       assert [public_activity.id, private_activity_1.id] == activities
1001       assert length(activities) == 2
1002     end
1003   end
1004
1005   describe "update" do
1006     test "it creates an update activity with the new user data" do
1007       user = insert(:user)
1008       {:ok, user} = User.ensure_keys_present(user)
1009       user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
1010
1011       {:ok, update} =
1012         ActivityPub.update(%{
1013           actor: user_data["id"],
1014           to: [user.follower_address],
1015           cc: [],
1016           object: user_data
1017         })
1018
1019       assert update.data["actor"] == user.ap_id
1020       assert update.data["to"] == [user.follower_address]
1021       assert embedded_object = update.data["object"]
1022       assert embedded_object["id"] == user_data["id"]
1023       assert embedded_object["type"] == user_data["type"]
1024     end
1025   end
1026
1027   test "returned pinned statuses" do
1028     Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
1029     user = insert(:user)
1030
1031     {:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
1032     {:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
1033     {:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})
1034
1035     CommonAPI.pin(activity_one.id, user)
1036     user = refresh_record(user)
1037
1038     CommonAPI.pin(activity_two.id, user)
1039     user = refresh_record(user)
1040
1041     CommonAPI.pin(activity_three.id, user)
1042     user = refresh_record(user)
1043
1044     activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})
1045
1046     assert 3 = length(activities)
1047   end
1048
1049   test "it can create a Flag activity" do
1050     reporter = insert(:user)
1051     target_account = insert(:user)
1052     {:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
1053     context = Utils.generate_context_id()
1054     content = "foobar"
1055
1056     reporter_ap_id = reporter.ap_id
1057     target_ap_id = target_account.ap_id
1058     activity_ap_id = activity.data["id"]
1059
1060     assert {:ok, activity} =
1061              ActivityPub.flag(%{
1062                actor: reporter,
1063                context: context,
1064                account: target_account,
1065                statuses: [activity],
1066                content: content
1067              })
1068
1069     assert %Activity{
1070              actor: ^reporter_ap_id,
1071              data: %{
1072                "type" => "Flag",
1073                "content" => ^content,
1074                "context" => ^context,
1075                "object" => [^target_ap_id, ^activity_ap_id]
1076              }
1077            } = activity
1078   end
1079
1080   describe "publish_one/1" do
1081     test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
1082                    Instances,
1083                    [:passthrough],
1084                    [] do
1085       actor = insert(:user)
1086       inbox = "http://200.site/users/nick1/inbox"
1087
1088       assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
1089
1090       assert called(Instances.set_reachable(inbox))
1091     end
1092
1093     test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
1094                    Instances,
1095                    [:passthrough],
1096                    [] do
1097       actor = insert(:user)
1098       inbox = "http://200.site/users/nick1/inbox"
1099
1100       assert {:ok, _} =
1101                Publisher.publish_one(%{
1102                  inbox: inbox,
1103                  json: "{}",
1104                  actor: actor,
1105                  id: 1,
1106                  unreachable_since: NaiveDateTime.utc_now()
1107                })
1108
1109       assert called(Instances.set_reachable(inbox))
1110     end
1111
1112     test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
1113                    Instances,
1114                    [:passthrough],
1115                    [] do
1116       actor = insert(:user)
1117       inbox = "http://200.site/users/nick1/inbox"
1118
1119       assert {:ok, _} =
1120                Publisher.publish_one(%{
1121                  inbox: inbox,
1122                  json: "{}",
1123                  actor: actor,
1124                  id: 1,
1125                  unreachable_since: nil
1126                })
1127
1128       refute called(Instances.set_reachable(inbox))
1129     end
1130
1131     test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
1132                    Instances,
1133                    [:passthrough],
1134                    [] do
1135       actor = insert(:user)
1136       inbox = "http://404.site/users/nick1/inbox"
1137
1138       assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
1139
1140       assert called(Instances.set_unreachable(inbox))
1141     end
1142
1143     test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
1144                    Instances,
1145                    [:passthrough],
1146                    [] do
1147       actor = insert(:user)
1148       inbox = "http://connrefused.site/users/nick1/inbox"
1149
1150       assert {:error, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
1151
1152       assert called(Instances.set_unreachable(inbox))
1153     end
1154
1155     test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
1156                    Instances,
1157                    [:passthrough],
1158                    [] do
1159       actor = insert(:user)
1160       inbox = "http://200.site/users/nick1/inbox"
1161
1162       assert {:ok, _} = Publisher.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})
1163
1164       refute called(Instances.set_unreachable(inbox))
1165     end
1166
1167     test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
1168                    Instances,
1169                    [:passthrough],
1170                    [] do
1171       actor = insert(:user)
1172       inbox = "http://connrefused.site/users/nick1/inbox"
1173
1174       assert {:error, _} =
1175                Publisher.publish_one(%{
1176                  inbox: inbox,
1177                  json: "{}",
1178                  actor: actor,
1179                  id: 1,
1180                  unreachable_since: NaiveDateTime.utc_now()
1181                })
1182
1183       refute called(Instances.set_unreachable(inbox))
1184     end
1185   end
1186
1187   def data_uri do
1188     File.read!("test/fixtures/avatar_data_uri")
1189   end
1190
1191   describe "fetch_activities_bounded" do
1192     test "fetches private posts for followed users" do
1193       user = insert(:user)
1194
1195       {:ok, activity} =
1196         CommonAPI.post(user, %{
1197           "status" => "thought I looked cute might delete later :3",
1198           "visibility" => "private"
1199         })
1200
1201       [result] = ActivityPub.fetch_activities_bounded([user.follower_address], [])
1202       assert result.id == activity.id
1203     end
1204
1205     test "fetches only public posts for other users" do
1206       user = insert(:user)
1207       {:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe", "visibility" => "public"})
1208
1209       {:ok, _private_activity} =
1210         CommonAPI.post(user, %{
1211           "status" => "why is tenshi eating a corndog so cute?",
1212           "visibility" => "private"
1213         })
1214
1215       [result] = ActivityPub.fetch_activities_bounded([], [user.follower_address])
1216       assert result.id == activity.id
1217     end
1218   end
1219 end