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