From a170e997f1c831b2c941e59f8c8e7d0c867e647a Mon Sep 17 00:00:00 2001 From: Christian Meunier Date: Tue, 21 May 2019 00:37:59 +1000 Subject: [PATCH] Update for Ecto 3.x --- README.md | 6 +- lib/{ecto_replay_sandbox.ex => sandbox.ex} | 366 ++++++++++-------- mix.exs | 15 +- mix.lock | 24 +- test/repo.exs | 24 +- ...play_sandbox_test.exs => sandbox_test.exs} | 140 ++++--- test/schema.exs | 68 ++-- test/test_helper.exs | 60 +-- 8 files changed, 419 insertions(+), 284 deletions(-) rename lib/{ecto_replay_sandbox.ex => sandbox.ex} (71%) rename test/{ecto_replay_sandbox_test.exs => sandbox_test.exs} (54%) diff --git a/README.md b/README.md index 1b96ddb..94eb34a 100644 --- a/README.md +++ b/README.md @@ -21,13 +21,13 @@ Once the test finishes, the managed transaction is being rollbacked to restore t ## Installation The package can be installed by adding `ecto_replay_sandbox` to your list of dependencies in `mix.exs`. -Make sure to also add [Postgrex CockroachDB variant](https://hexdocs.pm/postgrex_cdb/readme.html). +Make sure to also add [CockroachDB adaptor](https://hexdocs.pm/ecto_cockroachdb/readme.html). ```elixir def deps do [ - {:postgrex, "~> 0.13", hex: :postgrex_cdb, override: true}, - {:ecto_replay_sandbox, "~> 1.0", only: :test}, + {:ecto_cockroachdb, "~> 1.0"}, + {:ecto_replay_sandbox, "~> 2.0", only: :test}, ] end ``` diff --git a/lib/ecto_replay_sandbox.ex b/lib/sandbox.ex similarity index 71% rename from lib/ecto_replay_sandbox.ex rename to lib/sandbox.ex index 5dd88b4..db140e8 100644 --- a/lib/ecto_replay_sandbox.ex +++ b/lib/sandbox.ex @@ -295,11 +295,29 @@ defmodule EctoReplaySandbox do you can always disable the test triggering the deadlock from running asynchronously by setting "async: false". """ - + defmodule Connection do - @begin_result %Postgrex.Result{columns: nil, command: :begin, connection_id: nil, num_rows: nil, rows: nil} - @commit_result %Postgrex.Result{columns: nil, command: :commit, connection_id: nil, num_rows: nil, rows: nil} - @rollback_result %Postgrex.Result{columns: nil, command: :rollback, connection_id: nil, num_rows: nil, rows: nil} + @begin_result %Postgrex.Result{ + columns: nil, + command: :begin, + connection_id: nil, + num_rows: nil, + rows: nil + } + @commit_result %Postgrex.Result{ + columns: nil, + command: :commit, + connection_id: nil, + num_rows: nil, + rows: nil + } + @rollback_result %Postgrex.Result{ + columns: nil, + command: :rollback, + connection_id: nil, + num_rows: nil, + rows: nil + } @moduledoc false if Code.ensure_loaded?(DBConnection) do @@ -310,7 +328,7 @@ defmodule EctoReplaySandbox do raise "should never be invoked" end - def disconnect(err, {conn_mod, state, _in_transaction?, _fixture_state}) do + def disconnect(err, {conn_mod, state, _in_transaction?}) do conn_mod.disconnect(err, state) end @@ -321,187 +339,162 @@ defmodule EctoReplaySandbox do def handle_begin(_opts, {conn_mod, state, false, {sandbox_log, _tx_log}}) do {:ok, @begin_result, {conn_mod, state, true, {sandbox_log, []}}} end + def handle_commit(_opts, {conn_mod, state, true, {sandbox_log, tx_log}}) do - {state, sandbox_log} = case sandbox_log do - [:error_detected | tail] -> - restart_result = restart_sandbox_tx(conn_mod, state) - {elem(restart_result, 2),[:replay_needed | tail]} - _ -> - {state, sandbox_log ++ tx_log} - end - + {state, sandbox_log} = + case sandbox_log do + [:error_detected | tail] -> + restart_result = restart_sandbox_tx(conn_mod, state) + {elem(restart_result, 2), [:replay_needed | tail]} + + _ -> + {state, sandbox_log ++ tx_log} + end + {:ok, @commit_result, {conn_mod, state, false, {sandbox_log, []}}} end + def handle_rollback(opts, {conn_mod, state, true, {sandbox_log, _}}) do - sandbox_log = case sandbox_log do - [:error_detected | tail] -> tail - _ -> sandbox_log - end + sandbox_log = + case sandbox_log do + [:error_detected | tail] -> tail + _ -> sandbox_log + end + case restart_sandbox_tx(conn_mod, state, opts) do {:ok, _, conn_state} -> - {:ok, @rollback_result, {conn_mod, conn_state, false, {[:replay_needed | sandbox_log], []}}} - error -> + {:ok, @rollback_result, + {conn_mod, conn_state, false, {[:replay_needed | sandbox_log], []}}} + + error -> pos = :erlang.tuple_size(error) - :erlang.setelement(pos, error, {conn_mod, :erlang.element(pos, error), false, {sandbox_log, []}}) + + :erlang.setelement( + pos, + error, + {conn_mod, :erlang.element(pos, error), false, {sandbox_log, []}} + ) end end + def handle_status(opts, state), + do: proxy(:handle_status, state, [opts]) + def handle_prepare(query, opts, state), do: proxy(:handle_prepare, state, [query, opts]) + def handle_execute(query, params, opts, state), do: proxy(:handle_execute, state, [query, params, opts]) + def handle_close(query, opts, state), do: proxy(:handle_close, state, [query, opts]) + def handle_declare(query, params, opts, state), do: proxy(:handle_declare, state, [query, params, opts]) - def handle_first(query, cursor, opts, state), - do: proxy(:handle_first, state, [query, cursor, opts]) - def handle_next(query, cursor, opts, state), - do: proxy(:handle_next, state, [query, cursor, opts]) + + def handle_fetch(query, cursor, opts, state), + do: proxy(:handle_fetch, state, [query, cursor, opts]) + def handle_deallocate(query, cursor, opts, state), do: proxy(:handle_deallocate, state, [query, cursor, opts]) - def handle_info(msg, state), - do: proxy(:handle_info, state, [msg]) defp proxy(fun, {conn_mod, state, in_transaction?, {sandbox_log, _tx_log} = log_state}, args) do # Handle replay - {state, log_state} = case sandbox_log do - [:replay_needed | tail] -> - state = tail - |> Enum.reduce(state, fn {replay_fun, replay_args}, state -> - {_status, _, state} = apply(conn_mod, replay_fun, replay_args ++ [state]) + {state, log_state} = + case sandbox_log do + [:replay_needed | tail] -> + state = + tail + |> Enum.reduce(state, fn {replay_fun, replay_args}, state -> + {:ok, _, state} = + apply(conn_mod, replay_fun, replay_args ++ [state]) |> normalize_result + state end) - {state, {tail, []}} - _ -> - {state, log_state} - end + + {state, {tail, []}} + + _ -> + {state, log_state} + end # Execute command - {status, result, state} = apply(conn_mod, fun, args ++ [state]) + {status, result, state} = apply(conn_mod, fun, args ++ [state]) |> normalize_result # Handle error - {state, log_state} = case status do - :ok -> - {state, log_command(fun, args, in_transaction?, log_state)} - :error -> - if(in_transaction?) do - log_state = case sandbox_log do - [:error_detected | _tail] -> {elem(log_state, 0), []} - _ -> {[:error_detected | elem(log_state, 0)], []} + {state, log_state} = + case status do + ok_val when ok_val in [:ok, :cont, :halt] -> + {state, log_command(fun, args, in_transaction?, log_state)} + + error_val when error_val in [:error, :disconnect] -> + if(in_transaction?) do + log_state = + case sandbox_log do + [:error_detected | _tail] -> {elem(log_state, 0), []} + _ -> {[:error_detected | elem(log_state, 0)], []} + end + + {state, log_state} + else + {_status, _result, state} = restart_sandbox_tx(conn_mod, state) + {state, {[:replay_needed | elem(log_state, 0)], []}} end - {state, log_state} - else - restart_result = restart_sandbox_tx(conn_mod, state) - {elem(restart_result, 2),{[:replay_needed | elem(log_state, 0)], []}} - end - end + end + + put_elem(result, tuple_size(result) - 1, {conn_mod, state, in_transaction?, log_state}) + end - {status, result, {conn_mod, state, in_transaction?, log_state}} + defp normalize_result(result) do + status = elem(result, 0) + state = elem(result, tuple_size(result) - 1) + {status, result, state} end defp log_command(fun, args, in_transactions?, {sandbox_log, tx_log}) do case fun do - command when command in [:handle_execute, :handle_close, :handle_declare, :handle_first, :handle_next, :handle_deallocate] -> + command + when command in [ + :handle_execute, + :handle_close, + :handle_declare, + :handle_fetch, + :handle_deallocate + ] -> if in_transactions? do {sandbox_log, tx_log ++ [{fun, args}]} else {sandbox_log ++ [{fun, args}], []} end + _ -> {sandbox_log, tx_log} end end defp restart_sandbox_tx(conn_mod, conn_state, opts \\ []) do - with {:ok, _, conn_state} <- conn_mod.handle_rollback([mode: :transaction] ++ opts, conn_state), + with {:ok, _, conn_state} <- + conn_mod.handle_rollback([mode: :transaction] ++ opts, conn_state), {:ok, _, _} = begin_result <- conn_mod.handle_begin([mode: :transaction], conn_state) do begin_result end end - - end - - defmodule Pool do - @moduledoc false - if Code.ensure_loaded?(DBConnection) do - @behaviour DBConnection.Pool - end - - def ensure_all_started(_opts, _type) do - raise "should never be invoked" - end - - def start_link(_module, _opts) do - raise "should never be invoked" - end - - def child_spec(_module, _opts, _child_opts) do - raise "should never be invoked" - end - - def checkout(pool, opts) do - pool_mod = opts[:sandbox_pool] - - case pool_mod.checkout(pool, opts) do - {:ok, pool_ref, conn_mod, conn_state} -> - case conn_mod.handle_begin([mode: :transaction] ++ opts, conn_state) do - {:ok, _, conn_state} -> - {:ok, pool_ref, Connection, {conn_mod, conn_state, false, {[], []}}} - {_error_or_disconnect, err, conn_state} -> - pool_mod.disconnect(pool_ref, err, conn_state, opts) - end - error -> - error - end - end - - def checkin(pool_ref, {conn_mod, conn_state, _in_transaction?, _log_state}, opts) do - pool_mod = opts[:sandbox_pool] - case conn_mod.handle_rollback([mode: :transaction] ++ opts, conn_state) do - {:ok, _, conn_state} -> - pool_mod.checkin(pool_ref, conn_state, opts) - {_error_or_disconnect, err, conn_state} -> - pool_mod.disconnect(pool_ref, err, conn_state, opts) - end - end - - def disconnect(owner, exception, {_conn_mod, conn_state, _in_transaction?, _log_state}, opts) do - opts[:sandbox_pool].disconnect(owner, exception, conn_state, opts) - end - - def stop(owner, reason, {_conn_mod, conn_state, _in_transaction?, _log_state}, opts) do - opts[:sandbox_pool].stop(owner, reason, conn_state, opts) - end end @doc """ Sets the mode for the `repo` pool. - The mode can be `:auto`, `:manual` or `:shared`. + The mode can be `:auto`, `:manual` or `{:shared, }`. + + Warning: you should only call this function in the setup block for a test and + not within a test, because if the mode is changed during the test it will cause + other database connections to be checked in (causing errors). """ def mode(repo, mode) - when mode in [:auto, :manual] - when elem(mode, 0) == :shared and is_pid(elem(mode, 1)) do - {_repo_mod, name, opts} = Ecto.Registry.lookup(repo) - - if opts[:pool] != DBConnection.Ownership do - raise """ - cannot configure sandbox with pool #{inspect opts[:pool]}. - To use the SQL Sandbox, configure your repository pool as: - - pool: #{inspect __MODULE__} - """ - end - - # If the mode is set to anything but shared, let's - # automatically checkin the current connection to - # force it to act according to the chosen mode. - if mode in [:auto, :manual] do - checkin(repo, []) - end - - DBConnection.Ownership.ownership_mode(name, mode, opts) + when is_atom(repo) and mode in [:auto, :manual] + when is_atom(repo) and elem(mode, 0) == :shared and is_pid(elem(mode, 1)) do + %{pid: pool, opts: opts} = lookup_meta!(repo) + DBConnection.Ownership.ownership_mode(pool, mode, opts) end @doc """ @@ -516,30 +509,40 @@ defmodule EctoReplaySandbox do * `:sandbox` - when true the connection is wrapped in a transaction. Defaults to true. - * `:isolation` - set the query to the given isolation level + * `:isolation` - set the query to the given isolation level. * `:ownership_timeout` - limits how long the connection can be - owned. Defaults to the compiled value from your repo config in + owned. Defaults to the value in your repo config in `config/config.exs` (or preferably in `config/test.exs`), or - 15000 ms if not set. + 60000 ms if not set. The timeout exists for sanity checking + purposes, to ensure there is no connection leakage, and can + be bumped whenever necessary. + """ - def checkout(repo, opts \\ []) do - {_repo_mod, name, pool_opts} = + def checkout(repo, opts \\ []) when is_atom(repo) do + %{pid: pool, opts: pool_opts} = lookup_meta!(repo) + + pool_opts = if Keyword.get(opts, :sandbox, true) do - proxy_pool(repo) + [ + post_checkout: &post_checkout(&1, &2, opts), + pre_checkin: &pre_checkin(&1, &2, &3, opts) + ] ++ pool_opts else - Ecto.Registry.lookup(repo) + pool_opts end pool_opts_overrides = Keyword.take(opts, [:ownership_timeout]) pool_opts = Keyword.merge(pool_opts, pool_opts_overrides) - case DBConnection.Ownership.ownership_checkout(name, pool_opts) do + case DBConnection.Ownership.ownership_checkout(pool, pool_opts) do :ok -> if isolation = opts[:isolation] do set_transaction_isolation_level(repo, isolation) end + :ok + other -> other end @@ -547,9 +550,11 @@ defmodule EctoReplaySandbox do defp set_transaction_isolation_level(repo, isolation) do query = "SET TRANSACTION ISOLATION LEVEL #{isolation}" + case Ecto.Adapters.SQL.query(repo, query, [], sandbox_subtransaction: false) do {:ok, _} -> :ok + {:error, error} -> checkin(repo, []) raise error @@ -559,33 +564,26 @@ defmodule EctoReplaySandbox do @doc """ Checks in the connection back into the sandbox pool. """ - def checkin(repo, _opts \\ []) do - {_repo_mod, name, opts} = Ecto.Registry.lookup(repo) - DBConnection.Ownership.ownership_checkin(name, opts) + def checkin(repo, _opts \\ []) when is_atom(repo) do + %{pid: pool, opts: opts} = lookup_meta!(repo) + DBConnection.Ownership.ownership_checkin(pool, opts) end @doc """ Allows the `allow` process to use the same connection as `parent`. """ - def allow(repo, parent, allow, _opts \\ []) do - {_repo_mod, name, opts} = Ecto.Registry.lookup(repo) - DBConnection.Ownership.ownership_allow(name, parent, allow, opts) - end - - def ensure_all_started(app, type \\ :temporary) do - DBConnection.Ownership.ensure_all_started(app, type) - end - - def child_spec(module, opts, child_opts) do - DBConnection.Ownership.child_spec(module, opts, child_opts) + def allow(repo, parent, allow, _opts \\ []) when is_atom(repo) do + %{pid: pool, opts: opts} = lookup_meta!(repo) + DBConnection.Ownership.ownership_allow(pool, parent, allow, opts) end @doc """ Runs a function outside of the sandbox. """ - def unboxed_run(repo, fun) do + def unboxed_run(repo, fun) when is_atom(repo) do checkin(repo) checkout(repo, sandbox: false) + try do fun.() after @@ -593,9 +591,63 @@ defmodule EctoReplaySandbox do end end - defp proxy_pool(repo) do - {repo_mod, name, opts} = Ecto.Registry.lookup(repo) - {pool, opts} = Keyword.pop(opts, :ownership_pool, DBConnection.Poolboy) - {repo_mod, name, [repo: repo, sandbox_pool: pool, ownership_pool: Pool] ++ opts} + defp lookup_meta!(repo) do + %{opts: opts} = meta = Ecto.Adapter.lookup_meta(repo) + + if opts[:pool] != DBConnection.Ownership do + raise """ + cannot invoke sandbox operation with pool #{inspect(opts[:pool])}. + To use the SQL Sandbox, configure your repository pool as: + + pool: #{inspect(__MODULE__)} + """ + end + + meta + end + + defp post_checkout(conn_mod, conn_state, opts) do + case conn_mod.handle_begin([mode: :transaction] ++ opts, conn_state) do + {:ok, _, conn_state} -> + {:ok, Connection, {conn_mod, conn_state, false, {[], []}}} + + {_error_or_disconnect, err, conn_state} -> + {:disconnect, err, conn_mod, conn_state} + end + end + + defp pre_checkin( + :checkin, + Connection, + {conn_mod, conn_state, _in_transaction?, _log_state}, + opts + ) do + case conn_mod.handle_rollback([mode: :transaction] ++ opts, conn_state) do + {:ok, _, conn_state} -> + {:ok, conn_mod, conn_state} + + {:idle, _conn_state} -> + raise """ + Ecto SQL sandbox transaction was already committed/rolled back. + + The sandbox works by running each test in a transaction and closing the\ + transaction afterwards. However, the transaction has already terminated.\ + Your test code is likely committing or rolling back transactions manually,\ + either by invoking procedures or running custom SQL commands. + + One option is to manually checkout a connection without a sandbox: + + Ecto.Adapters.SQL.Sandbox.checkout(repo, sandbox: false) + + But remember you will have to undo any database changes performed by such tests. + """ + + {_error_or_disconnect, err, conn_state} -> + {:disconnect, err, conn_mod, conn_state} + end + end + + defp pre_checkin(_, Connection, {conn_mod, conn_state, _in_transaction?, _log_state}, _opts) do + {:ok, conn_mod, conn_state} end -end \ No newline at end of file +end diff --git a/mix.exs b/mix.exs index 2ccb784..f3931a7 100644 --- a/mix.exs +++ b/mix.exs @@ -1,13 +1,13 @@ defmodule EctoReplaySandbox.Mixfile do use Mix.Project - @version "1.0.0" + @version "2.0.0" def project do [ app: :ecto_replay_sandbox, version: @version, - elixir: "~> 1.4", + elixir: "~> 1.5", build_embedded: Mix.env() == :prod, start_permanent: Mix.env() == :prod, package: package(), @@ -35,11 +35,12 @@ defmodule EctoReplaySandbox.Mixfile do defp deps do [ - {:ex_doc, ">= 0.0.0", only: :dev}, - {:ecto, "~> 2.2"}, - {:db_connection, "~> 1.1"}, - # {:postgrex, "~> 0.13"}, - {:postgrex, "~> 0.14.0-dev", hex: :postgrex_cdb, override: true} + {:ex_doc, "~> 0.20", only: :dev}, + {:ecto, "~> 3.1"}, + {:ecto_sql, "~> 3.1"}, + {:ecto_cockroachdb, "~> 1.0"}, + {:db_connection, "~> 2.0"}, + {:postgrex, ">= 0.14.3"} ] end end diff --git a/mix.lock b/mix.lock index 8448c1b..0b22c5f 100644 --- a/mix.lock +++ b/mix.lock @@ -1,8 +1,16 @@ -%{"connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], []}, - "db_connection": {:hex, :db_connection, "1.1.2", "2865c2a4bae0714e2213a0ce60a1b12d76a6efba0c51fbda59c9ab8d1accc7a8", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, optional: true]}]}, - "decimal": {:hex, :decimal, "1.4.0", "fac965ce71a46aab53d3a6ce45662806bdd708a4a95a65cde8a12eb0124a1333", [:mix], []}, - "earmark": {:hex, :earmark, "1.2.3", "206eb2e2ac1a794aa5256f3982de7a76bf4579ff91cb28d0e17ea2c9491e46a4", [:mix], []}, - "ecto": {:hex, :ecto, "2.2.4", "defde3c8eca385bd86466d2e1491d19e77f9b79ad996dc8e89e4e107f3942f40", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, optional: true]}]}, - "ex_doc": {:hex, :ex_doc, "0.16.4", "4bf6b82d4f0a643b500366ed7134896e8cccdbab4d1a7a35524951b25b1ec9f0", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, optional: false]}]}, - "poolboy": {:hex, :poolboy, "1.5.1", "6b46163901cfd0a1b43d692657ed9d7e599853b3b21b95ae5ae0a777cf9b6ca8", [:rebar], []}, - "postgrex": {:hex, :postgrex_cdb, "0.13.3", "06b13cc193701ab43f8cb141fcc3a5a56fc21de5386abc77eb9006851c21181c", [:mix], [{:connection, "~> 1.0", [hex: :connection, optional: false]}, {:db_connection, "~> 1.1", [hex: :db_connection, optional: false]}, {:decimal, "~> 1.0", [hex: :decimal, optional: false]}]}} +%{ + "connection": {:hex, :connection, "1.0.4", "a1cae72211f0eef17705aaededacac3eb30e6625b04a6117c1b2db6ace7d5976", [:mix], [], "hexpm"}, + "db_connection": {:hex, :db_connection, "2.0.6", "bde2f85d047969c5b5800cb8f4b3ed6316c8cb11487afedac4aa5f93fd39abfa", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}], "hexpm"}, + "decimal": {:hex, :decimal, "1.7.0", "30d6b52c88541f9a66637359ddf85016df9eb266170d53105f02e4a67e00c5aa", [:mix], [], "hexpm"}, + "earmark": {:hex, :earmark, "1.3.2", "b840562ea3d67795ffbb5bd88940b1bed0ed9fa32834915125ea7d02e35888a5", [:mix], [], "hexpm"}, + "ecto": {:hex, :ecto, "3.1.4", "69d852da7a9f04ede725855a35ede48d158ca11a404fe94f8b2fb3b2162cd3c9", [:mix], [{:decimal, "~> 1.6", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"}, + "ecto_cockroachdb": {:hex, :ecto_cockroachdb, "1.0.0", "7f78652aef651d4f14f63e570185cdda8c6d0bb28f8d531ca97f5332c40d46ad", [:mix], [{:ecto, "~> 3.1", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.1", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, ">= 0.14.3", [hex: :postgrex, repo: "hexpm", optional: false]}], "hexpm"}, + "ecto_sql": {:hex, :ecto_sql, "3.1.3", "2c536139190492d9de33c5fefac7323c5eaaa82e1b9bf93482a14649042f7cd9", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.1.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.9.1", [hex: :mariaex, repo: "hexpm", optional: true]}, {:myxql, "~> 0.2.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.14.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"}, + "ex_doc": {:hex, :ex_doc, "0.20.2", "1bd0dfb0304bade58beb77f20f21ee3558cc3c753743ae0ddbb0fd7ba2912331", [:mix], [{:earmark, "~> 1.3", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.10", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"}, + "makeup": {:hex, :makeup, "0.8.0", "9cf32aea71c7fe0a4b2e9246c2c4978f9070257e5c9ce6d4a28ec450a839b55f", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"}, + "makeup_elixir": {:hex, :makeup_elixir, "0.13.0", "be7a477997dcac2e48a9d695ec730b2d22418292675c75aa2d34ba0909dcdeda", [:mix], [{:makeup, "~> 0.8", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"}, + "nimble_parsec": {:hex, :nimble_parsec, "0.5.0", "90e2eca3d0266e5c53f8fbe0079694740b9c91b6747f2b7e3c5d21966bba8300", [:mix], [], "hexpm"}, + "poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm"}, + "postgrex": {:hex, :postgrex, "0.14.3", "5754dee2fdf6e9e508cbf49ab138df964278700b764177e8f3871e658b345a1e", [:mix], [{:connection, "~> 1.0", [hex: :connection, repo: "hexpm", optional: false]}, {:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm"}, + "telemetry": {:hex, :telemetry, "0.4.0", "8339bee3fa8b91cb84d14c2935f8ecf399ccd87301ad6da6b71c09553834b2ab", [:rebar3], [], "hexpm"}, +} diff --git a/test/repo.exs b/test/repo.exs index 7161ff2..cf25ba9 100644 --- a/test/repo.exs +++ b/test/repo.exs @@ -1,17 +1,23 @@ defmodule EctoReplaySandbox.Integration.Repo do defmacro __using__(opts) do quote do - config = Application.get_env(:ecto_replay_sandbox, __MODULE__) - config = Keyword.put(config, :loggers, [Ecto.LogEntry, - {EctoReplaySandbox.Integration.Repo, :log, [:on_log]}]) - Application.put_env(:ecto_replay_sandbox, __MODULE__, config) use Ecto.Repo, unquote(opts) + + @query_event __MODULE__ + |> Module.split() + |> Enum.map(&(&1 |> Macro.underscore() |> String.to_atom())) + |> Kernel.++([:query]) + + def init(_, opts) do + fun = &EctoReplaySandbox.Integration.Repo.handle_event/4 + :telemetry.attach_many(__MODULE__, [[:custom], @query_event], fun, :ok) + {:ok, opts} + end end end - def log(entry, key) do - on_log = Process.delete(key) || fn _ -> :ok end - on_log.(entry) - entry + def handle_event(event, latency, metadata, _config) do + handler = Process.delete(:telemetry) || fn _, _, _ -> :ok end + handler.(event, latency, metadata) end -end \ No newline at end of file +end diff --git a/test/ecto_replay_sandbox_test.exs b/test/sandbox_test.exs similarity index 54% rename from test/ecto_replay_sandbox_test.exs rename to test/sandbox_test.exs index 8b63501..aada266 100644 --- a/test/ecto_replay_sandbox_test.exs +++ b/test/sandbox_test.exs @@ -2,53 +2,79 @@ defmodule EctoReplaySandboxTest do use ExUnit.Case alias EctoReplaySandbox, as: Sandbox - alias EctoReplaySandbox.Integration.TestRepo + alias EctoReplaySandbox.Integration.{PoolRepo, TestRepo} alias EctoReplaySandbox.Integration.Post import ExUnit.CaptureLog - test "include link to SQL sandbox on ownership errors" do - assert_raise DBConnection.OwnershipError, - ~r"See Ecto.Adapters.SQL.Sandbox docs for more information.", fn -> - TestRepo.all(Post) + describe "errors" do + test "raises if repo is not started or not exist" do + assert_raise RuntimeError, + ~r"could not lookup UnknownRepo because it was not started", + fn -> + Sandbox.mode(UnknownRepo, :manual) + end end - end - test "can use the repository when checked out" do - assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> - TestRepo.all(Post) + test "raises if repo is not using sandbox" do + assert_raise RuntimeError, ~r"cannot invoke sandbox operation with pool DBConnection", fn -> + Sandbox.mode(PoolRepo, :manual) + end + + assert_raise RuntimeError, ~r"cannot invoke sandbox operation with pool DBConnection", fn -> + Sandbox.checkout(PoolRepo) + end end - Sandbox.checkout(TestRepo) - assert TestRepo.all(Post) == [] - Sandbox.checkin(TestRepo) - assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> - TestRepo.all(Post) + + test "include link to SQL sandbox on ownership errors" do + assert_raise DBConnection.OwnershipError, + ~r"See Ecto.Adapters.SQL.Sandbox docs for more information.", + fn -> + TestRepo.all(Post) + end end end - test "can use the repository when allowed from another process" do - assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> - TestRepo.all(Post) - end + describe "mode" do + test "uses the repository when checked out" do + assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> + TestRepo.all(Post) + end - parent = self() - Task.start_link fn -> Sandbox.checkout(TestRepo) - Sandbox.allow(TestRepo, self(), parent) - send parent, :allowed - :timer.sleep(:infinity) + assert TestRepo.all(Post) == [] + Sandbox.checkin(TestRepo) + + assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> + TestRepo.all(Post) + end end - assert_receive :allowed - assert TestRepo.all(Post) == [] - end + test "uses the repository when allowed from another process" do + assert_raise DBConnection.OwnershipError, ~r"cannot find ownership process", fn -> + TestRepo.all(Post) + end - test "can use the repository when shared from another process" do - Sandbox.checkout(TestRepo) - Sandbox.mode(TestRepo, {:shared, self()}) - assert Task.async(fn -> TestRepo.all(Post) end) |> Task.await == [] - after - Sandbox.mode(TestRepo, :manual) + parent = self() + + Task.start_link(fn -> + Sandbox.checkout(TestRepo) + Sandbox.allow(TestRepo, self(), parent) + send(parent, :allowed) + Process.sleep(:infinity) + end) + + assert_receive :allowed + assert TestRepo.all(Post) == [] + end + + test "uses the repository when shared from another process" do + Sandbox.checkout(TestRepo) + Sandbox.mode(TestRepo, {:shared, self()}) + assert Task.async(fn -> TestRepo.all(Post) end) |> Task.await() == [] + after + Sandbox.mode(TestRepo, :manual) + end end test "runs inside a sandbox that is rolled back on checkin" do @@ -78,20 +104,22 @@ defmodule EctoReplaySandboxTest do test "transaction works inside the sandbox" do Sandbox.checkout(TestRepo) - TestRepo.transaction fn -> + + TestRepo.transaction(fn -> TestRepo.all(Post) - end + end) + Sandbox.checkin(TestRepo) end test "works even with failed queries" do Sandbox.checkout(TestRepo) - {:ok, _} = TestRepo.insert(%Post{}, skip_transaction: true) + {:ok, _} = TestRepo.insert(%Post{}, skip_transaction: true) # This is a failed query but it should not taint the sandbox transaction {:error, _} = TestRepo.query("INVALID") - {:ok, _} = TestRepo.insert(%Post{}, skip_transaction: true) - assert TestRepo.all(Post) |> Enum.count == 2 + {:ok, _} = TestRepo.insert(%Post{}, skip_transaction: true) + assert TestRepo.all(Post) |> Enum.count() == 2 Sandbox.checkin(TestRepo) end @@ -99,11 +127,12 @@ defmodule EctoReplaySandboxTest do test "the failed transaction is properly rollbacked" do Sandbox.checkout(TestRepo) - TestRepo.transaction fn -> + TestRepo.transaction(fn -> TestRepo.insert(%Post{}) # This is a failed query to trigger a rollback {:error, _} = TestRepo.query("INVALID") - end + end) + assert TestRepo.all(Post) == [] Sandbox.checkin(TestRepo) @@ -113,10 +142,12 @@ defmodule EctoReplaySandboxTest do Sandbox.checkout(TestRepo) {:ok, _} = TestRepo.insert(%Post{}, skip_transaction: true) - TestRepo.transaction fn -> + + TestRepo.transaction(fn -> # This is a failed query to trigger a rollback {:error, _} = TestRepo.query("INVALID") - end + end) + assert TestRepo.all(Post) != [] Sandbox.checkin(TestRepo) @@ -127,11 +158,11 @@ defmodule EctoReplaySandboxTest do {:ok, _} = TestRepo.insert(%Post{id: 1}, skip_transaction: true) - TestRepo.transaction fn -> + TestRepo.transaction(fn -> %Post{} |> Post.changeset(%{id: 1}) - |> TestRepo.insert - end + |> TestRepo.insert() + end) TestRepo.all(Post) @@ -159,25 +190,26 @@ defmodule EctoReplaySandboxTest do assert TestRepo.insert(%Post{}) parent = self() - Task.start_link fn -> + Task.start_link(fn -> Sandbox.allow(TestRepo, parent, self()) assert [_] = TestRepo.all(Post) |> TestRepo.preload([:author, :comments]) - send parent, :success - end + send(parent, :success) + end) assert_receive :success end test "allows an ownership timeout to be passed for an individual `checkout` call" do - log = capture_log fn -> - :ok = Sandbox.checkout(TestRepo, ownership_timeout: 20) + log = + capture_log(fn -> + :ok = Sandbox.checkout(TestRepo, ownership_timeout: 20) - Process.sleep(1000) + Process.sleep(1000) - assert_raise DBConnection.OwnershipError, fn -> - TestRepo.all(Post) - end - end + assert_raise DBConnection.OwnershipError, fn -> + TestRepo.all(Post) + end + end) assert log =~ ~r/timed out.*20ms/ end diff --git a/test/schema.exs b/test/schema.exs index 8a02007..1fec2b5 100644 --- a/test/schema.exs +++ b/test/schema.exs @@ -5,7 +5,8 @@ defmodule EctoReplaySandbox.Integration.Schema do type = Application.get_env(:ecto, :primary_key_type) || - raise ":primary_key_type not set in :ecto application" + raise ":primary_key_type not set in :ecto application" + @primary_key {:id, type, autogenerate: true} @foreign_key_type type @timestamps_opts [usec: false] @@ -24,9 +25,20 @@ defmodule EctoReplaySandbox.Integration.User do use EctoReplaySandbox.Integration.Schema schema "users" do - field :name, :string - has_many :comments, EctoReplaySandbox.Integration.Comment, foreign_key: :author_id, on_delete: :nilify_all, on_replace: :nilify - has_many :posts, EctoReplaySandbox.Integration.Post, foreign_key: :author_id, on_delete: :nothing, on_replace: :delete + field(:name, :string) + + has_many(:comments, EctoReplaySandbox.Integration.Comment, + foreign_key: :author_id, + on_delete: :nilify_all, + on_replace: :nilify + ) + + has_many(:posts, EctoReplaySandbox.Integration.Post, + foreign_key: :author_id, + on_delete: :nothing, + on_replace: :delete + ) + timestamps(type: :utc_datetime) end end @@ -46,23 +58,29 @@ defmodule EctoReplaySandbox.Integration.Post do import Ecto.Changeset schema "posts" do - field :counter, :id # Same as integer - field :title, :string - field :text, :binary - field :temp, :string, default: "temp", virtual: true - field :public, :boolean, default: true - field :cost, :decimal - field :visits, :integer - field :intensity, :float - field :posted, :date - has_many :comments, EctoReplaySandbox.Integration.Comment, on_delete: :delete_all, on_replace: :delete - belongs_to :author, EctoReplaySandbox.Integration.User + # Same as integer + field(:counter, :id) + field(:title, :string) + field(:text, :binary) + field(:temp, :string, default: "temp", virtual: true) + field(:public, :boolean, default: true) + field(:cost, :decimal) + field(:visits, :integer) + field(:intensity, :float) + field(:posted, :date) + + has_many(:comments, EctoReplaySandbox.Integration.Comment, + on_delete: :delete_all, + on_replace: :delete + ) + + belongs_to(:author, EctoReplaySandbox.Integration.User) timestamps() end - def changeset(schema, params) do - cast(schema, params, ~w(counter title text temp public cost visits - intensity posted)) + def changeset(post, params) do + post + |> cast(params, ~w(counter title text temp public cost visits intensity posted)a) end end @@ -75,14 +93,16 @@ defmodule EctoReplaySandbox.Integration.Comment do """ use EctoReplaySandbox.Integration.Schema + import Ecto.Changeset schema "comments" do - field :text, :string - belongs_to :post, EctoReplaySandbox.Integration.Post - belongs_to :author, EctoReplaySandbox.Integration.User + field(:text, :string) + belongs_to(:post, EctoReplaySandbox.Integration.Post) + belongs_to(:author, EctoReplaySandbox.Integration.User) end - def changeset(schema, params) do - Ecto.Changeset.cast(schema, params, [:text]) + def changeset(comment, params) do + comment + |> cast(params, [:text]) end -end \ No newline at end of file +end diff --git a/test/test_helper.exs b/test/test_helper.exs index 6a0ad18..9a06baa 100644 --- a/test/test_helper.exs +++ b/test/test_helper.exs @@ -1,50 +1,66 @@ -Code.compiler_options(ignore_module_conflict: true) - Logger.configure(level: :info) ExUnit.configure(exclude: [:pending, :without_conflict_target]) -ExUnit.start() # Configure Ecto for support and tests -Application.put_env(:ecto, :lock_for_update, "FOR UPDATE") Application.put_env(:ecto, :primary_key_type, :id) +Application.put_env(:ecto, :async_integration_tests, true) +Application.put_env(:ecto_replay_sandbox, :lock_for_update, nil) # Configure CockroachDB connection -Application.put_env(:ecto_replay_sandbox, :cdb_test_url, +Application.put_env( + :ecto_replay_sandbox, + :cdb_test_url, "ecto://" <> (System.get_env("CDB_URL") || "root@localhost:26257") ) # Load support files -Code.require_file "./repo.exs", __DIR__ -Code.require_file "./schema.exs", __DIR__ -Code.require_file "./migration.exs", __DIR__ - -pool = - case System.get_env("ECTO_POOL") || "poolboy" do - "poolboy" -> DBConnection.Poolboy - "sbroker" -> DBConnection.Sojourn - end +Code.require_file("./repo.exs", __DIR__) # Pool repo for async, safe tests alias EctoReplaySandbox.Integration.TestRepo Application.put_env(:ecto_replay_sandbox, TestRepo, - adapter: Ecto.Adapters.Postgres, url: Application.get_env(:ecto_replay_sandbox, :cdb_test_url) <> "/ecto_replay_sandbox_test", - pool: EctoReplaySandbox, - ownership_pool: pool) + pool: EctoReplaySandbox +) defmodule EctoReplaySandbox.Integration.TestRepo do - use EctoReplaySandbox.Integration.Repo, otp_app: :ecto_replay_sandbox + use EctoReplaySandbox.Integration.Repo, + otp_app: :ecto_replay_sandbox, + adapter: Ecto.Adapters.CockroachDB +end + +# Pool repo for non-async tests +alias EctoReplaySandbox.Integration.PoolRepo + +Application.put_env(:ecto_replay_sandbox, PoolRepo, + url: Application.get_env(:ecto_replay_sandbox, :cdb_test_url) <> "/ecto_replay_sandbox_test", + pool_size: 10, + max_restarts: 20, + max_seconds: 10 +) + +defmodule EctoReplaySandbox.Integration.PoolRepo do + use EctoReplaySandbox.Integration.Repo, + otp_app: :ecto_replay_sandbox, + adapter: Ecto.Adapters.CockroachDB end -{:ok, _} = Ecto.Adapters.Postgres.ensure_all_started(TestRepo, :temporary) +# Load support files +Code.require_file("./schema.exs", __DIR__) +Code.require_file("./migration.exs", __DIR__) + +{:ok, _} = Ecto.Adapters.CockroachDB.ensure_all_started(TestRepo.config(), :temporary) # Load up the repository, start it, and run migrations -_ = Ecto.Adapters.Postgres.storage_down(TestRepo.config) -:ok = Ecto.Adapters.Postgres.storage_up(TestRepo.config) +_ = Ecto.Adapters.CockroachDB.storage_down(TestRepo.config()) +:ok = Ecto.Adapters.CockroachDB.storage_up(TestRepo.config()) -{:ok, _pid} = TestRepo.start_link +{:ok, _pid} = TestRepo.start_link() +{:ok, _pid} = PoolRepo.start_link() :ok = Ecto.Migrator.up(TestRepo, 0, EctoReplaySandbox.Integration.Migration, log: false) EctoReplaySandbox.mode(TestRepo, :manual) Process.flag(:trap_exit, true) + +ExUnit.start()