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 "it works for incoming unblocks with an existing block" do
 386       user = insert(:user)
 387
 388       block_data =
 389         File.read!("test/fixtures/mastodon-block-activity.json")
 390         |> Poison.decode!()
 391         |> Map.put("object", user.ap_id)
 392
 393       {:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)
 394
 395       data =
 396         File.read!("test/fixtures/mastodon-unblock-activity.json")
 397         |> Poison.decode!()
 398         |> Map.put("object", block_data)
 399
 400       {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
 401       assert data["type"] == "Undo"
 402       assert data["object"]["type"] == "Block"
 403       assert data["object"]["object"] == user.ap_id
 404       assert data["actor"] == "http://mastodon.example.org/users/admin"
 405
 406       blocker = User.get_by_ap_id(data["actor"])
 407
 408       refute User.blocks?(blocker, user)
 409     end
 410
 411     test "it works for incoming accepts which were pre-accepted" do
 412       follower = insert(:user)
 413       followed = insert(:user)
 414
 415       {:ok, follower} = User.follow(follower, followed)
 416       assert User.following?(follower, followed) == true
 417
 418       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 419
 420       accept_data =
 421         File.read!("test/fixtures/mastodon-accept-activity.json")
 422         |> Poison.decode!()
 423         |> Map.put("actor", followed.ap_id)
 424
 425       object =
 426         accept_data["object"]
 427         |> Map.put("actor", follower.ap_id)
 428         |> Map.put("id", follow_activity.data["id"])
 429
 430       accept_data = Map.put(accept_data, "object", object)
 431
 432       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 433       refute activity.local
 434
 435       assert activity.data["object"] == follow_activity.data["id"]
 436
 437       follower = Repo.get(User, follower.id)
 438
 439       assert User.following?(follower, followed) == true
 440     end
 441
 442     test "it works for incoming accepts which were orphaned" do
 443       follower = insert(:user)
 444       followed = insert(:user, %{info: %{"locked" => true}})
 445
 446       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 447
 448       accept_data =
 449         File.read!("test/fixtures/mastodon-accept-activity.json")
 450         |> Poison.decode!()
 451         |> Map.put("actor", followed.ap_id)
 452
 453       accept_data =
 454         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 455
 456       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 457       assert activity.data["object"] == follow_activity.data["id"]
 458
 459       follower = Repo.get(User, follower.id)
 460
 461       assert User.following?(follower, followed) == true
 462     end
 463
 464     test "it works for incoming accepts which are referenced by IRI only" do
 465       follower = insert(:user)
 466       followed = insert(:user, %{info: %{"locked" => true}})
 467
 468       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 469
 470       accept_data =
 471         File.read!("test/fixtures/mastodon-accept-activity.json")
 472         |> Poison.decode!()
 473         |> Map.put("actor", followed.ap_id)
 474         |> Map.put("object", follow_activity.data["id"])
 475
 476       {:ok, activity} = Transmogrifier.handle_incoming(accept_data)
 477       assert activity.data["object"] == follow_activity.data["id"]
 478
 479       follower = Repo.get(User, follower.id)
 480
 481       assert User.following?(follower, followed) == true
 482     end
 483
 484     test "it fails for incoming accepts which cannot be correlated" do
 485       follower = insert(:user)
 486       followed = insert(:user, %{info: %{"locked" => true}})
 487
 488       accept_data =
 489         File.read!("test/fixtures/mastodon-accept-activity.json")
 490         |> Poison.decode!()
 491         |> Map.put("actor", followed.ap_id)
 492
 493       accept_data =
 494         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 495
 496       :error = Transmogrifier.handle_incoming(accept_data)
 497
 498       follower = Repo.get(User, follower.id)
 499
 500       refute User.following?(follower, followed) == true
 501     end
 502
 503     test "it fails for incoming rejects which cannot be correlated" do
 504       follower = insert(:user)
 505       followed = insert(:user, %{info: %{"locked" => true}})
 506
 507       accept_data =
 508         File.read!("test/fixtures/mastodon-reject-activity.json")
 509         |> Poison.decode!()
 510         |> Map.put("actor", followed.ap_id)
 511
 512       accept_data =
 513         Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))
 514
 515       :error = Transmogrifier.handle_incoming(accept_data)
 516
 517       follower = Repo.get(User, follower.id)
 518
 519       refute User.following?(follower, followed) == true
 520     end
 521
 522     test "it works for incoming rejects which are orphaned" do
 523       follower = insert(:user)
 524       followed = insert(:user, %{info: %{"locked" => true}})
 525
 526       {:ok, follower} = User.follow(follower, followed)
 527       {:ok, _follow_activity} = ActivityPub.follow(follower, followed)
 528
 529       assert User.following?(follower, followed) == true
 530
 531       reject_data =
 532         File.read!("test/fixtures/mastodon-reject-activity.json")
 533         |> Poison.decode!()
 534         |> Map.put("actor", followed.ap_id)
 535
 536       reject_data =
 537         Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))
 538
 539       {:ok, activity} = Transmogrifier.handle_incoming(reject_data)
 540       refute activity.local
 541
 542       follower = Repo.get(User, follower.id)
 543
 544       assert User.following?(follower, followed) == false
 545     end
 546
 547     test "it works for incoming rejects which are referenced by IRI only" do
 548       follower = insert(:user)
 549       followed = insert(:user, %{info: %{"locked" => true}})
 550
 551       {:ok, follower} = User.follow(follower, followed)
 552       {:ok, follow_activity} = ActivityPub.follow(follower, followed)
 553
 554       assert User.following?(follower, followed) == true
 555
 556       reject_data =
 557         File.read!("test/fixtures/mastodon-reject-activity.json")
 558         |> Poison.decode!()
 559         |> Map.put("actor", followed.ap_id)
 560         |> Map.put("object", follow_activity.data["id"])
 561
 562       {:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)
 563
 564       follower = Repo.get(User, follower.id)
 565
 566       assert User.following?(follower, followed) == false
 567     end
 568   end
 569
 570   describe "prepare outgoing" do
 571     test "it turns mentions into tags" do
 572       user = insert(:user)
 573       other_user = insert(:user)
 574
 575       {:ok, activity} =
 576         CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})
 577
 578       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 579       object = modified["object"]
 580
 581       expected_mention = %{
 582         "href" => other_user.ap_id,
 583         "name" => "@#{other_user.nickname}",
 584         "type" => "Mention"
 585       }
 586
 587       expected_tag = %{
 588         "href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
 589         "type" => "Hashtag",
 590         "name" => "#2hu"
 591       }
 592
 593       assert Enum.member?(object["tag"], expected_tag)
 594       assert Enum.member?(object["tag"], expected_mention)
 595     end
 596
 597     test "it adds the sensitive property" do
 598       user = insert(:user)
 599
 600       {:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
 601       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 602
 603       assert modified["object"]["sensitive"]
 604     end
 605
 606     test "it adds the json-ld context and the conversation property" do
 607       user = insert(:user)
 608
 609       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 610       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 611
 612       assert modified["@context"] == "https://www.w3.org/ns/activitystreams"
 613       assert modified["object"]["conversation"] == modified["context"]
 614     end
 615
 616     test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
 617       user = insert(:user)
 618
 619       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
 620       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 621
 622       assert modified["object"]["actor"] == modified["object"]["attributedTo"]
 623     end
 624
 625     test "it translates ostatus IDs to external URLs" do
 626       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 627       {:ok, [referent_activity]} = OStatus.handle_incoming(incoming)
 628
 629       user = insert(:user)
 630
 631       {:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
 632       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 633
 634       assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
 635     end
 636
 637     test "it translates ostatus reply_to IDs to external URLs" do
 638       incoming = File.read!("test/fixtures/incoming_note_activity.xml")
 639       {:ok, [referred_activity]} = OStatus.handle_incoming(incoming)
 640
 641       user = insert(:user)
 642
 643       {:ok, activity} =
 644         CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})
 645
 646       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 647
 648       assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
 649     end
 650   end
 651
 652   describe "user upgrade" do
 653     test "it upgrades a user to activitypub" do
 654       user =
 655         insert(:user, %{
 656           nickname: "rye@niu.moe",
 657           local: false,
 658           ap_id: "https://niu.moe/users/rye",
 659           follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
 660         })
 661
 662       user_two = insert(:user, %{following: [user.follower_address]})
 663
 664       {:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
 665       {:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
 666       assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients
 667
 668       user = Repo.get(User, user.id)
 669       assert user.info["note_count"] == 1
 670
 671       {:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
 672       assert user.info["ap_enabled"]
 673       assert user.info["note_count"] == 1
 674       assert user.follower_address == "https://niu.moe/users/rye/followers"
 675
 676       # Wait for the background task
 677       :timer.sleep(1000)
 678
 679       user = Repo.get(User, user.id)
 680       assert user.info["note_count"] == 1
 681
 682       activity = Repo.get(Activity, activity.id)
 683       assert user.follower_address in activity.recipients
 684
 685       assert %{
 686                "url" => [
 687                  %{
 688                    "href" =>
 689                      "https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
 690                  }
 691                ]
 692              } = user.avatar
 693
 694       assert %{
 695                "url" => [
 696                  %{
 697                    "href" =>
 698                      "https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
 699                  }
 700                ]
 701              } = user.info["banner"]
 702
 703       refute "..." in activity.recipients
 704
 705       unrelated_activity = Repo.get(Activity, unrelated_activity.id)
 706       refute user.follower_address in unrelated_activity.recipients
 707
 708       user_two = Repo.get(User, user_two.id)
 709       assert user.follower_address in user_two.following
 710       refute "..." in user_two.following
 711     end
 712   end
 713
 714   describe "maybe_retire_websub" do
 715     test "it deletes all websub client subscripitions with the user as topic" do
 716       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
 717       {:ok, ws} = Repo.insert(subscription)
 718
 719       subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
 720       {:ok, ws2} = Repo.insert(subscription)
 721
 722       Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")
 723
 724       refute Repo.get(WebsubClientSubscription, ws.id)
 725       assert Repo.get(WebsubClientSubscription, ws2.id)
 726     end
 727   end
 728
 729   describe "actor rewriting" do
 730     test "it fixes the actor URL property to be a proper URI" do
 731       data = %{
 732         "url" => %{"href" => "http://example.com"}
 733       }
 734
 735       rewritten = Transmogrifier.maybe_fix_user_object(data)
 736       assert rewritten["url"] == "http://example.com"
 737     end
 738   end
 739 end