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

   1 defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
   2   use Pleroma.DataCase
   3   alias Pleroma.Web.ActivityPub.Transmogrifier
   4   alias Pleroma.Web.ActivityPub.Utils
   5   alias Pleroma.Web.ActivityPub.ActivityPub
   6   alias Pleroma.Web.OStatus
   7   alias Pleroma.Activity
   8   alias Pleroma.User
   9   alias Pleroma.Repo
  10   alias Pleroma.Web.Websub.WebsubClientSubscription
  11
  12   import Pleroma.Factory
  13   alias Pleroma.Web.CommonAPI
  14
  15   describe "handle_incoming" do
  16     test "it ignores an incoming notice if we already have it" do
  17       activity = insert(:note_activity)
  18
  19       data =
  20         File.read!("test/fixtures/mastodon-post-activity.json")
  21         |> Poison.decode!()
  22         |> Map.put("object", activity.data["object"])
  23
  24       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  25
  26       assert activity == returned_activity
  27     end
  28
  29     test "it fetches replied-to activities if we don't have them" do
  30       data =
  31         File.read!("test/fixtures/mastodon-post-activity.json")
  32         |> Poison.decode!()
  33
  34       object =
  35         data["object"]
  36         |> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")
  37
  38       data =
  39         data
  40         |> Map.put("object", object)
  41
  42       {:ok, returned_activity} = Transmogrifier.handle_incoming(data)
  43
  44       assert activity =
  45                Activity.get_create_activity_by_object_ap_id(
  46                  "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
  47                )
  48
  49       assert returned_activity.data["object"]["inReplyToAtomUri"] ==
  50                "https://shitposter.club/notice/2827873"
  51
  52       assert returned_activity.data["object"]["inReplyToStatusId"] == activity.id
  53     end
  54
  55     test "it works for incoming notices" do
  56       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
  57
  58       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
  59
  60       assert data["id"] ==
  61                "http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"
  62
  63       assert data["context"] ==
  64                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
  65
  66       assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
  67
  68       assert data["cc"] == [
  69                "http://mastodon.example.org/users/admin/followers",
  70                "http://localtesting.pleroma.lol/users/lain"
  71              ]
  72
  73       assert data["actor"] == "http://mastodon.example.org/users/admin"
  74
  75       object = data["object"]
  76       assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"
  77
  78       assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]
  79
  80       assert object["cc"] == [
  81                "http://mastodon.example.org/users/admin/followers",
  82                "http://localtesting.pleroma.lol/users/lain"
  83              ]
  84
  85       assert object["actor"] == "http://mastodon.example.org/users/admin"
  86       assert object["attributedTo"] == "http://mastodon.example.org/users/admin"
  87
  88       assert object["context"] ==
  89                "tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"
  90
  91       assert object["sensitive"] == true
  92
  93       user = User.get_by_ap_id(object["actor"])
  94
  95       assert user.info["note_count"] == 1
  96     end
  97
  98     test "it works for incoming notices with hashtags" do
  99       data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") |> Poison.decode!()
 100
 101       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 102       assert Enum.at(data["object"]["tag"], 2) == "moo"
 103     end
 104
 105     test "it works for incoming follow requests" do
 106       user = insert(:user)
 107
 108       data =
 109         File.read!("test/fixtures/mastodon-follow-activity.json")
 110         |> Poison.decode!()
 111         |> Map.put("object", user.ap_id)
 112
 113       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 114
 115       assert data["actor"] == "http://mastodon.example.org/users/admin"
 116       assert data["type"] == "Follow"
 117       assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
 118       assert User.following?(User.get_by_ap_id(data["actor"]), user)
 119     end
 120
 121     test "it works for incoming follow requests from hubzilla" do
 122       user = insert(:user)
 123
 124       data =
 125         File.read!("test/fixtures/hubzilla-follow-activity.json")
 126         |> Poison.decode!()
 127         |> Map.put("object", user.ap_id)
 128         |> Utils.normalize_params()
 129
 130       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 131
 132       assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
 133       assert data["type"] == "Follow"
 134       assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
 135       assert User.following?(User.get_by_ap_id(data["actor"]), user)
 136     end
 137
 138     test "it works for incoming likes" do
 139       user = insert(:user)
 140       {:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})
 141
 142       data =
 143         File.read!("test/fixtures/mastodon-like.json")
 144         |> Poison.decode!()
 145         |> Map.put("object", activity.data["object"]["id"])
 146
 147       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 148
 149       assert data["actor"] == "http://mastodon.example.org/users/admin"
 150       assert data["type"] == "Like"
 151       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
 152       assert data["object"] == activity.data["object"]["id"]
 153     end
 154
 155     test "it returns an error for incoming unlikes wihout a like activity" do
 156       user = insert(:user)
 157       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 158
 159       data =
 160         File.read!("test/fixtures/mastodon-undo-like.json")
 161         |> Poison.decode!()
 162         |> Map.put("object", activity.data["object"]["id"])
 163
 164       assert Transmogrifier.handle_incoming(data) == :error
 165     end
 166
 167     test "it works for incoming unlikes with an existing like activity" do
 168       user = insert(:user)
 169       {:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})
 170
 171       like_data =
 172         File.read!("test/fixtures/mastodon-like.json")
 173         |> Poison.decode!()
 174         |> Map.put("object", activity.data["object"]["id"])
 175
 176       {:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)
 177
 178       data =
 179         File.read!("test/fixtures/mastodon-undo-like.json")
 180         |> Poison.decode!()
 181         |> Map.put("object", like_data)
 182         |> Map.put("actor", like_data["actor"])
 183
 184       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 185
 186       assert data["actor"] == "http://mastodon.example.org/users/admin"
 187       assert data["type"] == "Undo"
 188       assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
 189       assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
 190     end
 191
 192     test "it works for incoming announces" do
 193       data = File.read!("test/fixtures/mastodon-announce.json") |> Poison.decode!()
 194
 195       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 196
 197       assert data["actor"] == "http://mastodon.example.org/users/admin"
 198       assert data["type"] == "Announce"
 199
 200       assert data["id"] ==
 201                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 202
 203       assert data["object"] ==
 204                "http://mastodon.example.org/users/admin/statuses/99541947525187367"
 205
 206       assert Activity.get_create_activity_by_object_ap_id(data["object"])
 207     end
 208
 209     test "it works for incoming announces with an existing activity" do
 210       user = insert(:user)
 211       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 212
 213       data =
 214         File.read!("test/fixtures/mastodon-announce.json")
 215         |> Poison.decode!()
 216         |> Map.put("object", activity.data["object"]["id"])
 217
 218       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 219
 220       assert data["actor"] == "http://mastodon.example.org/users/admin"
 221       assert data["type"] == "Announce"
 222
 223       assert data["id"] ==
 224                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 225
 226       assert data["object"] == activity.data["object"]["id"]
 227
 228       assert Activity.get_create_activity_by_object_ap_id(data["object"]).id == activity.id
 229     end
 230
 231     test "it works for incoming update activities" do
 232       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 233
 234       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 235       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 236
 237       object =
 238         update_data["object"]
 239         |> Map.put("actor", data["actor"])
 240         |> Map.put("id", data["actor"])
 241
 242       update_data =
 243         update_data
 244         |> Map.put("actor", data["actor"])
 245         |> Map.put("object", object)
 246
 247       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 248
 249       user = User.get_cached_by_ap_id(data["actor"])
 250       assert user.name == "gargle"
 251
 252       assert user.avatar["url"] == [
 253                %{
 254                  "href" =>
 255                    "https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 256                }
 257              ]
 258
 259       assert user.info["banner"]["url"] == [
 260                %{
 261                  "href" =>
 262                    "https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 263                }
 264              ]
 265
 266       assert user.bio == "<p>Some bio</p>"
 267     end
 268
 269     test "it works for incoming update activities which lock the account" do
 270       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 271
 272       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 273       update_data = File.read!("test/fixtures/mastodon-update.json") |> Poison.decode!()
 274
 275       object =
 276         update_data["object"]
 277         |> Map.put("actor", data["actor"])
 278         |> Map.put("id", data["actor"])
 279         |> Map.put("manuallyApprovesFollowers", true)
 280
 281       update_data =
 282         update_data
 283         |> Map.put("actor", data["actor"])
 284         |> Map.put("object", object)
 285
 286       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)
 287
 288       user = User.get_cached_by_ap_id(data["actor"])
 289       assert user.info["locked"] == true
 290     end
 291
 292     test "it works for incoming deletes" do
 293       activity = insert(:note_activity)
 294
 295       data =
 296         File.read!("test/fixtures/mastodon-delete.json")
 297         |> Poison.decode!()
 298
 299       object =
 300         data["object"]
 301         |> Map.put("id", activity.data["object"]["id"])
 302
 303       data =
 304         data
 305         |> Map.put("object", object)
 306         |> Map.put("actor", activity.data["actor"])
 307
 308       {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
 309
 310       refute Repo.get(Activity, activity.id)
 311     end
 312
 313     test "it works for incoming unannounces with an existing notice" do
 314       user = insert(:user)
 315       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 316
 317       announce_data =
 318         File.read!("test/fixtures/mastodon-announce.json")
 319         |> Poison.decode!()
 320         |> Map.put("object", activity.data["object"]["id"])
 321
 322       {:ok, %Activity{data: announce_data, local: false}} =
 323         Transmogrifier.handle_incoming(announce_data)
 324
 325       data =
 326         File.read!("test/fixtures/mastodon-undo-announce.json")
 327         |> Poison.decode!()
 328         |> Map.put("object", announce_data)
 329         |> Map.put("actor", announce_data["actor"])
 330
 331       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 332
 333       assert data["type"] == "Undo"
 334       assert data["object"]["type"] == "Announce"
 335       assert data["object"]["object"] == activity.data["object"]["id"]
 336
 337       assert data["object"]["id"] ==
 338                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 339     end
 340
 341     test "it works for incomming unfollows with an existing follow" do
 342       user = insert(:user)
 343
 344       follow_data =
 345         File.read!("test/fixtures/mastodon-follow-activity.json")
 346         |> Poison.decode!()
 347         |> Map.put("object", user.ap_id)
 348
 349       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)
 350
 351       data =
 352         File.read!("test/fixtures/mastodon-unfollow-activity.json")
 353         |> Poison.decode!()
 354         |> Map.put("object", follow_data)
 355
 356       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 357
 358       assert data["type"] == "Undo"
 359       assert data["object"]["type"] == "Follow"
 360       assert data["object"]["object"] == user.ap_id
 361       assert data["actor"] == "http://mastodon.example.org/users/admin"
 362
 363       refute User.following?(User.get_by_ap_id(data["actor"]), user)
 364     end
 365
 366     test "it works for incoming blocks" do
 367       user = insert(:user)
 368
 369       data =
 370         File.read!("test/fixtures/mastodon-block-activity.json")
 371         |> Poison.decode!()
 372         |> Map.put("object", user.ap_id)
 373
 374       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 375
 376       assert data["type"] == "Block"
 377       assert data["object"] == user.ap_id
 378       assert data["actor"] == "http://mastodon.example.org/users/admin"
 379
 380       blocker = User.get_by_ap_id(data["actor"])
 381
 382       assert User.blocks?(blocker, user)
 383     end
 384
 385     test "incoming blocks successfully tear down any follow relationship" do
 386       blocker = insert(:user)
 387       blocked = insert(:user)
 388
 389       data =
 390         File.read!("test/fixtures/mastodon-block-activity.json")
 391         |> Poison.decode!()
 392         |> Map.put("object", blocked.ap_id)
 393         |> Map.put("actor", blocker.ap_id)
 394
 395       {:ok, blocker} = User.follow(blocker, blocked)
 396       {:ok, blocked} = User.follow(blocked, blocker)
 397
 398       assert User.following?(blocker, blocked)
 399       assert User.following?(blocked, blocker)
 400
 401       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 402
 403       assert data["type"] == "Block"
 404       assert data["object"] == blocked.ap_id
 405       assert data["actor"] == blocker.ap_id
 406
 407       blocker = User.get_by_ap_id(data["actor"])
 408       blocked = User.get_by_ap_id(data["object"])
 409
 410       assert User.blocks?(blocker, blocked)
 411
 412       refute User.following?(blocker, blocked)
 413       refute User.following?(blocked, blocker)
 414     end
 415
 416     test "it works for incoming unblocks with an existing block" do
 417       user = insert(:user)
 418
 419       block_data =
 420         File.read!("test/fixtures/mastodon-block-activity.json")
 421         |> Poison.decode!()
 422         |> Map.put("object", user.ap_id)
 423
 424       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
 425
 426       data =
 427         File.read!("test/fixtures/mastodon-unblock-activity.json")
 428         |> Poison.decode!()
 429         |> Map.put("object", block_data)
 430
 431       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 432       assert data["type"] == "Undo"
 433       assert data["object"]["type"] == "Block"
 434       assert data["object"]["object"] == user.ap_id
 435       assert data["actor"] == "http://mastodon.example.org/users/admin"
 436
 437       blocker = User.get_by_ap_id(data["actor"])
 438
 439       refute User.blocks?(blocker, user)
 440     end
 441
 442     test "it works for incoming accepts which were pre-accepted" do
 443       follower = insert(:user)
 444       followed = insert(:user)
 445
 446       {:ok, follower} = User.follow(follower, followed)
 447       assert User.following?(follower, followed) == true
 448
 449       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 450
 451       accept_data =
 452         File.read!("test/fixtures/mastodon-accept-activity.json")
 453         |> Poison.decode!()
 454         |> Map.put("actor", followed.ap_id)
 455
 456       object =
 457         accept_data["object"]
 458         |> Map.put("actor", follower.ap_id)
 459         |> Map.put("id", follow_activity.data["id"])
 460
 461       accept_data = Map.put(accept_data, "object", object)
 462
 463       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 464       refute activity.local
 465
 466       assert activity.data["object"] == follow_activity.data["id"]
 467
 468       follower = Repo.get(User, follower.id)
 469
 470       assert User.following?(follower, followed) == true
 471     end
 472
 473     test "it works for incoming accepts which were orphaned" do
 474       follower = insert(:user)
 475       followed = insert(:user, %{info: %{"locked" => true}})
 476
 477       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 478
 479       accept_data =
 480         File.read!("test/fixtures/mastodon-accept-activity.json")
 481         |> Poison.decode!()
 482         |> Map.put("actor", followed.ap_id)
 483
 484       accept_data =
 485         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 486
 487       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 488       assert activity.data["object"] == follow_activity.data["id"]
 489
 490       follower = Repo.get(User, follower.id)
 491
 492       assert User.following?(follower, followed) == true
 493     end
 494
 495     test "it works for incoming accepts which are referenced by IRI only" do
 496       follower = insert(:user)
 497       followed = insert(:user, %{info: %{"locked" => true}})
 498
 499       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 500
 501       accept_data =
 502         File.read!("test/fixtures/mastodon-accept-activity.json")
 503         |> Poison.decode!()
 504         |> Map.put("actor", followed.ap_id)
 505         |> Map.put("object", follow_activity.data["id"])
 506
 507       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 508       assert activity.data["object"] == follow_activity.data["id"]
 509
 510       follower = Repo.get(User, follower.id)
 511
 512       assert User.following?(follower, followed) == true
 513     end
 514
 515     test "it fails for incoming accepts which cannot be correlated" do
 516       follower = insert(:user)
 517       followed = insert(:user, %{info: %{"locked" => true}})
 518
 519       accept_data =
 520         File.read!("test/fixtures/mastodon-accept-activity.json")
 521         |> Poison.decode!()
 522         |> Map.put("actor", followed.ap_id)
 523
 524       accept_data =
 525         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 526
 527       :error = Transmogrifier.handle_incoming(accept_data)
 528
 529       follower = Repo.get(User, follower.id)
 530
 531       refute User.following?(follower, followed) == true
 532     end
 533
 534     test "it fails for incoming rejects which cannot be correlated" do
 535       follower = insert(:user)
 536       followed = insert(:user, %{info: %{"locked" => true}})
 537
 538       accept_data =
 539         File.read!("test/fixtures/mastodon-reject-activity.json")
 540         |> Poison.decode!()
 541         |> Map.put("actor", followed.ap_id)
 542
 543       accept_data =
 544         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 545
 546       :error = Transmogrifier.handle_incoming(accept_data)
 547
 548       follower = Repo.get(User, follower.id)
 549
 550       refute User.following?(follower, followed) == true
 551     end
 552
 553     test "it works for incoming rejects which are orphaned" do
 554       follower = insert(:user)
 555       followed = insert(:user, %{info: %{"locked" => true}})
 556
 557       {:ok, follower} = User.follow(follower, followed)
 558       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
 559
 560       assert User.following?(follower, followed) == true
 561
 562       reject_data =
 563         File.read!("test/fixtures/mastodon-reject-activity.json")
 564         |> Poison.decode!()
 565         |> Map.put("actor", followed.ap_id)
 566
 567       reject_data =
 568         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
 569
 570       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
 571       refute activity.local
 572
 573       follower = Repo.get(User, follower.id)
 574
 575       assert User.following?(follower, followed) == false
 576     end
 577
 578     test "it works for incoming rejects which are referenced by IRI only" do
 579       follower = insert(:user)
 580       followed = insert(:user, %{info: %{"locked" => true}})
 581
 582       {:ok, follower} = User.follow(follower, followed)
 583       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 584
 585       assert User.following?(follower, followed) == true
 586
 587       reject_data =
 588         File.read!("test/fixtures/mastodon-reject-activity.json")
 589         |> Poison.decode!()
 590         |> Map.put("actor", followed.ap_id)
 591         |> Map.put("object", follow_activity.data["id"])
 592
 593       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
 594
 595       follower = Repo.get(User, follower.id)
 596
 597       assert User.following?(follower, followed) == false
 598     end
 599   end
 600
 601   describe "prepare outgoing" do
 602     test "it turns mentions into tags" do
 603       user = insert(:user)
 604       other_user = insert(:user)
 605
 606       {:ok, activity} =
 607         CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
 608
 609       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 610       object = modified["object"]
 611
 612       expected_mention = %{
 613         "href" => other_user.ap_id,
 614         "name" => "@#{other_user.nickname}",
 615         "type" => "Mention"
 616       }
 617
 618       expected_tag = %{
 619         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
 620         "type" => "Hashtag",
 621         "name" => "#2hu"
 622       }
 623
 624       assert Enum.member?(object["tag"], expected_tag)
 625       assert Enum.member?(object["tag"], expected_mention)
 626     end
 627
 628     test "it adds the sensitive property" do
 629       user = insert(:user)
 630
 631       {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
 632       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 633
 634       assert modified["object"]["sensitive"]
 635     end
 636
 637     test "it adds the json-ld context and the conversation property" do
 638       user = insert(:user)
 639
 640       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 641       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 642
 643       assert modified["@context"] == "https://www.w3.org/ns/activitystreams"
 644       assert modified["object"]["conversation"] == modified["context"]
 645     end
 646
 647     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
 648       user = insert(:user)
 649
 650       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 651       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 652
 653       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
 654     end
 655
 656     test "it translates ostatus IDs to external URLs" do
 657       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 658       {:ok, [referent_activity]} = OStatus.handle_incoming(incoming)
 659
 660       user = insert(:user)
 661
 662       {:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
 663       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 664
 665       assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
 666     end
 667
 668     test "it translates ostatus reply_to IDs to external URLs" do
 669       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 670       {:ok, [referred_activity]} = OStatus.handle_incoming(incoming)
 671
 672       user = insert(:user)
 673
 674       {:ok, activity} =
 675         CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})
 676
 677       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 678
 679       assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
 680     end
 681   end
 682
 683   describe "user upgrade" do
 684     test "it upgrades a user to activitypub" do
 685       user =
 686         insert(:user, %{
 687           nickname: "rye@niu.moe",
 688           local: false,
 689           ap_id: "https://niu.moe/users/rye",
 690           follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
 691         })
 692
 693       user_two = insert(:user, %{following: [user.follower_address]})
 694
 695       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
 696       {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
 697       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
 698
 699       user = Repo.get(User, user.id)
 700       assert user.info["note_count"] == 1
 701
 702       {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
 703       assert user.info["ap_enabled"]
 704       assert user.info["note_count"] == 1
 705       assert user.follower_address == "https://niu.moe/users/rye/followers"
 706
 707       # Wait for the background task
 708       :timer.sleep(1000)
 709
 710       user = Repo.get(User, user.id)
 711       assert user.info["note_count"] == 1
 712
 713       activity = Repo.get(Activity, activity.id)
 714       assert user.follower_address in activity.recipients
 715
 716       assert %{
 717                "url" => [
 718                  %{
 719                    "href" =>
 720                      "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 721                  }
 722                ]
 723              } = user.avatar
 724
 725       assert %{
 726                "url" => [
 727                  %{
 728                    "href" =>
 729                      "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 730                  }
 731                ]
 732              } = user.info["banner"]
 733
 734       refute "..." in activity.recipients
 735
 736       unrelated_activity = Repo.get(Activity, unrelated_activity.id)
 737       refute user.follower_address in unrelated_activity.recipients
 738
 739       user_two = Repo.get(User, user_two.id)
 740       assert user.follower_address in user_two.following
 741       refute "..." in user_two.following
 742     end
 743   end
 744
 745   describe "maybe_retire_websub" do
 746     test "it deletes all websub client subscripitions with the user as topic" do
 747       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
 748       {:ok, ws} = Repo.insert(subscription)
 749
 750       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
 751       {:ok, ws2} = Repo.insert(subscription)
 752
 753       Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")
 754
 755       refute Repo.get(WebsubClientSubscription, ws.id)
 756       assert Repo.get(WebsubClientSubscription, ws2.id)
 757     end
 758   end
 759
 760   describe "actor rewriting" do
 761     test "it fixes the actor URL property to be a proper URI" do
 762       data = %{
 763         "url" => %{"href" => "http://example.com"}
 764       }
 765
 766       rewritten = Transmogrifier.maybe_fix_user_object(data)
 767       assert rewritten["url"] == "http://example.com"
 768     end
 769   end
 770 end