mirror of
https://github.com/TheRealOwenRees/chess-endgame-trainer.git
synced 2026-11-18 03:32:06 +00:00
Add user accounts, roles, and admin gating
- Scaffold password auth (email or username) with phx.gen.auth; no magic links - Add role (member/moderator/admin/super_admin) and plan (free/premium) enums - Gate /admin behind admin-or-above via plug + on_mount; hide the nav link - Add mix accounts.promote for CLI role changes - Disable email confirmation by confirming accounts at registration Closes #3
This commit is contained in:
@@ -0,0 +1,36 @@
|
||||
defmodule Chesstrainer.Accounts.RoleTest do
|
||||
use ExUnit.Case, async: true
|
||||
|
||||
alias Chesstrainer.Accounts.Role
|
||||
|
||||
test "values/0 returns roles from least to most authority" do
|
||||
assert Role.values() == [:member, :moderator, :admin, :super_admin]
|
||||
end
|
||||
|
||||
test "rank/1 orders roles" do
|
||||
assert Role.rank(:member) < Role.rank(:moderator)
|
||||
assert Role.rank(:moderator) < Role.rank(:admin)
|
||||
assert Role.rank(:admin) < Role.rank(:super_admin)
|
||||
end
|
||||
|
||||
test "at_least?/2 compares ranks" do
|
||||
assert Role.at_least?(:admin, :admin)
|
||||
assert Role.at_least?(:super_admin, :admin)
|
||||
assert Role.at_least?(:moderator, :member)
|
||||
refute Role.at_least?(:moderator, :admin)
|
||||
refute Role.at_least?(:member, :moderator)
|
||||
end
|
||||
|
||||
test "at_least?/2 is false when there is no valid role" do
|
||||
refute Role.at_least?(nil, :member)
|
||||
refute Role.at_least?(:unknown, :member)
|
||||
end
|
||||
|
||||
test "admin?/1 is true only for admin and above" do
|
||||
assert Role.admin?(:admin)
|
||||
assert Role.admin?(:super_admin)
|
||||
refute Role.admin?(:moderator)
|
||||
refute Role.admin?(:member)
|
||||
refute Role.admin?(nil)
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,449 @@
|
||||
defmodule Chesstrainer.AccountsTest do
|
||||
use Chesstrainer.DataCase
|
||||
|
||||
alias Chesstrainer.Accounts
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
alias Chesstrainer.Accounts.{User, UserToken}
|
||||
|
||||
describe "get_user_by_email/1" do
|
||||
test "does not return the user if the email does not exist" do
|
||||
refute Accounts.get_user_by_email("unknown@example.com")
|
||||
end
|
||||
|
||||
test "returns the user if the email exists" do
|
||||
%{id: id} = user = user_fixture()
|
||||
assert %User{id: ^id} = Accounts.get_user_by_email(user.email)
|
||||
end
|
||||
end
|
||||
|
||||
describe "get_user_by_login/1" do
|
||||
test "returns the user by email" do
|
||||
%{id: id} = user = user_fixture()
|
||||
assert %User{id: ^id} = Accounts.get_user_by_login(user.email)
|
||||
end
|
||||
|
||||
test "returns the user by username" do
|
||||
%{id: id} = user = user_fixture()
|
||||
assert %User{id: ^id} = Accounts.get_user_by_login(user.username)
|
||||
end
|
||||
|
||||
test "ignores case for both email and username" do
|
||||
user = user_fixture()
|
||||
|
||||
assert %User{id: id} = Accounts.get_user_by_login(String.upcase(user.email))
|
||||
assert user.id == id
|
||||
|
||||
assert %User{id: ^id} = Accounts.get_user_by_login(String.upcase(user.username))
|
||||
end
|
||||
|
||||
test "does not return the user if neither identifier exists" do
|
||||
refute Accounts.get_user_by_login("unknown")
|
||||
end
|
||||
end
|
||||
|
||||
describe "get_user_by_login_and_password/2" do
|
||||
test "does not return the user if the login does not exist" do
|
||||
refute Accounts.get_user_by_login_and_password("unknown@example.com", "hello world!")
|
||||
end
|
||||
|
||||
test "does not return the user if the password is not valid" do
|
||||
user = user_fixture() |> set_password()
|
||||
refute Accounts.get_user_by_login_and_password(user.email, "invalid")
|
||||
end
|
||||
|
||||
test "returns the user if the email and password are valid" do
|
||||
%{id: id} = user = user_fixture() |> set_password()
|
||||
|
||||
assert %User{id: ^id} =
|
||||
Accounts.get_user_by_login_and_password(user.email, valid_user_password())
|
||||
end
|
||||
|
||||
test "returns the user if the username and password are valid" do
|
||||
%{id: id} = user = user_fixture() |> set_password()
|
||||
|
||||
assert %User{id: ^id} =
|
||||
Accounts.get_user_by_login_and_password(user.username, valid_user_password())
|
||||
end
|
||||
end
|
||||
|
||||
describe "get_user!/1" do
|
||||
test "raises if id is invalid" do
|
||||
assert_raise Ecto.NoResultsError, fn ->
|
||||
Accounts.get_user!("11111111-1111-1111-1111-111111111111")
|
||||
end
|
||||
end
|
||||
|
||||
test "returns the user with the given id" do
|
||||
%{id: id} = user = user_fixture()
|
||||
assert %User{id: ^id} = Accounts.get_user!(user.id)
|
||||
end
|
||||
end
|
||||
|
||||
describe "register_user/1" do
|
||||
test "requires email, username and password to be set" do
|
||||
{:error, changeset} = Accounts.register_user(%{})
|
||||
|
||||
assert %{
|
||||
email: ["can't be blank"],
|
||||
username: ["can't be blank"],
|
||||
password: ["can't be blank"]
|
||||
} = errors_on(changeset)
|
||||
end
|
||||
|
||||
test "validates email when given" do
|
||||
{:error, changeset} = Accounts.register_user(valid_user_attributes(email: "not valid"))
|
||||
|
||||
assert %{email: ["must have the @ sign and no spaces"]} = errors_on(changeset)
|
||||
end
|
||||
|
||||
test "validates maximum values for email for security" do
|
||||
too_long = String.duplicate("db", 100)
|
||||
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(email: too_long))
|
||||
|
||||
assert "should be at most 160 character(s)" in errors_on(changeset).email
|
||||
end
|
||||
|
||||
test "validates username format" do
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(username: "no spaces allowed"))
|
||||
|
||||
assert "only letters, numbers and underscores" in errors_on(changeset).username
|
||||
end
|
||||
|
||||
test "validates username length" do
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(username: "ab"))
|
||||
|
||||
assert "should be at least 3 character(s)" in errors_on(changeset).username
|
||||
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(username: String.duplicate("a", 31)))
|
||||
|
||||
assert "should be at most 30 character(s)" in errors_on(changeset).username
|
||||
end
|
||||
|
||||
test "validates password confirmation when given" do
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(password_confirmation: "something else"))
|
||||
|
||||
assert %{password_confirmation: ["does not match password"]} = errors_on(changeset)
|
||||
end
|
||||
|
||||
test "validates email uniqueness" do
|
||||
%{email: email} = user_fixture()
|
||||
|
||||
{:error, changeset} = Accounts.register_user(valid_user_attributes(email: email))
|
||||
assert "has already been taken" in errors_on(changeset).email
|
||||
|
||||
# Now try with the uppercased email too, to check that email case is ignored.
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(email: String.upcase(email)))
|
||||
|
||||
assert "has already been taken" in errors_on(changeset).email
|
||||
end
|
||||
|
||||
test "validates username uniqueness, ignoring case" do
|
||||
%{username: username} = user_fixture()
|
||||
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(username: username))
|
||||
|
||||
assert "has already been taken" in errors_on(changeset).username
|
||||
|
||||
{:error, changeset} =
|
||||
Accounts.register_user(valid_user_attributes(username: String.upcase(username)))
|
||||
|
||||
assert "has already been taken" in errors_on(changeset).username
|
||||
end
|
||||
|
||||
test "registers users with a password, a confirmed account and default access" do
|
||||
email = unique_user_email()
|
||||
username = unique_username()
|
||||
|
||||
{:ok, user} =
|
||||
Accounts.register_user(valid_user_attributes(email: email, username: username))
|
||||
|
||||
assert user.email == email
|
||||
assert user.username == username
|
||||
assert is_binary(user.hashed_password)
|
||||
assert is_nil(user.password)
|
||||
assert user.confirmed_at
|
||||
assert user.role == :member
|
||||
assert user.plan == :free
|
||||
end
|
||||
end
|
||||
|
||||
describe "change_user_registration/3" do
|
||||
test "returns a user changeset" do
|
||||
assert %Ecto.Changeset{} = changeset = Accounts.change_user_registration(%User{})
|
||||
assert Enum.sort(changeset.required) == [:email, :password, :username]
|
||||
end
|
||||
|
||||
test "does not cast the role or plan" do
|
||||
changeset =
|
||||
Accounts.change_user_registration(%User{}, %{
|
||||
email: unique_user_email(),
|
||||
username: unique_username(),
|
||||
password: valid_user_password(),
|
||||
role: :super_admin,
|
||||
plan: :premium
|
||||
})
|
||||
|
||||
refute Map.has_key?(changeset.changes, :role)
|
||||
refute Map.has_key?(changeset.changes, :plan)
|
||||
end
|
||||
end
|
||||
|
||||
describe "update_user_role/2" do
|
||||
test "changes the user's role" do
|
||||
user = user_fixture()
|
||||
|
||||
assert {:ok, %User{role: :admin}} = Accounts.update_user_role(user, :admin)
|
||||
end
|
||||
|
||||
test "rejects a role that is not in the enum" do
|
||||
user = user_fixture()
|
||||
|
||||
assert {:error, changeset} = Accounts.update_user_role(user, :wizard)
|
||||
assert %{role: ["is invalid"]} = errors_on(changeset)
|
||||
end
|
||||
end
|
||||
|
||||
describe "sudo_mode?/2" do
|
||||
test "validates the authenticated_at time" do
|
||||
now = DateTime.utc_now()
|
||||
|
||||
assert Accounts.sudo_mode?(%User{authenticated_at: DateTime.utc_now()})
|
||||
assert Accounts.sudo_mode?(%User{authenticated_at: DateTime.add(now, -19, :minute)})
|
||||
refute Accounts.sudo_mode?(%User{authenticated_at: DateTime.add(now, -21, :minute)})
|
||||
|
||||
# minute override
|
||||
refute Accounts.sudo_mode?(
|
||||
%User{authenticated_at: DateTime.add(now, -11, :minute)},
|
||||
-10
|
||||
)
|
||||
|
||||
# not authenticated
|
||||
refute Accounts.sudo_mode?(%User{})
|
||||
end
|
||||
end
|
||||
|
||||
describe "change_user_email/3" do
|
||||
test "returns a user changeset" do
|
||||
assert %Ecto.Changeset{} = changeset = Accounts.change_user_email(%User{})
|
||||
assert changeset.required == [:email]
|
||||
end
|
||||
end
|
||||
|
||||
describe "deliver_user_update_email_instructions/3" do
|
||||
setup do
|
||||
%{user: user_fixture()}
|
||||
end
|
||||
|
||||
test "sends token through notification", %{user: user} do
|
||||
token =
|
||||
extract_user_token(fn url ->
|
||||
Accounts.deliver_user_update_email_instructions(user, "current@example.com", url)
|
||||
end)
|
||||
|
||||
{:ok, token} = Base.url_decode64(token, padding: false)
|
||||
assert user_token = Repo.get_by(UserToken, token: :crypto.hash(:sha256, token))
|
||||
assert user_token.user_id == user.id
|
||||
assert user_token.sent_to == user.email
|
||||
assert user_token.context == "change:current@example.com"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update_user_email/2" do
|
||||
setup do
|
||||
user = user_fixture()
|
||||
email = unique_user_email()
|
||||
|
||||
token =
|
||||
extract_user_token(fn url ->
|
||||
Accounts.deliver_user_update_email_instructions(%{user | email: email}, user.email, url)
|
||||
end)
|
||||
|
||||
%{user: user, token: token, email: email}
|
||||
end
|
||||
|
||||
test "updates the email with a valid token", %{user: user, token: token, email: email} do
|
||||
assert {:ok, %{email: ^email}} = Accounts.update_user_email(user, token)
|
||||
changed_user = Repo.get!(User, user.id)
|
||||
assert changed_user.email != user.email
|
||||
assert changed_user.email == email
|
||||
refute Repo.get_by(UserToken, user_id: user.id)
|
||||
end
|
||||
|
||||
test "does not update email with invalid token", %{user: user} do
|
||||
assert Accounts.update_user_email(user, "oops") ==
|
||||
{:error, :transaction_aborted}
|
||||
|
||||
assert Repo.get!(User, user.id).email == user.email
|
||||
assert Repo.get_by(UserToken, user_id: user.id)
|
||||
end
|
||||
|
||||
test "does not update email if user email changed", %{user: user, token: token} do
|
||||
assert Accounts.update_user_email(%{user | email: "current@example.com"}, token) ==
|
||||
{:error, :transaction_aborted}
|
||||
|
||||
assert Repo.get!(User, user.id).email == user.email
|
||||
assert Repo.get_by(UserToken, user_id: user.id)
|
||||
end
|
||||
|
||||
test "does not update email if token expired", %{user: user, token: token} do
|
||||
{1, nil} = Repo.update_all(UserToken, set: [inserted_at: ~N[2020-01-01 00:00:00]])
|
||||
|
||||
assert Accounts.update_user_email(user, token) ==
|
||||
{:error, :transaction_aborted}
|
||||
|
||||
assert Repo.get!(User, user.id).email == user.email
|
||||
assert Repo.get_by(UserToken, user_id: user.id)
|
||||
end
|
||||
end
|
||||
|
||||
describe "change_user_password/3" do
|
||||
test "returns a user changeset" do
|
||||
assert %Ecto.Changeset{} = changeset = Accounts.change_user_password(%User{})
|
||||
assert changeset.required == [:password]
|
||||
end
|
||||
|
||||
test "allows fields to be set" do
|
||||
changeset =
|
||||
Accounts.change_user_password(
|
||||
%User{},
|
||||
%{
|
||||
"password" => "new valid password"
|
||||
},
|
||||
hash_password: false
|
||||
)
|
||||
|
||||
assert changeset.valid?
|
||||
assert get_change(changeset, :password) == "new valid password"
|
||||
assert is_nil(get_change(changeset, :hashed_password))
|
||||
end
|
||||
end
|
||||
|
||||
describe "update_user_password/2" do
|
||||
setup do
|
||||
%{user: user_fixture()}
|
||||
end
|
||||
|
||||
test "validates password", %{user: user} do
|
||||
{:error, changeset} =
|
||||
Accounts.update_user_password(user, %{
|
||||
password: "not valid",
|
||||
password_confirmation: "another"
|
||||
})
|
||||
|
||||
assert %{
|
||||
password: ["should be at least 12 character(s)"],
|
||||
password_confirmation: ["does not match password"]
|
||||
} = errors_on(changeset)
|
||||
end
|
||||
|
||||
test "validates maximum values for password for security", %{user: user} do
|
||||
too_long = String.duplicate("db", 100)
|
||||
|
||||
{:error, changeset} =
|
||||
Accounts.update_user_password(user, %{password: too_long})
|
||||
|
||||
assert "should be at most 72 character(s)" in errors_on(changeset).password
|
||||
end
|
||||
|
||||
test "updates the password", %{user: user} do
|
||||
{:ok, {user, expired_tokens}} =
|
||||
Accounts.update_user_password(user, %{
|
||||
password: "new valid password"
|
||||
})
|
||||
|
||||
assert expired_tokens == []
|
||||
assert is_nil(user.password)
|
||||
assert Accounts.get_user_by_login_and_password(user.email, "new valid password")
|
||||
end
|
||||
|
||||
test "deletes all tokens for the given user", %{user: user} do
|
||||
_ = Accounts.generate_user_session_token(user)
|
||||
|
||||
{:ok, {_, _}} =
|
||||
Accounts.update_user_password(user, %{
|
||||
password: "new valid password"
|
||||
})
|
||||
|
||||
refute Repo.get_by(UserToken, user_id: user.id)
|
||||
end
|
||||
end
|
||||
|
||||
describe "generate_user_session_token/1" do
|
||||
setup do
|
||||
%{user: user_fixture()}
|
||||
end
|
||||
|
||||
test "generates a token", %{user: user} do
|
||||
token = Accounts.generate_user_session_token(user)
|
||||
assert user_token = Repo.get_by(UserToken, token: token)
|
||||
assert user_token.context == "session"
|
||||
assert user_token.authenticated_at != nil
|
||||
|
||||
# Creating the same token for another user should fail
|
||||
assert_raise Ecto.ConstraintError, fn ->
|
||||
Repo.insert!(%UserToken{
|
||||
token: user_token.token,
|
||||
user_id: user_fixture().id,
|
||||
context: "session"
|
||||
})
|
||||
end
|
||||
end
|
||||
|
||||
test "duplicates the authenticated_at of given user in new token", %{user: user} do
|
||||
user = %{user | authenticated_at: DateTime.add(DateTime.utc_now(:second), -3600)}
|
||||
token = Accounts.generate_user_session_token(user)
|
||||
assert user_token = Repo.get_by(UserToken, token: token)
|
||||
assert user_token.authenticated_at == user.authenticated_at
|
||||
assert DateTime.compare(user_token.inserted_at, user.authenticated_at) == :gt
|
||||
end
|
||||
end
|
||||
|
||||
describe "get_user_by_session_token/1" do
|
||||
setup do
|
||||
user = user_fixture()
|
||||
token = Accounts.generate_user_session_token(user)
|
||||
%{user: user, token: token}
|
||||
end
|
||||
|
||||
test "returns user by token", %{user: user, token: token} do
|
||||
assert {session_user, token_inserted_at} = Accounts.get_user_by_session_token(token)
|
||||
assert session_user.id == user.id
|
||||
assert session_user.authenticated_at != nil
|
||||
assert token_inserted_at != nil
|
||||
end
|
||||
|
||||
test "does not return user for invalid token" do
|
||||
refute Accounts.get_user_by_session_token("oops")
|
||||
end
|
||||
|
||||
test "does not return user for expired token", %{token: token} do
|
||||
dt = ~N[2020-01-01 00:00:00]
|
||||
{1, nil} = Repo.update_all(UserToken, set: [inserted_at: dt, authenticated_at: dt])
|
||||
refute Accounts.get_user_by_session_token(token)
|
||||
end
|
||||
end
|
||||
|
||||
describe "delete_user_session_token/1" do
|
||||
test "deletes the token" do
|
||||
user = user_fixture()
|
||||
token = Accounts.generate_user_session_token(user)
|
||||
assert Accounts.delete_user_session_token(token) == :ok
|
||||
refute Accounts.get_user_by_session_token(token)
|
||||
end
|
||||
end
|
||||
|
||||
describe "inspect/2 for the User module" do
|
||||
test "does not include password" do
|
||||
refute inspect(%User{password: "123456"}) =~ "password: \"123456\""
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,81 @@
|
||||
defmodule ChesstrainerWeb.AdminGatingTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
alias Chesstrainer.Accounts
|
||||
|
||||
test "unauthenticated visitors are redirected to log in", %{conn: conn} do
|
||||
conn = get(conn, ~p"/admin/endgames")
|
||||
|
||||
assert redirected_to(conn) == ~p"/users/log-in"
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"You must log in to access this page."
|
||||
end
|
||||
|
||||
test "members are redirected home", %{conn: conn} do
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user_fixture())
|
||||
|> get(~p"/admin/endgames")
|
||||
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"You are not authorized to access this page."
|
||||
end
|
||||
|
||||
test "moderators are redirected home", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :moderator)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user)
|
||||
|> get(~p"/admin/endgames")
|
||||
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
|
||||
test "admins are admitted", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :admin)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user)
|
||||
|> get(~p"/admin/endgames")
|
||||
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "super admins are admitted", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :super_admin)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user)
|
||||
|> get(~p"/admin/endgames")
|
||||
|
||||
assert html_response(conn, 200)
|
||||
end
|
||||
|
||||
test "the navbar hides the Admin link from members", %{conn: conn} do
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user_fixture())
|
||||
|> get(~p"/")
|
||||
|
||||
refute html_response(conn, 200) =~ ~p"/admin/endgames"
|
||||
end
|
||||
|
||||
test "the navbar shows the Admin link to admins", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :admin)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> log_in_user(user)
|
||||
|> get(~p"/")
|
||||
|
||||
assert html_response(conn, 200) =~ ~p"/admin/endgames"
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,95 @@
|
||||
defmodule ChesstrainerWeb.UserSessionControllerTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
setup do
|
||||
%{user: user_fixture()}
|
||||
end
|
||||
|
||||
describe "POST /users/log-in - email or username and password" do
|
||||
test "logs the user in with their email", %{conn: conn, user: user} do
|
||||
conn =
|
||||
post(conn, ~p"/users/log-in", %{
|
||||
"user" => %{"email" => user.email, "password" => valid_user_password()}
|
||||
})
|
||||
|
||||
assert get_session(conn, :user_token)
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
|
||||
# Now do a logged in request and assert on the menu
|
||||
conn = get(conn, ~p"/")
|
||||
response = html_response(conn, 200)
|
||||
assert response =~ user.username
|
||||
assert response =~ ~p"/users/settings"
|
||||
assert response =~ ~p"/users/log-out"
|
||||
end
|
||||
|
||||
test "logs the user in with their username", %{conn: conn, user: user} do
|
||||
conn =
|
||||
post(conn, ~p"/users/log-in", %{
|
||||
"user" => %{"email" => user.username, "password" => valid_user_password()}
|
||||
})
|
||||
|
||||
assert get_session(conn, :user_token)
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
|
||||
test "logs the user in with remember me", %{conn: conn, user: user} do
|
||||
conn =
|
||||
post(conn, ~p"/users/log-in", %{
|
||||
"user" => %{
|
||||
"email" => user.email,
|
||||
"password" => valid_user_password(),
|
||||
"remember_me" => "true"
|
||||
}
|
||||
})
|
||||
|
||||
assert conn.resp_cookies["_chesstrainer_web_user_remember_me"]
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
|
||||
test "logs the user in with return to", %{conn: conn, user: user} do
|
||||
conn =
|
||||
conn
|
||||
|> init_test_session(user_return_to: "/foo/bar")
|
||||
|> post(~p"/users/log-in", %{
|
||||
"user" => %{
|
||||
"email" => user.email,
|
||||
"password" => valid_user_password()
|
||||
}
|
||||
})
|
||||
|
||||
assert redirected_to(conn) == "/foo/bar"
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Welcome back!"
|
||||
end
|
||||
|
||||
test "redirects to login page with invalid credentials", %{conn: conn, user: user} do
|
||||
conn =
|
||||
post(conn, ~p"/users/log-in", %{
|
||||
"user" => %{"email" => user.email, "password" => "invalid_password"}
|
||||
})
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"Invalid email, username or password"
|
||||
|
||||
assert redirected_to(conn) == ~p"/users/log-in"
|
||||
end
|
||||
end
|
||||
|
||||
describe "DELETE /users/log-out" do
|
||||
test "logs the user out", %{conn: conn, user: user} do
|
||||
conn = conn |> log_in_user(user) |> delete(~p"/users/log-out")
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
refute get_session(conn, :user_token)
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Logged out successfully"
|
||||
end
|
||||
|
||||
test "succeeds even if the user is not logged in", %{conn: conn} do
|
||||
conn = delete(conn, ~p"/users/log-out")
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
refute get_session(conn, :user_token)
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :info) =~ "Logged out successfully"
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -10,6 +10,8 @@ defmodule ChesstrainerWeb.EndgameLive.FormTest do
|
||||
|
||||
@fen "8/8/3k4/8/8/3K1R2/8/8 w - - 0 1"
|
||||
|
||||
setup :register_and_log_in_admin
|
||||
|
||||
describe "rating default" do
|
||||
test "new endgame form pre-fills rating with 1500", %{conn: conn} do
|
||||
{:ok, view, _html} = live(conn, ~p"/admin/endgames/new")
|
||||
|
||||
@@ -7,6 +7,8 @@ defmodule ChesstrainerWeb.EndgameLive.IndexTest do
|
||||
|
||||
alias Chesstrainer.Endgames
|
||||
|
||||
setup :register_and_log_in_admin
|
||||
|
||||
test "groups endgames by Key with a count", %{conn: conn} do
|
||||
endgame_fixture()
|
||||
endgame_fixture()
|
||||
|
||||
@@ -0,0 +1,98 @@
|
||||
defmodule ChesstrainerWeb.UserLive.LoginTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
import Phoenix.LiveViewTest
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
describe "login page" do
|
||||
test "renders login page", %{conn: conn} do
|
||||
{:ok, _lv, html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
assert html =~ "Log in"
|
||||
assert html =~ "Sign up"
|
||||
assert html =~ "Email or username"
|
||||
end
|
||||
end
|
||||
|
||||
describe "user login - password" do
|
||||
test "redirects if user logs in with email", %{conn: conn} do
|
||||
user = user_fixture()
|
||||
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
form =
|
||||
form(lv, "#login_form_password",
|
||||
user: %{email: user.email, password: valid_user_password(), remember_me: true}
|
||||
)
|
||||
|
||||
conn = submit_form(form, conn)
|
||||
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
|
||||
test "redirects if user logs in with username", %{conn: conn} do
|
||||
user = user_fixture()
|
||||
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
form =
|
||||
form(lv, "#login_form_password",
|
||||
user: %{email: user.username, password: valid_user_password(), remember_me: true}
|
||||
)
|
||||
|
||||
conn = submit_form(form, conn)
|
||||
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
|
||||
test "redirects to login page with a flash error if credentials are invalid", %{
|
||||
conn: conn
|
||||
} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
form =
|
||||
form(lv, "#login_form_password", user: %{email: "test@email.com", password: "123456"})
|
||||
|
||||
render_submit(form, %{user: %{remember_me: true}})
|
||||
|
||||
conn = follow_trigger_action(form, conn)
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"Invalid email, username or password"
|
||||
|
||||
assert redirected_to(conn) == ~p"/users/log-in"
|
||||
end
|
||||
end
|
||||
|
||||
describe "login navigation" do
|
||||
test "redirects to registration page when the Register button is clicked", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
{:ok, _login_live, login_html} =
|
||||
lv
|
||||
|> element("main a", "Sign up")
|
||||
|> render_click()
|
||||
|> follow_redirect(conn, ~p"/users/register")
|
||||
|
||||
assert login_html =~ "Register"
|
||||
end
|
||||
end
|
||||
|
||||
describe "re-authentication (sudo mode)" do
|
||||
setup %{conn: conn} do
|
||||
user = user_fixture()
|
||||
%{user: user, conn: log_in_user(conn, user)}
|
||||
end
|
||||
|
||||
test "shows login page with email filled in", %{conn: conn, user: user} do
|
||||
{:ok, _lv, html} = live(conn, ~p"/users/log-in")
|
||||
|
||||
assert html =~ "You need to reauthenticate"
|
||||
refute html =~ "Register"
|
||||
assert html =~ "Email or username"
|
||||
|
||||
assert html =~
|
||||
~s(<input type="text" name="user[email]" id="login_form_password_email" value="#{user.email}")
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,134 @@
|
||||
defmodule ChesstrainerWeb.UserLive.RegistrationTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
import Phoenix.LiveViewTest
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
describe "Registration page" do
|
||||
test "renders registration page", %{conn: conn} do
|
||||
{:ok, _lv, html} = live(conn, ~p"/users/register")
|
||||
|
||||
assert html =~ "Register"
|
||||
assert html =~ "Log in"
|
||||
end
|
||||
|
||||
test "redirects if already logged in", %{conn: conn} do
|
||||
result =
|
||||
conn
|
||||
|> log_in_user(user_fixture())
|
||||
|> live(~p"/users/register")
|
||||
|> follow_redirect(conn, ~p"/")
|
||||
|
||||
assert {:ok, _conn} = result
|
||||
end
|
||||
|
||||
test "renders errors for invalid data", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> element("#registration_form")
|
||||
|> render_change(user: %{"email" => "with spaces"})
|
||||
|
||||
assert result =~ "Register"
|
||||
assert result =~ "must have the @ sign and no spaces"
|
||||
end
|
||||
end
|
||||
|
||||
describe "register user" do
|
||||
test "creates account but does not log in", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
email = unique_user_email()
|
||||
username = unique_username()
|
||||
|
||||
form =
|
||||
form(lv, "#registration_form",
|
||||
user: %{
|
||||
"username" => username,
|
||||
"email" => email,
|
||||
"password" => valid_user_password(),
|
||||
"password_confirmation" => valid_user_password()
|
||||
}
|
||||
)
|
||||
|
||||
{:ok, _lv, html} =
|
||||
render_submit(form)
|
||||
|> follow_redirect(conn, ~p"/users/log-in")
|
||||
|
||||
assert html =~ "Account created successfully"
|
||||
end
|
||||
|
||||
test "renders errors for duplicated email", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
user = user_fixture(%{email: "test@email.com"})
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#registration_form",
|
||||
user: %{
|
||||
"username" => unique_username(),
|
||||
"email" => user.email,
|
||||
"password" => valid_user_password(),
|
||||
"password_confirmation" => valid_user_password()
|
||||
}
|
||||
)
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "has already been taken"
|
||||
end
|
||||
|
||||
test "renders errors for duplicated username", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
user = user_fixture()
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#registration_form",
|
||||
user: %{
|
||||
"username" => user.username,
|
||||
"email" => unique_user_email(),
|
||||
"password" => valid_user_password(),
|
||||
"password_confirmation" => valid_user_password()
|
||||
}
|
||||
)
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "has already been taken"
|
||||
end
|
||||
|
||||
test "renders errors for mismatched passwords", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#registration_form",
|
||||
user: %{
|
||||
"username" => unique_username(),
|
||||
"email" => unique_user_email(),
|
||||
"password" => valid_user_password(),
|
||||
"password_confirmation" => "something else"
|
||||
}
|
||||
)
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "does not match password"
|
||||
end
|
||||
end
|
||||
|
||||
describe "registration navigation" do
|
||||
test "redirects to login page when the Log in button is clicked", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/register")
|
||||
|
||||
{:ok, _login_live, login_html} =
|
||||
lv
|
||||
|> element("main a", "Log in")
|
||||
|> render_click()
|
||||
|> follow_redirect(conn, ~p"/users/log-in")
|
||||
|
||||
assert login_html =~ "Log in"
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,212 @@
|
||||
defmodule ChesstrainerWeb.UserLive.SettingsTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
alias Chesstrainer.Accounts
|
||||
import Phoenix.LiveViewTest
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
describe "Settings page" do
|
||||
test "renders settings page", %{conn: conn} do
|
||||
{:ok, _lv, html} =
|
||||
conn
|
||||
|> log_in_user(user_fixture())
|
||||
|> live(~p"/users/settings")
|
||||
|
||||
assert html =~ "Change Email"
|
||||
assert html =~ "Save Password"
|
||||
end
|
||||
|
||||
test "redirects if user is not logged in", %{conn: conn} do
|
||||
assert {:error, redirect} = live(conn, ~p"/users/settings")
|
||||
|
||||
assert {:redirect, %{to: path, flash: flash}} = redirect
|
||||
assert path == ~p"/users/log-in"
|
||||
assert %{"error" => "You must log in to access this page."} = flash
|
||||
end
|
||||
|
||||
test "redirects if user is not in sudo mode", %{conn: conn} do
|
||||
{:ok, conn} =
|
||||
conn
|
||||
|> log_in_user(user_fixture(),
|
||||
token_authenticated_at: DateTime.add(DateTime.utc_now(:second), -11, :minute)
|
||||
)
|
||||
|> live(~p"/users/settings")
|
||||
|> follow_redirect(conn, ~p"/users/log-in")
|
||||
|
||||
assert conn.resp_body =~ "You must re-authenticate to access this page."
|
||||
end
|
||||
end
|
||||
|
||||
describe "update email form" do
|
||||
setup %{conn: conn} do
|
||||
user = user_fixture()
|
||||
%{conn: log_in_user(conn, user), user: user}
|
||||
end
|
||||
|
||||
test "updates the user email", %{conn: conn, user: user} do
|
||||
new_email = unique_user_email()
|
||||
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#email_form", %{
|
||||
"user" => %{"email" => new_email}
|
||||
})
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "A link to confirm your email"
|
||||
assert Accounts.get_user_by_email(user.email)
|
||||
end
|
||||
|
||||
test "renders errors with invalid data (phx-change)", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> element("#email_form")
|
||||
|> render_change(%{
|
||||
"action" => "update_email",
|
||||
"user" => %{"email" => "with spaces"}
|
||||
})
|
||||
|
||||
assert result =~ "Change Email"
|
||||
assert result =~ "must have the @ sign and no spaces"
|
||||
end
|
||||
|
||||
test "renders errors with invalid data (phx-submit)", %{conn: conn, user: user} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#email_form", %{
|
||||
"user" => %{"email" => user.email}
|
||||
})
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "Change Email"
|
||||
assert result =~ "did not change"
|
||||
end
|
||||
end
|
||||
|
||||
describe "update password form" do
|
||||
setup %{conn: conn} do
|
||||
user = user_fixture()
|
||||
%{conn: log_in_user(conn, user), user: user}
|
||||
end
|
||||
|
||||
test "updates the user password", %{conn: conn, user: user} do
|
||||
new_password = valid_user_password()
|
||||
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
form =
|
||||
form(lv, "#password_form", %{
|
||||
"user" => %{
|
||||
"email" => user.email,
|
||||
"password" => new_password,
|
||||
"password_confirmation" => new_password
|
||||
}
|
||||
})
|
||||
|
||||
render_submit(form)
|
||||
|
||||
new_password_conn = follow_trigger_action(form, conn)
|
||||
|
||||
assert redirected_to(new_password_conn) == ~p"/users/settings"
|
||||
|
||||
assert get_session(new_password_conn, :user_token) != get_session(conn, :user_token)
|
||||
|
||||
assert Phoenix.Flash.get(new_password_conn.assigns.flash, :info) =~
|
||||
"Password updated successfully"
|
||||
|
||||
assert Accounts.get_user_by_login_and_password(user.email, new_password)
|
||||
end
|
||||
|
||||
test "renders errors with invalid data (phx-change)", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> element("#password_form")
|
||||
|> render_change(%{
|
||||
"user" => %{
|
||||
"password" => "too short",
|
||||
"password_confirmation" => "does not match"
|
||||
}
|
||||
})
|
||||
|
||||
assert result =~ "Save Password"
|
||||
assert result =~ "should be at least 12 character(s)"
|
||||
assert result =~ "does not match password"
|
||||
end
|
||||
|
||||
test "renders errors with invalid data (phx-submit)", %{conn: conn} do
|
||||
{:ok, lv, _html} = live(conn, ~p"/users/settings")
|
||||
|
||||
result =
|
||||
lv
|
||||
|> form("#password_form", %{
|
||||
"user" => %{
|
||||
"password" => "too short",
|
||||
"password_confirmation" => "does not match"
|
||||
}
|
||||
})
|
||||
|> render_submit()
|
||||
|
||||
assert result =~ "Save Password"
|
||||
assert result =~ "should be at least 12 character(s)"
|
||||
assert result =~ "does not match password"
|
||||
end
|
||||
end
|
||||
|
||||
describe "confirm email" do
|
||||
setup %{conn: conn} do
|
||||
user = user_fixture()
|
||||
email = unique_user_email()
|
||||
|
||||
token =
|
||||
extract_user_token(fn url ->
|
||||
Accounts.deliver_user_update_email_instructions(%{user | email: email}, user.email, url)
|
||||
end)
|
||||
|
||||
%{conn: log_in_user(conn, user), token: token, email: email, user: user}
|
||||
end
|
||||
|
||||
test "updates the user email once", %{conn: conn, user: user, token: token, email: email} do
|
||||
{:error, redirect} = live(conn, ~p"/users/settings/confirm-email/#{token}")
|
||||
|
||||
assert {:live_redirect, %{to: path, flash: flash}} = redirect
|
||||
assert path == ~p"/users/settings"
|
||||
assert %{"info" => message} = flash
|
||||
assert message == "Email changed successfully."
|
||||
refute Accounts.get_user_by_email(user.email)
|
||||
assert Accounts.get_user_by_email(email)
|
||||
|
||||
# use confirm token again
|
||||
{:error, redirect} = live(conn, ~p"/users/settings/confirm-email/#{token}")
|
||||
assert {:live_redirect, %{to: path, flash: flash}} = redirect
|
||||
assert path == ~p"/users/settings"
|
||||
assert %{"error" => message} = flash
|
||||
assert message == "Email change link is invalid or it has expired."
|
||||
end
|
||||
|
||||
test "does not update email with invalid token", %{conn: conn, user: user} do
|
||||
{:error, redirect} = live(conn, ~p"/users/settings/confirm-email/oops")
|
||||
assert {:live_redirect, %{to: path, flash: flash}} = redirect
|
||||
assert path == ~p"/users/settings"
|
||||
assert %{"error" => message} = flash
|
||||
assert message == "Email change link is invalid or it has expired."
|
||||
assert Accounts.get_user_by_email(user.email)
|
||||
end
|
||||
|
||||
test "redirects if user is not logged in", %{token: token} do
|
||||
conn = build_conn()
|
||||
{:error, redirect} = live(conn, ~p"/users/settings/confirm-email/#{token}")
|
||||
assert {:redirect, %{to: path, flash: flash}} = redirect
|
||||
assert path == ~p"/users/log-in"
|
||||
assert %{"error" => message} = flash
|
||||
assert message == "You must log in to access this page."
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,497 @@
|
||||
defmodule ChesstrainerWeb.UserAuthTest do
|
||||
use ChesstrainerWeb.ConnCase, async: true
|
||||
|
||||
alias Phoenix.LiveView
|
||||
alias Chesstrainer.Accounts
|
||||
alias Chesstrainer.Accounts.Scope
|
||||
alias ChesstrainerWeb.UserAuth
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
|
||||
@remember_me_cookie "_chesstrainer_web_user_remember_me"
|
||||
@remember_me_cookie_max_age 60 * 60 * 24 * 14
|
||||
|
||||
setup %{conn: conn} do
|
||||
conn =
|
||||
conn
|
||||
|> Map.replace!(:secret_key_base, ChesstrainerWeb.Endpoint.config(:secret_key_base))
|
||||
|> init_test_session(%{})
|
||||
|
||||
%{user: %{user_fixture() | authenticated_at: DateTime.utc_now(:second)}, conn: conn}
|
||||
end
|
||||
|
||||
describe "log_in_user/3" do
|
||||
test "stores the user token in the session", %{conn: conn, user: user} do
|
||||
conn = UserAuth.log_in_user(conn, user)
|
||||
assert token = get_session(conn, :user_token)
|
||||
assert get_session(conn, :live_socket_id) == "users_sessions:#{Base.url_encode64(token)}"
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
assert Accounts.get_user_by_session_token(token)
|
||||
end
|
||||
|
||||
test "clears everything previously stored in the session", %{conn: conn, user: user} do
|
||||
conn = conn |> put_session(:to_be_removed, "value") |> UserAuth.log_in_user(user)
|
||||
refute get_session(conn, :to_be_removed)
|
||||
end
|
||||
|
||||
test "keeps session when re-authenticating", %{conn: conn, user: user} do
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(user))
|
||||
|> put_session(:to_be_removed, "value")
|
||||
|> UserAuth.log_in_user(user)
|
||||
|
||||
assert get_session(conn, :to_be_removed)
|
||||
end
|
||||
|
||||
test "clears session when user does not match when re-authenticating", %{
|
||||
conn: conn,
|
||||
user: user
|
||||
} do
|
||||
other_user = user_fixture()
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(other_user))
|
||||
|> put_session(:to_be_removed, "value")
|
||||
|> UserAuth.log_in_user(user)
|
||||
|
||||
refute get_session(conn, :to_be_removed)
|
||||
end
|
||||
|
||||
test "redirects to the configured path", %{conn: conn, user: user} do
|
||||
conn = conn |> put_session(:user_return_to, "/hello") |> UserAuth.log_in_user(user)
|
||||
assert redirected_to(conn) == "/hello"
|
||||
end
|
||||
|
||||
test "writes a cookie if remember_me is configured", %{conn: conn, user: user} do
|
||||
conn = conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
|
||||
assert get_session(conn, :user_token) == conn.cookies[@remember_me_cookie]
|
||||
assert get_session(conn, :user_remember_me) == true
|
||||
|
||||
assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie]
|
||||
assert signed_token != get_session(conn, :user_token)
|
||||
assert max_age == @remember_me_cookie_max_age
|
||||
end
|
||||
|
||||
test "redirects to settings when user is already logged in", %{conn: conn, user: user} do
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(user))
|
||||
|> UserAuth.log_in_user(user)
|
||||
|
||||
assert redirected_to(conn) == ~p"/users/settings"
|
||||
end
|
||||
|
||||
test "writes a cookie if remember_me was set in previous session", %{conn: conn, user: user} do
|
||||
conn = conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
|
||||
assert get_session(conn, :user_token) == conn.cookies[@remember_me_cookie]
|
||||
assert get_session(conn, :user_remember_me) == true
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> recycle()
|
||||
|> Map.replace!(:secret_key_base, ChesstrainerWeb.Endpoint.config(:secret_key_base))
|
||||
|> fetch_cookies()
|
||||
|> init_test_session(%{user_remember_me: true})
|
||||
|
||||
# the conn is already logged in and has the remember_me cookie set,
|
||||
# now we log in again and even without explicitly setting remember_me,
|
||||
# the cookie should be set again
|
||||
conn = conn |> UserAuth.log_in_user(user, %{})
|
||||
assert %{value: signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie]
|
||||
assert signed_token != get_session(conn, :user_token)
|
||||
assert max_age == @remember_me_cookie_max_age
|
||||
assert get_session(conn, :user_remember_me) == true
|
||||
end
|
||||
end
|
||||
|
||||
describe "logout_user/1" do
|
||||
test "erases session and cookies", %{conn: conn, user: user} do
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> put_session(:user_token, user_token)
|
||||
|> put_req_cookie(@remember_me_cookie, user_token)
|
||||
|> fetch_cookies()
|
||||
|> UserAuth.log_out_user()
|
||||
|
||||
refute get_session(conn, :user_token)
|
||||
refute conn.cookies[@remember_me_cookie]
|
||||
assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
refute Accounts.get_user_by_session_token(user_token)
|
||||
end
|
||||
|
||||
test "broadcasts to the given live_socket_id", %{conn: conn} do
|
||||
live_socket_id = "users_sessions:abcdef-token"
|
||||
ChesstrainerWeb.Endpoint.subscribe(live_socket_id)
|
||||
|
||||
conn
|
||||
|> put_session(:live_socket_id, live_socket_id)
|
||||
|> UserAuth.log_out_user()
|
||||
|
||||
assert_receive %Phoenix.Socket.Broadcast{event: "disconnect", topic: ^live_socket_id}
|
||||
end
|
||||
|
||||
test "works even if user is already logged out", %{conn: conn} do
|
||||
conn = conn |> fetch_cookies() |> UserAuth.log_out_user()
|
||||
refute get_session(conn, :user_token)
|
||||
assert %{max_age: 0} = conn.resp_cookies[@remember_me_cookie]
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
end
|
||||
end
|
||||
|
||||
describe "fetch_current_scope_for_user/2" do
|
||||
test "authenticates user from session", %{conn: conn, user: user} do
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
|
||||
conn =
|
||||
conn |> put_session(:user_token, user_token) |> UserAuth.fetch_current_scope_for_user([])
|
||||
|
||||
assert conn.assigns.current_scope.user.id == user.id
|
||||
assert conn.assigns.current_scope.user.authenticated_at == user.authenticated_at
|
||||
assert get_session(conn, :user_token) == user_token
|
||||
end
|
||||
|
||||
test "authenticates user from cookies", %{conn: conn, user: user} do
|
||||
logged_in_conn =
|
||||
conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
|
||||
|
||||
user_token = logged_in_conn.cookies[@remember_me_cookie]
|
||||
%{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie]
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> put_req_cookie(@remember_me_cookie, signed_token)
|
||||
|> UserAuth.fetch_current_scope_for_user([])
|
||||
|
||||
assert conn.assigns.current_scope.user.id == user.id
|
||||
assert conn.assigns.current_scope.user.authenticated_at == user.authenticated_at
|
||||
assert get_session(conn, :user_token) == user_token
|
||||
assert get_session(conn, :user_remember_me)
|
||||
|
||||
assert get_session(conn, :live_socket_id) ==
|
||||
"users_sessions:#{Base.url_encode64(user_token)}"
|
||||
end
|
||||
|
||||
test "does not authenticate if data is missing", %{conn: conn, user: user} do
|
||||
_ = Accounts.generate_user_session_token(user)
|
||||
conn = UserAuth.fetch_current_scope_for_user(conn, [])
|
||||
refute get_session(conn, :user_token)
|
||||
refute conn.assigns.current_scope
|
||||
end
|
||||
|
||||
test "reissues a new token after a few days and refreshes cookie", %{conn: conn, user: user} do
|
||||
logged_in_conn =
|
||||
conn |> fetch_cookies() |> UserAuth.log_in_user(user, %{"remember_me" => "true"})
|
||||
|
||||
token = logged_in_conn.cookies[@remember_me_cookie]
|
||||
%{value: signed_token} = logged_in_conn.resp_cookies[@remember_me_cookie]
|
||||
|
||||
offset_user_token(token, -10, :day)
|
||||
{user, _} = Accounts.get_user_by_session_token(token)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> put_session(:user_token, token)
|
||||
|> put_session(:user_remember_me, true)
|
||||
|> put_req_cookie(@remember_me_cookie, signed_token)
|
||||
|> UserAuth.fetch_current_scope_for_user([])
|
||||
|
||||
assert conn.assigns.current_scope.user.id == user.id
|
||||
assert conn.assigns.current_scope.user.authenticated_at == user.authenticated_at
|
||||
assert new_token = get_session(conn, :user_token)
|
||||
assert new_token != token
|
||||
assert %{value: new_signed_token, max_age: max_age} = conn.resp_cookies[@remember_me_cookie]
|
||||
assert new_signed_token != signed_token
|
||||
assert max_age == @remember_me_cookie_max_age
|
||||
end
|
||||
end
|
||||
|
||||
describe "on_mount :mount_current_scope" do
|
||||
setup %{conn: conn} do
|
||||
%{conn: UserAuth.fetch_current_scope_for_user(conn, [])}
|
||||
end
|
||||
|
||||
test "assigns current_scope based on a valid user_token", %{conn: conn, user: user} do
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
{:cont, updated_socket} =
|
||||
UserAuth.on_mount(:mount_current_scope, %{}, session, %LiveView.Socket{})
|
||||
|
||||
assert updated_socket.assigns.current_scope.user.id == user.id
|
||||
end
|
||||
|
||||
test "assigns nil to current_scope assign if there isn't a valid user_token", %{conn: conn} do
|
||||
user_token = "invalid_token"
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
{:cont, updated_socket} =
|
||||
UserAuth.on_mount(:mount_current_scope, %{}, session, %LiveView.Socket{})
|
||||
|
||||
assert updated_socket.assigns.current_scope == nil
|
||||
end
|
||||
|
||||
test "assigns nil to current_scope assign if there isn't a user_token", %{conn: conn} do
|
||||
session = conn |> get_session()
|
||||
|
||||
{:cont, updated_socket} =
|
||||
UserAuth.on_mount(:mount_current_scope, %{}, session, %LiveView.Socket{})
|
||||
|
||||
assert updated_socket.assigns.current_scope == nil
|
||||
end
|
||||
end
|
||||
|
||||
describe "on_mount :require_authenticated" do
|
||||
test "authenticates current_scope based on a valid user_token", %{conn: conn, user: user} do
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
{:cont, updated_socket} =
|
||||
UserAuth.on_mount(:require_authenticated, %{}, session, %LiveView.Socket{})
|
||||
|
||||
assert updated_socket.assigns.current_scope.user.id == user.id
|
||||
end
|
||||
|
||||
test "redirects to login page if there isn't a valid user_token", %{conn: conn} do
|
||||
user_token = "invalid_token"
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
socket = %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
}
|
||||
|
||||
{:halt, updated_socket} = UserAuth.on_mount(:require_authenticated, %{}, session, socket)
|
||||
assert updated_socket.assigns.current_scope == nil
|
||||
end
|
||||
|
||||
test "redirects to login page if there isn't a user_token", %{conn: conn} do
|
||||
session = conn |> get_session()
|
||||
|
||||
socket = %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
}
|
||||
|
||||
{:halt, updated_socket} = UserAuth.on_mount(:require_authenticated, %{}, session, socket)
|
||||
assert updated_socket.assigns.current_scope == nil
|
||||
end
|
||||
end
|
||||
|
||||
describe "on_mount :require_sudo_mode" do
|
||||
test "allows users that have authenticated in the last 10 minutes", %{conn: conn, user: user} do
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
socket = %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
}
|
||||
|
||||
assert {:cont, _updated_socket} =
|
||||
UserAuth.on_mount(:require_sudo_mode, %{}, session, socket)
|
||||
end
|
||||
|
||||
test "redirects when authentication is too old", %{conn: conn, user: user} do
|
||||
eleven_minutes_ago = DateTime.utc_now(:second) |> DateTime.add(-11, :minute)
|
||||
user = %{user | authenticated_at: eleven_minutes_ago}
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
{user, token_inserted_at} = Accounts.get_user_by_session_token(user_token)
|
||||
assert DateTime.compare(token_inserted_at, user.authenticated_at) == :gt
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
socket = %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
}
|
||||
|
||||
assert {:halt, _updated_socket} =
|
||||
UserAuth.on_mount(:require_sudo_mode, %{}, session, socket)
|
||||
end
|
||||
end
|
||||
|
||||
describe "require_authenticated_user/2" do
|
||||
setup %{conn: conn} do
|
||||
%{conn: UserAuth.fetch_current_scope_for_user(conn, [])}
|
||||
end
|
||||
|
||||
test "redirects if user is not authenticated", %{conn: conn} do
|
||||
conn = conn |> fetch_flash() |> UserAuth.require_authenticated_user([])
|
||||
assert conn.halted
|
||||
|
||||
assert redirected_to(conn) == ~p"/users/log-in"
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"You must log in to access this page."
|
||||
end
|
||||
|
||||
test "stores the path to redirect to on GET", %{conn: conn} do
|
||||
halted_conn =
|
||||
%{conn | path_info: ["foo"], query_string: ""}
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_authenticated_user([])
|
||||
|
||||
assert halted_conn.halted
|
||||
assert get_session(halted_conn, :user_return_to) == "/foo"
|
||||
|
||||
halted_conn =
|
||||
%{conn | path_info: ["foo"], query_string: "bar=baz"}
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_authenticated_user([])
|
||||
|
||||
assert halted_conn.halted
|
||||
assert get_session(halted_conn, :user_return_to) == "/foo?bar=baz"
|
||||
|
||||
halted_conn =
|
||||
%{conn | path_info: ["foo"], query_string: "bar", method: "POST"}
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_authenticated_user([])
|
||||
|
||||
assert halted_conn.halted
|
||||
refute get_session(halted_conn, :user_return_to)
|
||||
end
|
||||
|
||||
test "does not redirect if user is authenticated", %{conn: conn, user: user} do
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(user))
|
||||
|> UserAuth.require_authenticated_user([])
|
||||
|
||||
refute conn.halted
|
||||
refute conn.status
|
||||
end
|
||||
end
|
||||
|
||||
describe "on_mount :require_admin" do
|
||||
setup %{conn: conn} do
|
||||
%{conn: UserAuth.fetch_current_scope_for_user(conn, [])}
|
||||
end
|
||||
|
||||
test "admits an admin", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :admin)
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
assert {:cont, updated_socket} =
|
||||
UserAuth.on_mount(:require_admin, %{}, session, %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
})
|
||||
|
||||
assert updated_socket.assigns.current_scope.user.id == user.id
|
||||
end
|
||||
|
||||
test "admits a super admin", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :super_admin)
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
assert {:cont, updated_socket} =
|
||||
UserAuth.on_mount(:require_admin, %{}, session, %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
})
|
||||
|
||||
assert updated_socket.assigns.current_scope.user.id == user.id
|
||||
end
|
||||
|
||||
test "redirects a member home", %{conn: conn} do
|
||||
user = user_fixture()
|
||||
user_token = Accounts.generate_user_session_token(user)
|
||||
session = conn |> put_session(:user_token, user_token) |> get_session()
|
||||
|
||||
assert {:halt, updated_socket} =
|
||||
UserAuth.on_mount(:require_admin, %{}, session, %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
})
|
||||
|
||||
assert {:redirect, %{to: "/"}} = updated_socket.redirected
|
||||
end
|
||||
|
||||
test "redirects an unauthenticated visitor to log in", %{conn: conn} do
|
||||
session = conn |> get_session()
|
||||
|
||||
assert {:halt, updated_socket} =
|
||||
UserAuth.on_mount(:require_admin, %{}, session, %LiveView.Socket{
|
||||
endpoint: ChesstrainerWeb.Endpoint,
|
||||
assigns: %{__changed__: %{}, flash: %{}}
|
||||
})
|
||||
|
||||
assert {:redirect, %{to: "/users/log-in"}} = updated_socket.redirected
|
||||
end
|
||||
end
|
||||
|
||||
describe "require_admin_user/2" do
|
||||
setup %{conn: conn} do
|
||||
%{conn: UserAuth.fetch_current_scope_for_user(conn, [])}
|
||||
end
|
||||
|
||||
test "does not halt an admin", %{conn: conn} do
|
||||
{:ok, user} = Accounts.update_user_role(user_fixture(), :admin)
|
||||
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(user))
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_admin_user([])
|
||||
|
||||
refute conn.halted
|
||||
refute conn.status
|
||||
end
|
||||
|
||||
test "halts a member and redirects home", %{conn: conn} do
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, Scope.for_user(user_fixture()))
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_admin_user([])
|
||||
|
||||
assert conn.halted
|
||||
assert redirected_to(conn) == ~p"/"
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"You are not authorized to access this page."
|
||||
end
|
||||
|
||||
test "redirects an unauthenticated visitor to log in", %{conn: conn} do
|
||||
conn =
|
||||
conn
|
||||
|> assign(:current_scope, nil)
|
||||
|> fetch_flash()
|
||||
|> UserAuth.require_admin_user([])
|
||||
|
||||
assert conn.halted
|
||||
assert redirected_to(conn) == ~p"/users/log-in"
|
||||
|
||||
assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
|
||||
"You must log in to access this page."
|
||||
end
|
||||
end
|
||||
|
||||
describe "disconnect_sessions/1" do
|
||||
test "broadcasts disconnect messages for each token" do
|
||||
tokens = [%{token: "token1"}, %{token: "token2"}]
|
||||
|
||||
for %{token: token} <- tokens do
|
||||
ChesstrainerWeb.Endpoint.subscribe("users_sessions:#{Base.url_encode64(token)}")
|
||||
end
|
||||
|
||||
UserAuth.disconnect_sessions(tokens)
|
||||
|
||||
assert_receive %Phoenix.Socket.Broadcast{
|
||||
event: "disconnect",
|
||||
topic: "users_sessions:dG9rZW4x"
|
||||
}
|
||||
|
||||
assert_receive %Phoenix.Socket.Broadcast{
|
||||
event: "disconnect",
|
||||
topic: "users_sessions:dG9rZW4y"
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -0,0 +1,46 @@
|
||||
defmodule Mix.Tasks.Accounts.PromoteTest do
|
||||
use Chesstrainer.DataCase
|
||||
|
||||
import Chesstrainer.AccountsFixtures
|
||||
import ExUnit.CaptureIO
|
||||
|
||||
alias Chesstrainer.Accounts
|
||||
|
||||
test "promotes a user by username" do
|
||||
user = user_fixture()
|
||||
|
||||
output =
|
||||
capture_io(fn -> Mix.Tasks.Accounts.Promote.run([user.username, "admin"]) end)
|
||||
|
||||
assert output =~ "role to admin"
|
||||
assert Accounts.get_user!(user.id).role == :admin
|
||||
end
|
||||
|
||||
test "promotes a user by email" do
|
||||
user = user_fixture()
|
||||
|
||||
capture_io(fn -> Mix.Tasks.Accounts.Promote.run([user.email, "super_admin"]) end)
|
||||
|
||||
assert Accounts.get_user!(user.id).role == :super_admin
|
||||
end
|
||||
|
||||
test "raises for an unknown role" do
|
||||
user = user_fixture()
|
||||
|
||||
assert_raise Mix.Error, ~r/Unknown role/, fn ->
|
||||
Mix.Tasks.Accounts.Promote.run([user.username, "wizard"])
|
||||
end
|
||||
end
|
||||
|
||||
test "raises when the user does not exist" do
|
||||
assert_raise Mix.Error, ~r/No user found/, fn ->
|
||||
Mix.Tasks.Accounts.Promote.run(["nobody@example.com", "admin"])
|
||||
end
|
||||
end
|
||||
|
||||
test "raises without the expected arguments" do
|
||||
assert_raise Mix.Error, ~r/Usage/, fn ->
|
||||
Mix.Tasks.Accounts.Promote.run([])
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -35,4 +35,69 @@ defmodule ChesstrainerWeb.ConnCase do
|
||||
Chesstrainer.DataCase.setup_sandbox(tags)
|
||||
{:ok, conn: Phoenix.ConnTest.build_conn()}
|
||||
end
|
||||
|
||||
@doc """
|
||||
Setup helper that registers and logs in users.
|
||||
|
||||
setup :register_and_log_in_user
|
||||
|
||||
It stores an updated connection and a registered user in the
|
||||
test context.
|
||||
"""
|
||||
def register_and_log_in_user(%{conn: conn} = context) do
|
||||
user = Chesstrainer.AccountsFixtures.user_fixture()
|
||||
scope = Chesstrainer.Accounts.Scope.for_user(user)
|
||||
|
||||
opts =
|
||||
context
|
||||
|> Map.take([:token_authenticated_at])
|
||||
|> Enum.into([])
|
||||
|
||||
%{conn: log_in_user(conn, user, opts), user: user, scope: scope}
|
||||
end
|
||||
|
||||
@doc """
|
||||
Setup helper that registers and logs in an admin user.
|
||||
|
||||
setup :register_and_log_in_admin
|
||||
|
||||
It stores an updated connection and an admin user in the test context.
|
||||
"""
|
||||
def register_and_log_in_admin(%{conn: conn} = context) do
|
||||
{:ok, user} =
|
||||
Chesstrainer.Accounts.update_user_role(
|
||||
Chesstrainer.AccountsFixtures.user_fixture(),
|
||||
:admin
|
||||
)
|
||||
|
||||
scope = Chesstrainer.Accounts.Scope.for_user(user)
|
||||
|
||||
opts =
|
||||
context
|
||||
|> Map.take([:token_authenticated_at])
|
||||
|> Enum.into([])
|
||||
|
||||
%{conn: log_in_user(conn, user, opts), user: user, scope: scope}
|
||||
end
|
||||
|
||||
@doc """
|
||||
Logs the given `user` into the `conn`.
|
||||
|
||||
It returns an updated `conn`.
|
||||
"""
|
||||
def log_in_user(conn, user, opts \\ []) do
|
||||
token = Chesstrainer.Accounts.generate_user_session_token(user)
|
||||
|
||||
maybe_set_token_authenticated_at(token, opts[:token_authenticated_at])
|
||||
|
||||
conn
|
||||
|> Phoenix.ConnTest.init_test_session(%{})
|
||||
|> Plug.Conn.put_session(:user_token, token)
|
||||
end
|
||||
|
||||
defp maybe_set_token_authenticated_at(_token, nil), do: nil
|
||||
|
||||
defp maybe_set_token_authenticated_at(token, authenticated_at) do
|
||||
Chesstrainer.AccountsFixtures.override_token_authenticated_at(token, authenticated_at)
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
defmodule Chesstrainer.AccountsFixtures do
|
||||
@moduledoc """
|
||||
This module defines test helpers for creating
|
||||
entities via the `Chesstrainer.Accounts` context.
|
||||
"""
|
||||
|
||||
import Ecto.Query
|
||||
|
||||
alias Chesstrainer.Accounts
|
||||
alias Chesstrainer.Accounts.Scope
|
||||
|
||||
def unique_user_email, do: "user#{System.unique_integer()}@example.com"
|
||||
def unique_username, do: "user#{System.unique_integer([:positive])}"
|
||||
def valid_user_password, do: "hello world!"
|
||||
|
||||
def valid_user_attributes(attrs \\ %{}) do
|
||||
Enum.into(attrs, %{
|
||||
email: unique_user_email(),
|
||||
username: unique_username(),
|
||||
password: valid_user_password()
|
||||
})
|
||||
end
|
||||
|
||||
def user_fixture(attrs \\ %{}) do
|
||||
{:ok, user} =
|
||||
attrs
|
||||
|> valid_user_attributes()
|
||||
|> Accounts.register_user()
|
||||
|
||||
user
|
||||
end
|
||||
|
||||
def user_scope_fixture do
|
||||
user = user_fixture()
|
||||
user_scope_fixture(user)
|
||||
end
|
||||
|
||||
def user_scope_fixture(user) do
|
||||
Scope.for_user(user)
|
||||
end
|
||||
|
||||
def set_password(user) do
|
||||
{:ok, {user, _expired_tokens}} =
|
||||
Accounts.update_user_password(user, %{password: valid_user_password()})
|
||||
|
||||
user
|
||||
end
|
||||
|
||||
def extract_user_token(fun) do
|
||||
{:ok, captured_email} = fun.(&"[TOKEN]#{&1}[TOKEN]")
|
||||
[_, token | _] = String.split(captured_email.text_body, "[TOKEN]")
|
||||
token
|
||||
end
|
||||
|
||||
def override_token_authenticated_at(token, authenticated_at) when is_binary(token) do
|
||||
Chesstrainer.Repo.update_all(
|
||||
from(t in Accounts.UserToken,
|
||||
where: t.token == ^token
|
||||
),
|
||||
set: [authenticated_at: authenticated_at]
|
||||
)
|
||||
end
|
||||
|
||||
def offset_user_token(token, amount_to_add, unit) do
|
||||
dt = DateTime.add(DateTime.utc_now(:second), amount_to_add, unit)
|
||||
|
||||
Chesstrainer.Repo.update_all(
|
||||
from(ut in Accounts.UserToken, where: ut.token == ^token),
|
||||
set: [inserted_at: dt, authenticated_at: dt]
|
||||
)
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user