Control request flow in tests

Author: danschultzer

test/extensions/persistent_session/plug/cookie_test.exs

@@ -45,15 +45,52 @@ defmodule PowPersistentSession.Plug.CookieTest do
     assert PersistentSessionCache.get([backend: ets], new_id) == {[id: 1], []}
   end
 
-  test "call/2 assigns user from cookie and doesn't expire with simultanous request", %{conn: conn, ets: ets} do
-    user = %User{id: 1}
-    id   = "test"
-    conn = store_persistent(conn, ets, id, {[id: user.id], []})
+  defmodule PersistentSessionCacheWaitDelete do
+    alias PowPersistentSession.Store.PersistentSessionCache
+
+    @timeout :timer.seconds(5)
+
+    defdelegate put(config, session_id, record_or_records), to: PersistentSessionCache
+
+    defdelegate get(config, session_id), to: PersistentSessionCache
+
+    def delete(config, session_id)do
+      send(self(), {__MODULE__, :wait})
+
+      receive do
+        {__MODULE__, :commit} -> :ok
+      after
+        @timeout -> raise "Timeout reached"
+      end
+
+      PersistentSessionCache.delete(config, session_id)
+    end
+  end
 
-    task_1 = Task.async(fn -> run_plug(conn) end)
-    task_2 = Task.async(fn -> run_plug(conn) end)
-    conn_1 = Task.await(task_1)
-    conn_2 = Task.await(task_2)
+  test "call/2 assigns user from cookie and doesn't expire with simultanous request", %{conn: conn, ets: ets} do
+    :ets.delete(EtsCacheMock)
+    :ets.new(EtsCacheMock, [:ordered_set, :public, :named_table])
+
+    user   = %User{id: 1}
+    id     = "test"
+    conn   = store_persistent(conn, ets, id, {[id: user.id], []})
+    config = [persistent_session_store: {PersistentSessionCacheWaitDelete, ttl: :timer.hours(24) * 30, namespace: "persistent_session"}]
+
+    task_1 =
+      fn -> run_plug(conn, config) end
+      |> Task.async()
+      |> wait_till_ready()
+
+    conn_2 =
+      fn -> 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 %{value: _id, max_age: @max_age, path: "/"} = conn_1.resp_cookies[@cookie_key]
@@ -62,6 +99,19 @@ defmodule PowPersistentSession.Plug.CookieTest do
     refute conn_2.resp_cookies[@cookie_key]
   end
 
+  defp wait_till_ready(%{pid: tracking_pid} = task) do
+    :erlang.trace(tracking_pid, true, [:receive])
+    assert_receive {:trace, ^tracking_pid, :receive, {PersistentSessionCacheWaitDelete, :wait}}
+
+    task
+  end
+
+  defp continue_work(%{pid: tracking_pid} = task) do
+    send(tracking_pid, {PersistentSessionCacheWaitDelete, :commit})
+
+    task
+  end
+
   test "call/2 assigns user from cookie passing fingerprint to the session metadata", %{conn: conn, ets: ets} do
     user = %User{id: 1}
     id   = "test"

test/pow/plug/session_test.exs

@@ -112,10 +112,35 @@ defmodule Pow.Plug.SessionTest do
     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
     session_id      = "token"
-    config          = Keyword.put(@default_opts, :session_ttl_renewal, ttl)
+    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
 
     conn =
@@ -130,16 +155,27 @@ defmodule Pow.Plug.SessionTest do
 
     CredentialsCache.put(@store_config, session_id, {@user, inserted_at: stale_timestamp})
 
-    task_1 = Task.async(fn ->
-      Process.put({:session, sid}, session_data)
-      run_plug(conn, config)
-    end)
-    task_2 = Task.async(fn ->
-      Process.put({:session, sid}, session_data)
-      run_plug(conn, config)
-    end)
-    conn_1 = Task.await(task_1)
-    conn_2 = Task.await(task_2)
+    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"]
@@ -152,6 +188,19 @@ defmodule Pow.Plug.SessionTest do
     assert CredentialsCache.get(@store_config, 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)})
 

test/support/ets_cache_mock.ex

@@ -2,7 +2,7 @@ defmodule Pow.Test.EtsCacheMock do
   @moduledoc false
   @tab __MODULE__
 
-  def init, do: :ets.new(@tab, [:ordered_set, :public, :named_table])
+  def init, do: :ets.new(@tab, [:ordered_set, :protected, :named_table])
 
   def get(config, key) do
     ets_key = ets_key(config, key)