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 deletes" do
 270       activity = insert(:note_activity)
 271
 272       data =
 273         File.read!("test/fixtures/mastodon-delete.json")
 274         |> Poison.decode!()
 275
 276       object =
 277         data["object"]
 278         |> Map.put("id", activity.data["object"]["id"])
 279
 280       data =
 281         data
 282         |> Map.put("object", object)
 283         |> Map.put("actor", activity.data["actor"])
 284
 285       {:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)
 286
 287       refute Repo.get(Activity, activity.id)
 288     end
 289
 290     test "it works for incoming unannounces with an existing notice" do
 291       user = insert(:user)
 292       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 293
 294       announce_data =
 295         File.read!("test/fixtures/mastodon-announce.json")
 296         |> Poison.decode!()
 297         |> Map.put("object", activity.data["object"]["id"])
 298
 299       {:ok, %Activity{data: announce_data, local: false}} =
 300         Transmogrifier.handle_incoming(announce_data)
 301
 302       data =
 303         File.read!("test/fixtures/mastodon-undo-announce.json")
 304         |> Poison.decode!()
 305         |> Map.put("object", announce_data)
 306         |> Map.put("actor", announce_data["actor"])
 307
 308       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 309
 310       assert data["type"] == "Undo"
 311       assert data["object"]["type"] == "Announce"
 312       assert data["object"]["object"] == activity.data["object"]["id"]
 313
 314       assert data["object"]["id"] ==
 315                "http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
 316     end
 317
 318     test "it works for incomming unfollows with an existing follow" do
 319       user = insert(:user)
 320
 321       follow_data =
 322         File.read!("test/fixtures/mastodon-follow-activity.json")
 323         |> Poison.decode!()
 324         |> Map.put("object", user.ap_id)
 325
 326       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)
 327
 328       data =
 329         File.read!("test/fixtures/mastodon-unfollow-activity.json")
 330         |> Poison.decode!()
 331         |> Map.put("object", follow_data)
 332
 333       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 334
 335       assert data["type"] == "Undo"
 336       assert data["object"]["type"] == "Follow"
 337       assert data["object"]["object"] == user.ap_id
 338       assert data["actor"] == "http://mastodon.example.org/users/admin"
 339
 340       refute User.following?(User.get_by_ap_id(data["actor"]), user)
 341     end
 342
 343     test "it works for incoming blocks" do
 344       user = insert(:user)
 345
 346       data =
 347         File.read!("test/fixtures/mastodon-block-activity.json")
 348         |> Poison.decode!()
 349         |> Map.put("object", user.ap_id)
 350
 351       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 352
 353       assert data["type"] == "Block"
 354       assert data["object"] == user.ap_id
 355       assert data["actor"] == "http://mastodon.example.org/users/admin"
 356
 357       blocker = User.get_by_ap_id(data["actor"])
 358
 359       assert User.blocks?(blocker, user)
 360     end
 361
 362     test "it works for incoming unblocks with an existing block" do
 363       user = insert(:user)
 364
 365       block_data =
 366         File.read!("test/fixtures/mastodon-block-activity.json")
 367         |> Poison.decode!()
 368         |> Map.put("object", user.ap_id)
 369
 370       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
 371
 372       data =
 373         File.read!("test/fixtures/mastodon-unblock-activity.json")
 374         |> Poison.decode!()
 375         |> Map.put("object", block_data)
 376
 377       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 378       assert data["type"] == "Undo"
 379       assert data["object"]["type"] == "Block"
 380       assert data["object"]["object"] == user.ap_id
 381       assert data["actor"] == "http://mastodon.example.org/users/admin"
 382
 383       blocker = User.get_by_ap_id(data["actor"])
 384
 385       refute User.blocks?(blocker, user)
 386     end
 387
 388     test "it works for incoming accepts which were pre-accepted" do
 389       follower = insert(:user)
 390       followed = insert(:user)
 391
 392       {:ok, follower} = User.follow(follower, followed)
 393       assert User.following?(follower, followed) == true
 394
 395       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 396
 397       accept_data =
 398         File.read!("test/fixtures/mastodon-accept-activity.json")
 399         |> Poison.decode!()
 400         |> Map.put("actor", followed.ap_id)
 401
 402       object =
 403         accept_data["object"]
 404         |> Map.put("actor", follower.ap_id)
 405         |> Map.put("id", follow_activity.data["id"])
 406
 407       accept_data = Map.put(accept_data, "object", object)
 408
 409       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 410       refute activity.local
 411
 412       assert activity.data["object"] == follow_activity.data["id"]
 413
 414       follower = Repo.get(User, follower.id)
 415
 416       assert User.following?(follower, followed) == true
 417     end
 418
 419     test "it works for incoming accepts which were orphaned" do
 420       follower = insert(:user)
 421       followed = insert(:user, %{info: %{"locked" => true}})
 422
 423       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 424
 425       accept_data =
 426         File.read!("test/fixtures/mastodon-accept-activity.json")
 427         |> Poison.decode!()
 428         |> Map.put("actor", followed.ap_id)
 429
 430       accept_data =
 431         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 432
 433       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 434       assert activity.data["object"] == follow_activity.data["id"]
 435
 436       follower = Repo.get(User, follower.id)
 437
 438       assert User.following?(follower, followed) == true
 439     end
 440
 441     test "it works for incoming accepts which are referenced by IRI only" do
 442       follower = insert(:user)
 443       followed = insert(:user, %{info: %{"locked" => true}})
 444
 445       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 446
 447       accept_data =
 448         File.read!("test/fixtures/mastodon-accept-activity.json")
 449         |> Poison.decode!()
 450         |> Map.put("actor", followed.ap_id)
 451         |> Map.put("object", follow_activity.data["id"])
 452
 453       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 454       assert activity.data["object"] == follow_activity.data["id"]
 455
 456       follower = Repo.get(User, follower.id)
 457
 458       assert User.following?(follower, followed) == true
 459     end
 460
 461     test "it fails for incoming accepts which cannot be correlated" do
 462       follower = insert(:user)
 463       followed = insert(:user, %{info: %{"locked" => true}})
 464
 465       accept_data =
 466         File.read!("test/fixtures/mastodon-accept-activity.json")
 467         |> Poison.decode!()
 468         |> Map.put("actor", followed.ap_id)
 469
 470       accept_data =
 471         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 472
 473       :error = Transmogrifier.handle_incoming(accept_data)
 474
 475       follower = Repo.get(User, follower.id)
 476
 477       refute User.following?(follower, followed) == true
 478     end
 479
 480     test "it fails for incoming rejects which cannot be correlated" do
 481       follower = insert(:user)
 482       followed = insert(:user, %{info: %{"locked" => true}})
 483
 484       accept_data =
 485         File.read!("test/fixtures/mastodon-reject-activity.json")
 486         |> Poison.decode!()
 487         |> Map.put("actor", followed.ap_id)
 488
 489       accept_data =
 490         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 491
 492       :error = Transmogrifier.handle_incoming(accept_data)
 493
 494       follower = Repo.get(User, follower.id)
 495
 496       refute User.following?(follower, followed) == true
 497     end
 498
 499     test "it works for incoming rejects which are orphaned" do
 500       follower = insert(:user)
 501       followed = insert(:user, %{info: %{"locked" => true}})
 502
 503       {:ok, follower} = User.follow(follower, followed)
 504       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
 505
 506       assert User.following?(follower, followed) == true
 507
 508       reject_data =
 509         File.read!("test/fixtures/mastodon-reject-activity.json")
 510         |> Poison.decode!()
 511         |> Map.put("actor", followed.ap_id)
 512
 513       reject_data =
 514         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
 515
 516       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
 517       refute activity.local
 518
 519       follower = Repo.get(User, follower.id)
 520
 521       assert User.following?(follower, followed) == false
 522     end
 523
 524     test "it works for incoming rejects which are referenced by IRI only" do
 525       follower = insert(:user)
 526       followed = insert(:user, %{info: %{"locked" => true}})
 527
 528       {:ok, follower} = User.follow(follower, followed)
 529       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 530
 531       assert User.following?(follower, followed) == true
 532
 533       reject_data =
 534         File.read!("test/fixtures/mastodon-reject-activity.json")
 535         |> Poison.decode!()
 536         |> Map.put("actor", followed.ap_id)
 537         |> Map.put("object", follow_activity.data["id"])
 538
 539       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
 540
 541       follower = Repo.get(User, follower.id)
 542
 543       assert User.following?(follower, followed) == false
 544     end
 545   end
 546
 547   describe "prepare outgoing" do
 548     test "it turns mentions into tags" do
 549       user = insert(:user)
 550       other_user = insert(:user)
 551
 552       {:ok, activity} =
 553         CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
 554
 555       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 556       object = modified["object"]
 557
 558       expected_mention = %{
 559         "href" => other_user.ap_id,
 560         "name" => "@#{other_user.nickname}",
 561         "type" => "Mention"
 562       }
 563
 564       expected_tag = %{
 565         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
 566         "type" => "Hashtag",
 567         "name" => "#2hu"
 568       }
 569
 570       assert Enum.member?(object["tag"], expected_tag)
 571       assert Enum.member?(object["tag"], expected_mention)
 572     end
 573
 574     test "it adds the sensitive property" do
 575       user = insert(:user)
 576
 577       {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
 578       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 579
 580       assert modified["object"]["sensitive"]
 581     end
 582
 583     test "it adds the json-ld context and the conversation property" do
 584       user = insert(:user)
 585
 586       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 587       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 588
 589       assert modified["@context"] == "https://www.w3.org/ns/activitystreams"
 590       assert modified["object"]["conversation"] == modified["context"]
 591     end
 592
 593     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
 594       user = insert(:user)
 595
 596       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 597       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 598
 599       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
 600     end
 601
 602     test "it translates ostatus IDs to external URLs" do
 603       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 604       {:ok, [referent_activity]} = OStatus.handle_incoming(incoming)
 605
 606       user = insert(:user)
 607
 608       {:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
 609       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 610
 611       assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
 612     end
 613
 614     test "it translates ostatus reply_to IDs to external URLs" do
 615       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 616       {:ok, [referred_activity]} = OStatus.handle_incoming(incoming)
 617
 618       user = insert(:user)
 619
 620       {:ok, activity} =
 621         CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})
 622
 623       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 624
 625       assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
 626     end
 627   end
 628
 629   describe "user upgrade" do
 630     test "it upgrades a user to activitypub" do
 631       user =
 632         insert(:user, %{
 633           nickname: "rye@niu.moe",
 634           local: false,
 635           ap_id: "https://niu.moe/users/rye",
 636           follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
 637         })
 638
 639       user_two = insert(:user, %{following: [user.follower_address]})
 640
 641       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
 642       {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
 643       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
 644
 645       user = Repo.get(User, user.id)
 646       assert user.info["note_count"] == 1
 647
 648       {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
 649       assert user.info["ap_enabled"]
 650       assert user.info["note_count"] == 1
 651       assert user.follower_address == "https://niu.moe/users/rye/followers"
 652
 653       # Wait for the background task
 654       :timer.sleep(1000)
 655
 656       user = Repo.get(User, user.id)
 657       assert user.info["note_count"] == 1
 658
 659       activity = Repo.get(Activity, activity.id)
 660       assert user.follower_address in activity.recipients
 661
 662       assert %{
 663                "url" => [
 664                  %{
 665                    "href" =>
 666                      "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 667                  }
 668                ]
 669              } = user.avatar
 670
 671       assert %{
 672                "url" => [
 673                  %{
 674                    "href" =>
 675                      "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 676                  }
 677                ]
 678              } = user.info["banner"]
 679
 680       refute "..." in activity.recipients
 681
 682       unrelated_activity = Repo.get(Activity, unrelated_activity.id)
 683       refute user.follower_address in unrelated_activity.recipients
 684
 685       user_two = Repo.get(User, user_two.id)
 686       assert user.follower_address in user_two.following
 687       refute "..." in user_two.following
 688     end
 689   end
 690
 691   describe "maybe_retire_websub" do
 692     test "it deletes all websub client subscripitions with the user as topic" do
 693       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
 694       {:ok, ws} = Repo.insert(subscription)
 695
 696       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
 697       {:ok, ws2} = Repo.insert(subscription)
 698
 699       Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")
 700
 701       refute Repo.get(WebsubClientSubscription, ws.id)
 702       assert Repo.get(WebsubClientSubscription, ws2.id)
 703     end
 704   end
 705
 706   describe "actor rewriting" do
 707     test "it fixes the actor URL property to be a proper URI" do
 708       data = %{
 709         "url" => %{"href" => "http://example.com"}
 710       }
 711
 712       rewritten = Transmogrifier.maybe_fix_user_object(data)
 713       assert rewritten["url"] == "http://example.com"
 714     end
 715   end
 716 end