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

   1 defmodule Pleroma.Web.ActivityPub.ActivityPubControllerTest do
   2   use Pleroma.Web.ConnCase
   3   import Pleroma.Factory
   4   alias Pleroma.Web.ActivityPub.{UserView, ObjectView}
   5   alias Pleroma.{Repo, User}
   6   alias Pleroma.Activity
   7
   8   describe "/relay" do
   9     test "with the relay active, it returns the relay user", %{conn: conn} do
  10       res =
  11         conn
  12         |> get(activity_pub_path(conn, :relay))
  13         |> json_response(200)
  14
  15       assert res["id"] =~ "/relay"
  16     end
  17
  18     test "with the relay disabled, it returns 404", %{conn: conn} do
  19       instance =
  20         Application.get_env(:pleroma, :instance)
  21         |> Keyword.put(:allow_relay, false)
  22
  23       Application.put_env(:pleroma, :instance, instance)
  24
  25       res =
  26         conn
  27         |> get(activity_pub_path(conn, :relay))
  28         |> json_response(404)
  29
  30       instance =
  31         Application.get_env(:pleroma, :instance)
  32         |> Keyword.put(:allow_relay, true)
  33
  34       Application.put_env(:pleroma, :instance, instance)
  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   end
  78
  79   describe "/inbox" do
  80     test "it inserts an incoming activity into the database", %{conn: conn} do
  81       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
  82
  83       conn =
  84         conn
  85         |> assign(:valid_signature, true)
  86         |> put_req_header("content-type", "application/activity+json")
  87         |> post("/inbox", data)
  88
  89       assert "ok" == json_response(conn, 200)
  90       :timer.sleep(500)
  91       assert Activity.get_by_ap_id(data["id"])
  92     end
  93   end
  94
  95   describe "/users/:nickname/inbox" do
  96     test "it inserts an incoming activity into the database", %{conn: conn} do
  97       user = insert(:user)
  98
  99       data =
 100         File.read!("test/fixtures/mastodon-post-activity.json")
 101         |> Poison.decode!()
 102         |> Map.put("bcc", [user.ap_id])
 103
 104       conn =
 105         conn
 106         |> assign(:valid_signature, true)
 107         |> put_req_header("content-type", "application/activity+json")
 108         |> post("/users/#{user.nickname}/inbox", data)
 109
 110       assert "ok" == json_response(conn, 200)
 111       :timer.sleep(500)
 112       assert Activity.get_by_ap_id(data["id"])
 113     end
 114   end
 115
 116   describe "/users/:nickname/outbox" do
 117     test "it returns a note activity in a collection", %{conn: conn} do
 118       note_activity = insert(:note_activity)
 119       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 120
 121       conn =
 122         conn
 123         |> put_req_header("accept", "application/activity+json")
 124         |> get("/users/#{user.nickname}/outbox")
 125
 126       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 127     end
 128
 129     test "it returns an announce activity in a collection", %{conn: conn} do
 130       announce_activity = insert(:announce_activity)
 131       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 132
 133       conn =
 134         conn
 135         |> put_req_header("accept", "application/activity+json")
 136         |> get("/users/#{user.nickname}/outbox")
 137
 138       assert response(conn, 200) =~ announce_activity.data["object"]
 139     end
 140   end
 141
 142   describe "/users/:nickname/followers" do
 143     test "it returns the followers in a collection", %{conn: conn} do
 144       user = insert(:user)
 145       user_two = insert(:user)
 146       User.follow(user, user_two)
 147
 148       result =
 149         conn
 150         |> get("/users/#{user_two.nickname}/followers")
 151         |> json_response(200)
 152
 153       assert result["first"]["orderedItems"] == [user.ap_id]
 154     end
 155
 156     test "it works for more than 10 users", %{conn: conn} do
 157       user = insert(:user)
 158
 159       Enum.each(1..15, fn _ ->
 160         other_user = insert(:user)
 161         User.follow(other_user, user)
 162       end)
 163
 164       result =
 165         conn
 166         |> get("/users/#{user.nickname}/followers")
 167         |> json_response(200)
 168
 169       assert length(result["first"]["orderedItems"]) == 10
 170       assert result["first"]["totalItems"] == 15
 171       assert result["totalItems"] == 15
 172
 173       result =
 174         conn
 175         |> get("/users/#{user.nickname}/followers?page=2")
 176         |> json_response(200)
 177
 178       assert length(result["orderedItems"]) == 5
 179       assert result["totalItems"] == 15
 180     end
 181   end
 182
 183   describe "/users/:nickname/following" do
 184     test "it returns the following in a collection", %{conn: conn} do
 185       user = insert(:user)
 186       user_two = insert(:user)
 187       User.follow(user, user_two)
 188
 189       result =
 190         conn
 191         |> get("/users/#{user.nickname}/following")
 192         |> json_response(200)
 193
 194       assert result["first"]["orderedItems"] == [user_two.ap_id]
 195     end
 196
 197     test "it works for more than 10 users", %{conn: conn} do
 198       user = insert(:user)
 199
 200       Enum.each(1..15, fn _ ->
 201         user = Repo.get(User, user.id)
 202         other_user = insert(:user)
 203         User.follow(user, other_user)
 204       end)
 205
 206       result =
 207         conn
 208         |> get("/users/#{user.nickname}/following")
 209         |> json_response(200)
 210
 211       assert length(result["first"]["orderedItems"]) == 10
 212       assert result["first"]["totalItems"] == 15
 213       assert result["totalItems"] == 15
 214
 215       result =
 216         conn
 217         |> get("/users/#{user.nickname}/following?page=2")
 218         |> json_response(200)
 219
 220       assert length(result["orderedItems"]) == 5
 221       assert result["totalItems"] == 15
 222     end
 223   end
 224 end