git.squeep.com Git - akkoma/blob - test/web/admin_api/admin_api_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.AdminAPI.AdminAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.{Repo, User}
   9   import Pleroma.Factory
  10
  11   describe "/api/pleroma/admin/user" do
  12     test "Delete" do
  13       admin = insert(:user, info: %{is_admin: true})
  14       user = insert(:user)
  15
  16       conn =
  17         build_conn()
  18         |> assign(:user, admin)
  19         |> put_req_header("accept", "application/json")
  20         |> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")
  21
  22       assert json_response(conn, 200) == user.nickname
  23     end
  24
  25     test "Create" do
  26       admin = insert(:user, info: %{is_admin: true})
  27
  28       conn =
  29         build_conn()
  30         |> assign(:user, admin)
  31         |> put_req_header("accept", "application/json")
  32         |> post("/api/pleroma/admin/user", %{
  33           "nickname" => "lain",
  34           "email" => "lain@example.org",
  35           "password" => "test"
  36         })
  37
  38       assert json_response(conn, 200) == "lain"
  39     end
  40   end
  41
  42   describe "PUT /api/pleroma/admin/users/tag" do
  43     setup do
  44       admin = insert(:user, info: %{is_admin: true})
  45       user1 = insert(:user, %{tags: ["x"]})
  46       user2 = insert(:user, %{tags: ["y"]})
  47       user3 = insert(:user, %{tags: ["unchanged"]})
  48
  49       conn =
  50         build_conn()
  51         |> assign(:user, admin)
  52         |> put_req_header("accept", "application/json")
  53         |> put(
  54           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
  55             user2.nickname
  56           }&tags[]=foo&tags[]=bar"
  57         )
  58
  59       %{conn: conn, user1: user1, user2: user2, user3: user3}
  60     end
  61
  62     test "it appends specified tags to users with specified nicknames", %{
  63       conn: conn,
  64       user1: user1,
  65       user2: user2
  66     } do
  67       assert json_response(conn, :no_content)
  68       assert Repo.get(User, user1.id).tags == ["x", "foo", "bar"]
  69       assert Repo.get(User, user2.id).tags == ["y", "foo", "bar"]
  70     end
  71
  72     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
  73       assert json_response(conn, :no_content)
  74       assert Repo.get(User, user3.id).tags == ["unchanged"]
  75     end
  76   end
  77
  78   describe "DELETE /api/pleroma/admin/users/tag" do
  79     setup do
  80       admin = insert(:user, info: %{is_admin: true})
  81       user1 = insert(:user, %{tags: ["x"]})
  82       user2 = insert(:user, %{tags: ["y", "z"]})
  83       user3 = insert(:user, %{tags: ["unchanged"]})
  84
  85       conn =
  86         build_conn()
  87         |> assign(:user, admin)
  88         |> put_req_header("accept", "application/json")
  89         |> delete(
  90           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
  91             user2.nickname
  92           }&tags[]=x&tags[]=z"
  93         )
  94
  95       %{conn: conn, user1: user1, user2: user2, user3: user3}
  96     end
  97
  98     test "it removes specified tags from users with specified nicknames", %{
  99       conn: conn,
 100       user1: user1,
 101       user2: user2
 102     } do
 103       assert json_response(conn, :no_content)
 104       assert Repo.get(User, user1.id).tags == []
 105       assert Repo.get(User, user2.id).tags == ["y"]
 106     end
 107
 108     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 109       assert json_response(conn, :no_content)
 110       assert Repo.get(User, user3.id).tags == ["unchanged"]
 111     end
 112   end
 113
 114   describe "/api/pleroma/admin/permission_group" do
 115     test "GET is giving user_info" do
 116       admin = insert(:user, info: %{is_admin: true})
 117
 118       conn =
 119         build_conn()
 120         |> assign(:user, admin)
 121         |> put_req_header("accept", "application/json")
 122         |> get("/api/pleroma/admin/permission_group/#{admin.nickname}")
 123
 124       assert json_response(conn, 200) == %{
 125                "is_admin" => true,
 126                "is_moderator" => false
 127              }
 128     end
 129
 130     test "/:right POST, can add to a permission group" do
 131       admin = insert(:user, info: %{is_admin: true})
 132       user = insert(:user)
 133
 134       conn =
 135         build_conn()
 136         |> assign(:user, admin)
 137         |> put_req_header("accept", "application/json")
 138         |> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
 139
 140       assert json_response(conn, 200) == %{
 141                "is_admin" => true
 142              }
 143     end
 144
 145     test "/:right DELETE, can remove from a permission group" do
 146       admin = insert(:user, info: %{is_admin: true})
 147       user = insert(:user, info: %{is_admin: true})
 148
 149       conn =
 150         build_conn()
 151         |> assign(:user, admin)
 152         |> put_req_header("accept", "application/json")
 153         |> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
 154
 155       assert json_response(conn, 200) == %{
 156                "is_admin" => false
 157              }
 158     end
 159   end
 160
 161   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 162     setup do
 163       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 164       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 165       Pleroma.Config.put([:instance, :registrations_open], false)
 166       Pleroma.Config.put([:instance, :invites_enabled], true)
 167
 168       on_exit(fn ->
 169         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 170         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 171         :ok
 172       end)
 173
 174       [user: insert(:user, info: %{is_admin: true})]
 175     end
 176
 177     test "sends invitation and returns 204", %{conn: conn, user: user} do
 178       recipient_email = "foo@bar.com"
 179       recipient_name = "J. D."
 180
 181       conn =
 182         conn
 183         |> assign(:user, user)
 184         |> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")
 185
 186       assert json_response(conn, :no_content)
 187
 188       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 189       assert token_record
 190       refute token_record.used
 191
 192       Swoosh.TestAssertions.assert_email_sent(
 193         Pleroma.UserEmail.user_invitation_email(
 194           user,
 195           token_record,
 196           recipient_email,
 197           recipient_name
 198         )
 199       )
 200     end
 201
 202     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 203       non_admin_user = insert(:user)
 204
 205       conn =
 206         conn
 207         |> assign(:user, non_admin_user)
 208         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 209
 210       assert json_response(conn, :forbidden)
 211     end
 212   end
 213
 214   describe "POST /api/pleroma/admin/email_invite, with invalid config" do
 215     setup do
 216       [user: insert(:user, info: %{is_admin: true})]
 217     end
 218
 219     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 220       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 221       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 222       Pleroma.Config.put([:instance, :registrations_open], false)
 223       Pleroma.Config.put([:instance, :invites_enabled], false)
 224
 225       on_exit(fn ->
 226         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 227         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 228         :ok
 229       end)
 230
 231       conn =
 232         conn
 233         |> assign(:user, user)
 234         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 235
 236       assert json_response(conn, :internal_server_error)
 237     end
 238
 239     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 240       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 241       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 242       Pleroma.Config.put([:instance, :registrations_open], true)
 243       Pleroma.Config.put([:instance, :invites_enabled], true)
 244
 245       on_exit(fn ->
 246         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 247         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 248         :ok
 249       end)
 250
 251       conn =
 252         conn
 253         |> assign(:user, user)
 254         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 255
 256       assert json_response(conn, :internal_server_error)
 257     end
 258   end
 259
 260   test "/api/pleroma/admin/invite_token" do
 261     admin = insert(:user, info: %{is_admin: true})
 262
 263     conn =
 264       build_conn()
 265       |> assign(:user, admin)
 266       |> put_req_header("accept", "application/json")
 267       |> get("/api/pleroma/admin/invite_token")
 268
 269     assert conn.status == 200
 270   end
 271
 272   test "/api/pleroma/admin/password_reset" do
 273     admin = insert(:user, info: %{is_admin: true})
 274     user = insert(:user)
 275
 276     conn =
 277       build_conn()
 278       |> assign(:user, admin)
 279       |> put_req_header("accept", "application/json")
 280       |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
 281
 282     assert conn.status == 200
 283   end
 284 end