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