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       like_object_ap_id = Object.normalize(like).data["id"]
 167       uuid = String.split(like_object_ap_id, "/") |> List.last()
 168
 169       result =
 170         conn
 171         |> put_req_header("accept", "application/activity+json")
 172         |> get("/objects/#{uuid}/likes")
 173         |> json_response(200)
 174
 175       assert List.first(result["first"]["orderedItems"])["id"] == like.data["id"]
 176     end
 177   end
 178
 179   describe "/activities/:uuid" do
 180     test "it returns a json representation of the activity", %{conn: conn} do
 181       activity = insert(:note_activity)
 182       uuid = String.split(activity.data["id"], "/") |> List.last()
 183
 184       conn =
 185         conn
 186         |> put_req_header("accept", "application/activity+json")
 187         |> get("/activities/#{uuid}")
 188
 189       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
 190     end
 191
 192     test "it returns 404 for non-public activities", %{conn: conn} do
 193       activity = insert(:direct_note_activity)
 194       uuid = String.split(activity.data["id"], "/") |> List.last()
 195
 196       conn =
 197         conn
 198         |> put_req_header("accept", "application/activity+json")
 199         |> get("/activities/#{uuid}")
 200
 201       assert json_response(conn, 404)
 202     end
 203   end
 204
 205   describe "/inbox" do
 206     test "it inserts an incoming activity into the database", %{conn: conn} do
 207       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 208
 209       conn =
 210         conn
 211         |> assign(:valid_signature, true)
 212         |> put_req_header("content-type", "application/activity+json")
 213         |> post("/inbox", data)
 214
 215       assert "ok" == json_response(conn, 200)
 216       :timer.sleep(500)
 217       assert Activity.get_by_ap_id(data["id"])
 218     end
 219
 220     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 221       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 222
 223       sender_url = data["actor"]
 224       Instances.set_consistently_unreachable(sender_url)
 225       refute Instances.reachable?(sender_url)
 226
 227       conn =
 228         conn
 229         |> assign(:valid_signature, true)
 230         |> put_req_header("content-type", "application/activity+json")
 231         |> post("/inbox", data)
 232
 233       assert "ok" == json_response(conn, 200)
 234       assert Instances.reachable?(sender_url)
 235     end
 236   end
 237
 238   describe "/users/:nickname/inbox" do
 239     setup do
 240       data =
 241         File.read!("test/fixtures/mastodon-post-activity.json")
 242         |> Poison.decode!()
 243
 244       [data: data]
 245     end
 246
 247     test "it inserts an incoming activity into the database", %{conn: conn, data: data} do
 248       user = insert(:user)
 249       data = Map.put(data, "bcc", [user.ap_id])
 250
 251       conn =
 252         conn
 253         |> assign(:valid_signature, true)
 254         |> put_req_header("content-type", "application/activity+json")
 255         |> post("/users/#{user.nickname}/inbox", data)
 256
 257       assert "ok" == json_response(conn, 200)
 258       :timer.sleep(500)
 259       assert Activity.get_by_ap_id(data["id"])
 260     end
 261
 262     test "it accepts messages from actors that are followed by the user", %{
 263       conn: conn,
 264       data: data
 265     } do
 266       recipient = insert(:user)
 267       actor = insert(:user, %{ap_id: "http://mastodon.example.org/users/actor"})
 268
 269       {:ok, recipient} = User.follow(recipient, actor)
 270
 271       object =
 272         data["object"]
 273         |> Map.put("attributedTo", actor.ap_id)
 274
 275       data =
 276         data
 277         |> Map.put("actor", actor.ap_id)
 278         |> Map.put("object", object)
 279
 280       conn =
 281         conn
 282         |> assign(:valid_signature, true)
 283         |> put_req_header("content-type", "application/activity+json")
 284         |> post("/users/#{recipient.nickname}/inbox", data)
 285
 286       assert "ok" == json_response(conn, 200)
 287       :timer.sleep(500)
 288       assert Activity.get_by_ap_id(data["id"])
 289     end
 290
 291     test "it rejects reads from other users", %{conn: conn} do
 292       user = insert(:user)
 293       otheruser = insert(:user)
 294
 295       conn =
 296         conn
 297         |> assign(:user, otheruser)
 298         |> put_req_header("accept", "application/activity+json")
 299         |> get("/users/#{user.nickname}/inbox")
 300
 301       assert json_response(conn, 403)
 302     end
 303
 304     test "it returns a note activity in a collection", %{conn: conn} do
 305       note_activity = insert(:direct_note_activity)
 306       note_object = Object.normalize(note_activity)
 307       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 308
 309       conn =
 310         conn
 311         |> assign(:user, user)
 312         |> put_req_header("accept", "application/activity+json")
 313         |> get("/users/#{user.nickname}/inbox")
 314
 315       assert response(conn, 200) =~ note_object.data["content"]
 316     end
 317
 318     test "it clears `unreachable` federation status of the sender", %{conn: conn, data: data} do
 319       user = insert(:user)
 320       data = Map.put(data, "bcc", [user.ap_id])
 321
 322       sender_host = URI.parse(data["actor"]).host
 323       Instances.set_consistently_unreachable(sender_host)
 324       refute Instances.reachable?(sender_host)
 325
 326       conn =
 327         conn
 328         |> assign(:valid_signature, true)
 329         |> put_req_header("content-type", "application/activity+json")
 330         |> post("/users/#{user.nickname}/inbox", data)
 331
 332       assert "ok" == json_response(conn, 200)
 333       assert Instances.reachable?(sender_host)
 334     end
 335
 336     test "it removes all follower collections but actor's", %{conn: conn} do
 337       [actor, recipient] = insert_pair(:user)
 338
 339       data =
 340         File.read!("test/fixtures/activitypub-client-post-activity.json")
 341         |> Poison.decode!()
 342
 343       object = Map.put(data["object"], "attributedTo", actor.ap_id)
 344
 345       data =
 346         data
 347         |> Map.put("id", Utils.generate_object_id())
 348         |> Map.put("actor", actor.ap_id)
 349         |> Map.put("object", object)
 350         |> Map.put("cc", [
 351           recipient.follower_address,
 352           actor.follower_address
 353         ])
 354         |> Map.put("to", [
 355           recipient.ap_id,
 356           recipient.follower_address,
 357           "https://www.w3.org/ns/activitystreams#Public"
 358         ])
 359
 360       conn
 361       |> assign(:valid_signature, true)
 362       |> put_req_header("content-type", "application/activity+json")
 363       |> post("/users/#{recipient.nickname}/inbox", data)
 364       |> json_response(200)
 365
 366       activity = Activity.get_by_ap_id(data["id"])
 367
 368       assert activity.id
 369       assert actor.follower_address in activity.recipients
 370       assert actor.follower_address in activity.data["cc"]
 371
 372       refute recipient.follower_address in activity.recipients
 373       refute recipient.follower_address in activity.data["cc"]
 374       refute recipient.follower_address in activity.data["to"]
 375     end
 376   end
 377
 378   describe "/users/:nickname/outbox" do
 379     test "it will not bomb when there is no activity", %{conn: conn} do
 380       user = insert(:user)
 381
 382       conn =
 383         conn
 384         |> put_req_header("accept", "application/activity+json")
 385         |> get("/users/#{user.nickname}/outbox")
 386
 387       result = json_response(conn, 200)
 388       assert user.ap_id <> "/outbox" == result["id"]
 389     end
 390
 391     test "it returns a note activity in a collection", %{conn: conn} do
 392       note_activity = insert(:note_activity)
 393       note_object = Object.normalize(note_activity)
 394       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 395
 396       conn =
 397         conn
 398         |> put_req_header("accept", "application/activity+json")
 399         |> get("/users/#{user.nickname}/outbox")
 400
 401       assert response(conn, 200) =~ note_object.data["content"]
 402     end
 403
 404     test "it returns an announce activity in a collection", %{conn: conn} do
 405       announce_activity = insert(:announce_activity)
 406       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 407
 408       conn =
 409         conn
 410         |> put_req_header("accept", "application/activity+json")
 411         |> get("/users/#{user.nickname}/outbox")
 412
 413       assert response(conn, 200) =~ announce_activity.data["object"]
 414     end
 415
 416     test "it rejects posts from other users", %{conn: conn} do
 417       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 418       user = insert(:user)
 419       otheruser = insert(:user)
 420
 421       conn =
 422         conn
 423         |> assign(:user, otheruser)
 424         |> put_req_header("content-type", "application/activity+json")
 425         |> post("/users/#{user.nickname}/outbox", data)
 426
 427       assert json_response(conn, 403)
 428     end
 429
 430     test "it inserts an incoming create activity into the database", %{conn: conn} do
 431       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 432       user = insert(:user)
 433
 434       conn =
 435         conn
 436         |> assign(:user, user)
 437         |> put_req_header("content-type", "application/activity+json")
 438         |> post("/users/#{user.nickname}/outbox", data)
 439
 440       result = json_response(conn, 201)
 441       assert Activity.get_by_ap_id(result["id"])
 442     end
 443
 444     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 445       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 446       user = insert(:user)
 447
 448       data =
 449         data
 450         |> Map.put("type", "BadType")
 451
 452       conn =
 453         conn
 454         |> assign(:user, user)
 455         |> put_req_header("content-type", "application/activity+json")
 456         |> post("/users/#{user.nickname}/outbox", data)
 457
 458       assert json_response(conn, 400)
 459     end
 460
 461     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 462       note_activity = insert(:note_activity)
 463       note_object = Object.normalize(note_activity)
 464       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 465
 466       data = %{
 467         type: "Delete",
 468         object: %{
 469           id: note_object.data["id"]
 470         }
 471       }
 472
 473       conn =
 474         conn
 475         |> assign(:user, user)
 476         |> put_req_header("content-type", "application/activity+json")
 477         |> post("/users/#{user.nickname}/outbox", data)
 478
 479       result = json_response(conn, 201)
 480       assert Activity.get_by_ap_id(result["id"])
 481
 482       assert object = Object.get_by_ap_id(note_object.data["id"])
 483       assert object.data["type"] == "Tombstone"
 484     end
 485
 486     test "it rejects delete activity of object from other actor", %{conn: conn} do
 487       note_activity = insert(:note_activity)
 488       note_object = Object.normalize(note_activity)
 489       user = insert(:user)
 490
 491       data = %{
 492         type: "Delete",
 493         object: %{
 494           id: note_object.data["id"]
 495         }
 496       }
 497
 498       conn =
 499         conn
 500         |> assign(:user, user)
 501         |> put_req_header("content-type", "application/activity+json")
 502         |> post("/users/#{user.nickname}/outbox", data)
 503
 504       assert json_response(conn, 400)
 505     end
 506
 507     test "it increases like count when receiving a like action", %{conn: conn} do
 508       note_activity = insert(:note_activity)
 509       note_object = Object.normalize(note_activity)
 510       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 511
 512       data = %{
 513         type: "Like",
 514         object: %{
 515           id: note_object.data["id"]
 516         }
 517       }
 518
 519       conn =
 520         conn
 521         |> assign(:user, user)
 522         |> put_req_header("content-type", "application/activity+json")
 523         |> post("/users/#{user.nickname}/outbox", data)
 524
 525       result = json_response(conn, 201)
 526       assert Activity.get_by_ap_id(result["id"])
 527
 528       assert object = Object.get_by_ap_id(note_object.data["id"])
 529       assert object.data["like_count"] == 1
 530     end
 531   end
 532
 533   describe "/users/:nickname/followers" do
 534     test "it returns the followers in a collection", %{conn: conn} do
 535       user = insert(:user)
 536       user_two = insert(:user)
 537       User.follow(user, user_two)
 538
 539       result =
 540         conn
 541         |> get("/users/#{user_two.nickname}/followers")
 542         |> json_response(200)
 543
 544       assert result["first"]["orderedItems"] == [user.ap_id]
 545     end
 546
 547     test "it returns returns empty if the user has 'hide_followers' set", %{conn: conn} do
 548       user = insert(:user)
 549       user_two = insert(:user, %{info: %{hide_followers: true}})
 550       User.follow(user, user_two)
 551
 552       result =
 553         conn
 554         |> get("/users/#{user_two.nickname}/followers")
 555         |> json_response(200)
 556
 557       assert result["first"]["orderedItems"] == []
 558       assert result["totalItems"] == 0
 559     end
 560
 561     test "it works for more than 10 users", %{conn: conn} do
 562       user = insert(:user)
 563
 564       Enum.each(1..15, fn _ ->
 565         other_user = insert(:user)
 566         User.follow(other_user, user)
 567       end)
 568
 569       result =
 570         conn
 571         |> get("/users/#{user.nickname}/followers")
 572         |> json_response(200)
 573
 574       assert length(result["first"]["orderedItems"]) == 10
 575       assert result["first"]["totalItems"] == 15
 576       assert result["totalItems"] == 15
 577
 578       result =
 579         conn
 580         |> get("/users/#{user.nickname}/followers?page=2")
 581         |> json_response(200)
 582
 583       assert length(result["orderedItems"]) == 5
 584       assert result["totalItems"] == 15
 585     end
 586   end
 587
 588   describe "/users/:nickname/following" do
 589     test "it returns the following in a collection", %{conn: conn} do
 590       user = insert(:user)
 591       user_two = insert(:user)
 592       User.follow(user, user_two)
 593
 594       result =
 595         conn
 596         |> get("/users/#{user.nickname}/following")
 597         |> json_response(200)
 598
 599       assert result["first"]["orderedItems"] == [user_two.ap_id]
 600     end
 601
 602     test "it returns returns empty if the user has 'hide_follows' set", %{conn: conn} do
 603       user = insert(:user, %{info: %{hide_follows: true}})
 604       user_two = insert(:user)
 605       User.follow(user, user_two)
 606
 607       result =
 608         conn
 609         |> get("/users/#{user.nickname}/following")
 610         |> json_response(200)
 611
 612       assert result["first"]["orderedItems"] == []
 613       assert result["totalItems"] == 0
 614     end
 615
 616     test "it works for more than 10 users", %{conn: conn} do
 617       user = insert(:user)
 618
 619       Enum.each(1..15, fn _ ->
 620         user = User.get_cached_by_id(user.id)
 621         other_user = insert(:user)
 622         User.follow(user, other_user)
 623       end)
 624
 625       result =
 626         conn
 627         |> get("/users/#{user.nickname}/following")
 628         |> json_response(200)
 629
 630       assert length(result["first"]["orderedItems"]) == 10
 631       assert result["first"]["totalItems"] == 15
 632       assert result["totalItems"] == 15
 633
 634       result =
 635         conn
 636         |> get("/users/#{user.nickname}/following?page=2")
 637         |> json_response(200)
 638
 639       assert length(result["orderedItems"]) == 5
 640       assert result["totalItems"] == 15
 641     end
 642   end
 643 end