"
@@ -24,7 +24,7 @@ defmodule Pow.Phoenix.HTML.FormTemplateTest do
html = FormTemplate.render([
{:text, {:changeset, :pow_user_id_field}},
{:password, :password},
- {:password, :confirm_password}
+ {:password, :password_confirmation}
], bootstrap: true)
assert html =~ "
"
diff --git a/test/pow/phoenix/mailer_test.exs b/test/pow/phoenix/mailer_test.exs
index 9078f9c0..8410eddf 100644
--- a/test/pow/phoenix/mailer_test.exs
+++ b/test/pow/phoenix/mailer_test.exs
@@ -19,7 +19,7 @@ defmodule Pow.Phoenix.MailerTest do
|> Plug.Conn.put_private(:pow_config, [])
|> Mailer.Mail.new(%{email: "test@example.com"}, {MailerView, :mail_test}, value: "test")
- {:ok, conn: conn, email: email}
+ {:ok, email: email}
end
test "deliver/2", %{conn: conn, email: email} do
diff --git a/test/pow/phoenix/views/view_helpers_test.exs b/test/pow/phoenix/views/view_helpers_test.exs
index 82419278..88bbc717 100644
--- a/test/pow/phoenix/views/view_helpers_test.exs
+++ b/test/pow/phoenix/views/view_helpers_test.exs
@@ -26,7 +26,7 @@ defmodule Pow.Phoenix.ViewHelpersTest do
|> Conn.assign(:changeset, User.changeset(%User{}, %{}))
|> Conn.assign(:action, "/")
- {:ok, %{conn: conn}}
+ {:ok, conn: conn}
end
test "layout/1", %{conn: conn} do
diff --git a/test/pow/plug/require_authenticated_test.exs b/test/pow/plug/require_authenticated_test.exs
index 4f645102..40dae82c 100644
--- a/test/pow/plug/require_authenticated_test.exs
+++ b/test/pow/plug/require_authenticated_test.exs
@@ -2,14 +2,13 @@ defmodule Pow.Plug.RequireAuthenticatedTest do
use ExUnit.Case
doctest Pow.Plug.RequireAuthenticated
- alias Plug.Conn
+ alias Plug.{Conn, Test}
alias Pow.{Config.ConfigError, Plug, Plug.RequireAuthenticated}
- alias Pow.Test.ConnHelpers
setup do
conn =
:get
- |> ConnHelpers.conn("/")
+ |> Test.conn("/")
|> Plug.put_config(current_user_assigns_key: :current_user)
{:ok, %{conn: conn}}
diff --git a/test/pow/plug/require_not_authenticated_test.exs b/test/pow/plug/require_not_authenticated_test.exs
index fb8dfdf1..50852abb 100644
--- a/test/pow/plug/require_not_authenticated_test.exs
+++ b/test/pow/plug/require_not_authenticated_test.exs
@@ -2,14 +2,13 @@ defmodule Pow.Plug.RequireNotAuthenticatedTest do
use ExUnit.Case
doctest Pow.Plug.RequireNotAuthenticated
- alias Plug.Conn
+ alias Plug.{Conn, Test}
alias Pow.{Config.ConfigError, Plug, Plug.RequireNotAuthenticated}
- alias Pow.Test.ConnHelpers
setup do
conn =
:get
- |> ConnHelpers.conn("/")
+ |> Test.conn("/")
|> Plug.put_config(current_user_assigns_key: :current_user)
{:ok, %{conn: conn}}
diff --git a/test/pow/plug/session_test.exs b/test/pow/plug/session_test.exs
index 6129fbc3..d0b89cea 100644
--- a/test/pow/plug/session_test.exs
+++ b/test/pow/plug/session_test.exs
@@ -2,14 +2,16 @@ defmodule Pow.Plug.SessionTest do
use ExUnit.Case
doctest Pow.Plug.Session
- alias Plug.Conn
+ alias Plug.{Conn, ProcessStore, Test}
+ alias Plug.Session, as: PlugSession
alias Pow.{Plug, Plug.Session, Store.Backend.EtsCache, Store.CredentialsCache}
- alias Pow.Test.{ConnHelpers, Ecto.Users.User, EtsCacheMock}
+ alias Pow.Test.{Ecto.Users.User, EtsCacheMock, MessageVerifier}
@default_opts [
current_user_assigns_key: :current_user,
session_key: "auth",
- cache_store_backend: EtsCacheMock
+ cache_store_backend: EtsCacheMock,
+ message_verifier: MessageVerifier
]
@store_config [backend: EtsCacheMock]
@user %User{id: 1}
@@ -17,17 +19,13 @@ defmodule Pow.Plug.SessionTest do
setup do
EtsCacheMock.init()
- conn =
- :get
- |> ConnHelpers.conn("/")
- |> ConnHelpers.init_session()
+ conn = conn_with_plug_session()
- {:ok, %{conn: conn}}
+ {:ok, conn: conn}
end
test "call/2 sets plug in :pow_config", %{conn: conn} do
- opts = Session.init(@default_opts)
- conn = Session.call(conn, opts)
+ conn = run_plug(conn)
expected_config = [mod: Session, plug: Session] ++ @default_opts
assert is_nil(conn.assigns[:current_user])
@@ -35,24 +33,21 @@ defmodule Pow.Plug.SessionTest do
end
test "call/2 with assigned current_user", %{conn: conn} do
- opts = Session.init(@default_opts)
conn =
conn
|> Plug.assign_current_user("assigned", @default_opts)
- |> Session.call(opts)
+ |> run_plug()
assert conn.assigns[:current_user] == "assigned"
end
test "call/2 with stored current_user", %{conn: conn} do
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: :os.system_time(:millisecond), fingerprint: "fingerprint"})
-
- opts = Session.init(@default_opts)
- conn =
+ session_id = store_in_cache("token", {@user, inserted_at: :os.system_time(:millisecond), fingerprint: "fingerprint"})
+ conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session(@default_opts[:session_key], "token")
- |> Session.call(opts)
+ |> Conn.put_session(@default_opts[:session_key], session_id)
+ |> run_plug()
assert conn.assigns[:current_user] == @user
assert conn.private[:pow_session_metadata][:fingerprint] == "fingerprint"
@@ -60,15 +55,14 @@ defmodule Pow.Plug.SessionTest do
test "call/2 with stored session and custom metadata", %{conn: conn} do
inserted_at = :os.system_time(:millisecond)
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: inserted_at, a: 1})
+ session_id = store_in_cache("token", {@user, inserted_at: inserted_at, a: 1})
- opts = Session.init(@default_opts)
conn =
conn
|> Conn.put_private(:pow_session_metadata, b: 2)
|> Conn.fetch_session()
- |> Conn.put_session(@default_opts[:session_key], "token")
- |> Session.call(opts)
+ |> Conn.put_session(@default_opts[:session_key], session_id)
+ |> run_plug()
assert conn.assigns[:current_user] == @user
assert conn.private[:pow_session_metadata][:inserted_at] == inserted_at
@@ -76,63 +70,162 @@ defmodule Pow.Plug.SessionTest do
end
test "call/2 with non existing cached key", %{conn: conn} do
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: :os.system_time(:millisecond)})
+ _session_id = store_in_cache("token", {@user, inserted_at: :os.system_time(:millisecond)})
+ invalid_id = sign_token("invalid")
- opts = Session.init(@default_opts)
conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session(@default_opts[:session_key], "invalid")
- |> Session.call(opts)
+ |> Conn.put_session(@default_opts[:session_key], invalid_id)
+ |> run_plug()
assert is_nil(conn.assigns[:current_user])
end
+ test "call/2 with unsigned session id", %{conn: conn} do
+ session_id = "token"
+ store_in_cache(session_id, {@user, inserted_at: :os.system_time(:millisecond), fingerprint: "fingerprint"})
+ conn =
+ conn
+ |> Conn.fetch_session()
+ |> Conn.put_session(@default_opts[:session_key], session_id)
+ |> run_plug()
+
+ assert is_nil(conn.assigns[:current_user])
+ assert {@user, _metadata} = CredentialsCache.get(@store_config, session_id)
+ end
+
test "call/2 creates new session when :session_renewal_ttl reached", %{conn: conn} do
ttl = 100
config = Keyword.put(@default_opts, :session_ttl_renewal, ttl)
timestamp = :os.system_time(:millisecond)
stale_timestamp = timestamp - ttl - 1
+ session_id = store_in_cache("token", {@user, inserted_at: timestamp, fingerprint: "fingerprint"})
init_conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session(config[:session_key], "token")
-
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: timestamp, fingerprint: "fingerprint"})
+ |> Conn.put_session(config[:session_key], session_id)
- opts = Session.init(config)
- conn = Session.call(init_conn, opts)
- session_id = get_session_id(conn)
+ conn = run_plug(init_conn, config)
+ assert session_id = get_session_id(conn)
assert conn.assigns[:current_user] == @user
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: stale_timestamp, fingerprint: "fingerprint"})
- CredentialsCache.put(@store_config, "newer_token", {@user, inserted_at: timestamp, fingerprint: "new_fingerprint"})
+ store_in_cache("token", {@user, inserted_at: stale_timestamp, fingerprint: "fingerprint"})
+ store_in_cache("newer_token", {@user, inserted_at: timestamp, fingerprint: "new_fingerprint"})
- conn = Session.call(init_conn, opts)
+ conn = run_plug(init_conn, config)
assert conn.assigns[:current_user] == @user
assert new_session_id = get_session_id(conn)
assert new_session_id != session_id
- assert {_user, metadata} = CredentialsCache.get(@store_config, new_session_id)
+ assert {_user, metadata} = get_from_cache(new_session_id)
assert metadata[:inserted_at] != stale_timestamp
assert metadata[:fingerprint] == "fingerprint"
assert conn.private[:pow_session_metadata][:fingerprint] == "fingerprint"
end
+ defmodule CredentialsCacheWaitDelete do
+ alias Pow.Store.CredentialsCache
+
+ @timeout :timer.seconds(5)
+
+ defdelegate put(config, session_id, record_or_records), to: CredentialsCache
+
+ defdelegate get(config, session_id), to: CredentialsCache
+
+ def delete(config, session_id)do
+ send(self(), {__MODULE__, :wait})
+
+ receive do
+ {__MODULE__, :commit} -> :ok
+ after
+ @timeout -> raise "Timeout reached"
+ end
+
+ CredentialsCache.delete(config, session_id)
+ end
+ end
+
+ test "call/2 creates new session when :session_renewal_ttl reached and doesn't delete with simultanous request", %{conn: conn} do
+ :ets.delete(EtsCacheMock)
+ :ets.new(EtsCacheMock, [:ordered_set, :public, :named_table])
+
+ ttl = 100
+ config = Keyword.merge(@default_opts, session_ttl_renewal: ttl, credentials_cache_store: {CredentialsCacheWaitDelete, [ttl: :timer.minutes(30), namespace: "credentials"]})
+ stale_timestamp = :os.system_time(:millisecond) - ttl - 1
+ session_id = store_in_cache("token", {@user, inserted_at: stale_timestamp})
+
+ conn =
+ conn
+ |> Conn.fetch_session()
+ |> Conn.put_session(config[:session_key], session_id)
+ |> Conn.send_resp(200, "")
+ |> recycle_session_conn()
+
+ sid = Conn.fetch_cookies(conn).cookies["foobar"]
+ session_data = Process.get({:session, sid})
+
+ CredentialsCache.put(@store_config, session_id, {@user, inserted_at: stale_timestamp})
+
+ task_1 =
+ fn ->
+ Process.put({:session, sid}, session_data)
+ run_plug(conn, config)
+ end
+ |> Task.async()
+ |> wait_till_ready()
+
+ conn_2 =
+ fn ->
+ Process.put({:session, sid}, session_data)
+ run_plug(conn, config)
+ end
+ |> Task.async()
+ |> continue_work()
+ |> Task.await()
+
+ conn_1 =
+ task_1
+ |> continue_work()
+ |> Task.await()
+
+ assert Plug.current_user(conn_1) == @user
+ assert conn_1.resp_cookies["foobar"]
+ refute get_session_id(conn_1) == session_id
+ assert {@user, _metadata} = get_from_cache(get_session_id(conn_1))
+
+ assert Plug.current_user(conn_2) == @user
+ refute conn_2.resp_cookies["foobar"]
+ assert get_session_id(conn_2) == session_id
+ assert get_from_cache(get_session_id(conn_2)) == :not_found
+ end
+
+ defp wait_till_ready(%{pid: tracking_pid} = task) do
+ :erlang.trace(tracking_pid, true, [:receive])
+ assert_receive {:trace, ^tracking_pid, :receive, {CredentialsCacheWaitDelete, :wait}}
+
+ task
+ end
+
+ defp continue_work(%{pid: tracking_pid} = task) do
+ send(tracking_pid, {CredentialsCacheWaitDelete, :commit})
+
+ task
+ end
+
test "call/2 with prepended `:otp_app` session key", %{conn: conn} do
- CredentialsCache.put(@store_config, "token", {@user, inserted_at: :os.system_time(:millisecond)})
+ id = store_in_cache("token", {@user, inserted_at: :os.system_time(:millisecond)})
- opts =
+ config =
@default_opts
|> Keyword.delete(:session_key)
|> Keyword.put(:otp_app, :test_app)
- |> Session.init()
conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session("test_app_auth", "token")
- |> Session.call(opts)
+ |> Conn.put_session("test_app_auth", id)
+ |> run_plug(config)
assert conn.assigns[:current_user] == @user
end
@@ -142,59 +235,79 @@ defmodule Pow.Plug.SessionTest do
ttl = 100
config = Keyword.put(@default_opts, :session_ttl_renewal, ttl)
stale_timestamp = :os.system_time(:millisecond) - ttl - 1
+ session_id = sign_token("token")
@store_config
|> Keyword.put(:namespace, "credentials")
|> EtsCacheMock.put({"token", {@user, stale_timestamp}})
- opts = Session.init(config)
conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session(config[:session_key], "token")
- |> Session.call(opts)
+ |> Conn.put_session(config[:session_key], session_id)
+ |> run_plug(config)
assert new_session_id = get_session_id(conn)
- assert new_session_id != "token"
+ assert new_session_id != session_id
assert conn.assigns[:current_user] == @user
end
describe "create/2" do
- test "creates new session id", %{conn: conn} do
- opts = Session.init(@default_opts)
+ test "deletes existing and creates new session id", %{conn: new_conn} do
conn =
- conn
- |> Session.call(opts)
- |> Session.do_create(@user, opts)
-
- session_id = get_session_id(conn)
+ new_conn
+ |> init_plug()
+ |> run_do_create(@user)
- assert {@user, metadata} = CredentialsCache.get(@store_config, session_id)
+ assert session_id = get_session_id(conn)
+ assert {@user, metadata} = get_from_cache(session_id)
assert is_binary(session_id)
assert Plug.current_user(conn) == @user
assert metadata[:inserted_at]
assert metadata[:fingerprint]
- conn = Session.do_create(conn, @user, opts)
- new_session_id = get_session_id(conn)
+ conn =
+ conn
+ |> recycle_session_conn()
+ |> init_plug()
+ |> run_do_create(@user)
- assert {@user, new_metadata} = CredentialsCache.get(@store_config, new_session_id)
+ assert new_session_id = get_session_id(conn)
+ assert {@user, new_metadata} = get_from_cache(new_session_id)
assert is_binary(session_id)
assert new_session_id != session_id
- assert CredentialsCache.get(@store_config, session_id) == :not_found
+ assert get_from_cache(session_id) == :not_found
assert Plug.current_user(conn) == @user
assert metadata[:fingerprint] == new_metadata[:fingerprint]
end
+ test "renews plug session", %{conn: new_conn} do
+ conn =
+ new_conn
+ |> init_plug()
+ |> run_do_create(@user)
+
+ assert %{"foobar" => %{value: plug_session_id}} = conn.resp_cookies
+
+ conn =
+ conn
+ |> recycle_session_conn()
+ |> init_plug()
+ |> run_do_create(@user)
+
+ assert %{"foobar" => %{value: new_plug_session_id}} = conn.resp_cookies
+
+ refute plug_session_id == new_plug_session_id
+ end
+
test "creates with custom metadata", %{conn: conn} do
inserted_at = :os.system_time(:millisecond) - 10
- opts = Session.init(@default_opts)
conn =
conn
|> Conn.put_private(:pow_session_metadata, inserted_at: inserted_at, a: 1)
- |> Session.call(opts)
- |> Session.do_create(@user, opts)
+ |> init_plug()
+ |> run_do_create(@user)
assert conn.assigns[:current_user] == @user
assert conn.private[:pow_session_metadata][:inserted_at] != inserted_at
@@ -203,41 +316,54 @@ defmodule Pow.Plug.SessionTest do
end
test "creates new session id with `:otp_app` prepended", %{conn: conn} do
- opts =
+ config =
@default_opts
|> Keyword.delete(:session_key)
|> Keyword.put(:otp_app, :test_app)
- |> Session.init()
conn =
conn
- |> Session.call(opts)
- |> Session.do_create(@user, opts)
+ |> init_plug(config)
+ |> run_do_create(@user)
refute get_session_id(conn)
session_id = conn.private[:plug_session]["test_app_auth"]
- assert String.starts_with?(session_id, "test_app_")
+ assert {:ok, decoded_session_id} = Plug.verify_token(conn, Atom.to_string(Session), session_id)
+ assert String.starts_with?(decoded_session_id, "test_app_")
end
end
- test "delete/1 removes session id", %{conn: conn} do
- opts = Session.init(@default_opts)
+ test "delete/2 removes session id", %{conn: new_conn} do
conn =
- conn
- |> Session.call(opts)
- |> Session.do_create(@user, opts)
+ new_conn
+ |> init_plug()
+ |> run_do_create(@user)
- session_id = get_session_id(conn)
-
- assert {@user, _metadata} = CredentialsCache.get(@store_config, session_id)
+ assert session_id = get_session_id(conn)
+ assert {@user, _metadata} = get_from_cache(session_id)
assert is_binary(session_id)
assert Plug.current_user(conn) == @user
- conn = Session.do_delete(conn, opts)
+ conn =
+ conn
+ |> recycle_session_conn()
+ |> init_plug()
+ |> run_do_delete()
refute new_session_id = get_session_id(conn)
assert is_nil(new_session_id)
- assert CredentialsCache.get(@store_config, session_id) == :not_found
+ assert get_from_cache(session_id) == :not_found
+ assert is_nil(Plug.current_user(conn))
+ end
+
+ test "delete/2 deletes when call create in sequence", %{conn: conn} do
+ conn =
+ conn
+ |> init_plug(@default_opts)
+ |> Session.do_create(@user, @default_opts)
+ |> run_do_delete()
+
+ refute get_session_id(conn)
assert is_nil(Plug.current_user(conn))
end
@@ -249,26 +375,79 @@ defmodule Pow.Plug.SessionTest do
end
test "call/2", %{conn: conn} do
- sesion_key = "auth"
- config = [session_key: sesion_key]
- token = "credentials_cache_test"
timestamp = :os.system_time(:millisecond)
- CredentialsCache.put(config, token, {@user, inserted_at: timestamp})
+ session_id = store_in_cache("credentials_cache_test", {@user, inserted_at: timestamp}, [])
:timer.sleep(100)
- opts = Session.init(session_key: "auth")
conn =
conn
|> Conn.fetch_session()
- |> Conn.put_session("auth", token)
- |> Session.call(opts)
+ |> Conn.put_session("auth", session_id)
+ |> run_plug(session_key: "auth", message_verifier: MessageVerifier)
assert conn.assigns[:current_user] == @user
end
end
+ defp conn_with_plug_session(conn \\ nil) do
+ conn
+ |> Kernel.||(Test.conn(:get, "/"))
+ |> PlugSession.call(PlugSession.init(store: ProcessStore, key: "foobar"))
+ end
+
+ defp recycle_session_conn(old_conn) do
+ :get
+ |> Test.conn("/")
+ |> Test.recycle_cookies(old_conn)
+ |> conn_with_plug_session()
+ end
+
+ defp init_plug(conn, config \\ @default_opts) do
+ opts = Session.init(config)
+
+ Session.call(conn, opts)
+ end
+
+ defp run_plug(conn, config \\ @default_opts) do
+ conn
+ |> init_plug(config)
+ |> Conn.send_resp(200, "")
+ end
+
def get_session_id(conn) do
conn.private[:plug_session][@default_opts[:session_key]]
end
+
+ defp run_do_create(conn, user) do
+ config = Plug.fetch_config(conn)
+
+ conn
+ |> Session.do_create(user, config)
+ |> Conn.send_resp(200, "")
+ end
+
+ defp run_do_delete(conn) do
+ config = Plug.fetch_config(conn)
+
+ conn
+ |> Session.do_delete(config)
+ |> Conn.send_resp(200, "")
+ end
+
+ defp store_in_cache(token, value, store_config \\ @store_config) do
+ CredentialsCache.put(store_config, token, value)
+
+ sign_token(token)
+ end
+
+ defp sign_token(token) do
+ Plug.sign_token(%Conn{}, Atom.to_string(Session), token, @default_opts)
+ end
+
+ defp get_from_cache(token) do
+ assert {:ok, token} = Plug.verify_token(%Conn{}, Atom.to_string(Session), token, @default_opts)
+
+ CredentialsCache.get(@store_config, token)
+ end
end
diff --git a/test/pow/plug_test.exs b/test/pow/plug_test.exs
index 92f42692..06b81f09 100644
--- a/test/pow/plug_test.exs
+++ b/test/pow/plug_test.exs
@@ -2,15 +2,17 @@ defmodule Pow.PlugTest do
use ExUnit.Case
doctest Pow.Plug
- alias Plug.Conn
+ alias Plug.{Conn, ProcessStore, Test}
+ alias Plug.Session, as: PlugSession
alias Pow.{Config, Config.ConfigError, Plug, Plug.Session}
- alias Pow.Test.{ConnHelpers, ContextMock, Ecto.Users.User, EtsCacheMock}
+ alias Pow.Test.{ContextMock, Ecto.Users.User, EtsCacheMock, MessageVerifier}
@default_config [
current_user_assigns_key: :current_user,
users_context: ContextMock,
cache_store_backend: EtsCacheMock,
- user: User
+ user: User,
+ message_verifier: MessageVerifier
]
@admin_config Config.put(@default_config, :current_user_assigns_key, :current_admin_user)
@@ -48,19 +50,15 @@ defmodule Pow.PlugTest do
test "authenticate_user/2" do
EtsCacheMock.init()
- opts = Session.init(@default_config)
- conn =
- conn()
- |> ConnHelpers.init_session()
- |> Session.call(opts)
+ conn = conn_with_session_plug()
- refute conn.private[:plug_session]["auth"]
+ refute fetch_session_id(conn)
refute Plug.current_user(conn)
assert {:ok, loaded_conn} = Plug.authenticate_user(conn, %{"email" => "test@example.com", "password" => "secret"})
assert user = Plug.current_user(loaded_conn)
assert user.id == 1
- assert loaded_conn.private[:plug_session]["auth"]
+ assert fetch_session_id(loaded_conn)
assert {:error, conn} = Plug.authenticate_user(conn, %{})
refute Plug.current_user(conn)
@@ -87,27 +85,6 @@ defmodule Pow.PlugTest do
end
end
- test "clear_authenticated_user/1" do
- EtsCacheMock.init()
-
- opts = Session.init(@default_config)
- conn =
- conn()
- |> ConnHelpers.init_session()
- |> Session.call(opts)
-
- assert {:ok, conn} = Plug.authenticate_user(conn, %{"email" => "test@example.com", "password" => "secret"})
- assert user = Plug.current_user(conn)
- assert session_id = conn.private[:plug_session]["auth"]
- assert {key, _metadata} = EtsCacheMock.get([namespace: "credentials"], session_id)
- assert EtsCacheMock.get([namespace: "credentials"], key) == user
-
- {:ok, conn} = Plug.clear_authenticated_user(conn)
- refute Plug.current_user(conn)
- refute conn.private[:plug_session]["auth"]
- assert EtsCacheMock.get([namespace: "credentials"], session_id) == :not_found
- end
-
test "change_user/2" do
conn = conn()
assert %Ecto.Changeset{} = Plug.change_user(conn)
@@ -120,63 +97,87 @@ defmodule Pow.PlugTest do
test "create_user/2" do
EtsCacheMock.init()
- opts = Session.init(@default_config)
- conn =
- conn()
- |> ConnHelpers.init_session()
- |> Session.call(opts)
+ conn = conn_with_session_plug()
assert {:error, _changeset, conn} = Plug.create_user(conn, %{})
refute Plug.current_user(conn)
- refute conn.private[:plug_session]["auth"]
+ refute fetch_session_id(conn)
assert {:ok, user, conn} = Plug.create_user(conn, %{"email" => "test@example.com", "password" => "secret"})
assert Plug.current_user(conn) == user
- assert conn.private[:plug_session]["auth"]
+ assert fetch_session_id(conn)
end
test "update_user/2" do
EtsCacheMock.init()
- opts = Session.init(@default_config)
- conn =
- conn()
- |> ConnHelpers.init_session()
- |> Session.call(opts)
-
- {:ok, conn} = Plug.authenticate_user(conn, %{"email" => "test@example.com", "password" => "secret"})
- user = Plug.current_user(conn)
- session_id = conn.private[:plug_session]["auth"]
+ conn = auth_user_conn()
+ assert user = Plug.current_user(conn)
+ assert session_id = fetch_session_id(conn)
assert {:error, _changeset, conn} = Plug.update_user(conn, %{})
assert Plug.current_user(conn) == user
- assert conn.private[:plug_session]["auth"] == session_id
+ assert fetch_session_id(conn) == session_id
assert {:ok, updated_user, conn} = Plug.update_user(conn, %{"email" => "test@example.com", "password" => "secret"})
assert updated_user.id == :updated
assert Plug.current_user(conn) == updated_user
refute updated_user == user
- refute conn.private[:plug_session]["auth"] == session_id
+ refute fetch_session_id(conn) == session_id
end
test "delete_user/2" do
EtsCacheMock.init()
- opts = Session.init(@default_config)
- conn =
- conn()
- |> ConnHelpers.init_session()
- |> Session.call(opts)
-
- {:ok, conn} = Plug.authenticate_user(conn, %{"email" => "test@example.com", "password" => "secret"})
+ conn = auth_user_conn()
assert {:ok, user, conn} = Plug.delete_user(conn)
assert user.id == :deleted
refute Plug.current_user(conn)
- refute conn.private[:plug_session]["auth"]
+ refute fetch_session_id(conn)
+ end
+
+ test "verify_token/4" do
+ conn =
+ @default_config
+ |> Keyword.put(:message_verifier, Pow.Plug.MessageVerifier)
+ |> conn()
+ |> Map.put(:secret_key_base, String.duplicate("abcdefghijklmnopqrstuvxyz0123456789", 2))
+
+ signed_token = Plug.sign_token(conn, "salt", "token")
+
+ assert Plug.verify_token(%{conn | secret_key_base: conn.secret_key_base <> "invalid"}, "salt", signed_token) == :error
+ assert Plug.verify_token(conn, "invalid", signed_token) == :error
+ assert Plug.verify_token(conn, "salt", "invalid") == :error
+ assert Plug.verify_token(conn, "salt", signed_token) == {:ok, "token"}
+ end
+
+ defp auth_user_conn() do
+ conn = conn_with_session_plug()
+ {:ok, conn} = Plug.authenticate_user(conn, %{"email" => "test@example.com", "password" => "secret"})
+ conn = Conn.send_resp(conn, 200, "")
+
+ conn()
+ |> Test.recycle_cookies(conn)
+ |> conn_with_session_plug()
+ end
+
+ defp conn_with_session_plug(conn \\ nil) do
+ conn
+ |> Kernel.||(conn())
+ |> PlugSession.call(PlugSession.init(store: ProcessStore, key: "foobar"))
+ |> Session.call(Session.init(@default_config))
+ end
+
+ defp fetch_session_id(conn) do
+ conn = Conn.send_resp(conn, 200, "")
+
+ Map.get(conn.private[:plug_session], "auth")
end
defp conn(config \\ @default_config) do
- %Conn{private: %{pow_config: config}}
+ :get
+ |> Test.conn("/")
+ |> Conn.put_private(:pow_config, config)
end
end
diff --git a/test/pow/store/credentials_cache_test.exs b/test/pow/store/credentials_cache_test.exs
index 9d3bea8b..58cab840 100644
--- a/test/pow/store/credentials_cache_test.exs
+++ b/test/pow/store/credentials_cache_test.exs
@@ -9,13 +9,13 @@ defmodule Pow.Store.CredentialsCacheTest do
@config [backend: EtsCacheMock]
@backend_config [namespace: "credentials"]
- setup context do
+ setup do
EtsCacheMock.init()
- {:ok, context}
+ {:ok, ets: EtsCacheMock}
end
- test "stores sessions" do
+ test "stores sessions", %{ets: ets} do
user_1 = %User{id: 1}
user_2 = %User{id: 2}
user_3 = %UsernameUser{id: 1}
@@ -37,9 +37,9 @@ defmodule Pow.Store.CredentialsCacheTest do
assert CredentialsCache.sessions(@config, user_2) == ["key_3"]
assert CredentialsCache.sessions(@config, user_3) == ["key_4"]
- assert EtsCacheMock.get(@backend_config, "key_1") == {[User, :user, 1], a: 1}
- assert EtsCacheMock.get(@backend_config, [User, :user, 1]) == user_1
- assert EtsCacheMock.get(@backend_config, [User, :user, 1, :session, "key_1"])
+ assert ets.get(@backend_config, "key_1") == {[User, :user, 1], a: 1}
+ assert ets.get(@backend_config, [User, :user, 1]) == user_1
+ assert ets.get(@backend_config, [User, :user, 1, :session, "key_1"])
CredentialsCache.put(@config, "key_2", {%{user_1 | email: :updated}, a: 5})
assert CredentialsCache.get(@config, "key_1") == {%{user_1 | email: :updated}, a: 1}
@@ -48,16 +48,16 @@ defmodule Pow.Store.CredentialsCacheTest do
assert CredentialsCache.get(@config, "key_1") == :not_found
assert CredentialsCache.sessions(@config, user_1) == ["key_2"]
- assert EtsCacheMock.get(@backend_config, "key_1") == :not_found
- assert EtsCacheMock.get(@backend_config, [User, :user, 1]) == %{user_1 | email: :updated}
- assert EtsCacheMock.get(@backend_config, [User, :user, 1, :session, "key_1"]) == :not_found
+ assert ets.get(@backend_config, "key_1") == :not_found
+ assert ets.get(@backend_config, [User, :user, 1]) == %{user_1 | email: :updated}
+ assert ets.get(@backend_config, [User, :user, 1, :session, "key_1"]) == :not_found
assert CredentialsCache.delete(@config, "key_2") == :ok
assert CredentialsCache.sessions(@config, user_1) == []
- assert EtsCacheMock.get(@backend_config, "key_1") == :not_found
- assert EtsCacheMock.get(@backend_config, [User, :user, 1]) == %{user_1 | email: :updated}
- assert EtsCacheMock.get(@backend_config, [User, :user, 1, :session, "key_1"]) == :not_found
+ assert ets.get(@backend_config, "key_1") == :not_found
+ assert ets.get(@backend_config, [User, :user, 1]) == %{user_1 | email: :updated}
+ assert ets.get(@backend_config, [User, :user, 1, :session, "key_1"]) == :not_found
end
test "put/3 invalidates sessions with identical fingerprint" do
@@ -75,23 +75,6 @@ defmodule Pow.Store.CredentialsCacheTest do
assert CredentialsCache.get(@config, "key_3") == {user, fingerprint: 1}
end
- test "raises for nil primary key value" do
- user_1 = %User{id: nil}
-
- assert_raise RuntimeError, "Primary key value for key `:id` in Pow.Test.Ecto.Users.User can't be `nil`", fn ->
- CredentialsCache.put(@config, "key_1", {user_1, a: 1})
- end
- end
-
- defmodule NoPrimaryFieldUser do
- use Ecto.Schema
-
- @primary_key false
- schema "users" do
- timestamps()
- end
- end
-
defmodule CompositePrimaryFieldsUser do
use Ecto.Schema
@@ -104,44 +87,21 @@ defmodule Pow.Store.CredentialsCacheTest do
end
end
- test "handles custom primary fields" do
- assert_raise RuntimeError, "No primary keys found for Pow.Store.CredentialsCacheTest.NoPrimaryFieldUser", fn ->
- CredentialsCache.put(@config, "key_1", {%NoPrimaryFieldUser{}, a: 1})
- end
-
- assert_raise RuntimeError, "Primary key value for key `:another_id` in Pow.Store.CredentialsCacheTest.CompositePrimaryFieldsUser can't be `nil`", fn ->
- CredentialsCache.put(@config, "key_1", {%CompositePrimaryFieldsUser{}, a: 1})
- end
-
+ test "sorts composite primary keys", %{ets: ets} do
user = %CompositePrimaryFieldsUser{some_id: 1, another_id: 2}
CredentialsCache.put(@config, "key_1", {user, a: 1})
assert CredentialsCache.users(@config, CompositePrimaryFieldsUser) == [user]
- end
-
- defmodule NonEctoUser do
- defstruct [:id]
- end
-
- test "handles non-ecto user struct" do
- assert_raise RuntimeError, "Primary key value for key `:id` in Pow.Store.CredentialsCacheTest.NonEctoUser can't be `nil`", fn ->
- CredentialsCache.put(@config, "key_1", {%NonEctoUser{}, a: 1})
- end
-
- user = %NonEctoUser{id: 1}
-
- assert CredentialsCache.put(@config, "key_1", {user, a: 1})
-
- assert CredentialsCache.users(@config, NonEctoUser) == [user]
+ assert ets.get(@backend_config, [CompositePrimaryFieldsUser, :user, [another_id: 2, some_id: 1]]) == user
end
# TODO: Remove by 1.1.0
- test "backwards compatible" do
+ test "backwards compatible", %{ets: ets} do
user_1 = %User{id: 1}
timestamp = :os.system_time(:millisecond)
- EtsCacheMock.put(@backend_config, {"key_1", {user_1, inserted_at: timestamp}})
+ ets.put(@backend_config, {"key_1", {user_1, inserted_at: timestamp}})
assert CredentialsCache.get(@config, @backend_config, "key_1") == {user_1, inserted_at: timestamp}
assert CredentialsCache.delete(@config, @backend_config, "key_1") == :ok
diff --git a/test/support/conn_helpers.ex b/test/support/conn_helpers.ex
deleted file mode 100644
index 395b00b2..00000000
--- a/test/support/conn_helpers.ex
+++ /dev/null
@@ -1,16 +0,0 @@
-defmodule Pow.Test.ConnHelpers do
- @moduledoc false
- alias Plug.{Conn, ProcessStore, Session, Test}
-
- @spec conn(String.Chars.t(), binary(), Test.params()) :: Conn.t()
- def conn(method, path, params_or_body \\ nil) do
- Test.conn(method, path, params_or_body)
- end
-
- @spec init_session(Conn.t()) :: Conn.t()
- def init_session(conn) do
- opts = Session.init(store: ProcessStore, key: "foobar")
-
- Session.call(conn, opts)
- end
-end
diff --git a/test/support/context_mock.ex b/test/support/context_mock.ex
index 349a2186..fe5e5e3c 100644
--- a/test/support/context_mock.ex
+++ b/test/support/context_mock.ex
@@ -10,7 +10,7 @@ defmodule Pow.Test.ContextMock do
def authenticate(_params), do: nil
def create(@valid_params), do: {:ok, @user}
- def create(params), do: {:error, %{User.changeset(%User{}, params) | action: :create}}
+ def create(params), do: {:error, %{User.changeset(%User{}, params) | action: :insert}}
def update(%{id: 1}, @valid_params), do: {:ok, %{@user | id: :updated}}
def update(user, params), do: {:error, %{User.changeset(user, params) | action: :update}}
diff --git a/test/support/extensions/email_confirmation/repo_mock.ex b/test/support/extensions/email_confirmation/repo_mock.ex
index c4219353..bb67b772 100644
--- a/test/support/extensions/email_confirmation/repo_mock.ex
+++ b/test/support/extensions/email_confirmation/repo_mock.ex
@@ -12,13 +12,6 @@ defmodule PowEmailConfirmation.Test.RepoMock do
}, state: :loaded)
end
- def one(query) do
- case inspect(query) =~ "where: u0.email == ^\"taken@example.com\"" do
- true -> user()
- false -> false
- end
- end
-
def get_by(User, [email: "test@example.com"], _opts), do: user()
def get_by(User, [email: "with-unconfirmed-changed-email@example.com"], _opts) do
%{user() | unconfirmed_email: "new@example.com", email_confirmed_at: DateTime.utc_now()}
@@ -31,11 +24,14 @@ defmodule PowEmailConfirmation.Test.RepoMock do
def get_by(User, [email_confirmation_token: "valid-with-unconfirmed-changed-email"], _opts) do
%{user() | unconfirmed_email: "new@example.com", email_confirmed_at: DateTime.utc_now()}
end
+ def get_by(User, [email_confirmation_token: "valid-with-taken-email"], _opts) do
+ %{user() | unconfirmed_email: "taken@example.com", email_confirmed_at: DateTime.utc_now()}
+ end
- def update(%{changes: %{email: "taken@example.com"}} = changeset, _opts) do
- changeset = Ecto.Changeset.add_error(changeset, :email, "has already been taken")
+ def update(%{changes: %{email: "taken@example.com"}, valid?: true} = changeset, _opts) do
+ changeset = Ecto.Changeset.add_error(changeset, :email, "has already been taken", constraint: :unique, constraint_name: "users_email_index")
- {:error, changeset}
+ {:error, %{changeset | action: :update}}
end
def update(%{valid?: true} = changeset, _opts) do
%{changeset | repo: __MODULE__}
@@ -57,6 +53,12 @@ defmodule PowEmailConfirmation.Test.RepoMock do
|> Enum.reduce(changeset, & &1.(&2))
end
+ def insert(%{valid?: false} = changeset, _opts), do: {:error, %{changeset | action: :insert}}
+ def insert(%{changes: %{email: "taken@example.com"}, valid?: true} = changeset, _opts) do
+ changeset = Ecto.Changeset.add_error(changeset, :email, "has already been taken", constraint: :unique, constraint_name: "users_email_index")
+
+ {:error, %{changeset | action: :insert}}
+ end
def insert(%{valid?: true} = changeset, _opts) do
user =
changeset
@@ -69,7 +71,7 @@ defmodule PowEmailConfirmation.Test.RepoMock do
{:ok, user}
end
- def get!(User, 1, _opts), do: Process.get({:user, 1})
+ def get_by!(User, [id: 1], _opts), do: Process.get({:user, 1})
defmodule Invitation do
@moduledoc false
@@ -80,6 +82,6 @@ defmodule PowEmailConfirmation.Test.RepoMock do
def update(changeset, opts), do: RepoMock.update(changeset, opts)
- def get!(User, 1, _opts), do: Process.get({:user, 1})
+ def get_by!(User, [id: 1], _opts), do: Process.get({:user, 1})
end
end
diff --git a/test/support/extensions/invitation/repo_mock.ex b/test/support/extensions/invitation/repo_mock.ex
index 4320c456..b515a6ce 100644
--- a/test/support/extensions/invitation/repo_mock.ex
+++ b/test/support/extensions/invitation/repo_mock.ex
@@ -5,6 +5,11 @@ defmodule PowInvitation.Test.RepoMock do
@user %User{id: 1, email: "test@example.com"}
+ def insert(%{changes: %{email: "taken@example.com"}, valid?: true} = changeset, _opts) do
+ changeset = Ecto.Changeset.add_error(changeset, :email, "has already been taken", constraint: :unique, constraint_name: "users_email_index")
+
+ {:error, %{changeset | action: :insert}}
+ end
def insert(%{valid?: true} = changeset, _opts) do
user = %{Ecto.Changeset.apply_changes(changeset) | id: 1}
@@ -22,12 +27,17 @@ defmodule PowInvitation.Test.RepoMock do
end
def insert(%{valid?: false} = changeset, _opts), do: {:error, %{changeset | action: :insert}}
- def get!(User, 1, _opts), do: Process.get({:user, 1})
+ def get_by!(User, [id: 1], _opts), do: Process.get({:user, 1})
def get_by(User, [invitation_token: "valid"], _opts), do: %{@user | invitation_token: "valid"}
def get_by(User, [invitation_token: "valid_but_accepted"], _opts), do: %{@user | invitation_accepted_at: :now}
def get_by(User, [invitation_token: "invalid"], _opts), do: nil
+ def update(%{changes: %{email: "taken@example.com"}, valid?: true} = changeset, _opts) do
+ changeset = Ecto.Changeset.add_error(changeset, :email, "has already been taken", constraint: :unique, constraint_name: "users_email_index")
+
+ {:error, %{changeset | action: :update}}
+ end
def update(%{valid?: true} = changeset, _opts) do
user = Ecto.Changeset.apply_changes(changeset)
diff --git a/test/support/extensions/mocks.ex b/test/support/extensions/mocks.ex
index 3d338689..a1955d9a 100644
--- a/test/support/extensions/mocks.ex
+++ b/test/support/extensions/mocks.ex
@@ -42,7 +42,9 @@ defmodule Pow.Test.ExtensionMocks do
messages_backend: Module.concat([web_module, Phoenix.Messages]),
routes_backend: Module.concat([web_module, Phoenix.Routes]),
extensions: extensions,
- controller_callbacks: Pow.Extension.Phoenix.ControllerCallbacks]
+ controller_callbacks: Pow.Extension.Phoenix.ControllerCallbacks,
+ message_verifier: Pow.Test.MessageVerifier
+ ]
__user_schema__(context_module, extensions)
__phoenix_endpoint__(web_module, config, opts)
@@ -122,6 +124,14 @@ defmodule Pow.Test.ExtensionMocks do
use Phoenix.Endpoint, otp_app: :pow
+ @session_options [
+ store: :cookie,
+ key: "_binaryid_key",
+ signing_salt: "secret"
+ ]
+
+ @pow_config unquote(config)
+
plug Plug.RequestId
plug Plug.Logger
@@ -133,17 +143,12 @@ defmodule Pow.Test.ExtensionMocks do
plug Plug.MethodOverride
plug Plug.Head
- plug Plug.Session,
- store: :cookie,
- key: "_binaryid_key",
- signing_salt: "secret"
-
- plug SessionPlugHelper, unquote(config)
-
- if Code.ensure_compiled?(unquote(opts[:plug])) do
+ plug Plug.Session, @session_options
+ plug SessionPlugHelper, @pow_config
+ if unquote(opts[:plug]) do
+ Code.ensure_compiled(unquote(opts[:plug]))
plug unquote(opts[:plug])
end
-
plug unquote(web_module).Phoenix.Router
end
@@ -168,7 +173,7 @@ defmodule Pow.Test.ExtensionMocks do
end
end
- setup _tags do
+ setup do
unquote(cache_backend).init()
{:ok, conn: Phoenix.ConnTest.build_conn(), ets: unquote(cache_backend)}
end
diff --git a/test/support/extensions/reset_password/no_registration/endpoint.ex b/test/support/extensions/reset_password/no_registration/endpoint.ex
deleted file mode 100644
index 90802dcd..00000000
--- a/test/support/extensions/reset_password/no_registration/endpoint.ex
+++ /dev/null
@@ -1,24 +0,0 @@
-defmodule PowResetPassword.NoRegistration.TestWeb.Phoenix.Endpoint do
- @moduledoc false
- use Phoenix.Endpoint, otp_app: :pow
-
- plug Plug.RequestId
- plug Plug.Logger
-
- plug Plug.Parsers,
- parsers: [:urlencoded, :multipart, :json],
- pass: ["*/*"],
- json_decoder: Phoenix.json_library()
-
- plug Plug.MethodOverride
- plug Plug.Head
-
- plug Plug.Session,
- store: :cookie,
- key: "_binaryid_key",
- signing_salt: "secret"
-
- plug Pow.Plug.Session, PowResetPassword.Test.pow_config()
-
- plug PowResetPassword.NoRegistration.TestWeb.Phoenix.Router
-end
diff --git a/test/support/extensions/reset_password/no_registration/router.ex b/test/support/extensions/reset_password/no_registration/router.ex
deleted file mode 100644
index 400a9fa5..00000000
--- a/test/support/extensions/reset_password/no_registration/router.ex
+++ /dev/null
@@ -1,22 +0,0 @@
-defmodule PowResetPassword.NoRegistration.TestWeb.Phoenix.Router do
- @moduledoc false
- use Phoenix.Router
- use Pow.Phoenix.Router
- use Pow.Extension.Phoenix.Router,
- extensions: [PowResetPassword]
-
- pipeline :browser do
- plug :accepts, ["html"]
- plug :fetch_session
- plug :fetch_flash
- plug :protect_from_forgery
- plug :put_secure_browser_headers
- end
-
- scope "/" do
- pipe_through :browser
-
- pow_session_routes()
- pow_extension_routes()
- end
-end
diff --git a/test/support/extensions/reset_password/repo_mock.ex b/test/support/extensions/reset_password/repo_mock.ex
index c02d13ef..147d5153 100644
--- a/test/support/extensions/reset_password/repo_mock.ex
+++ b/test/support/extensions/reset_password/repo_mock.ex
@@ -6,17 +6,18 @@ defmodule PowResetPassword.Test.RepoMock do
def get_by(User, [email: "test@example.com"], _opts), do: @user
def get_by(User, [email: "invalid@example.com"], _opts), do: nil
+ def get_by(User, [email: "missing@example.com"], _opts), do: %User{id: :missing}
def update(%{valid?: true} = changeset, _opts) do
user = Ecto.Changeset.apply_changes(changeset)
# We store the user in the process because the user is force reloaded with `get!/2`
- Process.put({:user, 1}, user)
+ Process.put({:user, user.id}, user)
{:ok, user}
end
def update(%{valid?: false} = changeset, _opts), do: {:error, %{changeset | action: :update}}
- def get!(User, 1, _opts), do: Process.get({:user, 1})
- def get!(User, :missing, _opts), do: nil
+ def get_by!(User, [id: 1], _opts), do: Process.get({:user, 1})
+ def get_by!(User, [id: :missing], _opts), do: nil
end
diff --git a/test/support/message_verifier.ex b/test/support/message_verifier.ex
new file mode 100644
index 00000000..0f2a272a
--- /dev/null
+++ b/test/support/message_verifier.ex
@@ -0,0 +1,19 @@
+defmodule Pow.Test.MessageVerifier do
+ @moduledoc false
+
+ @behaviour Pow.Plug.MessageVerifier
+
+ @impl true
+ def sign(_conn, salt, message, _config),
+ do: "signed.#{salt}.#{message}"
+
+ @impl true
+ def verify(_conn, salt, message, _config) do
+ prepend = "signed." <> salt <> "."
+
+ case String.replace(message, prepend, "") do
+ ^message -> :error
+ message -> {:ok, message}
+ end
+ end
+end
diff --git a/test/support/mix/test_case.ex b/test/support/mix/test_case.ex
index cba0fc67..ac13c1c2 100644
--- a/test/support/mix/test_case.ex
+++ b/test/support/mix/test_case.ex
@@ -8,7 +8,7 @@ defmodule Pow.Test.Mix.TestCase do
:ok
end
- setup _context do
+ setup do
current_shell = Mix.shell()
on_exit fn ->
diff --git a/test/support/phoenix/conn_case.ex b/test/support/phoenix/conn_case.ex
index 3bf73fbd..28d04f73 100644
--- a/test/support/phoenix/conn_case.ex
+++ b/test/support/phoenix/conn_case.ex
@@ -16,7 +16,7 @@ defmodule Pow.Test.Phoenix.ConnCase do
end
end
- setup _tags do
+ setup do
EtsCacheMock.init()
{:ok, conn: Phoenix.ConnTest.build_conn(), ets: EtsCacheMock}
diff --git a/test/support/phoenix/endpoint.ex b/test/support/phoenix/endpoint.ex
index e84415a4..c22c76a0 100644
--- a/test/support/phoenix/endpoint.ex
+++ b/test/support/phoenix/endpoint.ex
@@ -20,6 +20,20 @@ defmodule Pow.Test.Phoenix.Endpoint do
@moduledoc false
use Phoenix.Endpoint, otp_app: :pow
+ @session_options [
+ store: :cookie,
+ key: "_binaryid_key",
+ signing_salt: "secret"
+ ]
+
+ @pow_config [
+ current_user_assigns_key: :current_user,
+ session_key: "auth",
+ cache_store_backend: Pow.Test.EtsCacheMock,
+ messages_backend: Pow.Test.Phoenix.Messages,
+ routes_backend: Pow.Test.Phoenix.Routes
+ ]
+
plug Plug.RequestId
plug Plug.Logger
@@ -31,17 +45,7 @@ defmodule Pow.Test.Phoenix.Endpoint do
plug Plug.MethodOverride
plug Plug.Head
- plug Plug.Session,
- store: :cookie,
- key: "_binaryid_key",
- signing_salt: "secret"
-
- plug SessionPlugHelper,
- current_user_assigns_key: :current_user,
- session_key: "auth",
- cache_store_backend: Pow.Test.EtsCacheMock,
- messages_backend: Pow.Test.Phoenix.Messages,
- routes_backend: Pow.Test.Phoenix.Routes
-
+ plug Plug.Session, @session_options
+ plug SessionPlugHelper, @pow_config
plug Pow.Test.Phoenix.Router
end
diff --git a/test/support/process_store.ex b/test/support/process_store.ex
index 997cb1aa..2add4941 100644
--- a/test/support/process_store.ex
+++ b/test/support/process_store.ex
@@ -1,6 +1,6 @@
defmodule Plug.ProcessStore do
@moduledoc """
- Used with `Plug.Conn` sessions in tests. See `Pow.Test.ConnHelpers` for more.
+ Used with `Plug.Conn` sessions in tests.
"""
@behaviour Plug.Session.Store