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.Web.ActivityPub.{UserView, ObjectView}
   9   alias Pleroma.{Object, Repo, Activity, User, Instances}
  10
  11   setup_all do
  12     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  13     :ok
  14   end
  15
  16   describe "/relay" do
  17     test "with the relay active, it returns the relay user", %{conn: conn} do
  18       res =
  19         conn
  20         |> get(activity_pub_path(conn, :relay))
  21         |> json_response(200)
  22
  23       assert res["id"] =~ "/relay"
  24     end
  25
  26     test "with the relay disabled, it returns 404", %{conn: conn} do
  27       Pleroma.Config.put([:instance, :allow_relay], false)
  28
  29       conn
  30       |> get(activity_pub_path(conn, :relay))
  31       |> json_response(404)
  32       |> assert
  33
  34       Pleroma.Config.put([:instance, :allow_relay], true)
  35     end
  36   end
  37
  38   describe "/users/:nickname" do
  39     test "it returns a json representation of the user", %{conn: conn} do
  40       user = insert(:user)
  41
  42       conn =
  43         conn
  44         |> put_req_header("accept", "application/activity+json")
  45         |> get("/users/#{user.nickname}")
  46
  47       user = Repo.get(User, user.id)
  48
  49       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  50     end
  51   end
  52
  53   describe "/object/:uuid" do
  54     test "it returns a json representation of the object", %{conn: conn} do
  55       note = insert(:note)
  56       uuid = String.split(note.data["id"], "/") |> List.last()
  57
  58       conn =
  59         conn
  60         |> put_req_header("accept", "application/activity+json")
  61         |> get("/objects/#{uuid}")
  62
  63       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
  64     end
  65
  66     test "it returns 404 for non-public messages", %{conn: conn} do
  67       note = insert(:direct_note)
  68       uuid = String.split(note.data["id"], "/") |> List.last()
  69
  70       conn =
  71         conn
  72         |> put_req_header("accept", "application/activity+json")
  73         |> get("/objects/#{uuid}")
  74
  75       assert json_response(conn, 404)
  76     end
  77
  78     test "it returns 404 for tombstone objects", %{conn: conn} do
  79       tombstone = insert(:tombstone)
  80       uuid = String.split(tombstone.data["id"], "/") |> List.last()
  81
  82       conn =
  83         conn
  84         |> put_req_header("accept", "application/activity+json")
  85         |> get("/objects/#{uuid}")
  86
  87       assert json_response(conn, 404)
  88     end
  89   end
  90
  91   describe "/object/:uuid/likes" do
  92     test "it returns the like activities in a collection", %{conn: conn} do
  93       like = insert(:like_activity)
  94       uuid = String.split(like.data["object"], "/") |> List.last()
  95
  96       result =
  97         conn
  98         |> put_req_header("accept", "application/activity+json")
  99         |> get("/objects/#{uuid}/likes")
 100         |> json_response(200)
 101
 102       assert List.first(result["first"]["orderedItems"])["id"] == like.data["id"]
 103     end
 104   end
 105
 106   describe "/activities/:uuid" do
 107     test "it returns a json representation of the activity", %{conn: conn} do
 108       activity = insert(:note_activity)
 109       uuid = String.split(activity.data["id"], "/") |> List.last()
 110
 111       conn =
 112         conn
 113         |> put_req_header("accept", "application/activity+json")
 114         |> get("/activities/#{uuid}")
 115
 116       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: activity})
 117     end
 118
 119     test "it returns 404 for non-public activities", %{conn: conn} do
 120       activity = insert(:direct_note_activity)
 121       uuid = String.split(activity.data["id"], "/") |> List.last()
 122
 123       conn =
 124         conn
 125         |> put_req_header("accept", "application/activity+json")
 126         |> get("/activities/#{uuid}")
 127
 128       assert json_response(conn, 404)
 129     end
 130   end
 131
 132   describe "/inbox" do
 133     test "it inserts an incoming activity into the database", %{conn: conn} do
 134       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 135
 136       conn =
 137         conn
 138         |> assign(:valid_signature, true)
 139         |> put_req_header("content-type", "application/activity+json")
 140         |> post("/inbox", data)
 141
 142       assert "ok" == json_response(conn, 200)
 143       :timer.sleep(500)
 144       assert Activity.get_by_ap_id(data["id"])
 145     end
 146
 147     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 148       sender_url = "https://pleroma.soykaf.com"
 149       Instances.set_consistently_unreachable(sender_url)
 150       refute Instances.reachable?(sender_url)
 151
 152       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
 153
 154       conn =
 155         conn
 156         |> assign(:valid_signature, true)
 157         |> put_req_header("content-type", "application/activity+json")
 158         |> put_req_header("referer", sender_url)
 159         |> post("/inbox", data)
 160
 161       assert "ok" == json_response(conn, 200)
 162       assert Instances.reachable?(sender_url)
 163     end
 164   end
 165
 166   describe "/users/:nickname/inbox" do
 167     test "it inserts an incoming activity into the database", %{conn: conn} do
 168       user = insert(:user)
 169
 170       data =
 171         File.read!("test/fixtures/mastodon-post-activity.json")
 172         |> Poison.decode!()
 173         |> Map.put("bcc", [user.ap_id])
 174
 175       conn =
 176         conn
 177         |> assign(:valid_signature, true)
 178         |> put_req_header("content-type", "application/activity+json")
 179         |> post("/users/#{user.nickname}/inbox", data)
 180
 181       assert "ok" == json_response(conn, 200)
 182       :timer.sleep(500)
 183       assert Activity.get_by_ap_id(data["id"])
 184     end
 185
 186     test "it rejects reads from other users", %{conn: conn} do
 187       user = insert(:user)
 188       otheruser = insert(:user)
 189
 190       conn =
 191         conn
 192         |> assign(:user, otheruser)
 193         |> put_req_header("accept", "application/activity+json")
 194         |> get("/users/#{user.nickname}/inbox")
 195
 196       assert json_response(conn, 403)
 197     end
 198
 199     test "it returns a note activity in a collection", %{conn: conn} do
 200       note_activity = insert(:direct_note_activity)
 201       user = User.get_cached_by_ap_id(hd(note_activity.data["to"]))
 202
 203       conn =
 204         conn
 205         |> assign(:user, user)
 206         |> put_req_header("accept", "application/activity+json")
 207         |> get("/users/#{user.nickname}/inbox")
 208
 209       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 210     end
 211
 212     test "it clears `unreachable` federation status of the sender", %{conn: conn} do
 213       sender_host = "pleroma.soykaf.com"
 214       Instances.set_consistently_unreachable(sender_host)
 215       refute Instances.reachable?(sender_host)
 216
 217       user = insert(:user)
 218
 219       data =
 220         File.read!("test/fixtures/mastodon-post-activity.json")
 221         |> Poison.decode!()
 222         |> Map.put("bcc", [user.ap_id])
 223
 224       conn =
 225         conn
 226         |> assign(:valid_signature, true)
 227         |> put_req_header("content-type", "application/activity+json")
 228         |> put_req_header("referer", "https://#{sender_host}")
 229         |> post("/users/#{user.nickname}/inbox", data)
 230
 231       assert "ok" == json_response(conn, 200)
 232       assert Instances.reachable?(sender_host)
 233     end
 234   end
 235
 236   describe "/users/:nickname/outbox" do
 237     test "it returns a note activity in a collection", %{conn: conn} do
 238       note_activity = insert(:note_activity)
 239       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 240
 241       conn =
 242         conn
 243         |> put_req_header("accept", "application/activity+json")
 244         |> get("/users/#{user.nickname}/outbox")
 245
 246       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 247     end
 248
 249     test "it returns an announce activity in a collection", %{conn: conn} do
 250       announce_activity = insert(:announce_activity)
 251       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 252
 253       conn =
 254         conn
 255         |> put_req_header("accept", "application/activity+json")
 256         |> get("/users/#{user.nickname}/outbox")
 257
 258       assert response(conn, 200) =~ announce_activity.data["object"]
 259     end
 260
 261     test "it rejects posts from other users", %{conn: conn} do
 262       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 263       user = insert(:user)
 264       otheruser = insert(:user)
 265
 266       conn =
 267         conn
 268         |> assign(:user, otheruser)
 269         |> put_req_header("content-type", "application/activity+json")
 270         |> post("/users/#{user.nickname}/outbox", data)
 271
 272       assert json_response(conn, 403)
 273     end
 274
 275     test "it inserts an incoming create activity into the database", %{conn: conn} do
 276       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 277       user = insert(:user)
 278
 279       conn =
 280         conn
 281         |> assign(:user, user)
 282         |> put_req_header("content-type", "application/activity+json")
 283         |> post("/users/#{user.nickname}/outbox", data)
 284
 285       result = json_response(conn, 201)
 286       assert Activity.get_by_ap_id(result["id"])
 287     end
 288
 289     test "it rejects an incoming activity with bogus type", %{conn: conn} do
 290       data = File.read!("test/fixtures/activitypub-client-post-activity.json") |> Poison.decode!()
 291       user = insert(:user)
 292
 293       data =
 294         data
 295         |> Map.put("type", "BadType")
 296
 297       conn =
 298         conn
 299         |> assign(:user, user)
 300         |> put_req_header("content-type", "application/activity+json")
 301         |> post("/users/#{user.nickname}/outbox", data)
 302
 303       assert json_response(conn, 400)
 304     end
 305
 306     test "it erects a tombstone when receiving a delete activity", %{conn: conn} do
 307       note_activity = insert(:note_activity)
 308       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 309
 310       data = %{
 311         type: "Delete",
 312         object: %{
 313           id: note_activity.data["object"]["id"]
 314         }
 315       }
 316
 317       conn =
 318         conn
 319         |> assign(:user, user)
 320         |> put_req_header("content-type", "application/activity+json")
 321         |> post("/users/#{user.nickname}/outbox", data)
 322
 323       result = json_response(conn, 201)
 324       assert Activity.get_by_ap_id(result["id"])
 325
 326       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 327       assert object
 328       assert object.data["type"] == "Tombstone"
 329     end
 330
 331     test "it rejects delete activity of object from other actor", %{conn: conn} do
 332       note_activity = insert(:note_activity)
 333       user = insert(:user)
 334
 335       data = %{
 336         type: "Delete",
 337         object: %{
 338           id: note_activity.data["object"]["id"]
 339         }
 340       }
 341
 342       conn =
 343         conn
 344         |> assign(:user, user)
 345         |> put_req_header("content-type", "application/activity+json")
 346         |> post("/users/#{user.nickname}/outbox", data)
 347
 348       assert json_response(conn, 400)
 349     end
 350
 351     test "it increases like count when receiving a like action", %{conn: conn} do
 352       note_activity = insert(:note_activity)
 353       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 354
 355       data = %{
 356         type: "Like",
 357         object: %{
 358           id: note_activity.data["object"]["id"]
 359         }
 360       }
 361
 362       conn =
 363         conn
 364         |> assign(:user, user)
 365         |> put_req_header("content-type", "application/activity+json")
 366         |> post("/users/#{user.nickname}/outbox", data)
 367
 368       result = json_response(conn, 201)
 369       assert Activity.get_by_ap_id(result["id"])
 370
 371       object = Object.get_by_ap_id(note_activity.data["object"]["id"])
 372       assert object
 373       assert object.data["like_count"] == 1
 374     end
 375   end
 376
 377   describe "/users/:nickname/followers" do
 378     test "it returns the followers in a collection", %{conn: conn} do
 379       user = insert(:user)
 380       user_two = insert(:user)
 381       User.follow(user, user_two)
 382
 383       result =
 384         conn
 385         |> get("/users/#{user_two.nickname}/followers")
 386         |> json_response(200)
 387
 388       assert result["first"]["orderedItems"] == [user.ap_id]
 389     end
 390
 391     test "it returns returns empty if the user has 'hide_network' set", %{conn: conn} do
 392       user = insert(:user)
 393       user_two = insert(:user, %{info: %{hide_network: true}})
 394       User.follow(user, user_two)
 395
 396       result =
 397         conn
 398         |> get("/users/#{user_two.nickname}/followers")
 399         |> json_response(200)
 400
 401       assert result["first"]["orderedItems"] == []
 402       assert result["totalItems"] == 1
 403     end
 404
 405     test "it works for more than 10 users", %{conn: conn} do
 406       user = insert(:user)
 407
 408       Enum.each(1..15, fn _ ->
 409         other_user = insert(:user)
 410         User.follow(other_user, user)
 411       end)
 412
 413       result =
 414         conn
 415         |> get("/users/#{user.nickname}/followers")
 416         |> json_response(200)
 417
 418       assert length(result["first"]["orderedItems"]) == 10
 419       assert result["first"]["totalItems"] == 15
 420       assert result["totalItems"] == 15
 421
 422       result =
 423         conn
 424         |> get("/users/#{user.nickname}/followers?page=2")
 425         |> json_response(200)
 426
 427       assert length(result["orderedItems"]) == 5
 428       assert result["totalItems"] == 15
 429     end
 430   end
 431
 432   describe "/users/:nickname/following" do
 433     test "it returns the following in a collection", %{conn: conn} do
 434       user = insert(:user)
 435       user_two = insert(:user)
 436       User.follow(user, user_two)
 437
 438       result =
 439         conn
 440         |> get("/users/#{user.nickname}/following")
 441         |> json_response(200)
 442
 443       assert result["first"]["orderedItems"] == [user_two.ap_id]
 444     end
 445
 446     test "it returns returns empty if the user has 'hide_network' set", %{conn: conn} do
 447       user = insert(:user, %{info: %{hide_network: true}})
 448       user_two = insert(:user)
 449       User.follow(user, user_two)
 450
 451       result =
 452         conn
 453         |> get("/users/#{user.nickname}/following")
 454         |> json_response(200)
 455
 456       assert result["first"]["orderedItems"] == []
 457       assert result["totalItems"] == 1
 458     end
 459
 460     test "it works for more than 10 users", %{conn: conn} do
 461       user = insert(:user)
 462
 463       Enum.each(1..15, fn _ ->
 464         user = Repo.get(User, user.id)
 465         other_user = insert(:user)
 466         User.follow(user, other_user)
 467       end)
 468
 469       result =
 470         conn
 471         |> get("/users/#{user.nickname}/following")
 472         |> json_response(200)
 473
 474       assert length(result["first"]["orderedItems"]) == 10
 475       assert result["first"]["totalItems"] == 15
 476       assert result["totalItems"] == 15
 477
 478       result =
 479         conn
 480         |> get("/users/#{user.nickname}/following?page=2")
 481         |> json_response(200)
 482
 483       assert length(result["orderedItems"]) == 5
 484       assert result["totalItems"] == 15
 485     end
 486   end
 487 end