git.squeep.com Git - akkoma/blob - test/web/activity_pub/transmogrifier_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.TransmogrifierTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Object
   9   alias Pleroma.Object.Fetcher
  10   alias Pleroma.Tests.ObanHelpers
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ActivityPub
  13   alias Pleroma.Web.ActivityPub.Transmogrifier
  14   alias Pleroma.Web.AdminAPI.AccountView
  15   alias Pleroma.Web.CommonAPI
  16
  17   import Mock
  18   import Pleroma.Factory
  19   import ExUnit.CaptureLog
  20
  21   setup_all do
  22     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  23     :ok
  24   end
  25
  26   clear_config([:instance, :max_remote_account_fields])
  27
  28   describe "handle_incoming" do
  29     test "it ignores an incoming notice if we already have it" do
  30       activity = insert(:note_activity)
  31
  32       data =
  33         File.read!("test/fixtures/mastodon-post-activity.json")
  34         |> Poison.decode!()
  35         |> Map.put("object", Object.normalize(activity).data)
  36
  37       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  38
  39       assert activity == returned_activity
  40     end
  41
  42     test "it fetches replied-to activities if we don't have them" do
  43       data =
  44         File.read!("test/fixtures/mastodon-post-activity.json")
  45         |> Poison.decode!()
  46
  47       object =
  48         data["object"]
  49         |> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")
  50
  51       data = Map.put(data, "object", object)
  52       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  53       returned_object = Object.normalize(returned_activity, false)
  54
  55       assert activity =
  56                Activity.get_create_by_object_ap_id(
  57                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
  58                )
  59
  60       assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
  61     end
  62
  63     test "it does not fetch replied-to activities beyond max_replies_depth" do
  64       data =
  65         File.read!("test/fixtures/mastodon-post-activity.json")
  66         |> Poison.decode!()
  67
  68       object =
  69         data["object"]
  70         |> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")
  71
  72       data = Map.put(data, "object", object)
  73
  74       with_mock Pleroma.Web.Federator,
  75         allowed_incoming_reply_depth?: fn _ -> false end do
  76         {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  77
  78         returned_object = Object.normalize(returned_activity, false)
  79
  80         refute Activity.get_create_by_object_ap_id(
  81                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
  82                )
  83
  84         assert returned_object.data["inReplyToAtomUri"] ==
  85                  "https://shitposter.club/notice/2827873"
  86       end
  87     end
  88
  89     test "it does not crash if the object in inReplyTo can't be fetched" do
  90       data =
  91         File.read!("test/fixtures/mastodon-post-activity.json")
  92         |> Poison.decode!()
  93
  94       object =
  95         data["object"]
  96         |> Map.put("inReplyTo", "https://404.site/whatever")
  97
  98       data =
  99         data
 100         |> Map.put("object", object)
 101
 102       assert capture_log(fn ->
 103                {:ok, _returned_activity} = Transmogrifier.handle_incoming(data)
 104              end) =~ "[error] Couldn't fetch \"https://404.site/whatever\", error: nil"
 105     end
 106
 107     test "it works for incoming notices" do
 108       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 109
 110       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 111
 112       assert data["id"] ==
 113                "http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"
 114
 115       assert data["context"] ==
 116                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
 117
 118       assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
 119
 120       assert data["cc"] == [
 121                "http://mastodon.example.org/users/admin/followers",
 122                "http://localtesting.pleroma.lol/users/lain"
 123              ]
 124
 125       assert data["actor"] == "http://mastodon.example.org/users/admin"
 126
 127       object_data = Object.normalize(data["object"]).data
 128
 129       assert object_data["id"] ==
 130                "http://mastodon.example.org/users/admin/statuses/99512778738411822"
 131
 132       assert object_data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
 133
 134       assert object_data["cc"] == [
 135                "http://mastodon.example.org/users/admin/followers",
 136                "http://localtesting.pleroma.lol/users/lain"
 137              ]
 138
 139       assert object_data["actor"] == "http://mastodon.example.org/users/admin"
 140       assert object_data["attributedTo"] == "http://mastodon.example.org/users/admin"
 141
 142       assert object_data["context"] ==
 143                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
 144
 145       assert object_data["sensitive"] == true
 146
 147       user = User.get_cached_by_ap_id(object_data["actor"])
 148
 149       assert user.note_count == 1
 150     end
 151
 152     test "it works for incoming notices with hashtags" do
 153       data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") |> Poison.decode!()
 154
 155       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 156       object = Object.normalize(data["object"])
 157
 158       assert Enum.at(object.data["tag"], 2) == "moo"
 159     end
 160
 161     test "it works for incoming questions" do
 162       data = File.read!("test/fixtures/mastodon-question-activity.json") |> Poison.decode!()
 163
 164       {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
 165
 166       object = Object.normalize(activity)
 167
 168       assert Enum.all?(object.data["oneOf"], fn choice ->
 169                choice["name"] in [
 170                  "Dunno",
 171                  "Everyone knows that!",
 172                  "25 char limit is dumb",
 173                  "I can't even fit a funny"
 174                ]
 175              end)
 176     end
 177
 178     test "it works for incoming listens" do
 179       data = %{
 180         "@context" => "https://www.w3.org/ns/activitystreams",
 181         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
 182         "cc" => [],
 183         "type" => "Listen",
 184         "id" => "http://mastodon.example.org/users/admin/listens/1234/activity",
 185         "actor" => "http://mastodon.example.org/users/admin",
 186         "object" => %{
 187           "type" => "Audio",
 188           "id" => "http://mastodon.example.org/users/admin/listens/1234",
 189           "attributedTo" => "http://mastodon.example.org/users/admin",
 190           "title" => "lain radio episode 1",
 191           "artist" => "lain",
 192           "album" => "lain radio",
 193           "length" => 180_000
 194         }
 195       }
 196
 197       {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
 198
 199       object = Object.normalize(activity)
 200
 201       assert object.data["title"] == "lain radio episode 1"
 202       assert object.data["artist"] == "lain"
 203       assert object.data["album"] == "lain radio"
 204       assert object.data["length"] == 180_000
 205     end
 206
 207     test "it rewrites Note votes to Answers and increments vote counters on question activities" do
 208       user = insert(:user)
 209
 210       {:ok, activity} =
 211         CommonAPI.post(user, %{
 212           "status" => "suya...",
 213           "poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
 214         })
 215
 216       object = Object.normalize(activity)
 217
 218       data =
 219         File.read!("test/fixtures/mastodon-vote.json")
 220         |> Poison.decode!()
 221         |> Kernel.put_in(["to"], user.ap_id)
 222         |> Kernel.put_in(["object", "inReplyTo"], object.data["id"])
 223         |> Kernel.put_in(["object", "to"], user.ap_id)
 224
 225       {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
 226       answer_object = Object.normalize(activity)
 227       assert answer_object.data["type"] == "Answer"
 228       object = Object.get_by_ap_id(object.data["id"])
 229
 230       assert Enum.any?(
 231                object.data["oneOf"],
 232                fn
 233                  %{"name" => "suya..", "replies" => %{"totalItems" => 1}} -> true
 234                  _ -> false
 235                end
 236              )
 237     end
 238
 239     test "it works for incoming notices with contentMap" do
 240       data =
 241         File.read!("test/fixtures/mastodon-post-activity-contentmap.json") |> Poison.decode!()
 242
 243       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 244       object = Object.normalize(data["object"])
 245
 246       assert object.data["content"] ==
 247                "<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
 248     end
 249
 250     test "it works for incoming notices with to/cc not being an array (kroeg)" do
 251       data = File.read!("test/fixtures/kroeg-post-activity.json") |> Poison.decode!()
 252
 253       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 254       object = Object.normalize(data["object"])
 255
 256       assert object.data["content"] ==
 257                "<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
 258     end
 259
 260     test "it works for incoming announces with actor being inlined (kroeg)" do
 261       data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") |> Poison.decode!()
 262
 263       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 264
 265       assert data["actor"] == "https://puckipedia.com/"
 266     end
 267
 268     test "it works for incoming notices with tag not being an array (kroeg)" do
 269       data = File.read!("test/fixtures/kroeg-array-less-emoji.json") |> Poison.decode!()
 270
 271       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 272       object = Object.normalize(data["object"])
 273
 274       assert object.data["emoji"] == %{
 275                "icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
 276              }
 277
 278       data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") |> Poison.decode!()
 279
 280       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 281       object = Object.normalize(data["object"])
 282
 283       assert "test" in object.data["tag"]
 284     end
 285
 286     test "it works for incoming notices with url not being a string (prismo)" do
 287       data = File.read!("test/fixtures/prismo-url-map.json") |> Poison.decode!()
 288
 289       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 290       object = Object.normalize(data["object"])
 291
 292       assert object.data["url"] == "https://prismo.news/posts/83"
 293     end
 294
 295     test "it cleans up incoming notices which are not really DMs" do
 296       user = insert(:user)
 297       other_user = insert(:user)
 298
 299       to = [user.ap_id, other_user.ap_id]
 300
 301       data =
 302         File.read!("test/fixtures/mastodon-post-activity.json")
 303         |> Poison.decode!()
 304         |> Map.put("to", to)
 305         |> Map.put("cc", [])
 306
 307       object =
 308         data["object"]
 309         |> Map.put("to", to)
 310         |> Map.put("cc", [])
 311
 312       data = Map.put(data, "object", object)
 313
 314       {:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)
 315
 316       assert data["to"] == []
 317       assert data["cc"] == to
 318
 319       object_data = Object.normalize(activity).data
 320
 321       assert object_data["to"] == []
 322       assert object_data["cc"] == to
 323     end
 324
 325     test "it works for incoming likes" do
 326       user = insert(:user)
 327       {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
 328
 329       data =
 330         File.read!("test/fixtures/mastodon-like.json")
 331         |> Poison.decode!()
 332         |> Map.put("object", activity.data["object"])
 333
 334       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 335
 336       assert data["actor"] == "http://mastodon.example.org/users/admin"
 337       assert data["type"] == "Like"
 338       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
 339       assert data["object"] == activity.data["object"]
 340     end
 341
 342     test "it returns an error for incoming unlikes wihout a like activity" do
 343       user = insert(:user)
 344       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 345
 346       data =
 347         File.read!("test/fixtures/mastodon-undo-like.json")
 348         |> Poison.decode!()
 349         |> Map.put("object", activity.data["object"])
 350
 351       assert Transmogrifier.handle_incoming(data) == :error
 352     end
 353
 354     test "it works for incoming unlikes with an existing like activity" do
 355       user = insert(:user)
 356       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 357
 358       like_data =
 359         File.read!("test/fixtures/mastodon-like.json")
 360         |> Poison.decode!()
 361         |> Map.put("object", activity.data["object"])
 362
 363       {:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)
 364
 365       data =
 366         File.read!("test/fixtures/mastodon-undo-like.json")
 367         |> Poison.decode!()
 368         |> Map.put("object", like_data)
 369         |> Map.put("actor", like_data["actor"])
 370
 371       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 372
 373       assert data["actor"] == "http://mastodon.example.org/users/admin"
 374       assert data["type"] == "Undo"
 375       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
 376       assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
 377     end
 378
 379     test "it works for incoming unlikes with an existing like activity and a compact object" do
 380       user = insert(:user)
 381       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 382
 383       like_data =
 384         File.read!("test/fixtures/mastodon-like.json")
 385         |> Poison.decode!()
 386         |> Map.put("object", activity.data["object"])
 387
 388       {:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)
 389
 390       data =
 391         File.read!("test/fixtures/mastodon-undo-like.json")
 392         |> Poison.decode!()
 393         |> Map.put("object", like_data["id"])
 394         |> Map.put("actor", like_data["actor"])
 395
 396       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 397
 398       assert data["actor"] == "http://mastodon.example.org/users/admin"
 399       assert data["type"] == "Undo"
 400       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
 401       assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
 402     end
 403
 404     test "it works for incoming announces" do
 405       data = File.read!("test/fixtures/mastodon-announce.json") |> Poison.decode!()
 406
 407       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 408
 409       assert data["actor"] == "http://mastodon.example.org/users/admin"
 410       assert data["type"] == "Announce"
 411
 412       assert data["id"] ==
 413                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 414
 415       assert data["object"] ==
 416                "http://mastodon.example.org/users/admin/statuses/99541947525187367"
 417
 418       assert Activity.get_create_by_object_ap_id(data["object"])
 419     end
 420
 421     test "it works for incoming announces with an existing activity" do
 422       user = insert(:user)
 423       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 424
 425       data =
 426         File.read!("test/fixtures/mastodon-announce.json")
 427         |> Poison.decode!()
 428         |> Map.put("object", activity.data["object"])
 429
 430       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 431
 432       assert data["actor"] == "http://mastodon.example.org/users/admin"
 433       assert data["type"] == "Announce"
 434
 435       assert data["id"] ==
 436                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 437
 438       assert data["object"] == activity.data["object"]
 439
 440       assert Activity.get_create_by_object_ap_id(data["object"]).id == activity.id
 441     end
 442
 443     test "it works for incoming announces with an inlined activity" do
 444       data =
 445         File.read!("test/fixtures/mastodon-announce-private.json")
 446         |> Poison.decode!()
 447
 448       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 449
 450       assert data["actor"] == "http://mastodon.example.org/users/admin"
 451       assert data["type"] == "Announce"
 452
 453       assert data["id"] ==
 454                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 455
 456       object = Object.normalize(data["object"])
 457
 458       assert object.data["id"] == "http://mastodon.example.org/@admin/99541947525187368"
 459       assert object.data["content"] == "this is a private toot"
 460     end
 461
 462     test "it rejects incoming announces with an inlined activity from another origin" do
 463       data =
 464         File.read!("test/fixtures/bogus-mastodon-announce.json")
 465         |> Poison.decode!()
 466
 467       assert :error = Transmogrifier.handle_incoming(data)
 468     end
 469
 470     test "it does not clobber the addressing on announce activities" do
 471       user = insert(:user)
 472       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 473
 474       data =
 475         File.read!("test/fixtures/mastodon-announce.json")
 476         |> Poison.decode!()
 477         |> Map.put("object", Object.normalize(activity).data["id"])
 478         |> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
 479         |> Map.put("cc", [])
 480
 481       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 482
 483       assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
 484     end
 485
 486     test "it ensures that as:Public activities make it to their followers collection" do
 487       user = insert(:user)
 488
 489       data =
 490         File.read!("test/fixtures/mastodon-post-activity.json")
 491         |> Poison.decode!()
 492         |> Map.put("actor", user.ap_id)
 493         |> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
 494         |> Map.put("cc", [])
 495
 496       object =
 497         data["object"]
 498         |> Map.put("attributedTo", user.ap_id)
 499         |> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
 500         |> Map.put("cc", [])
 501         |> Map.put("id", user.ap_id <> "/activities/12345678")
 502
 503       data = Map.put(data, "object", object)
 504
 505       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 506
 507       assert data["cc"] == [User.ap_followers(user)]
 508     end
 509
 510     test "it ensures that address fields become lists" do
 511       user = insert(:user)
 512
 513       data =
 514         File.read!("test/fixtures/mastodon-post-activity.json")
 515         |> Poison.decode!()
 516         |> Map.put("actor", user.ap_id)
 517         |> Map.put("to", nil)
 518         |> Map.put("cc", nil)
 519
 520       object =
 521         data["object"]
 522         |> Map.put("attributedTo", user.ap_id)
 523         |> Map.put("to", nil)
 524         |> Map.put("cc", nil)
 525         |> Map.put("id", user.ap_id <> "/activities/12345678")
 526
 527       data = Map.put(data, "object", object)
 528
 529       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 530
 531       assert !is_nil(data["to"])
 532       assert !is_nil(data["cc"])
 533     end
 534
 535     test "it strips internal likes" do
 536       data =
 537         File.read!("test/fixtures/mastodon-post-activity.json")
 538         |> Poison.decode!()
 539
 540       likes = %{
 541         "first" =>
 542           "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes?page=1",
 543         "id" => "http://mastodon.example.org/objects/dbdbc507-52c8-490d-9b7c-1e1d52e5c132/likes",
 544         "totalItems" => 3,
 545         "type" => "OrderedCollection"
 546       }
 547
 548       object = Map.put(data["object"], "likes", likes)
 549       data = Map.put(data, "object", object)
 550
 551       {:ok, %Activity{object: object}} = Transmogrifier.handle_incoming(data)
 552
 553       refute Map.has_key?(object.data, "likes")
 554     end
 555
 556     test "it works for incoming update activities" do
 557       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 558
 559       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 560       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 561
 562       object =
 563         update_data["object"]
 564         |> Map.put("actor", data["actor"])
 565         |> Map.put("id", data["actor"])
 566
 567       update_data =
 568         update_data
 569         |> Map.put("actor", data["actor"])
 570         |> Map.put("object", object)
 571
 572       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 573
 574       assert data["id"] == update_data["id"]
 575
 576       user = User.get_cached_by_ap_id(data["actor"])
 577       assert user.name == "gargle"
 578
 579       assert user.avatar["url"] == [
 580                %{
 581                  "href" =>
 582                    "https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 583                }
 584              ]
 585
 586       assert user.banner["url"] == [
 587                %{
 588                  "href" =>
 589                    "https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 590                }
 591              ]
 592
 593       assert user.bio == "<p>Some bio</p>"
 594     end
 595
 596     test "it works with custom profile fields" do
 597       {:ok, activity} =
 598         "test/fixtures/mastodon-post-activity.json"
 599         |> File.read!()
 600         |> Poison.decode!()
 601         |> Transmogrifier.handle_incoming()
 602
 603       user = User.get_cached_by_ap_id(activity.actor)
 604
 605       assert User.fields(user) == [
 606                %{"name" => "foo", "value" => "bar"},
 607                %{"name" => "foo1", "value" => "bar1"}
 608              ]
 609
 610       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 611
 612       object =
 613         update_data["object"]
 614         |> Map.put("actor", user.ap_id)
 615         |> Map.put("id", user.ap_id)
 616
 617       update_data =
 618         update_data
 619         |> Map.put("actor", user.ap_id)
 620         |> Map.put("object", object)
 621
 622       {:ok, _update_activity} = Transmogrifier.handle_incoming(update_data)
 623
 624       user = User.get_cached_by_ap_id(user.ap_id)
 625
 626       assert User.fields(user) == [
 627                %{"name" => "foo", "value" => "updated"},
 628                %{"name" => "foo1", "value" => "updated"}
 629              ]
 630
 631       Pleroma.Config.put([:instance, :max_remote_account_fields], 2)
 632
 633       update_data =
 634         put_in(update_data, ["object", "attachment"], [
 635           %{"name" => "foo", "type" => "PropertyValue", "value" => "bar"},
 636           %{"name" => "foo11", "type" => "PropertyValue", "value" => "bar11"},
 637           %{"name" => "foo22", "type" => "PropertyValue", "value" => "bar22"}
 638         ])
 639
 640       {:ok, _} = Transmogrifier.handle_incoming(update_data)
 641
 642       user = User.get_cached_by_ap_id(user.ap_id)
 643
 644       assert User.fields(user) == [
 645                %{"name" => "foo", "value" => "updated"},
 646                %{"name" => "foo1", "value" => "updated"}
 647              ]
 648
 649       update_data = put_in(update_data, ["object", "attachment"], [])
 650
 651       {:ok, _} = Transmogrifier.handle_incoming(update_data)
 652
 653       user = User.get_cached_by_ap_id(user.ap_id)
 654
 655       assert User.fields(user) == []
 656     end
 657
 658     test "it works for incoming update activities which lock the account" do
 659       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 660
 661       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 662       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 663
 664       object =
 665         update_data["object"]
 666         |> Map.put("actor", data["actor"])
 667         |> Map.put("id", data["actor"])
 668         |> Map.put("manuallyApprovesFollowers", true)
 669
 670       update_data =
 671         update_data
 672         |> Map.put("actor", data["actor"])
 673         |> Map.put("object", object)
 674
 675       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 676
 677       user = User.get_cached_by_ap_id(data["actor"])
 678       assert user.locked == true
 679     end
 680
 681     test "it works for incoming deletes" do
 682       activity = insert(:note_activity)
 683       deleting_user = insert(:user)
 684
 685       data =
 686         File.read!("test/fixtures/mastodon-delete.json")
 687         |> Poison.decode!()
 688
 689       object =
 690         data["object"]
 691         |> Map.put("id", activity.data["object"])
 692
 693       data =
 694         data
 695         |> Map.put("object", object)
 696         |> Map.put("actor", deleting_user.ap_id)
 697
 698       {:ok, %Activity{actor: actor, local: false, data: %{"id" => id}}} =
 699         Transmogrifier.handle_incoming(data)
 700
 701       assert id == data["id"]
 702       refute Activity.get_by_id(activity.id)
 703       assert actor == deleting_user.ap_id
 704     end
 705
 706     test "it fails for incoming deletes with spoofed origin" do
 707       activity = insert(:note_activity)
 708
 709       data =
 710         File.read!("test/fixtures/mastodon-delete.json")
 711         |> Poison.decode!()
 712
 713       object =
 714         data["object"]
 715         |> Map.put("id", activity.data["object"])
 716
 717       data =
 718         data
 719         |> Map.put("object", object)
 720
 721       assert capture_log(fn ->
 722                :error = Transmogrifier.handle_incoming(data)
 723              end) =~
 724                "[error] Could not decode user at fetch http://mastodon.example.org/users/gargron, {:error, :nxdomain}"
 725
 726       assert Activity.get_by_id(activity.id)
 727     end
 728
 729     test "it works for incoming user deletes" do
 730       %{ap_id: ap_id} = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
 731
 732       data =
 733         File.read!("test/fixtures/mastodon-delete-user.json")
 734         |> Poison.decode!()
 735
 736       {:ok, _} = Transmogrifier.handle_incoming(data)
 737       ObanHelpers.perform_all()
 738
 739       refute User.get_cached_by_ap_id(ap_id)
 740     end
 741
 742     test "it fails for incoming user deletes with spoofed origin" do
 743       %{ap_id: ap_id} = insert(:user)
 744
 745       data =
 746         File.read!("test/fixtures/mastodon-delete-user.json")
 747         |> Poison.decode!()
 748         |> Map.put("actor", ap_id)
 749
 750       assert capture_log(fn ->
 751                assert :error == Transmogrifier.handle_incoming(data)
 752              end) =~ "Object containment failed"
 753
 754       assert User.get_cached_by_ap_id(ap_id)
 755     end
 756
 757     test "it works for incoming unannounces with an existing notice" do
 758       user = insert(:user)
 759       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 760
 761       announce_data =
 762         File.read!("test/fixtures/mastodon-announce.json")
 763         |> Poison.decode!()
 764         |> Map.put("object", activity.data["object"])
 765
 766       {:ok, %Activity{data: announce_data, local: false}} =
 767         Transmogrifier.handle_incoming(announce_data)
 768
 769       data =
 770         File.read!("test/fixtures/mastodon-undo-announce.json")
 771         |> Poison.decode!()
 772         |> Map.put("object", announce_data)
 773         |> Map.put("actor", announce_data["actor"])
 774
 775       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 776
 777       assert data["type"] == "Undo"
 778       assert object_data = data["object"]
 779       assert object_data["type"] == "Announce"
 780       assert object_data["object"] == activity.data["object"]
 781
 782       assert object_data["id"] ==
 783                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 784     end
 785
 786     test "it works for incomming unfollows with an existing follow" do
 787       user = insert(:user)
 788
 789       follow_data =
 790         File.read!("test/fixtures/mastodon-follow-activity.json")
 791         |> Poison.decode!()
 792         |> Map.put("object", user.ap_id)
 793
 794       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)
 795
 796       data =
 797         File.read!("test/fixtures/mastodon-unfollow-activity.json")
 798         |> Poison.decode!()
 799         |> Map.put("object", follow_data)
 800
 801       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 802
 803       assert data["type"] == "Undo"
 804       assert data["object"]["type"] == "Follow"
 805       assert data["object"]["object"] == user.ap_id
 806       assert data["actor"] == "http://mastodon.example.org/users/admin"
 807
 808       refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
 809     end
 810
 811     test "it works for incoming follows to locked account" do
 812       pending_follower = insert(:user, ap_id: "http://mastodon.example.org/users/admin")
 813       user = insert(:user, locked: true)
 814
 815       data =
 816         File.read!("test/fixtures/mastodon-follow-activity.json")
 817         |> Poison.decode!()
 818         |> Map.put("object", user.ap_id)
 819
 820       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 821
 822       assert data["type"] == "Follow"
 823       assert data["object"] == user.ap_id
 824       assert data["state"] == "pending"
 825       assert data["actor"] == "http://mastodon.example.org/users/admin"
 826
 827       assert [^pending_follower] = User.get_follow_requests(user)
 828     end
 829
 830     test "it works for incoming blocks" do
 831       user = insert(:user)
 832
 833       data =
 834         File.read!("test/fixtures/mastodon-block-activity.json")
 835         |> Poison.decode!()
 836         |> Map.put("object", user.ap_id)
 837
 838       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 839
 840       assert data["type"] == "Block"
 841       assert data["object"] == user.ap_id
 842       assert data["actor"] == "http://mastodon.example.org/users/admin"
 843
 844       blocker = User.get_cached_by_ap_id(data["actor"])
 845
 846       assert User.blocks?(blocker, user)
 847     end
 848
 849     test "incoming blocks successfully tear down any follow relationship" do
 850       blocker = insert(:user)
 851       blocked = insert(:user)
 852
 853       data =
 854         File.read!("test/fixtures/mastodon-block-activity.json")
 855         |> Poison.decode!()
 856         |> Map.put("object", blocked.ap_id)
 857         |> Map.put("actor", blocker.ap_id)
 858
 859       {:ok, blocker} = User.follow(blocker, blocked)
 860       {:ok, blocked} = User.follow(blocked, blocker)
 861
 862       assert User.following?(blocker, blocked)
 863       assert User.following?(blocked, blocker)
 864
 865       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 866
 867       assert data["type"] == "Block"
 868       assert data["object"] == blocked.ap_id
 869       assert data["actor"] == blocker.ap_id
 870
 871       blocker = User.get_cached_by_ap_id(data["actor"])
 872       blocked = User.get_cached_by_ap_id(data["object"])
 873
 874       assert User.blocks?(blocker, blocked)
 875
 876       refute User.following?(blocker, blocked)
 877       refute User.following?(blocked, blocker)
 878     end
 879
 880     test "it works for incoming unblocks with an existing block" do
 881       user = insert(:user)
 882
 883       block_data =
 884         File.read!("test/fixtures/mastodon-block-activity.json")
 885         |> Poison.decode!()
 886         |> Map.put("object", user.ap_id)
 887
 888       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
 889
 890       data =
 891         File.read!("test/fixtures/mastodon-unblock-activity.json")
 892         |> Poison.decode!()
 893         |> Map.put("object", block_data)
 894
 895       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 896       assert data["type"] == "Undo"
 897       assert data["object"]["type"] == "Block"
 898       assert data["object"]["object"] == user.ap_id
 899       assert data["actor"] == "http://mastodon.example.org/users/admin"
 900
 901       blocker = User.get_cached_by_ap_id(data["actor"])
 902
 903       refute User.blocks?(blocker, user)
 904     end
 905
 906     test "it works for incoming accepts which were pre-accepted" do
 907       follower = insert(:user)
 908       followed = insert(:user)
 909
 910       {:ok, follower} = User.follow(follower, followed)
 911       assert User.following?(follower, followed) == true
 912
 913       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 914
 915       accept_data =
 916         File.read!("test/fixtures/mastodon-accept-activity.json")
 917         |> Poison.decode!()
 918         |> Map.put("actor", followed.ap_id)
 919
 920       object =
 921         accept_data["object"]
 922         |> Map.put("actor", follower.ap_id)
 923         |> Map.put("id", follow_activity.data["id"])
 924
 925       accept_data = Map.put(accept_data, "object", object)
 926
 927       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 928       refute activity.local
 929
 930       assert activity.data["object"] == follow_activity.data["id"]
 931
 932       assert activity.data["id"] == accept_data["id"]
 933
 934       follower = User.get_cached_by_id(follower.id)
 935
 936       assert User.following?(follower, followed) == true
 937     end
 938
 939     test "it works for incoming accepts which were orphaned" do
 940       follower = insert(:user)
 941       followed = insert(:user, locked: true)
 942
 943       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 944
 945       accept_data =
 946         File.read!("test/fixtures/mastodon-accept-activity.json")
 947         |> Poison.decode!()
 948         |> Map.put("actor", followed.ap_id)
 949
 950       accept_data =
 951         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 952
 953       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 954       assert activity.data["object"] == follow_activity.data["id"]
 955
 956       follower = User.get_cached_by_id(follower.id)
 957
 958       assert User.following?(follower, followed) == true
 959     end
 960
 961     test "it works for incoming accepts which are referenced by IRI only" do
 962       follower = insert(:user)
 963       followed = insert(:user, locked: true)
 964
 965       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 966
 967       accept_data =
 968         File.read!("test/fixtures/mastodon-accept-activity.json")
 969         |> Poison.decode!()
 970         |> Map.put("actor", followed.ap_id)
 971         |> Map.put("object", follow_activity.data["id"])
 972
 973       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 974       assert activity.data["object"] == follow_activity.data["id"]
 975
 976       follower = User.get_cached_by_id(follower.id)
 977
 978       assert User.following?(follower, followed) == true
 979     end
 980
 981     test "it fails for incoming accepts which cannot be correlated" do
 982       follower = insert(:user)
 983       followed = insert(:user, locked: true)
 984
 985       accept_data =
 986         File.read!("test/fixtures/mastodon-accept-activity.json")
 987         |> Poison.decode!()
 988         |> Map.put("actor", followed.ap_id)
 989
 990       accept_data =
 991         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 992
 993       :error = Transmogrifier.handle_incoming(accept_data)
 994
 995       follower = User.get_cached_by_id(follower.id)
 996
 997       refute User.following?(follower, followed) == true
 998     end
 999
1000     test "it fails for incoming rejects which cannot be correlated" do
1001       follower = insert(:user)
1002       followed = insert(:user, locked: true)
1003
1004       accept_data =
1005         File.read!("test/fixtures/mastodon-reject-activity.json")
1006         |> Poison.decode!()
1007         |> Map.put("actor", followed.ap_id)
1008
1009       accept_data =
1010         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
1011
1012       :error = Transmogrifier.handle_incoming(accept_data)
1013
1014       follower = User.get_cached_by_id(follower.id)
1015
1016       refute User.following?(follower, followed) == true
1017     end
1018
1019     test "it works for incoming rejects which are orphaned" do
1020       follower = insert(:user)
1021       followed = insert(:user, locked: true)
1022
1023       {:ok, follower} = User.follow(follower, followed)
1024       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
1025
1026       assert User.following?(follower, followed) == true
1027
1028       reject_data =
1029         File.read!("test/fixtures/mastodon-reject-activity.json")
1030         |> Poison.decode!()
1031         |> Map.put("actor", followed.ap_id)
1032
1033       reject_data =
1034         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
1035
1036       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
1037       refute activity.local
1038       assert activity.data["id"] == reject_data["id"]
1039
1040       follower = User.get_cached_by_id(follower.id)
1041
1042       assert User.following?(follower, followed) == false
1043     end
1044
1045     test "it works for incoming rejects which are referenced by IRI only" do
1046       follower = insert(:user)
1047       followed = insert(:user, locked: true)
1048
1049       {:ok, follower} = User.follow(follower, followed)
1050       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
1051
1052       assert User.following?(follower, followed) == true
1053
1054       reject_data =
1055         File.read!("test/fixtures/mastodon-reject-activity.json")
1056         |> Poison.decode!()
1057         |> Map.put("actor", followed.ap_id)
1058         |> Map.put("object", follow_activity.data["id"])
1059
1060       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
1061
1062       follower = User.get_cached_by_id(follower.id)
1063
1064       assert User.following?(follower, followed) == false
1065     end
1066
1067     test "it rejects activities without a valid ID" do
1068       user = insert(:user)
1069
1070       data =
1071         File.read!("test/fixtures/mastodon-follow-activity.json")
1072         |> Poison.decode!()
1073         |> Map.put("object", user.ap_id)
1074         |> Map.put("id", "")
1075
1076       :error = Transmogrifier.handle_incoming(data)
1077     end
1078
1079     test "it remaps video URLs as attachments if necessary" do
1080       {:ok, object} =
1081         Fetcher.fetch_object_from_id(
1082           "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
1083         )
1084
1085       attachment = %{
1086         "type" => "Link",
1087         "mediaType" => "video/mp4",
1088         "href" =>
1089           "https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
1090         "mimeType" => "video/mp4",
1091         "size" => 5_015_880,
1092         "url" => [
1093           %{
1094             "href" =>
1095               "https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
1096             "mediaType" => "video/mp4",
1097             "type" => "Link"
1098           }
1099         ],
1100         "width" => 480
1101       }
1102
1103       assert object.data["url"] ==
1104                "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
1105
1106       assert object.data["attachment"] == [attachment]
1107     end
1108
1109     test "it accepts Flag activities" do
1110       user = insert(:user)
1111       other_user = insert(:user)
1112
1113       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
1114       object = Object.normalize(activity)
1115
1116       note_obj = %{
1117         "type" => "Note",
1118         "id" => activity.data["id"],
1119         "content" => "test post",
1120         "published" => object.data["published"],
1121         "actor" => AccountView.render("show.json", %{user: user})
1122       }
1123
1124       message = %{
1125         "@context" => "https://www.w3.org/ns/activitystreams",
1126         "cc" => [user.ap_id],
1127         "object" => [user.ap_id, activity.data["id"]],
1128         "type" => "Flag",
1129         "content" => "blocked AND reported!!!",
1130         "actor" => other_user.ap_id
1131       }
1132
1133       assert {:ok, activity} = Transmogrifier.handle_incoming(message)
1134
1135       assert activity.data["object"] == [user.ap_id, note_obj]
1136       assert activity.data["content"] == "blocked AND reported!!!"
1137       assert activity.data["actor"] == other_user.ap_id
1138       assert activity.data["cc"] == [user.ap_id]
1139     end
1140
1141     test "it correctly processes messages with non-array to field" do
1142       user = insert(:user)
1143
1144       message = %{
1145         "@context" => "https://www.w3.org/ns/activitystreams",
1146         "to" => "https://www.w3.org/ns/activitystreams#Public",
1147         "type" => "Create",
1148         "object" => %{
1149           "content" => "blah blah blah",
1150           "type" => "Note",
1151           "attributedTo" => user.ap_id,
1152           "inReplyTo" => nil
1153         },
1154         "actor" => user.ap_id
1155       }
1156
1157       assert {:ok, activity} = Transmogrifier.handle_incoming(message)
1158
1159       assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["to"]
1160     end
1161
1162     test "it correctly processes messages with non-array cc field" do
1163       user = insert(:user)
1164
1165       message = %{
1166         "@context" => "https://www.w3.org/ns/activitystreams",
1167         "to" => user.follower_address,
1168         "cc" => "https://www.w3.org/ns/activitystreams#Public",
1169         "type" => "Create",
1170         "object" => %{
1171           "content" => "blah blah blah",
1172           "type" => "Note",
1173           "attributedTo" => user.ap_id,
1174           "inReplyTo" => nil
1175         },
1176         "actor" => user.ap_id
1177       }
1178
1179       assert {:ok, activity} = Transmogrifier.handle_incoming(message)
1180
1181       assert ["https://www.w3.org/ns/activitystreams#Public"] == activity.data["cc"]
1182       assert [user.follower_address] == activity.data["to"]
1183     end
1184   end
1185
1186   describe "prepare outgoing" do
1187     test "it inlines private announced objects" do
1188       user = insert(:user)
1189
1190       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey", "visibility" => "private"})
1191
1192       {:ok, announce_activity, _} = CommonAPI.repeat(activity.id, user)
1193
1194       {:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)
1195
1196       assert modified["object"]["content"] == "hey"
1197       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
1198     end
1199
1200     test "it turns mentions into tags" do
1201       user = insert(:user)
1202       other_user = insert(:user)
1203
1204       {:ok, activity} =
1205         CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
1206
1207       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1208       object = modified["object"]
1209
1210       expected_mention = %{
1211         "href" => other_user.ap_id,
1212         "name" => "@#{other_user.nickname}",
1213         "type" => "Mention"
1214       }
1215
1216       expected_tag = %{
1217         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
1218         "type" => "Hashtag",
1219         "name" => "#2hu"
1220       }
1221
1222       assert Enum.member?(object["tag"], expected_tag)
1223       assert Enum.member?(object["tag"], expected_mention)
1224     end
1225
1226     test "it adds the sensitive property" do
1227       user = insert(:user)
1228
1229       {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
1230       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1231
1232       assert modified["object"]["sensitive"]
1233     end
1234
1235     test "it adds the json-ld context and the conversation property" do
1236       user = insert(:user)
1237
1238       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
1239       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1240
1241       assert modified["@context"] ==
1242                Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]
1243
1244       assert modified["object"]["conversation"] == modified["context"]
1245     end
1246
1247     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
1248       user = insert(:user)
1249
1250       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
1251       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1252
1253       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
1254     end
1255
1256     test "it strips internal hashtag data" do
1257       user = insert(:user)
1258
1259       {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})
1260
1261       expected_tag = %{
1262         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
1263         "type" => "Hashtag",
1264         "name" => "#2hu"
1265       }
1266
1267       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1268
1269       assert modified["object"]["tag"] == [expected_tag]
1270     end
1271
1272     test "it strips internal fields" do
1273       user = insert(:user)
1274
1275       {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"})
1276
1277       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1278
1279       assert length(modified["object"]["tag"]) == 2
1280
1281       assert is_nil(modified["object"]["emoji"])
1282       assert is_nil(modified["object"]["like_count"])
1283       assert is_nil(modified["object"]["announcements"])
1284       assert is_nil(modified["object"]["announcement_count"])
1285       assert is_nil(modified["object"]["context_id"])
1286     end
1287
1288     test "it strips internal fields of article" do
1289       activity = insert(:article_activity)
1290
1291       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1292
1293       assert length(modified["object"]["tag"]) == 2
1294
1295       assert is_nil(modified["object"]["emoji"])
1296       assert is_nil(modified["object"]["like_count"])
1297       assert is_nil(modified["object"]["announcements"])
1298       assert is_nil(modified["object"]["announcement_count"])
1299       assert is_nil(modified["object"]["context_id"])
1300       assert is_nil(modified["object"]["likes"])
1301     end
1302
1303     test "the directMessage flag is present" do
1304       user = insert(:user)
1305       other_user = insert(:user)
1306
1307       {:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})
1308
1309       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1310
1311       assert modified["directMessage"] == false
1312
1313       {:ok, activity} =
1314         CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})
1315
1316       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1317
1318       assert modified["directMessage"] == false
1319
1320       {:ok, activity} =
1321         CommonAPI.post(user, %{
1322           "status" => "@#{other_user.nickname} :moominmamma:",
1323           "visibility" => "direct"
1324         })
1325
1326       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1327
1328       assert modified["directMessage"] == true
1329     end
1330
1331     test "it strips BCC field" do
1332       user = insert(:user)
1333       {:ok, list} = Pleroma.List.create("foo", user)
1334
1335       {:ok, activity} =
1336         CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})
1337
1338       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
1339
1340       assert is_nil(modified["bcc"])
1341     end
1342
1343     test "it can handle Listen activities" do
1344       listen_activity = insert(:listen)
1345
1346       {:ok, modified} = Transmogrifier.prepare_outgoing(listen_activity.data)
1347
1348       assert modified["type"] == "Listen"
1349
1350       user = insert(:user)
1351
1352       {:ok, activity} = CommonAPI.listen(user, %{"title" => "lain radio episode 1"})
1353
1354       {:ok, _modified} = Transmogrifier.prepare_outgoing(activity.data)
1355     end
1356   end
1357
1358   describe "user upgrade" do
1359     test "it upgrades a user to activitypub" do
1360       user =
1361         insert(:user, %{
1362           nickname: "rye@niu.moe",
1363           local: false,
1364           ap_id: "https://niu.moe/users/rye",
1365           follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
1366         })
1367
1368       user_two = insert(:user)
1369       Pleroma.FollowingRelationship.follow(user_two, user, "accept")
1370
1371       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
1372       {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
1373       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
1374
1375       user = User.get_cached_by_id(user.id)
1376       assert user.note_count == 1
1377
1378       {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
1379       ObanHelpers.perform_all()
1380
1381       assert user.ap_enabled
1382       assert user.note_count == 1
1383       assert user.follower_address == "https://niu.moe/users/rye/followers"
1384       assert user.following_address == "https://niu.moe/users/rye/following"
1385
1386       user = User.get_cached_by_id(user.id)
1387       assert user.note_count == 1
1388
1389       activity = Activity.get_by_id(activity.id)
1390       assert user.follower_address in activity.recipients
1391
1392       assert %{
1393                "url" => [
1394                  %{
1395                    "href" =>
1396                      "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
1397                  }
1398                ]
1399              } = user.avatar
1400
1401       assert %{
1402                "url" => [
1403                  %{
1404                    "href" =>
1405                      "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
1406                  }
1407                ]
1408              } = user.banner
1409
1410       refute "..." in activity.recipients
1411
1412       unrelated_activity = Activity.get_by_id(unrelated_activity.id)
1413       refute user.follower_address in unrelated_activity.recipients
1414
1415       user_two = User.get_cached_by_id(user_two.id)
1416       assert User.following?(user_two, user)
1417       refute "..." in User.following(user_two)
1418     end
1419   end
1420
1421   describe "actor rewriting" do
1422     test "it fixes the actor URL property to be a proper URI" do
1423       data = %{
1424         "url" => %{"href" => "http://example.com"}
1425       }
1426
1427       rewritten = Transmogrifier.maybe_fix_user_object(data)
1428       assert rewritten["url"] == "http://example.com"
1429     end
1430   end
1431
1432   describe "actor origin containment" do
1433     test "it rejects activities which reference objects with bogus origins" do
1434       data = %{
1435         "@context" => "https://www.w3.org/ns/activitystreams",
1436         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1437         "actor" => "http://mastodon.example.org/users/admin",
1438         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1439         "object" => "https://info.pleroma.site/activity.json",
1440         "type" => "Announce"
1441       }
1442
1443       assert capture_log(fn ->
1444                :error = Transmogrifier.handle_incoming(data)
1445              end) =~ "Object containment failed"
1446     end
1447
1448     test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
1449       data = %{
1450         "@context" => "https://www.w3.org/ns/activitystreams",
1451         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1452         "actor" => "http://mastodon.example.org/users/admin",
1453         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1454         "object" => "https://info.pleroma.site/activity2.json",
1455         "type" => "Announce"
1456       }
1457
1458       assert capture_log(fn ->
1459                :error = Transmogrifier.handle_incoming(data)
1460              end) =~ "Object containment failed"
1461     end
1462
1463     test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
1464       data = %{
1465         "@context" => "https://www.w3.org/ns/activitystreams",
1466         "id" => "http://mastodon.example.org/users/admin/activities/1234",
1467         "actor" => "http://mastodon.example.org/users/admin",
1468         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1469         "object" => "https://info.pleroma.site/activity3.json",
1470         "type" => "Announce"
1471       }
1472
1473       assert capture_log(fn ->
1474                :error = Transmogrifier.handle_incoming(data)
1475              end) =~ "Object containment failed"
1476     end
1477   end
1478
1479   describe "reserialization" do
1480     test "successfully reserializes a message with inReplyTo == nil" do
1481       user = insert(:user)
1482
1483       message = %{
1484         "@context" => "https://www.w3.org/ns/activitystreams",
1485         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1486         "cc" => [],
1487         "type" => "Create",
1488         "object" => %{
1489           "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1490           "cc" => [],
1491           "type" => "Note",
1492           "content" => "Hi",
1493           "inReplyTo" => nil,
1494           "attributedTo" => user.ap_id
1495         },
1496         "actor" => user.ap_id
1497       }
1498
1499       {:ok, activity} = Transmogrifier.handle_incoming(message)
1500
1501       {:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
1502     end
1503
1504     test "successfully reserializes a message with AS2 objects in IR" do
1505       user = insert(:user)
1506
1507       message = %{
1508         "@context" => "https://www.w3.org/ns/activitystreams",
1509         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1510         "cc" => [],
1511         "type" => "Create",
1512         "object" => %{
1513           "to" => ["https://www.w3.org/ns/activitystreams#Public"],
1514           "cc" => [],
1515           "type" => "Note",
1516           "content" => "Hi",
1517           "inReplyTo" => nil,
1518           "attributedTo" => user.ap_id,
1519           "tag" => [
1520             %{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
1521             %{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
1522           ]
1523         },
1524         "actor" => user.ap_id
1525       }
1526
1527       {:ok, activity} = Transmogrifier.handle_incoming(message)
1528
1529       {:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
1530     end
1531   end
1532
1533   test "Rewrites Answers to Notes" do
1534     user = insert(:user)
1535
1536     {:ok, poll_activity} =
1537       CommonAPI.post(user, %{
1538         "status" => "suya...",
1539         "poll" => %{"options" => ["suya", "suya.", "suya.."], "expires_in" => 10}
1540       })
1541
1542     poll_object = Object.normalize(poll_activity)
1543     # TODO: Replace with CommonAPI vote creation when implemented
1544     data =
1545       File.read!("test/fixtures/mastodon-vote.json")
1546       |> Poison.decode!()
1547       |> Kernel.put_in(["to"], user.ap_id)
1548       |> Kernel.put_in(["object", "inReplyTo"], poll_object.data["id"])
1549       |> Kernel.put_in(["object", "to"], user.ap_id)
1550
1551     {:ok, %Activity{local: false} = activity} = Transmogrifier.handle_incoming(data)
1552     {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
1553
1554     assert data["object"]["type"] == "Note"
1555   end
1556
1557   describe "fix_explicit_addressing" do
1558     setup do
1559       user = insert(:user)
1560       [user: user]
1561     end
1562
1563     test "moves non-explicitly mentioned actors to cc", %{user: user} do
1564       explicitly_mentioned_actors = [
1565         "https://pleroma.gold/users/user1",
1566         "https://pleroma.gold/user2"
1567       ]
1568
1569       object = %{
1570         "actor" => user.ap_id,
1571         "to" => explicitly_mentioned_actors ++ ["https://social.beepboop.ga/users/dirb"],
1572         "cc" => [],
1573         "tag" =>
1574           Enum.map(explicitly_mentioned_actors, fn href ->
1575             %{"type" => "Mention", "href" => href}
1576           end)
1577       }
1578
1579       fixed_object = Transmogrifier.fix_explicit_addressing(object)
1580       assert Enum.all?(explicitly_mentioned_actors, &(&1 in fixed_object["to"]))
1581       refute "https://social.beepboop.ga/users/dirb" in fixed_object["to"]
1582       assert "https://social.beepboop.ga/users/dirb" in fixed_object["cc"]
1583     end
1584
1585     test "does not move actor's follower collection to cc", %{user: user} do
1586       object = %{
1587         "actor" => user.ap_id,
1588         "to" => [user.follower_address],
1589         "cc" => []
1590       }
1591
1592       fixed_object = Transmogrifier.fix_explicit_addressing(object)
1593       assert user.follower_address in fixed_object["to"]
1594       refute user.follower_address in fixed_object["cc"]
1595     end
1596
1597     test "removes recipient's follower collection from cc", %{user: user} do
1598       recipient = insert(:user)
1599
1600       object = %{
1601         "actor" => user.ap_id,
1602         "to" => [recipient.ap_id, "https://www.w3.org/ns/activitystreams#Public"],
1603         "cc" => [user.follower_address, recipient.follower_address]
1604       }
1605
1606       fixed_object = Transmogrifier.fix_explicit_addressing(object)
1607
1608       assert user.follower_address in fixed_object["cc"]
1609       refute recipient.follower_address in fixed_object["cc"]
1610       refute recipient.follower_address in fixed_object["to"]
1611     end
1612   end
1613
1614   describe "fix_summary/1" do
1615     test "returns fixed object" do
1616       assert Transmogrifier.fix_summary(%{"summary" => nil}) == %{"summary" => ""}
1617       assert Transmogrifier.fix_summary(%{"summary" => "ok"}) == %{"summary" => "ok"}
1618       assert Transmogrifier.fix_summary(%{}) == %{"summary" => ""}
1619     end
1620   end
1621
1622   describe "fix_in_reply_to/2" do
1623     clear_config([:instance, :federation_incoming_replies_max_depth])
1624
1625     setup do
1626       data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
1627       [data: data]
1628     end
1629
1630     test "returns not modified object when hasn't containts inReplyTo field", %{data: data} do
1631       assert Transmogrifier.fix_in_reply_to(data) == data
1632     end
1633
1634     test "returns object with inReplyToAtomUri when denied incoming reply", %{data: data} do
1635       Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 0)
1636
1637       object_with_reply =
1638         Map.put(data["object"], "inReplyTo", "https://shitposter.club/notice/2827873")
1639
1640       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
1641       assert modified_object["inReplyTo"] == "https://shitposter.club/notice/2827873"
1642       assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
1643
1644       object_with_reply =
1645         Map.put(data["object"], "inReplyTo", %{"id" => "https://shitposter.club/notice/2827873"})
1646
1647       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
1648       assert modified_object["inReplyTo"] == %{"id" => "https://shitposter.club/notice/2827873"}
1649       assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
1650
1651       object_with_reply =
1652         Map.put(data["object"], "inReplyTo", ["https://shitposter.club/notice/2827873"])
1653
1654       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
1655       assert modified_object["inReplyTo"] == ["https://shitposter.club/notice/2827873"]
1656       assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
1657
1658       object_with_reply = Map.put(data["object"], "inReplyTo", [])
1659       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
1660       assert modified_object["inReplyTo"] == []
1661       assert modified_object["inReplyToAtomUri"] == ""
1662     end
1663
1664     test "returns modified object when allowed incoming reply", %{data: data} do
1665       object_with_reply =
1666         Map.put(
1667           data["object"],
1668           "inReplyTo",
1669           "https://shitposter.club/notice/2827873"
1670         )
1671
1672       Pleroma.Config.put([:instance, :federation_incoming_replies_max_depth], 5)
1673       modified_object = Transmogrifier.fix_in_reply_to(object_with_reply)
1674
1675       assert modified_object["inReplyTo"] ==
1676                "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
1677
1678       assert modified_object["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
1679
1680       assert modified_object["conversation"] ==
1681                "tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"
1682
1683       assert modified_object["context"] ==
1684                "tag:shitposter.club,2017-05-05:objectType=thread:nonce=3c16e9c2681f6d26"
1685     end
1686   end
1687
1688   describe "fix_url/1" do
1689     test "fixes data for object when url is map" do
1690       object = %{
1691         "url" => %{
1692           "type" => "Link",
1693           "mimeType" => "video/mp4",
1694           "href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
1695         }
1696       }
1697
1698       assert Transmogrifier.fix_url(object) == %{
1699                "url" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
1700              }
1701     end
1702
1703     test "fixes data for video object" do
1704       object = %{
1705         "type" => "Video",
1706         "url" => [
1707           %{
1708             "type" => "Link",
1709             "mimeType" => "video/mp4",
1710             "href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4"
1711           },
1712           %{
1713             "type" => "Link",
1714             "mimeType" => "video/mp4",
1715             "href" => "https://peertube46fb-ad81-2d4c2d1630e3-240.mp4"
1716           },
1717           %{
1718             "type" => "Link",
1719             "mimeType" => "text/html",
1720             "href" => "https://peertube.-2d4c2d1630e3"
1721           },
1722           %{
1723             "type" => "Link",
1724             "mimeType" => "text/html",
1725             "href" => "https://peertube.-2d4c2d16377-42"
1726           }
1727         ]
1728       }
1729
1730       assert Transmogrifier.fix_url(object) == %{
1731                "attachment" => [
1732                  %{
1733                    "href" => "https://peede8d-46fb-ad81-2d4c2d1630e3-480.mp4",
1734                    "mimeType" => "video/mp4",
1735                    "type" => "Link"
1736                  }
1737                ],
1738                "type" => "Video",
1739                "url" => "https://peertube.-2d4c2d1630e3"
1740              }
1741     end
1742
1743     test "fixes url for not Video object" do
1744       object = %{
1745         "type" => "Text",
1746         "url" => [
1747           %{
1748             "type" => "Link",
1749             "mimeType" => "text/html",
1750             "href" => "https://peertube.-2d4c2d1630e3"
1751           },
1752           %{
1753             "type" => "Link",
1754             "mimeType" => "text/html",
1755             "href" => "https://peertube.-2d4c2d16377-42"
1756           }
1757         ]
1758       }
1759
1760       assert Transmogrifier.fix_url(object) == %{
1761                "type" => "Text",
1762                "url" => "https://peertube.-2d4c2d1630e3"
1763              }
1764
1765       assert Transmogrifier.fix_url(%{"type" => "Text", "url" => []}) == %{
1766                "type" => "Text",
1767                "url" => ""
1768              }
1769     end
1770
1771     test "retunrs not modified object" do
1772       assert Transmogrifier.fix_url(%{"type" => "Text"}) == %{"type" => "Text"}
1773     end
1774   end
1775
1776   describe "get_obj_helper/2" do
1777     test "returns nil when cannot normalize object" do
1778       assert capture_log(fn ->
1779                refute Transmogrifier.get_obj_helper("test-obj-id")
1780              end) =~ "Unsupported URI scheme"
1781     end
1782
1783     test "returns {:ok, %Object{}} for success case" do
1784       assert {:ok, %Object{}} =
1785                Transmogrifier.get_obj_helper("https://shitposter.club/notice/2827873")
1786     end
1787   end
1788
1789   describe "fix_attachments/1" do
1790     test "returns not modified object" do
1791       data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
1792       assert Transmogrifier.fix_attachments(data) == data
1793     end
1794
1795     test "returns modified object when attachment is map" do
1796       assert Transmogrifier.fix_attachments(%{
1797                "attachment" => %{
1798                  "mediaType" => "video/mp4",
1799                  "url" => "https://peertube.moe/stat-480.mp4"
1800                }
1801              }) == %{
1802                "attachment" => [
1803                  %{
1804                    "mediaType" => "video/mp4",
1805                    "url" => [
1806                      %{
1807                        "href" => "https://peertube.moe/stat-480.mp4",
1808                        "mediaType" => "video/mp4",
1809                        "type" => "Link"
1810                      }
1811                    ]
1812                  }
1813                ]
1814              }
1815     end
1816
1817     test "returns modified object when attachment is list" do
1818       assert Transmogrifier.fix_attachments(%{
1819                "attachment" => [
1820                  %{"mediaType" => "video/mp4", "url" => "https://pe.er/stat-480.mp4"},
1821                  %{"mimeType" => "video/mp4", "href" => "https://pe.er/stat-480.mp4"}
1822                ]
1823              }) == %{
1824                "attachment" => [
1825                  %{
1826                    "mediaType" => "video/mp4",
1827                    "url" => [
1828                      %{
1829                        "href" => "https://pe.er/stat-480.mp4",
1830                        "mediaType" => "video/mp4",
1831                        "type" => "Link"
1832                      }
1833                    ]
1834                  },
1835                  %{
1836                    "href" => "https://pe.er/stat-480.mp4",
1837                    "mediaType" => "video/mp4",
1838                    "mimeType" => "video/mp4",
1839                    "url" => [
1840                      %{
1841                        "href" => "https://pe.er/stat-480.mp4",
1842                        "mediaType" => "video/mp4",
1843                        "type" => "Link"
1844                      }
1845                    ]
1846                  }
1847                ]
1848              }
1849     end
1850   end
1851
1852   describe "fix_emoji/1" do
1853     test "returns not modified object when object not contains tags" do
1854       data = Poison.decode!(File.read!("test/fixtures/mastodon-post-activity.json"))
1855       assert Transmogrifier.fix_emoji(data) == data
1856     end
1857
1858     test "returns object with emoji when object contains list tags" do
1859       assert Transmogrifier.fix_emoji(%{
1860                "tag" => [
1861                  %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}},
1862                  %{"type" => "Hashtag"}
1863                ]
1864              }) == %{
1865                "emoji" => %{"bib" => "/test"},
1866                "tag" => [
1867                  %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"},
1868                  %{"type" => "Hashtag"}
1869                ]
1870              }
1871     end
1872
1873     test "returns object with emoji when object contains map tag" do
1874       assert Transmogrifier.fix_emoji(%{
1875                "tag" => %{"type" => "Emoji", "name" => ":bib:", "icon" => %{"url" => "/test"}}
1876              }) == %{
1877                "emoji" => %{"bib" => "/test"},
1878                "tag" => %{"icon" => %{"url" => "/test"}, "name" => ":bib:", "type" => "Emoji"}
1879              }
1880     end
1881   end
1882 end