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