Git of dcc - anni/blob - test/pleroma/web/admin_api/controllers/invite_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.InviteControllerTest do
   6   use Pleroma.Web.ConnCase, async: false
   7
   8   import Pleroma.Factory
   9
  10   alias Pleroma.Repo
  11   alias Pleroma.UserInviteToken
  12
  13   setup do
  14     admin = insert(:user, is_admin: true)
  15     token = insert(:oauth_admin_token, user: admin)
  16
  17     conn =
  18       build_conn()
  19       |> assign(:user, admin)
  20       |> assign(:token, token)
  21
  22     {:ok, %{admin: admin, token: token, conn: conn}}
  23   end
  24
  25   describe "POST /api/pleroma/admin/users/email_invite, with valid config" do
  26     setup do
  27       clear_config([:instance, :registrations_open], false)
  28       clear_config([:instance, :invites_enabled], true)
  29       clear_config([:instance, :admin_privileges], [:users_manage_invites])
  30     end
  31
  32     test "returns 403 if not privileged with :users_manage_invites", %{conn: conn} do
  33       clear_config([:instance, :admin_privileges], [])
  34
  35       conn =
  36         conn
  37         |> put_req_header("content-type", "application/json;charset=utf-8")
  38         |> post("/api/pleroma/admin/users/email_invite", %{
  39           email: "foo@bar.com",
  40           name: "J. D."
  41         })
  42
  43       assert json_response(conn, :forbidden)
  44     end
  45
  46     test "sends invitation and returns 204", %{admin: admin, conn: conn} do
  47       recipient_email = "foo@bar.com"
  48       recipient_name = "J. D."
  49
  50       conn =
  51         conn
  52         |> put_req_header("content-type", "application/json;charset=utf-8")
  53         |> post("/api/pleroma/admin/users/email_invite", %{
  54           email: recipient_email,
  55           name: recipient_name
  56         })
  57
  58       assert json_response_and_validate_schema(conn, :no_content)
  59
  60       token_record = List.last(Repo.all(Pleroma.UserInviteToken))
  61       assert token_record
  62       refute token_record.used
  63
  64       notify_email = Config.get([:instance, :notify_email])
  65       instance_name = Config.get([:instance, :name])
  66
  67       email =
  68         Pleroma.Emails.UserEmail.user_invitation_email(
  69           admin,
  70           token_record,
  71           recipient_email,
  72           recipient_name
  73         )
  74
  75       Swoosh.TestAssertions.assert_email_sent(
  76         from: {instance_name, notify_email},
  77         to: {recipient_name, recipient_email},
  78         html_body: email.html_body
  79       )
  80     end
  81
  82     test "it returns 403 if requested by a non-admin" do
  83       non_admin_user = insert(:user)
  84       token = insert(:oauth_token, user: non_admin_user)
  85
  86       conn =
  87         build_conn()
  88         |> assign(:user, non_admin_user)
  89         |> assign(:token, token)
  90         |> put_req_header("content-type", "application/json;charset=utf-8")
  91         |> post("/api/pleroma/admin/users/email_invite", %{
  92           email: "foo@bar.com",
  93           name: "JD"
  94         })
  95
  96       assert json_response(conn, :forbidden)
  97     end
  98
  99     test "email with +", %{conn: conn, admin: admin} do
 100       recipient_email = "foo+bar@baz.com"
 101
 102       conn
 103       |> put_req_header("content-type", "application/json;charset=utf-8")
 104       |> post("/api/pleroma/admin/users/email_invite", %{email: recipient_email})
 105       |> json_response_and_validate_schema(:no_content)
 106
 107       token_record =
 108         Pleroma.UserInviteToken
 109         |> Repo.all()
 110         |> List.last()
 111
 112       assert token_record
 113       refute token_record.used
 114
 115       notify_email = Config.get([:instance, :notify_email])
 116       instance_name = Config.get([:instance, :name])
 117
 118       email =
 119         Pleroma.Emails.UserEmail.user_invitation_email(
 120           admin,
 121           token_record,
 122           recipient_email
 123         )
 124
 125       Swoosh.TestAssertions.assert_email_sent(
 126         from: {instance_name, notify_email},
 127         to: recipient_email,
 128         html_body: email.html_body
 129       )
 130     end
 131   end
 132
 133   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 134     setup do
 135       clear_config([:instance, :registrations_open])
 136       clear_config([:instance, :invites_enabled])
 137       clear_config([:instance, :admin_privileges], [:users_manage_invites])
 138     end
 139
 140     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn} do
 141       clear_config([:instance, :registrations_open], false)
 142       clear_config([:instance, :invites_enabled], false)
 143
 144       conn =
 145         conn
 146         |> put_req_header("content-type", "application/json")
 147         |> post("/api/pleroma/admin/users/email_invite", %{
 148           email: "foo@bar.com",
 149           name: "JD"
 150         })
 151
 152       assert json_response_and_validate_schema(conn, :bad_request) ==
 153                %{
 154                  "error" =>
 155                    "To send invites you need to set the `invites_enabled` option to true."
 156                }
 157     end
 158
 159     test "it returns 500 if `registrations_open` is enabled", %{conn: conn} do
 160       clear_config([:instance, :registrations_open], true)
 161       clear_config([:instance, :invites_enabled], true)
 162
 163       conn =
 164         conn
 165         |> put_req_header("content-type", "application/json")
 166         |> post("/api/pleroma/admin/users/email_invite", %{
 167           email: "foo@bar.com",
 168           name: "JD"
 169         })
 170
 171       assert json_response_and_validate_schema(conn, :bad_request) ==
 172                %{
 173                  "error" =>
 174                    "To send invites you need to set the `registrations_open` option to false."
 175                }
 176     end
 177   end
 178
 179   describe "POST /api/pleroma/admin/users/invite_token" do
 180     setup do
 181       clear_config([:instance, :admin_privileges], [:users_manage_invites])
 182     end
 183
 184     test "returns 403 if not privileged with :users_manage_invites", %{conn: conn} do
 185       clear_config([:instance, :admin_privileges], [])
 186
 187       conn =
 188         conn
 189         |> put_req_header("content-type", "application/json")
 190         |> post("/api/pleroma/admin/users/invite_token")
 191
 192       assert json_response(conn, :forbidden)
 193     end
 194
 195     test "without options", %{conn: conn} do
 196       conn =
 197         conn
 198         |> put_req_header("content-type", "application/json")
 199         |> post("/api/pleroma/admin/users/invite_token")
 200
 201       invite_json = json_response_and_validate_schema(conn, 200)
 202       invite = UserInviteToken.find_by_token!(invite_json["token"])
 203       refute invite.used
 204       refute invite.expires_at
 205       refute invite.max_use
 206       assert invite.invite_type == "one_time"
 207     end
 208
 209     test "with expires_at", %{conn: conn} do
 210       conn =
 211         conn
 212         |> put_req_header("content-type", "application/json")
 213         |> post("/api/pleroma/admin/users/invite_token", %{
 214           "expires_at" => Date.to_string(Date.utc_today())
 215         })
 216
 217       invite_json = json_response_and_validate_schema(conn, 200)
 218       invite = UserInviteToken.find_by_token!(invite_json["token"])
 219
 220       refute invite.used
 221       assert invite.expires_at == Date.utc_today()
 222       refute invite.max_use
 223       assert invite.invite_type == "date_limited"
 224     end
 225
 226     test "with max_use", %{conn: conn} do
 227       conn =
 228         conn
 229         |> put_req_header("content-type", "application/json")
 230         |> post("/api/pleroma/admin/users/invite_token", %{"max_use" => 150})
 231
 232       invite_json = json_response_and_validate_schema(conn, 200)
 233       invite = UserInviteToken.find_by_token!(invite_json["token"])
 234       refute invite.used
 235       refute invite.expires_at
 236       assert invite.max_use == 150
 237       assert invite.invite_type == "reusable"
 238     end
 239
 240     test "with max use and expires_at", %{conn: conn} do
 241       conn =
 242         conn
 243         |> put_req_header("content-type", "application/json")
 244         |> post("/api/pleroma/admin/users/invite_token", %{
 245           "max_use" => 150,
 246           "expires_at" => Date.to_string(Date.utc_today())
 247         })
 248
 249       invite_json = json_response_and_validate_schema(conn, 200)
 250       invite = UserInviteToken.find_by_token!(invite_json["token"])
 251       refute invite.used
 252       assert invite.expires_at == Date.utc_today()
 253       assert invite.max_use == 150
 254       assert invite.invite_type == "reusable_date_limited"
 255     end
 256   end
 257
 258   describe "GET /api/pleroma/admin/users/invites" do
 259     setup do
 260       clear_config([:instance, :admin_privileges], [:users_manage_invites])
 261     end
 262
 263     test "returns 403 if not privileged with :users_manage_invites", %{conn: conn} do
 264       clear_config([:instance, :admin_privileges], [])
 265
 266       conn = get(conn, "/api/pleroma/admin/users/invites")
 267
 268       assert json_response(conn, :forbidden)
 269     end
 270
 271     test "no invites", %{conn: conn} do
 272       conn = get(conn, "/api/pleroma/admin/users/invites")
 273
 274       assert json_response_and_validate_schema(conn, 200) == %{"invites" => []}
 275     end
 276
 277     test "with invite", %{conn: conn} do
 278       {:ok, invite} = UserInviteToken.create_invite()
 279
 280       conn = get(conn, "/api/pleroma/admin/users/invites")
 281
 282       assert json_response_and_validate_schema(conn, 200) == %{
 283                "invites" => [
 284                  %{
 285                    "expires_at" => nil,
 286                    "id" => invite.id,
 287                    "invite_type" => "one_time",
 288                    "max_use" => nil,
 289                    "token" => invite.token,
 290                    "used" => false,
 291                    "uses" => 0
 292                  }
 293                ]
 294              }
 295     end
 296   end
 297
 298   describe "POST /api/pleroma/admin/users/revoke_invite" do
 299     setup do
 300       clear_config([:instance, :admin_privileges], [:users_manage_invites])
 301     end
 302
 303     test "returns 403 if not privileged with :users_manage_invites", %{conn: conn} do
 304       clear_config([:instance, :admin_privileges], [])
 305
 306       conn =
 307         conn
 308         |> put_req_header("content-type", "application/json")
 309         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
 310
 311       assert json_response(conn, :forbidden)
 312     end
 313
 314     test "with token", %{conn: conn} do
 315       {:ok, invite} = UserInviteToken.create_invite()
 316
 317       conn =
 318         conn
 319         |> put_req_header("content-type", "application/json")
 320         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 321
 322       assert json_response_and_validate_schema(conn, 200) == %{
 323                "expires_at" => nil,
 324                "id" => invite.id,
 325                "invite_type" => "one_time",
 326                "max_use" => nil,
 327                "token" => invite.token,
 328                "used" => true,
 329                "uses" => 0
 330              }
 331     end
 332
 333     test "with invalid token", %{conn: conn} do
 334       conn =
 335         conn
 336         |> put_req_header("content-type", "application/json")
 337         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
 338
 339       assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
 340     end
 341   end
 342 end