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