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