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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Object
   9   alias Pleroma.Object.Fetcher
  10   alias Pleroma.Repo
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.ActivityPub.Transmogrifier
  14   alias Pleroma.Web.ActivityPub.Utils
  15   alias Pleroma.Web.OStatus
  16   alias Pleroma.Web.Websub.WebsubClientSubscription
  17
  18   import Pleroma.Factory
  19   alias Pleroma.Web.CommonAPI
  20
  21   setup_all do
  22     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  23     :ok
  24   end
  25
  26   describe "handle_incoming" do
  27     test "it ignores an incoming notice if we already have it" do
  28       activity = insert(:note_activity)
  29
  30       data =
  31         File.read!("test/fixtures/mastodon-post-activity.json")
  32         |> Poison.decode!()
  33         |> Map.put("object", activity.data["object"])
  34
  35       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  36
  37       assert activity == returned_activity
  38     end
  39
  40     test "it fetches replied-to activities if we don't have them" do
  41       data =
  42         File.read!("test/fixtures/mastodon-post-activity.json")
  43         |> Poison.decode!()
  44
  45       object =
  46         data["object"]
  47         |> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")
  48
  49       data =
  50         data
  51         |> Map.put("object", object)
  52
  53       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  54       returned_object = Object.normalize(returned_activity.data["object"])
  55
  56       assert activity =
  57                Activity.get_create_by_object_ap_id(
  58                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
  59                )
  60
  61       assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
  62     end
  63
  64     test "it works for incoming notices" do
  65       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
  66
  67       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
  68
  69       assert data["id"] ==
  70                "http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"
  71
  72       assert data["context"] ==
  73                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
  74
  75       assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
  76
  77       assert data["cc"] == [
  78                "http://mastodon.example.org/users/admin/followers",
  79                "http://localtesting.pleroma.lol/users/lain"
  80              ]
  81
  82       assert data["actor"] == "http://mastodon.example.org/users/admin"
  83
  84       object = Object.normalize(data["object"]).data
  85       assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"
  86
  87       assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
  88
  89       assert object["cc"] == [
  90                "http://mastodon.example.org/users/admin/followers",
  91                "http://localtesting.pleroma.lol/users/lain"
  92              ]
  93
  94       assert object["actor"] == "http://mastodon.example.org/users/admin"
  95       assert object["attributedTo"] == "http://mastodon.example.org/users/admin"
  96
  97       assert object["context"] ==
  98                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
  99
 100       assert object["sensitive"] == true
 101
 102       user = User.get_cached_by_ap_id(object["actor"])
 103
 104       assert user.info.note_count == 1
 105     end
 106
 107     test "it works for incoming notices with hashtags" do
 108       data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") |> Poison.decode!()
 109
 110       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 111       object = Object.normalize(data["object"])
 112
 113       assert Enum.at(object.data["tag"], 2) == "moo"
 114     end
 115
 116     test "it works for incoming notices with contentMap" do
 117       data =
 118         File.read!("test/fixtures/mastodon-post-activity-contentmap.json") |> Poison.decode!()
 119
 120       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 121       object = Object.normalize(data["object"])
 122
 123       assert object.data["content"] ==
 124                "<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
 125     end
 126
 127     test "it works for incoming notices with to/cc not being an array (kroeg)" do
 128       data = File.read!("test/fixtures/kroeg-post-activity.json") |> Poison.decode!()
 129
 130       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 131       object = Object.normalize(data["object"])
 132
 133       assert object.data["content"] ==
 134                "<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
 135     end
 136
 137     test "it works for incoming announces with actor being inlined (kroeg)" do
 138       data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") |> Poison.decode!()
 139
 140       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 141
 142       assert data["actor"] == "https://puckipedia.com/"
 143     end
 144
 145     test "it works for incoming notices with tag not being an array (kroeg)" do
 146       data = File.read!("test/fixtures/kroeg-array-less-emoji.json") |> Poison.decode!()
 147
 148       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 149       object = Object.normalize(data["object"])
 150
 151       assert object.data["emoji"] == %{
 152                "icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
 153              }
 154
 155       data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") |> Poison.decode!()
 156
 157       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 158       object = Object.normalize(data["object"])
 159
 160       assert "test" in object.data["tag"]
 161     end
 162
 163     test "it works for incoming notices with url not being a string (prismo)" do
 164       data = File.read!("test/fixtures/prismo-url-map.json") |> Poison.decode!()
 165
 166       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 167       object = Object.normalize(data["object"])
 168
 169       assert object.data["url"] == "https://prismo.news/posts/83"
 170     end
 171
 172     test "it cleans up incoming notices which are not really DMs" do
 173       user = insert(:user)
 174       other_user = insert(:user)
 175
 176       to = [user.ap_id, other_user.ap_id]
 177
 178       data =
 179         File.read!("test/fixtures/mastodon-post-activity.json")
 180         |> Poison.decode!()
 181         |> Map.put("to", to)
 182         |> Map.put("cc", [])
 183
 184       object =
 185         data["object"]
 186         |> Map.put("to", to)
 187         |> Map.put("cc", [])
 188
 189       data = Map.put(data, "object", object)
 190
 191       {:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)
 192
 193       assert data["to"] == []
 194       assert data["cc"] == to
 195
 196       object_data = Object.normalize(activity).data
 197
 198       assert object_data["to"] == []
 199       assert object_data["cc"] == to
 200     end
 201
 202     test "it works for incoming follow requests" do
 203       user = insert(:user)
 204
 205       data =
 206         File.read!("test/fixtures/mastodon-follow-activity.json")
 207         |> Poison.decode!()
 208         |> Map.put("object", user.ap_id)
 209
 210       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 211
 212       assert data["actor"] == "http://mastodon.example.org/users/admin"
 213       assert data["type"] == "Follow"
 214       assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
 215       assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
 216     end
 217
 218     test "it rejects incoming follow requests from blocked users when deny_follow_blocked is enabled" do
 219       Pleroma.Config.put([:user, :deny_follow_blocked], true)
 220
 221       user = insert(:user)
 222       {:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")
 223
 224       {:ok, user} = User.block(user, target)
 225
 226       data =
 227         File.read!("test/fixtures/mastodon-follow-activity.json")
 228         |> Poison.decode!()
 229         |> Map.put("object", user.ap_id)
 230
 231       {:ok, %Activity{data: %{"id" => id}}} = Transmogrifier.handle_incoming(data)
 232
 233       %Activity{} = activity = Activity.get_by_ap_id(id)
 234
 235       assert activity.data["state"] == "reject"
 236     end
 237
 238     test "it works for incoming follow requests from hubzilla" do
 239       user = insert(:user)
 240
 241       data =
 242         File.read!("test/fixtures/hubzilla-follow-activity.json")
 243         |> Poison.decode!()
 244         |> Map.put("object", user.ap_id)
 245         |> Utils.normalize_params()
 246
 247       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 248
 249       assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
 250       assert data["type"] == "Follow"
 251       assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
 252       assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
 253     end
 254
 255     test "it works for incoming likes" do
 256       user = insert(:user)
 257       {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
 258
 259       data =
 260         File.read!("test/fixtures/mastodon-like.json")
 261         |> Poison.decode!()
 262         |> Map.put("object", activity.data["object"])
 263
 264       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 265
 266       assert data["actor"] == "http://mastodon.example.org/users/admin"
 267       assert data["type"] == "Like"
 268       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
 269       assert data["object"] == activity.data["object"]
 270     end
 271
 272     test "it returns an error for incoming unlikes wihout a like activity" do
 273       user = insert(:user)
 274       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 275
 276       data =
 277         File.read!("test/fixtures/mastodon-undo-like.json")
 278         |> Poison.decode!()
 279         |> Map.put("object", activity.data["object"])
 280
 281       assert Transmogrifier.handle_incoming(data) == :error
 282     end
 283
 284     test "it works for incoming unlikes with an existing like activity" do
 285       user = insert(:user)
 286       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 287
 288       like_data =
 289         File.read!("test/fixtures/mastodon-like.json")
 290         |> Poison.decode!()
 291         |> Map.put("object", activity.data["object"])
 292
 293       {:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)
 294
 295       data =
 296         File.read!("test/fixtures/mastodon-undo-like.json")
 297         |> Poison.decode!()
 298         |> Map.put("object", like_data)
 299         |> Map.put("actor", like_data["actor"])
 300
 301       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 302
 303       assert data["actor"] == "http://mastodon.example.org/users/admin"
 304       assert data["type"] == "Undo"
 305       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
 306       assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
 307     end
 308
 309     test "it works for incoming announces" do
 310       data = File.read!("test/fixtures/mastodon-announce.json") |> Poison.decode!()
 311
 312       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 313
 314       assert data["actor"] == "http://mastodon.example.org/users/admin"
 315       assert data["type"] == "Announce"
 316
 317       assert data["id"] ==
 318                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 319
 320       assert data["object"] ==
 321                "http://mastodon.example.org/users/admin/statuses/99541947525187367"
 322
 323       assert Activity.get_create_by_object_ap_id(data["object"])
 324     end
 325
 326     test "it works for incoming announces with an existing activity" do
 327       user = insert(:user)
 328       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 329
 330       data =
 331         File.read!("test/fixtures/mastodon-announce.json")
 332         |> Poison.decode!()
 333         |> Map.put("object", activity.data["object"])
 334
 335       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 336
 337       assert data["actor"] == "http://mastodon.example.org/users/admin"
 338       assert data["type"] == "Announce"
 339
 340       assert data["id"] ==
 341                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 342
 343       assert data["object"] == activity.data["object"]
 344
 345       assert Activity.get_create_by_object_ap_id(data["object"]).id == activity.id
 346     end
 347
 348     test "it does not clobber the addressing on announce activities" do
 349       user = insert(:user)
 350       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 351
 352       data =
 353         File.read!("test/fixtures/mastodon-announce.json")
 354         |> Poison.decode!()
 355         |> Map.put("object", Object.normalize(activity).data["id"])
 356         |> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
 357         |> Map.put("cc", [])
 358
 359       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 360
 361       assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
 362     end
 363
 364     test "it ensures that as:Public activities make it to their followers collection" do
 365       user = insert(:user)
 366
 367       data =
 368         File.read!("test/fixtures/mastodon-post-activity.json")
 369         |> Poison.decode!()
 370         |> Map.put("actor", user.ap_id)
 371         |> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
 372         |> Map.put("cc", [])
 373
 374       object =
 375         data["object"]
 376         |> Map.put("attributedTo", user.ap_id)
 377         |> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
 378         |> Map.put("cc", [])
 379
 380       data = Map.put(data, "object", object)
 381
 382       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 383
 384       assert data["cc"] == [User.ap_followers(user)]
 385     end
 386
 387     test "it ensures that address fields become lists" do
 388       user = insert(:user)
 389
 390       data =
 391         File.read!("test/fixtures/mastodon-post-activity.json")
 392         |> Poison.decode!()
 393         |> Map.put("actor", user.ap_id)
 394         |> Map.put("to", nil)
 395         |> Map.put("cc", nil)
 396
 397       object =
 398         data["object"]
 399         |> Map.put("attributedTo", user.ap_id)
 400         |> Map.put("to", nil)
 401         |> Map.put("cc", nil)
 402
 403       data = Map.put(data, "object", object)
 404
 405       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 406
 407       assert !is_nil(data["to"])
 408       assert !is_nil(data["cc"])
 409     end
 410
 411     test "it works for incoming update activities" do
 412       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 413
 414       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 415       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 416
 417       object =
 418         update_data["object"]
 419         |> Map.put("actor", data["actor"])
 420         |> Map.put("id", data["actor"])
 421
 422       update_data =
 423         update_data
 424         |> Map.put("actor", data["actor"])
 425         |> Map.put("object", object)
 426
 427       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 428
 429       user = User.get_cached_by_ap_id(data["actor"])
 430       assert user.name == "gargle"
 431
 432       assert user.avatar["url"] == [
 433                %{
 434                  "href" =>
 435                    "https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 436                }
 437              ]
 438
 439       assert user.info.banner["url"] == [
 440                %{
 441                  "href" =>
 442                    "https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 443                }
 444              ]
 445
 446       assert user.bio == "<p>Some bio</p>"
 447     end
 448
 449     test "it works for incoming update activities which lock the account" do
 450       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 451
 452       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 453       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 454
 455       object =
 456         update_data["object"]
 457         |> Map.put("actor", data["actor"])
 458         |> Map.put("id", data["actor"])
 459         |> Map.put("manuallyApprovesFollowers", true)
 460
 461       update_data =
 462         update_data
 463         |> Map.put("actor", data["actor"])
 464         |> Map.put("object", object)
 465
 466       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 467
 468       user = User.get_cached_by_ap_id(data["actor"])
 469       assert user.info.locked == true
 470     end
 471
 472     test "it works for incoming deletes" do
 473       activity = insert(:note_activity)
 474
 475       data =
 476         File.read!("test/fixtures/mastodon-delete.json")
 477         |> Poison.decode!()
 478
 479       object =
 480         data["object"]
 481         |> Map.put("id", activity.data["object"])
 482
 483       data =
 484         data
 485         |> Map.put("object", object)
 486         |> Map.put("actor", activity.data["actor"])
 487
 488       {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
 489
 490       refute Activity.get_by_id(activity.id)
 491     end
 492
 493     test "it fails for incoming deletes with spoofed origin" do
 494       activity = insert(:note_activity)
 495
 496       data =
 497         File.read!("test/fixtures/mastodon-delete.json")
 498         |> Poison.decode!()
 499
 500       object =
 501         data["object"]
 502         |> Map.put("id", activity.data["object"])
 503
 504       data =
 505         data
 506         |> Map.put("object", object)
 507
 508       :error = Transmogrifier.handle_incoming(data)
 509
 510       assert Activity.get_by_id(activity.id)
 511     end
 512
 513     test "it works for incoming unannounces with an existing notice" do
 514       user = insert(:user)
 515       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 516
 517       announce_data =
 518         File.read!("test/fixtures/mastodon-announce.json")
 519         |> Poison.decode!()
 520         |> Map.put("object", activity.data["object"])
 521
 522       {:ok, %Activity{data: announce_data, local: false}} =
 523         Transmogrifier.handle_incoming(announce_data)
 524
 525       data =
 526         File.read!("test/fixtures/mastodon-undo-announce.json")
 527         |> Poison.decode!()
 528         |> Map.put("object", announce_data)
 529         |> Map.put("actor", announce_data["actor"])
 530
 531       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 532
 533       assert data["type"] == "Undo"
 534       assert data["object"]["type"] == "Announce"
 535       assert data["object"]["object"] == activity.data["object"]
 536
 537       assert data["object"]["id"] ==
 538                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 539     end
 540
 541     test "it works for incomming unfollows with an existing follow" do
 542       user = insert(:user)
 543
 544       follow_data =
 545         File.read!("test/fixtures/mastodon-follow-activity.json")
 546         |> Poison.decode!()
 547         |> Map.put("object", user.ap_id)
 548
 549       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)
 550
 551       data =
 552         File.read!("test/fixtures/mastodon-unfollow-activity.json")
 553         |> Poison.decode!()
 554         |> Map.put("object", follow_data)
 555
 556       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 557
 558       assert data["type"] == "Undo"
 559       assert data["object"]["type"] == "Follow"
 560       assert data["object"]["object"] == user.ap_id
 561       assert data["actor"] == "http://mastodon.example.org/users/admin"
 562
 563       refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
 564     end
 565
 566     test "it works for incoming blocks" do
 567       user = insert(:user)
 568
 569       data =
 570         File.read!("test/fixtures/mastodon-block-activity.json")
 571         |> Poison.decode!()
 572         |> Map.put("object", user.ap_id)
 573
 574       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 575
 576       assert data["type"] == "Block"
 577       assert data["object"] == user.ap_id
 578       assert data["actor"] == "http://mastodon.example.org/users/admin"
 579
 580       blocker = User.get_cached_by_ap_id(data["actor"])
 581
 582       assert User.blocks?(blocker, user)
 583     end
 584
 585     test "incoming blocks successfully tear down any follow relationship" do
 586       blocker = insert(:user)
 587       blocked = insert(:user)
 588
 589       data =
 590         File.read!("test/fixtures/mastodon-block-activity.json")
 591         |> Poison.decode!()
 592         |> Map.put("object", blocked.ap_id)
 593         |> Map.put("actor", blocker.ap_id)
 594
 595       {:ok, blocker} = User.follow(blocker, blocked)
 596       {:ok, blocked} = User.follow(blocked, blocker)
 597
 598       assert User.following?(blocker, blocked)
 599       assert User.following?(blocked, blocker)
 600
 601       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 602
 603       assert data["type"] == "Block"
 604       assert data["object"] == blocked.ap_id
 605       assert data["actor"] == blocker.ap_id
 606
 607       blocker = User.get_cached_by_ap_id(data["actor"])
 608       blocked = User.get_cached_by_ap_id(data["object"])
 609
 610       assert User.blocks?(blocker, blocked)
 611
 612       refute User.following?(blocker, blocked)
 613       refute User.following?(blocked, blocker)
 614     end
 615
 616     test "it works for incoming unblocks with an existing block" do
 617       user = insert(:user)
 618
 619       block_data =
 620         File.read!("test/fixtures/mastodon-block-activity.json")
 621         |> Poison.decode!()
 622         |> Map.put("object", user.ap_id)
 623
 624       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
 625
 626       data =
 627         File.read!("test/fixtures/mastodon-unblock-activity.json")
 628         |> Poison.decode!()
 629         |> Map.put("object", block_data)
 630
 631       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 632       assert data["type"] == "Undo"
 633       assert data["object"]["type"] == "Block"
 634       assert data["object"]["object"] == user.ap_id
 635       assert data["actor"] == "http://mastodon.example.org/users/admin"
 636
 637       blocker = User.get_cached_by_ap_id(data["actor"])
 638
 639       refute User.blocks?(blocker, user)
 640     end
 641
 642     test "it works for incoming accepts which were pre-accepted" do
 643       follower = insert(:user)
 644       followed = insert(:user)
 645
 646       {:ok, follower} = User.follow(follower, followed)
 647       assert User.following?(follower, followed) == true
 648
 649       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 650
 651       accept_data =
 652         File.read!("test/fixtures/mastodon-accept-activity.json")
 653         |> Poison.decode!()
 654         |> Map.put("actor", followed.ap_id)
 655
 656       object =
 657         accept_data["object"]
 658         |> Map.put("actor", follower.ap_id)
 659         |> Map.put("id", follow_activity.data["id"])
 660
 661       accept_data = Map.put(accept_data, "object", object)
 662
 663       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 664       refute activity.local
 665
 666       assert activity.data["object"] == follow_activity.data["id"]
 667
 668       follower = User.get_cached_by_id(follower.id)
 669
 670       assert User.following?(follower, followed) == true
 671     end
 672
 673     test "it works for incoming accepts which were orphaned" do
 674       follower = insert(:user)
 675       followed = insert(:user, %{info: %User.Info{locked: true}})
 676
 677       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 678
 679       accept_data =
 680         File.read!("test/fixtures/mastodon-accept-activity.json")
 681         |> Poison.decode!()
 682         |> Map.put("actor", followed.ap_id)
 683
 684       accept_data =
 685         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 686
 687       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 688       assert activity.data["object"] == follow_activity.data["id"]
 689
 690       follower = User.get_cached_by_id(follower.id)
 691
 692       assert User.following?(follower, followed) == true
 693     end
 694
 695     test "it works for incoming accepts which are referenced by IRI only" do
 696       follower = insert(:user)
 697       followed = insert(:user, %{info: %User.Info{locked: true}})
 698
 699       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 700
 701       accept_data =
 702         File.read!("test/fixtures/mastodon-accept-activity.json")
 703         |> Poison.decode!()
 704         |> Map.put("actor", followed.ap_id)
 705         |> Map.put("object", follow_activity.data["id"])
 706
 707       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 708       assert activity.data["object"] == follow_activity.data["id"]
 709
 710       follower = User.get_cached_by_id(follower.id)
 711
 712       assert User.following?(follower, followed) == true
 713     end
 714
 715     test "it fails for incoming accepts which cannot be correlated" do
 716       follower = insert(:user)
 717       followed = insert(:user, %{info: %User.Info{locked: true}})
 718
 719       accept_data =
 720         File.read!("test/fixtures/mastodon-accept-activity.json")
 721         |> Poison.decode!()
 722         |> Map.put("actor", followed.ap_id)
 723
 724       accept_data =
 725         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 726
 727       :error = Transmogrifier.handle_incoming(accept_data)
 728
 729       follower = User.get_cached_by_id(follower.id)
 730
 731       refute User.following?(follower, followed) == true
 732     end
 733
 734     test "it fails for incoming rejects which cannot be correlated" do
 735       follower = insert(:user)
 736       followed = insert(:user, %{info: %User.Info{locked: true}})
 737
 738       accept_data =
 739         File.read!("test/fixtures/mastodon-reject-activity.json")
 740         |> Poison.decode!()
 741         |> Map.put("actor", followed.ap_id)
 742
 743       accept_data =
 744         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 745
 746       :error = Transmogrifier.handle_incoming(accept_data)
 747
 748       follower = User.get_cached_by_id(follower.id)
 749
 750       refute User.following?(follower, followed) == true
 751     end
 752
 753     test "it works for incoming rejects which are orphaned" do
 754       follower = insert(:user)
 755       followed = insert(:user, %{info: %User.Info{locked: true}})
 756
 757       {:ok, follower} = User.follow(follower, followed)
 758       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
 759
 760       assert User.following?(follower, followed) == true
 761
 762       reject_data =
 763         File.read!("test/fixtures/mastodon-reject-activity.json")
 764         |> Poison.decode!()
 765         |> Map.put("actor", followed.ap_id)
 766
 767       reject_data =
 768         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
 769
 770       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
 771       refute activity.local
 772
 773       follower = User.get_cached_by_id(follower.id)
 774
 775       assert User.following?(follower, followed) == false
 776     end
 777
 778     test "it works for incoming rejects which are referenced by IRI only" do
 779       follower = insert(:user)
 780       followed = insert(:user, %{info: %User.Info{locked: true}})
 781
 782       {:ok, follower} = User.follow(follower, followed)
 783       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 784
 785       assert User.following?(follower, followed) == true
 786
 787       reject_data =
 788         File.read!("test/fixtures/mastodon-reject-activity.json")
 789         |> Poison.decode!()
 790         |> Map.put("actor", followed.ap_id)
 791         |> Map.put("object", follow_activity.data["id"])
 792
 793       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
 794
 795       follower = User.get_cached_by_id(follower.id)
 796
 797       assert User.following?(follower, followed) == false
 798     end
 799
 800     test "it rejects activities without a valid ID" do
 801       user = insert(:user)
 802
 803       data =
 804         File.read!("test/fixtures/mastodon-follow-activity.json")
 805         |> Poison.decode!()
 806         |> Map.put("object", user.ap_id)
 807         |> Map.put("id", "")
 808
 809       :error = Transmogrifier.handle_incoming(data)
 810     end
 811
 812     test "it remaps video URLs as attachments if necessary" do
 813       {:ok, object} =
 814         Fetcher.fetch_object_from_id(
 815           "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
 816         )
 817
 818       attachment = %{
 819         "type" => "Link",
 820         "mediaType" => "video/mp4",
 821         "href" =>
 822           "https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
 823         "mimeType" => "video/mp4",
 824         "size" => 5_015_880,
 825         "url" => [
 826           %{
 827             "href" =>
 828               "https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
 829             "mediaType" => "video/mp4",
 830             "type" => "Link"
 831           }
 832         ],
 833         "width" => 480
 834       }
 835
 836       assert object.data["url"] ==
 837                "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
 838
 839       assert object.data["attachment"] == [attachment]
 840     end
 841
 842     test "it accepts Flag activities" do
 843       user = insert(:user)
 844       other_user = insert(:user)
 845
 846       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 847       object = Object.normalize(activity.data["object"])
 848
 849       message = %{
 850         "@context" => "https://www.w3.org/ns/activitystreams",
 851         "cc" => [user.ap_id],
 852         "object" => [user.ap_id, object.data["id"]],
 853         "type" => "Flag",
 854         "content" => "blocked AND reported!!!",
 855         "actor" => other_user.ap_id
 856       }
 857
 858       assert {:ok, activity} = Transmogrifier.handle_incoming(message)
 859
 860       assert activity.data["object"] == [user.ap_id, object.data["id"]]
 861       assert activity.data["content"] == "blocked AND reported!!!"
 862       assert activity.data["actor"] == other_user.ap_id
 863       assert activity.data["cc"] == [user.ap_id]
 864     end
 865   end
 866
 867   describe "prepare outgoing" do
 868     test "it turns mentions into tags" do
 869       user = insert(:user)
 870       other_user = insert(:user)
 871
 872       {:ok, activity} =
 873         CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
 874
 875       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 876       object = modified["object"]
 877
 878       expected_mention = %{
 879         "href" => other_user.ap_id,
 880         "name" => "@#{other_user.nickname}",
 881         "type" => "Mention"
 882       }
 883
 884       expected_tag = %{
 885         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
 886         "type" => "Hashtag",
 887         "name" => "#2hu"
 888       }
 889
 890       assert Enum.member?(object["tag"], expected_tag)
 891       assert Enum.member?(object["tag"], expected_mention)
 892     end
 893
 894     test "it adds the sensitive property" do
 895       user = insert(:user)
 896
 897       {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
 898       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 899
 900       assert modified["object"]["sensitive"]
 901     end
 902
 903     test "it adds the json-ld context and the conversation property" do
 904       user = insert(:user)
 905
 906       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 907       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 908
 909       assert modified["@context"] ==
 910                Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]
 911
 912       assert modified["object"]["conversation"] == modified["context"]
 913     end
 914
 915     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
 916       user = insert(:user)
 917
 918       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 919       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 920
 921       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
 922     end
 923
 924     test "it translates ostatus IDs to external URLs" do
 925       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 926       {:ok, [referent_activity]} = OStatus.handle_incoming(incoming)
 927
 928       user = insert(:user)
 929
 930       {:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
 931       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 932
 933       assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
 934     end
 935
 936     test "it translates ostatus reply_to IDs to external URLs" do
 937       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 938       {:ok, [referred_activity]} = OStatus.handle_incoming(incoming)
 939
 940       user = insert(:user)
 941
 942       {:ok, activity} =
 943         CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})
 944
 945       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 946
 947       assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
 948     end
 949
 950     test "it strips internal hashtag data" do
 951       user = insert(:user)
 952
 953       {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})
 954
 955       expected_tag = %{
 956         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
 957         "type" => "Hashtag",
 958         "name" => "#2hu"
 959       }
 960
 961       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 962
 963       assert modified["object"]["tag"] == [expected_tag]
 964     end
 965
 966     test "it strips internal fields" do
 967       user = insert(:user)
 968
 969       {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"})
 970
 971       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 972
 973       assert length(modified["object"]["tag"]) == 2
 974
 975       assert is_nil(modified["object"]["emoji"])
 976       assert is_nil(modified["object"]["like_count"])
 977       assert is_nil(modified["object"]["announcements"])
 978       assert is_nil(modified["object"]["announcement_count"])
 979       assert is_nil(modified["object"]["context_id"])
 980     end
 981
 982     test "it strips internal fields of article" do
 983       activity = insert(:article_activity)
 984
 985       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 986
 987       assert length(modified["object"]["tag"]) == 2
 988
 989       assert is_nil(modified["object"]["emoji"])
 990       assert is_nil(modified["object"]["like_count"])
 991       assert is_nil(modified["object"]["announcements"])
 992       assert is_nil(modified["object"]["announcement_count"])
 993       assert is_nil(modified["object"]["context_id"])
 994     end
 995
 996     test "it adds like collection to object" do
 997       activity = insert(:note_activity)
 998       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 999
1000       assert modified["object"]["likes"]["type"] == "OrderedCollection"
1001       assert modified["object"]["likes"]["totalItems"] == 0
1002     end
1003
1004     test "the directMessage flag is present" do
1005       user = insert(:user)
1006       other_user = insert(:user)
1007
1008       {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})
1009
1010       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1011
1012       assert modified["directMessage"] == false
1013
1014       {:ok, activity} =
1015         CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})
1016
1017       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1018
1019       assert modified["directMessage"] == false
1020
1021       {:ok, activity} =
1022         CommonAPI.post(user, %{
1023           "status" => "@#{other_user.nickname} :moominmamma:",
1024           "visibility" => "direct"
1025         })
1026
1027       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1028
1029       assert modified["directMessage"] == true
1030     end
1031
1032     test "it strips BCC field" do
1033       user = insert(:user)
1034       {:ok, list} = Pleroma.List.create("foo", user)
1035
1036       {:ok, activity} =
1037         CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1038
1039       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1040
1041       assert is_nil(modified["bcc"])
1042     end
1043   end
1044
1045   describe "user upgrade" do
1046     test "it upgrades a user to activitypub" do
1047       user =
1048         insert(:user, %{
1049           nickname: "rye@niu.moe",
1050           local: false,
1051           ap_id: "https://niu.moe/users/rye",
1052           follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
1053         })
1054
1055       user_two = insert(:user, %{following: [user.follower_address]})
1056
1057       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1058       {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
1059       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
1060
1061       user = User.get_cached_by_id(user.id)
1062       assert user.info.note_count == 1
1063
1064       {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
1065       assert user.info.ap_enabled
1066       assert user.info.note_count == 1
1067       assert user.follower_address == "https://niu.moe/users/rye/followers"
1068
1069       user = User.get_cached_by_id(user.id)
1070       assert user.info.note_count == 1
1071
1072       activity = Activity.get_by_id(activity.id)
1073       assert user.follower_address in activity.recipients
1074
1075       assert %{
1076                "url" => [
1077                  %{
1078                    "href" =>
1079                      "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
1080                  }
1081                ]
1082              } = user.avatar
1083
1084       assert %{
1085                "url" => [
1086                  %{
1087                    "href" =>
1088                      "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
1089                  }
1090                ]
1091              } = user.info.banner
1092
1093       refute "..." in activity.recipients
1094
1095       unrelated_activity = Activity.get_by_id(unrelated_activity.id)
1096       refute user.follower_address in unrelated_activity.recipients
1097
1098       user_two = User.get_cached_by_id(user_two.id)
1099       assert user.follower_address in user_two.following
1100       refute "..." in user_two.following
1101     end
1102   end
1103
1104   describe "maybe_retire_websub" do
1105     test "it deletes all websub client subscripitions with the user as topic" do
1106       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
1107       {:ok, ws} = Repo.insert(subscription)
1108
1109       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
1110       {:ok, ws2} = Repo.insert(subscription)
1111
1112       Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")
1113
1114       refute Repo.get(WebsubClientSubscription, ws.id)
1115       assert Repo.get(WebsubClientSubscription, ws2.id)
1116     end
1117   end
1118
1119   describe "actor rewriting" do
1120     test "it fixes the actor URL property to be a proper URI" do
1121       data = %{
1122         "url" => %{"href" => "http://example.com"}
1123       }
1124
1125       rewritten = Transmogrifier.maybe_fix_user_object(data)
1126       assert rewritten["url"] == "http://example.com"
1127     end
1128   end
1129
1130   describe "actor origin containment" do
1131     test "it rejects activities which reference objects with bogus origins" do
1132       data = %{
1133         "@context" => "https://www.w3.org/ns/activitystreams",
1134         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1135         "actor" => "http://mastodon.example.org/users/admin",
1136         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1137         "object" => "https://info.pleroma.site/activity.json",
1138         "type" => "Announce"
1139       }
1140
1141       :error = Transmogrifier.handle_incoming(data)
1142     end
1143
1144     test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
1145       data = %{
1146         "@context" => "https://www.w3.org/ns/activitystreams",
1147         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1148         "actor" => "http://mastodon.example.org/users/admin",
1149         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1150         "object" => "https://info.pleroma.site/activity2.json",
1151         "type" => "Announce"
1152       }
1153
1154       :error = Transmogrifier.handle_incoming(data)
1155     end
1156
1157     test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
1158       data = %{
1159         "@context" => "https://www.w3.org/ns/activitystreams",
1160         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1161         "actor" => "http://mastodon.example.org/users/admin",
1162         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1163         "object" => "https://info.pleroma.site/activity3.json",
1164         "type" => "Announce"
1165       }
1166
1167       :error = Transmogrifier.handle_incoming(data)
1168     end
1169   end
1170
1171   describe "reserialization" do
1172     test "successfully reserializes a message with inReplyTo == nil" do
1173       user = insert(:user)
1174
1175       message = %{
1176         "@context" => "https://www.w3.org/ns/activitystreams",
1177         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1178         "cc" => [],
1179         "type" => "Create",
1180         "object" => %{
1181           "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1182           "cc" => [],
1183           "type" => "Note",
1184           "content" => "Hi",
1185           "inReplyTo" => nil,
1186           "attributedTo" => user.ap_id
1187         },
1188         "actor" => user.ap_id
1189       }
1190
1191       {:ok, activity} = Transmogrifier.handle_incoming(message)
1192
1193       {:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
1194     end
1195
1196     test "successfully reserializes a message with AS2 objects in IR" do
1197       user = insert(:user)
1198
1199       message = %{
1200         "@context" => "https://www.w3.org/ns/activitystreams",
1201         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1202         "cc" => [],
1203         "type" => "Create",
1204         "object" => %{
1205           "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1206           "cc" => [],
1207           "type" => "Note",
1208           "content" => "Hi",
1209           "inReplyTo" => nil,
1210           "attributedTo" => user.ap_id,
1211           "tag" => [
1212             %{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
1213             %{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
1214           ]
1215         },
1216         "actor" => user.ap_id
1217       }
1218
1219       {:ok, activity} = Transmogrifier.handle_incoming(message)
1220
1221       {:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
1222     end
1223   end
1224 end