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   setup_all do
   9     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  10     :ok
  11   end
  12
  13   describe "/relay" do
  14     test "with the relay active, it returns the relay user", %{conn: conn} do
  15       res =
  16         conn
  17         |> get(activity_pub_path(conn, :relay))
  18         |> json_response(200)
  19
  20       assert res["id"] =~ "/relay"
  21     end
  22
  23     test "with the relay disabled, it returns 404", %{conn: conn} do
  24       Pleroma.Config.put([:instance, :allow_relay], false)
  25
  26       res =
  27         conn
  28         |> get(activity_pub_path(conn, :relay))
  29         |> json_response(404)
  30
  31       Pleroma.Config.put([:instance, :allow_relay], true)
  32     end
  33   end
  34
  35   describe "/users/:nickname" do
  36     test "it returns a json representation of the user", %{conn: conn} do
  37       user = insert(:user)
  38
  39       conn =
  40         conn
  41         |> put_req_header("accept", "application/activity+json")
  42         |> get("/users/#{user.nickname}")
  43
  44       user = Repo.get(User, user.id)
  45
  46       assert json_response(conn, 200) == UserView.render("user.json", %{user: user})
  47     end
  48   end
  49
  50   describe "/object/:uuid" do
  51     test "it returns a json representation of the object", %{conn: conn} do
  52       note = insert(:note)
  53       uuid = String.split(note.data["id"], "/") |> List.last()
  54
  55       conn =
  56         conn
  57         |> put_req_header("accept", "application/activity+json")
  58         |> get("/objects/#{uuid}")
  59
  60       assert json_response(conn, 200) == ObjectView.render("object.json", %{object: note})
  61     end
  62
  63     test "it returns 404 for non-public messages", %{conn: conn} do
  64       note = insert(:direct_note)
  65       uuid = String.split(note.data["id"], "/") |> List.last()
  66
  67       conn =
  68         conn
  69         |> put_req_header("accept", "application/activity+json")
  70         |> get("/objects/#{uuid}")
  71
  72       assert json_response(conn, 404)
  73     end
  74   end
  75
  76   describe "/inbox" do
  77     test "it inserts an incoming activity into the database", %{conn: conn} do
  78       data = File.read!("test/fixtures/mastodon-post-activity.json") |> Poison.decode!()
  79
  80       conn =
  81         conn
  82         |> assign(:valid_signature, true)
  83         |> put_req_header("content-type", "application/activity+json")
  84         |> post("/inbox", data)
  85
  86       assert "ok" == json_response(conn, 200)
  87       :timer.sleep(500)
  88       assert Activity.get_by_ap_id(data["id"])
  89     end
  90   end
  91
  92   describe "/users/:nickname/inbox" do
  93     test "it inserts an incoming activity into the database", %{conn: conn} do
  94       user = insert(:user)
  95
  96       data =
  97         File.read!("test/fixtures/mastodon-post-activity.json")
  98         |> Poison.decode!()
  99         |> Map.put("bcc", [user.ap_id])
 100
 101       conn =
 102         conn
 103         |> assign(:valid_signature, true)
 104         |> put_req_header("content-type", "application/activity+json")
 105         |> post("/users/#{user.nickname}/inbox", data)
 106
 107       assert "ok" == json_response(conn, 200)
 108       :timer.sleep(500)
 109       assert Activity.get_by_ap_id(data["id"])
 110     end
 111   end
 112
 113   describe "/users/:nickname/outbox" do
 114     test "it returns a note activity in a collection", %{conn: conn} do
 115       note_activity = insert(:note_activity)
 116       user = User.get_cached_by_ap_id(note_activity.data["actor"])
 117
 118       conn =
 119         conn
 120         |> put_req_header("accept", "application/activity+json")
 121         |> get("/users/#{user.nickname}/outbox")
 122
 123       assert response(conn, 200) =~ note_activity.data["object"]["content"]
 124     end
 125
 126     test "it returns an announce activity in a collection", %{conn: conn} do
 127       announce_activity = insert(:announce_activity)
 128       user = User.get_cached_by_ap_id(announce_activity.data["actor"])
 129
 130       conn =
 131         conn
 132         |> put_req_header("accept", "application/activity+json")
 133         |> get("/users/#{user.nickname}/outbox")
 134
 135       assert response(conn, 200) =~ announce_activity.data["object"]
 136     end
 137   end
 138
 139   describe "/users/:nickname/followers" do
 140     test "it returns the followers in a collection", %{conn: conn} do
 141       user = insert(:user)
 142       user_two = insert(:user)
 143       User.follow(user, user_two)
 144
 145       result =
 146         conn
 147         |> get("/users/#{user_two.nickname}/followers")
 148         |> json_response(200)
 149
 150       assert result["first"]["orderedItems"] == [user.ap_id]
 151     end
 152
 153     test "it works for more than 10 users", %{conn: conn} do
 154       user = insert(:user)
 155
 156       Enum.each(1..15, fn _ ->
 157         other_user = insert(:user)
 158         User.follow(other_user, user)
 159       end)
 160
 161       result =
 162         conn
 163         |> get("/users/#{user.nickname}/followers")
 164         |> json_response(200)
 165
 166       assert length(result["first"]["orderedItems"]) == 10
 167       assert result["first"]["totalItems"] == 15
 168       assert result["totalItems"] == 15
 169
 170       result =
 171         conn
 172         |> get("/users/#{user.nickname}/followers?page=2")
 173         |> json_response(200)
 174
 175       assert length(result["orderedItems"]) == 5
 176       assert result["totalItems"] == 15
 177     end
 178   end
 179
 180   describe "/users/:nickname/following" do
 181     test "it returns the following in a collection", %{conn: conn} do
 182       user = insert(:user)
 183       user_two = insert(:user)
 184       User.follow(user, user_two)
 185
 186       result =
 187         conn
 188         |> get("/users/#{user.nickname}/following")
 189         |> json_response(200)
 190
 191       assert result["first"]["orderedItems"] == [user_two.ap_id]
 192     end
 193
 194     test "it works for more than 10 users", %{conn: conn} do
 195       user = insert(:user)
 196
 197       Enum.each(1..15, fn _ ->
 198         user = Repo.get(User, user.id)
 199         other_user = insert(:user)
 200         User.follow(user, other_user)
 201       end)
 202
 203       result =
 204         conn
 205         |> get("/users/#{user.nickname}/following")
 206         |> json_response(200)
 207
 208       assert length(result["first"]["orderedItems"]) == 10
 209       assert result["first"]["totalItems"] == 15
 210       assert result["totalItems"] == 15
 211
 212       result =
 213         conn
 214         |> get("/users/#{user.nickname}/following?page=2")
 215         |> json_response(200)
 216
 217       assert length(result["orderedItems"]) == 5
 218       assert result["totalItems"] == 15
 219     end
 220   end
 221 end