git.squeep.com Git - akkoma/blob - test/pleroma/web/admin_api/controllers/invite_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 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: true
   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/v1/pleroma/admin/users/email_invite, with valid config" do
  26     setup do: clear_config([:instance, :registrations_open], false)
  27     setup do: clear_config([:instance, :invites_enabled], true)
  28
  29     test "sends invitation and returns 204", %{admin: admin, conn: conn} do
  30       recipient_email = "foo@bar.com"
  31       recipient_name = "J. D."
  32
  33       conn =
  34         conn
  35         |> put_req_header("content-type", "application/json;charset=utf-8")
  36         |> post("/api/v1/pleroma/admin/users/email_invite", %{
  37           email: recipient_email,
  38           name: recipient_name
  39         })
  40
  41       assert json_response_and_validate_schema(conn, :no_content)
  42
  43       token_record = List.last(Repo.all(Pleroma.UserInviteToken))
  44       assert token_record
  45       refute token_record.used
  46
  47       notify_email = Config.get([:instance, :notify_email])
  48       instance_name = Config.get([:instance, :name])
  49
  50       email =
  51         Pleroma.Emails.UserEmail.user_invitation_email(
  52           admin,
  53           token_record,
  54           recipient_email,
  55           recipient_name
  56         )
  57
  58       Swoosh.TestAssertions.assert_email_sent(
  59         from: {instance_name, notify_email},
  60         to: {recipient_name, recipient_email},
  61         html_body: email.html_body
  62       )
  63     end
  64
  65     test "it returns 403 if requested by a non-admin" do
  66       non_admin_user = insert(:user)
  67       token = insert(:oauth_token, user: non_admin_user)
  68
  69       conn =
  70         build_conn()
  71         |> assign(:user, non_admin_user)
  72         |> assign(:token, token)
  73         |> put_req_header("content-type", "application/json;charset=utf-8")
  74         |> post("/api/v1/pleroma/admin/users/email_invite", %{
  75           email: "foo@bar.com",
  76           name: "JD"
  77         })
  78
  79       assert json_response(conn, :forbidden)
  80     end
  81
  82     test "email with +", %{conn: conn, admin: admin} do
  83       recipient_email = "foo+bar@baz.com"
  84
  85       conn
  86       |> put_req_header("content-type", "application/json;charset=utf-8")
  87       |> post("/api/v1/pleroma/admin/users/email_invite", %{email: recipient_email})
  88       |> json_response_and_validate_schema(:no_content)
  89
  90       token_record =
  91         Pleroma.UserInviteToken
  92         |> Repo.all()
  93         |> List.last()
  94
  95       assert token_record
  96       refute token_record.used
  97
  98       notify_email = Config.get([:instance, :notify_email])
  99       instance_name = Config.get([:instance, :name])
 100
 101       email =
 102         Pleroma.Emails.UserEmail.user_invitation_email(
 103           admin,
 104           token_record,
 105           recipient_email
 106         )
 107
 108       Swoosh.TestAssertions.assert_email_sent(
 109         from: {instance_name, notify_email},
 110         to: recipient_email,
 111         html_body: email.html_body
 112       )
 113     end
 114   end
 115
 116   describe "POST /api/v1/pleroma/admin/users/email_invite, with invalid config" do
 117     setup do: clear_config([:instance, :registrations_open])
 118     setup do: clear_config([:instance, :invites_enabled])
 119
 120     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn} do
 121       clear_config([:instance, :registrations_open], false)
 122       clear_config([:instance, :invites_enabled], false)
 123
 124       conn =
 125         conn
 126         |> put_req_header("content-type", "application/json")
 127         |> post("/api/v1/pleroma/admin/users/email_invite", %{
 128           email: "foo@bar.com",
 129           name: "JD"
 130         })
 131
 132       assert json_response_and_validate_schema(conn, :bad_request) ==
 133                %{
 134                  "error" =>
 135                    "To send invites you need to set the `invites_enabled` option to true."
 136                }
 137     end
 138
 139     test "it returns 500 if `registrations_open` is enabled", %{conn: conn} do
 140       clear_config([:instance, :registrations_open], true)
 141       clear_config([:instance, :invites_enabled], true)
 142
 143       conn =
 144         conn
 145         |> put_req_header("content-type", "application/json")
 146         |> post("/api/v1/pleroma/admin/users/email_invite", %{
 147           email: "foo@bar.com",
 148           name: "JD"
 149         })
 150
 151       assert json_response_and_validate_schema(conn, :bad_request) ==
 152                %{
 153                  "error" =>
 154                    "To send invites you need to set the `registrations_open` option to false."
 155                }
 156     end
 157   end
 158
 159   describe "POST /api/v1/pleroma/admin/users/invite_token" do
 160     test "without options", %{conn: conn} do
 161       conn =
 162         conn
 163         |> put_req_header("content-type", "application/json")
 164         |> post("/api/v1/pleroma/admin/users/invite_token")
 165
 166       invite_json = json_response_and_validate_schema(conn, 200)
 167       invite = UserInviteToken.find_by_token!(invite_json["token"])
 168       refute invite.used
 169       refute invite.expires_at
 170       refute invite.max_use
 171       assert invite.invite_type == "one_time"
 172     end
 173
 174     test "with expires_at", %{conn: conn} do
 175       conn =
 176         conn
 177         |> put_req_header("content-type", "application/json")
 178         |> post("/api/v1/pleroma/admin/users/invite_token", %{
 179           "expires_at" => Date.to_string(Date.utc_today())
 180         })
 181
 182       invite_json = json_response_and_validate_schema(conn, 200)
 183       invite = UserInviteToken.find_by_token!(invite_json["token"])
 184
 185       refute invite.used
 186       assert invite.expires_at == Date.utc_today()
 187       refute invite.max_use
 188       assert invite.invite_type == "date_limited"
 189     end
 190
 191     test "with max_use", %{conn: conn} do
 192       conn =
 193         conn
 194         |> put_req_header("content-type", "application/json")
 195         |> post("/api/v1/pleroma/admin/users/invite_token", %{"max_use" => 150})
 196
 197       invite_json = json_response_and_validate_schema(conn, 200)
 198       invite = UserInviteToken.find_by_token!(invite_json["token"])
 199       refute invite.used
 200       refute invite.expires_at
 201       assert invite.max_use == 150
 202       assert invite.invite_type == "reusable"
 203     end
 204
 205     test "with max use and expires_at", %{conn: conn} do
 206       conn =
 207         conn
 208         |> put_req_header("content-type", "application/json")
 209         |> post("/api/v1/pleroma/admin/users/invite_token", %{
 210           "max_use" => 150,
 211           "expires_at" => Date.to_string(Date.utc_today())
 212         })
 213
 214       invite_json = json_response_and_validate_schema(conn, 200)
 215       invite = UserInviteToken.find_by_token!(invite_json["token"])
 216       refute invite.used
 217       assert invite.expires_at == Date.utc_today()
 218       assert invite.max_use == 150
 219       assert invite.invite_type == "reusable_date_limited"
 220     end
 221   end
 222
 223   describe "GET /api/v1/pleroma/admin/users/invites" do
 224     test "no invites", %{conn: conn} do
 225       conn = get(conn, "/api/v1/pleroma/admin/users/invites")
 226
 227       assert json_response_and_validate_schema(conn, 200) == %{"invites" => []}
 228     end
 229
 230     test "with invite", %{conn: conn} do
 231       {:ok, invite} = UserInviteToken.create_invite()
 232
 233       conn = get(conn, "/api/v1/pleroma/admin/users/invites")
 234
 235       assert json_response_and_validate_schema(conn, 200) == %{
 236                "invites" => [
 237                  %{
 238                    "expires_at" => nil,
 239                    "id" => invite.id,
 240                    "invite_type" => "one_time",
 241                    "max_use" => nil,
 242                    "token" => invite.token,
 243                    "used" => false,
 244                    "uses" => 0
 245                  }
 246                ]
 247              }
 248     end
 249   end
 250
 251   describe "POST /api/v1/pleroma/admin/users/revoke_invite" do
 252     test "with token", %{conn: conn} do
 253       {:ok, invite} = UserInviteToken.create_invite()
 254
 255       conn =
 256         conn
 257         |> put_req_header("content-type", "application/json")
 258         |> post("/api/v1/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 259
 260       assert json_response_and_validate_schema(conn, 200) == %{
 261                "expires_at" => nil,
 262                "id" => invite.id,
 263                "invite_type" => "one_time",
 264                "max_use" => nil,
 265                "token" => invite.token,
 266                "used" => true,
 267                "uses" => 0
 268              }
 269     end
 270
 271     test "with invalid token", %{conn: conn} do
 272       conn =
 273         conn
 274         |> put_req_header("content-type", "application/json")
 275         |> post("/api/v1/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
 276
 277       assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
 278     end
 279   end
 280 end