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 "PUT /api/pleroma/admin/activation_status" do
 163     setup %{conn: conn} do
 164       admin = insert(:user, info: %{is_admin: true})
 165
 166       conn =
 167         conn
 168         |> assign(:user, admin)
 169         |> put_req_header("accept", "application/json")
 170
 171       %{conn: conn}
 172     end
 173
 174     test "deactivates the user", %{conn: conn} do
 175       user = insert(:user)
 176
 177       conn =
 178         conn
 179         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
 180
 181       user = Repo.get(User, user.id)
 182       assert user.info.deactivated == true
 183       assert json_response(conn, :no_content)
 184     end
 185
 186     test "activates the user", %{conn: conn} do
 187       user = insert(:user, info: %{deactivated: true})
 188
 189       conn =
 190         conn
 191         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})
 192
 193       user = Repo.get(User, user.id)
 194       assert user.info.deactivated == false
 195       assert json_response(conn, :no_content)
 196     end
 197
 198     test "returns 403 when requested by a non-admin", %{conn: conn} do
 199       user = insert(:user)
 200
 201       conn =
 202         conn
 203         |> assign(:user, user)
 204         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
 205
 206       assert json_response(conn, :forbidden)
 207     end
 208   end
 209
 210   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 211     setup do
 212       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 213       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 214       Pleroma.Config.put([:instance, :registrations_open], false)
 215       Pleroma.Config.put([:instance, :invites_enabled], true)
 216
 217       on_exit(fn ->
 218         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 219         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 220         :ok
 221       end)
 222
 223       [user: insert(:user, info: %{is_admin: true})]
 224     end
 225
 226     test "sends invitation and returns 204", %{conn: conn, user: user} do
 227       recipient_email = "foo@bar.com"
 228       recipient_name = "J. D."
 229
 230       conn =
 231         conn
 232         |> assign(:user, user)
 233         |> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")
 234
 235       assert json_response(conn, :no_content)
 236
 237       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 238       assert token_record
 239       refute token_record.used
 240
 241       Swoosh.TestAssertions.assert_email_sent(
 242         Pleroma.UserEmail.user_invitation_email(
 243           user,
 244           token_record,
 245           recipient_email,
 246           recipient_name
 247         )
 248       )
 249     end
 250
 251     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 252       non_admin_user = insert(:user)
 253
 254       conn =
 255         conn
 256         |> assign(:user, non_admin_user)
 257         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 258
 259       assert json_response(conn, :forbidden)
 260     end
 261   end
 262
 263   describe "POST /api/pleroma/admin/email_invite, with invalid config" do
 264     setup do
 265       [user: insert(:user, info: %{is_admin: true})]
 266     end
 267
 268     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 269       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 270       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 271       Pleroma.Config.put([:instance, :registrations_open], false)
 272       Pleroma.Config.put([:instance, :invites_enabled], false)
 273
 274       on_exit(fn ->
 275         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 276         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 277         :ok
 278       end)
 279
 280       conn =
 281         conn
 282         |> assign(:user, user)
 283         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 284
 285       assert json_response(conn, :internal_server_error)
 286     end
 287
 288     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 289       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 290       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 291       Pleroma.Config.put([:instance, :registrations_open], true)
 292       Pleroma.Config.put([:instance, :invites_enabled], true)
 293
 294       on_exit(fn ->
 295         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 296         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 297         :ok
 298       end)
 299
 300       conn =
 301         conn
 302         |> assign(:user, user)
 303         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 304
 305       assert json_response(conn, :internal_server_error)
 306     end
 307   end
 308
 309   test "/api/pleroma/admin/invite_token" do
 310     admin = insert(:user, info: %{is_admin: true})
 311
 312     conn =
 313       build_conn()
 314       |> assign(:user, admin)
 315       |> put_req_header("accept", "application/json")
 316       |> get("/api/pleroma/admin/invite_token")
 317
 318     assert conn.status == 200
 319   end
 320
 321   test "/api/pleroma/admin/password_reset" do
 322     admin = insert(:user, info: %{is_admin: true})
 323     user = insert(:user)
 324
 325     conn =
 326       build_conn()
 327       |> assign(:user, admin)
 328       |> put_req_header("accept", "application/json")
 329       |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
 330
 331     assert conn.status == 200
 332   end
 333 end