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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
   6   use Pleroma.Web.ConnCase
   7   import Pleroma.Factory
   8   alias Pleroma.Activity
   9   alias Pleroma.Instances
  10   alias Pleroma.Object
  11   alias Pleroma.User
  12   alias Pleroma.Web.ActivityPub.ObjectView
  13   alias Pleroma.Web.ActivityPub.UserView
  14   alias Pleroma.Web.ActivityPub.Utils
  15
  16   setup_all do
  17     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  18     :ok
  19   end
  20
  21   describe "/relay" do
  22     test "with the relay active, it returns the relay user", %{conn: conn} do
  23       res =
  24         conn
  25         |> get(activity_pub_path(conn, :relay))
  26         |> json_response(200)
  27
  28       assert res["id"] =~ "/relay"
  29     end
  30
  31     test "with the relay disabled, it returns 404", %{conn: conn} do
  32       Pleroma.Config.put([:instance, :allow_relay], false)
  33
  34       conn
  35       |> get(activity_pub_path(conn, :relay))
  36       |> json_response(404)
  37       |> assert
  38
  39       Pleroma.Config.put([:instance, :allow_relay], true)
  40     end
  41   end
  42
  43   describe "/users/:nickname" do
  44     test "it returns a json representation of the user with accept application/json", %{
  45       conn: conn
  46     } do
  47       user = insert(:user)
  48
  49       conn =
  50         conn
  51         |> put_req_header("accept", "application/json")
  52         |> get("/users/#{user.nickname}")
  53
  54       user = User.get_cached_by_id(user.id)
  55
  56       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  57     end
  58
  59     test "it returns a json representation of the user with accept application/activity+json", %{
  60       conn: conn
  61     } do
  62       user = insert(:user)
  63
  64       conn =
  65         conn
  66         |> put_req_header("accept", "application/activity+json")
  67         |> get("/users/#{user.nickname}")
  68
  69       user = User.get_cached_by_id(user.id)
  70
  71       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  72     end
  73
  74     test "it returns a json representation of the user with accept application/ld+json", %{
  75       conn: conn
  76     } do
  77       user = insert(:user)
  78
  79       conn =
  80         conn
  81         |> put_req_header(
  82           "accept",
  83           "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
  84         )
  85         |> get("/users/#{user.nickname}")
  86
  87       user = User.get_cached_by_id(user.id)
  88
  89       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  90     end
  91   end
  92
  93   describe "/object/:uuid" do
  94     test "it returns a json representation of the object with accept application/json", %{
  95       conn: conn
  96     } do
  97       note = insert(:note)
  98       uuid = String.split(note.data["id"], "/") |> List.last()
  99
 100       conn =
 101         conn
 102         |> put_req_header("accept", "application/json")
 103         |> get("/objects/#{uuid}")
 104
 105       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 106     end
 107
 108     test "it returns a json representation of the object with accept application/activity+json",
 109          %{conn: conn} do
 110       note = insert(:note)
 111       uuid = String.split(note.data["id"], "/") |> List.last()
 112
 113       conn =
 114         conn
 115         |> put_req_header("accept", "application/activity+json")
 116         |> get("/objects/#{uuid}")
 117
 118       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 119     end
 120
 121     test "it returns a json representation of the object with accept application/ld+json", %{
 122       conn: conn
 123     } do
 124       note = insert(:note)
 125       uuid = String.split(note.data["id"], "/") |> List.last()
 126
 127       conn =
 128         conn
 129         |> put_req_header(
 130           "accept",
 131           "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\""
 132         )
 133         |> get("/objects/#{uuid}")
 134
 135       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
 136     end
 137
 138     test "it returns 404 for non-public messages", %{conn: conn} do
 139       note = insert(:direct_note)
 140       uuid = String.split(note.data["id"], "/") |> List.last()
 141
 142       conn =
 143         conn
 144         |> put_req_header("accept", "application/activity+json")
 145         |> get("/objects/#{uuid}")
 146
 147       assert json_response(conn, 404)
 148     end
 149
 150     test "it returns 404 for tombstone objects", %{conn: conn} do
 151       tombstone = insert(:tombstone)
 152       uuid = String.split(tombstone.data["id"], "/") |> List.last()
 153
 154       conn =
 155         conn
 156         |> put_req_header("accept", "application/activity+json")
 157         |> get("/objects/#{uuid}")
 158
 159       assert json_response(conn, 404)
 160     end
 161   end
 162
 163   describe "/object/:uuid/likes" do
 164     test "it returns the like activities in a collection", %{conn: conn} do
 165       like = insert(:like_activity)
 166       uuid = String.split(like.data["object"], "/") |> List.last()
 167
 168       result =
 169         conn
 170         |> put_req_header("accept", "application/activity+json")
 171         |> get("/objects/#{uuid}/likes")
 172         |> json_response(200)
 173
 174       assert List.first(result["first"]["orderedItems"])["id"] == like.data["id"]
 175     end
 176   end
 177
 178   describe "/activities/:uuid" do
 179     test "it returns a json representation of the activity", %{conn: conn} do
 180       activity = insert(:note_activity)
 181       uuid = String.split(activity.data["id"], "/") |> List.last()
 182
 183       conn =
 184         conn
 185         |> put_req_header("accept", "application/activity+json")
 186         |> get("/activities/#{uuid}")
 187
 188       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
 189     end
 190
 191     test "it returns 404 for non-public activities", %{conn: conn} do
 192       activity = insert(:direct_note_activity)
 193       uuid = String.split(activity.data["id"], "/") |> List.last()
 194
 195       conn =
 196         conn
 197         |> put_req_header("accept", "application/activity+json")
 198         |> get("/activities/#{uuid}")
 199
 200       assert json_response(conn, 404)
 201     end
 202   end
 203
 204   describe "/inbox" do
 205     test "it inserts an incoming activity into the database", %{conn: conn} do
 206       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 207
 208       conn =
 209         conn
 210         |> assign(:valid_signature, true)
 211         |> put_req_header("content-type", "application/activity+json")
 212         |> post("/inbox", data)
 213
 214       assert "ok" == json_response(conn, 200)
 215       :timer.sleep(500)
 216       assert Activity.get_by_ap_id(data["id"])
 217     end
 218
 219     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 220       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 221
 222       sender_url = data["actor"]
 223       Instances.set_consistently_unreachable(sender_url)
 224       refute Instances.reachable?(sender_url)
 225
 226       conn =
 227         conn
 228         |> assign(:valid_signature, true)
 229         |> put_req_header("content-type", "application/activity+json")
 230         |> post("/inbox", data)
 231
 232       assert "ok" == json_response(conn, 200)
 233       assert Instances.reachable?(sender_url)
 234     end
 235   end
 236
 237   describe "/users/:nickname/inbox" do
 238     setup do
 239       data =
 240         File.read!("test/fixtures/mastodon-post-activity.json")
 241         |> Poison.decode!()
 242
 243       [data: data]
 244     end
 245
 246     test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
 247       user = insert(:user)
 248       data = Map.put(data, "bcc", [user.ap_id])
 249
 250       conn =
 251         conn
 252         |> assign(:valid_signature, true)
 253         |> put_req_header("content-type", "application/activity+json")
 254         |> post("/users/#{user.nickname}/inbox", data)
 255
 256       assert "ok" == json_response(conn, 200)
 257       :timer.sleep(500)
 258       assert Activity.get_by_ap_id(data["id"])
 259     end
 260
 261     test "it accepts messages from actors that are followed by the user", %{
 262       conn: conn,
 263       data: data
 264     } do
 265       recipient = insert(:user)
 266       actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})
 267
 268       {:ok, recipient} = User.follow(recipient, actor)
 269
 270       object =
 271         data["object"]
 272         |> Map.put("attributedTo", actor.ap_id)
 273
 274       data =
 275         data
 276         |> Map.put("actor", actor.ap_id)
 277         |> Map.put("object", object)
 278
 279       conn =
 280         conn
 281         |> assign(:valid_signature, true)
 282         |> put_req_header("content-type", "application/activity+json")
 283         |> post("/users/#{recipient.nickname}/inbox", data)
 284
 285       assert "ok" == json_response(conn, 200)
 286       :timer.sleep(500)
 287       assert Activity.get_by_ap_id(data["id"])
 288     end
 289
 290     test "it rejects reads from other users", %{conn: conn} do
 291       user = insert(:user)
 292       otheruser = insert(:user)
 293
 294       conn =
 295         conn
 296         |> assign(:user, otheruser)
 297         |> put_req_header("accept", "application/activity+json")
 298         |> get("/users/#{user.nickname}/inbox")
 299
 300       assert json_response(conn, 403)
 301     end
 302
 303     test "it returns a note activity in a collection", %{conn: conn} do
 304       note_activity = insert(:direct_note_activity)
 305       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 306
 307       conn =
 308         conn
 309         |> assign(:user, user)
 310         |> put_req_header("accept", "application/activity+json")
 311         |> get("/users/#{user.nickname}/inbox")
 312
 313       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 314     end
 315
 316     test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
 317       user = insert(:user)
 318       data = Map.put(data, "bcc", [user.ap_id])
 319
 320       sender_host = URI.parse(data["actor"]).host
 321       Instances.set_consistently_unreachable(sender_host)
 322       refute Instances.reachable?(sender_host)
 323
 324       conn =
 325         conn
 326         |> assign(:valid_signature, true)
 327         |> put_req_header("content-type", "application/activity+json")
 328         |> post("/users/#{user.nickname}/inbox", data)
 329
 330       assert "ok" == json_response(conn, 200)
 331       assert Instances.reachable?(sender_host)
 332     end
 333
 334     test "it removes all follower collections but actor's", %{conn: conn} do
 335       [actor, recipient] = insert_pair(:user)
 336
 337       data =
 338         File.read!("test/fixtures/activitypub-client-post-activity.json")
 339         |> Poison.decode!()
 340
 341       object = Map.put(data["object"], "attributedTo", actor.ap_id)
 342
 343       data =
 344         data
 345         |> Map.put("id", Utils.generate_object_id())
 346         |> Map.put("actor", actor.ap_id)
 347         |> Map.put("object", object)
 348         |> Map.put("cc", [
 349           recipient.follower_address,
 350           actor.follower_address
 351         ])
 352         |> Map.put("to", [
 353           recipient.ap_id,
 354           recipient.follower_address,
 355           "https://www.w3.org/ns/activitystreams#Public"
 356         ])
 357
 358       conn
 359       |> assign(:valid_signature, true)
 360       |> put_req_header("content-type", "application/activity+json")
 361       |> post("/users/#{recipient.nickname}/inbox", data)
 362       |> json_response(200)
 363
 364       activity = Activity.get_by_ap_id(data["id"])
 365
 366       assert activity.id
 367       assert actor.follower_address in activity.recipients
 368       assert actor.follower_address in activity.data["cc"]
 369
 370       refute recipient.follower_address in activity.recipients
 371       refute recipient.follower_address in activity.data["cc"]
 372       refute recipient.follower_address in activity.data["to"]
 373     end
 374   end
 375
 376   describe "/users/:nickname/outbox" do
 377     test "it will not bomb when there is no activity", %{conn: conn} do
 378       user = insert(:user)
 379
 380       conn =
 381         conn
 382         |> put_req_header("accept", "application/activity+json")
 383         |> get("/users/#{user.nickname}/outbox")
 384
 385       result = json_response(conn, 200)
 386       assert user.ap_id <> "/outbox" == result["id"]
 387     end
 388
 389     test "it returns a note activity in a collection", %{conn: conn} do
 390       note_activity = insert(:note_activity)
 391       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 392
 393       conn =
 394         conn
 395         |> put_req_header("accept", "application/activity+json")
 396         |> get("/users/#{user.nickname}/outbox")
 397
 398       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 399     end
 400
 401     test "it returns an announce activity in a collection", %{conn: conn} do
 402       announce_activity = insert(:announce_activity)
 403       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 404
 405       conn =
 406         conn
 407         |> put_req_header("accept", "application/activity+json")
 408         |> get("/users/#{user.nickname}/outbox")
 409
 410       assert response(conn, 200) =~ announce_activity.data["object"]
 411     end
 412
 413     test "it rejects posts from other users", %{conn: conn} do
 414       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 415       user = insert(:user)
 416       otheruser = insert(:user)
 417
 418       conn =
 419         conn
 420         |> assign(:user, otheruser)
 421         |> put_req_header("content-type", "application/activity+json")
 422         |> post("/users/#{user.nickname}/outbox", data)
 423
 424       assert json_response(conn, 403)
 425     end
 426
 427     test "it inserts an incoming create activity into the database", %{conn: conn} do
 428       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 429       user = insert(:user)
 430
 431       conn =
 432         conn
 433         |> assign(:user, user)
 434         |> put_req_header("content-type", "application/activity+json")
 435         |> post("/users/#{user.nickname}/outbox", data)
 436
 437       result = json_response(conn, 201)
 438       assert Activity.get_by_ap_id(result["id"])
 439     end
 440
 441     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 442       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 443       user = insert(:user)
 444
 445       data =
 446         data
 447         |> Map.put("type", "BadType")
 448
 449       conn =
 450         conn
 451         |> assign(:user, user)
 452         |> put_req_header("content-type", "application/activity+json")
 453         |> post("/users/#{user.nickname}/outbox", data)
 454
 455       assert json_response(conn, 400)
 456     end
 457
 458     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 459       note_activity = insert(:note_activity)
 460       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 461
 462       data = %{
 463         type: "Delete",
 464         object: %{
 465           id: note_activity.data["object"]["id"]
 466         }
 467       }
 468
 469       conn =
 470         conn
 471         |> assign(:user, user)
 472         |> put_req_header("content-type", "application/activity+json")
 473         |> post("/users/#{user.nickname}/outbox", data)
 474
 475       result = json_response(conn, 201)
 476       assert Activity.get_by_ap_id(result["id"])
 477
 478       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 479       assert object
 480       assert object.data["type"] == "Tombstone"
 481     end
 482
 483     test "it rejects delete activity of object from other actor", %{conn: conn} do
 484       note_activity = insert(:note_activity)
 485       user = insert(:user)
 486
 487       data = %{
 488         type: "Delete",
 489         object: %{
 490           id: note_activity.data["object"]["id"]
 491         }
 492       }
 493
 494       conn =
 495         conn
 496         |> assign(:user, user)
 497         |> put_req_header("content-type", "application/activity+json")
 498         |> post("/users/#{user.nickname}/outbox", data)
 499
 500       assert json_response(conn, 400)
 501     end
 502
 503     test "it increases like count when receiving a like action", %{conn: conn} do
 504       note_activity = insert(:note_activity)
 505       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 506
 507       data = %{
 508         type: "Like",
 509         object: %{
 510           id: note_activity.data["object"]["id"]
 511         }
 512       }
 513
 514       conn =
 515         conn
 516         |> assign(:user, user)
 517         |> put_req_header("content-type", "application/activity+json")
 518         |> post("/users/#{user.nickname}/outbox", data)
 519
 520       result = json_response(conn, 201)
 521       assert Activity.get_by_ap_id(result["id"])
 522
 523       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 524       assert object
 525       assert object.data["like_count"] == 1
 526     end
 527   end
 528
 529   describe "/users/:nickname/followers" do
 530     test "it returns the followers in a collection", %{conn: conn} do
 531       user = insert(:user)
 532       user_two = insert(:user)
 533       User.follow(user, user_two)
 534
 535       result =
 536         conn
 537         |> get("/users/#{user_two.nickname}/followers")
 538         |> json_response(200)
 539
 540       assert result["first"]["orderedItems"] == [user.ap_id]
 541     end
 542
 543     test "it returns returns empty if the user has 'hide_followers' set", %{conn: conn} do
 544       user = insert(:user)
 545       user_two = insert(:user, %{info: %{hide_followers: true}})
 546       User.follow(user, user_two)
 547
 548       result =
 549         conn
 550         |> get("/users/#{user_two.nickname}/followers")
 551         |> json_response(200)
 552
 553       assert result["first"]["orderedItems"] == []
 554       assert result["totalItems"] == 0
 555     end
 556
 557     test "it works for more than 10 users", %{conn: conn} do
 558       user = insert(:user)
 559
 560       Enum.each(1..15, fn _ ->
 561         other_user = insert(:user)
 562         User.follow(other_user, user)
 563       end)
 564
 565       result =
 566         conn
 567         |> get("/users/#{user.nickname}/followers")
 568         |> json_response(200)
 569
 570       assert length(result["first"]["orderedItems"]) == 10
 571       assert result["first"]["totalItems"] == 15
 572       assert result["totalItems"] == 15
 573
 574       result =
 575         conn
 576         |> get("/users/#{user.nickname}/followers?page=2")
 577         |> json_response(200)
 578
 579       assert length(result["orderedItems"]) == 5
 580       assert result["totalItems"] == 15
 581     end
 582   end
 583
 584   describe "/users/:nickname/following" do
 585     test "it returns the following in a collection", %{conn: conn} do
 586       user = insert(:user)
 587       user_two = insert(:user)
 588       User.follow(user, user_two)
 589
 590       result =
 591         conn
 592         |> get("/users/#{user.nickname}/following")
 593         |> json_response(200)
 594
 595       assert result["first"]["orderedItems"] == [user_two.ap_id]
 596     end
 597
 598     test "it returns returns empty if the user has 'hide_follows' set", %{conn: conn} do
 599       user = insert(:user, %{info: %{hide_follows: true}})
 600       user_two = insert(:user)
 601       User.follow(user, user_two)
 602
 603       result =
 604         conn
 605         |> get("/users/#{user.nickname}/following")
 606         |> json_response(200)
 607
 608       assert result["first"]["orderedItems"] == []
 609       assert result["totalItems"] == 0
 610     end
 611
 612     test "it works for more than 10 users", %{conn: conn} do
 613       user = insert(:user)
 614
 615       Enum.each(1..15, fn _ ->
 616         user = User.get_cached_by_id(user.id)
 617         other_user = insert(:user)
 618         User.follow(user, other_user)
 619       end)
 620
 621       result =
 622         conn
 623         |> get("/users/#{user.nickname}/following")
 624         |> json_response(200)
 625
 626       assert length(result["first"]["orderedItems"]) == 10
 627       assert result["first"]["totalItems"] == 15
 628       assert result["totalItems"] == 15
 629
 630       result =
 631         conn
 632         |> get("/users/#{user.nickname}/following?page=2")
 633         |> json_response(200)
 634
 635       assert length(result["orderedItems"]) == 5
 636       assert result["totalItems"] == 15
 637     end
 638   end
 639 end