update

phoenix/deps/ecto_sql/integration_test/sql/transaction.exs

@@ -0,0 +1,277 @@
+defmodule Ecto.Integration.TransactionTest do
+  # We can keep this test async as long as it
+  # is the only one access the transactions table
+  use Ecto.Integration.Case, async: true
+
+  import Ecto.Query
+  alias Ecto.Integration.PoolRepo # Used for writes
+  alias Ecto.Integration.TestRepo # Used for reads
+
+  @moduletag :capture_log
+
+  defmodule UniqueError do
+    defexception message: "unique error"
+  end
+
+  setup do
+    PoolRepo.delete_all "transactions"
+    :ok
+  end
+
+  defmodule Trans do
+    use Ecto.Schema
+
+    schema "transactions" do
+      field :num, :integer
+    end
+  end
+
+  test "transaction returns value" do
+    refute PoolRepo.in_transaction?()
+    {:ok, val} = PoolRepo.transaction(fn ->
+      assert PoolRepo.in_transaction?()
+      {:ok, val} =
+        PoolRepo.transaction(fn ->
+          assert PoolRepo.in_transaction?()
+          42
+        end)
+      assert PoolRepo.in_transaction?()
+      val
+    end)
+    refute PoolRepo.in_transaction?()
+    assert val == 42
+  end
+
+  test "transaction re-raises" do
+    assert_raise UniqueError, fn ->
+      PoolRepo.transaction(fn ->
+        PoolRepo.transaction(fn ->
+          raise UniqueError
+        end)
+      end)
+    end
+  end
+
+  # tag is required for TestRepo, since it is checkout in
+  # Ecto.Integration.Case setup
+  @tag isolation_level: :snapshot
+  test "transaction commits" do
+    # mssql requires that all transactions that use same shared lock are set
+    # to :snapshot isolation level
+    opts = [isolation_level: :snapshot]
+
+    PoolRepo.transaction(fn ->
+      e = PoolRepo.insert!(%Trans{num: 1})
+      assert [^e] = PoolRepo.all(Trans)
+      assert [] = TestRepo.all(Trans)
+    end, opts)
+
+    assert [%Trans{num: 1}] = PoolRepo.all(Trans)
+  end
+
+  @tag isolation_level: :snapshot
+  test "transaction rolls back" do
+    opts = [isolation_level: :snapshot]
+    try do
+      PoolRepo.transaction(fn ->
+        e = PoolRepo.insert!(%Trans{num: 2})
+        assert [^e] = PoolRepo.all(Trans)
+        assert [] = TestRepo.all(Trans)
+        raise UniqueError
+      end, opts)
+    rescue
+      UniqueError -> :ok
+    end
+
+    assert [] = TestRepo.all(Trans)
+  end
+
+  test "transaction rolls back per repository" do
+    message = "cannot call rollback outside of transaction"
+
+    assert_raise RuntimeError, message, fn ->
+      PoolRepo.rollback(:done)
+    end
+
+    assert_raise RuntimeError, message, fn ->
+      TestRepo.transaction fn ->
+        PoolRepo.rollback(:done)
+      end
+    end
+  end
+
+  @tag :assigns_id_type
+  test "transaction rolls back with reason on aborted transaction" do
+    e1 = PoolRepo.insert!(%Trans{num: 13})
+
+    assert_raise Ecto.ConstraintError, fn ->
+      TestRepo.transaction fn ->
+        PoolRepo.insert!(%Trans{id: e1.id, num: 14})
+      end
+    end
+  end
+
+  test "nested transaction partial rollback" do
+    assert PoolRepo.transaction(fn ->
+      e1 = PoolRepo.insert!(%Trans{num: 3})
+      assert [^e1] = PoolRepo.all(Trans)
+
+      try do
+        PoolRepo.transaction(fn ->
+          e2 = PoolRepo.insert!(%Trans{num: 4})
+          assert [^e1, ^e2] = PoolRepo.all(from(t in Trans, order_by: t.num))
+          raise UniqueError
+        end)
+      rescue
+        UniqueError -> :ok
+      end
+
+      assert_raise DBConnection.ConnectionError, "transaction rolling back",
+        fn() -> PoolRepo.insert!(%Trans{num: 5}) end
+    end) == {:error, :rollback}
+
+    assert TestRepo.all(Trans) == []
+  end
+
+  test "manual rollback doesn't bubble up" do
+    x = PoolRepo.transaction(fn ->
+      e = PoolRepo.insert!(%Trans{num: 6})
+      assert [^e] = PoolRepo.all(Trans)
+      PoolRepo.rollback(:oops)
+    end)
+
+    assert x == {:error, :oops}
+    assert [] = TestRepo.all(Trans)
+  end
+
+  test "manual rollback bubbles up on nested transaction" do
+    assert PoolRepo.transaction(fn ->
+      e = PoolRepo.insert!(%Trans{num: 7})
+      assert [^e] = PoolRepo.all(Trans)
+      assert {:error, :oops} = PoolRepo.transaction(fn ->
+        PoolRepo.rollback(:oops)
+      end)
+      assert_raise DBConnection.ConnectionError, "transaction rolling back",
+        fn() -> PoolRepo.insert!(%Trans{num: 8}) end
+    end) == {:error, :rollback}
+
+    assert [] = TestRepo.all(Trans)
+  end
+
+  test "transactions are not shared in repo" do
+    pid = self()
+    opts = [isolation_level: :snapshot]
+
+    new_pid = spawn_link fn ->
+      PoolRepo.transaction(fn ->
+        e = PoolRepo.insert!(%Trans{num: 9})
+        assert [^e] = PoolRepo.all(Trans)
+        send(pid, :in_transaction)
+        receive do
+          :commit -> :ok
+        after
+          5000 -> raise "timeout"
+        end
+      end, opts)
+      send(pid, :committed)
+    end
+
+    receive do
+      :in_transaction -> :ok
+    after
+      5000 -> raise "timeout"
+    end
+
+    # mssql requires that all transactions that use same shared lock
+    # set transaction isolation level to "snapshot" so this must be wrapped into
+    # explicit transaction
+    PoolRepo.transaction(fn ->
+      assert [] = PoolRepo.all(Trans)
+    end, opts)
+
+    send(new_pid, :commit)
+    receive do
+      :committed -> :ok
+    after
+      5000 -> raise "timeout"
+    end
+
+    assert [%Trans{num: 9}] = PoolRepo.all(Trans)
+  end
+
+  ## Checkout
+
+  describe "with checkouts" do
+    test "transaction inside checkout" do
+      PoolRepo.checkout(fn ->
+        refute PoolRepo.in_transaction?()
+        PoolRepo.transaction(fn ->
+          assert PoolRepo.in_transaction?()
+        end)
+        refute PoolRepo.in_transaction?()
+      end)
+    end
+
+    test "checkout inside transaction" do
+      PoolRepo.transaction(fn ->
+        assert PoolRepo.in_transaction?()
+        PoolRepo.checkout(fn ->
+          assert PoolRepo.in_transaction?()
+        end)
+        assert PoolRepo.in_transaction?()
+      end)
+    end
+
+    @tag :transaction_checkout_raises
+    test "checkout raises on transaction attempt" do
+      assert_raise DBConnection.ConnectionError, ~r"connection was checked out with status", fn ->
+        PoolRepo.checkout(fn -> PoolRepo.query!("BEGIN") end)
+      end
+    end
+  end
+
+  ## Logging
+
+  defp register_telemetry() do
+    Process.put(:telemetry, fn _, measurements, event -> send(self(), {measurements, event}) end)
+  end
+
+  test "log begin, commit and rollback" do
+    register_telemetry()
+
+    PoolRepo.transaction(fn ->
+      assert_received {measurements, %{params: [], result: {:ok, _res}}}
+      assert is_integer(measurements.query_time) and measurements.query_time >= 0
+      assert is_integer(measurements.queue_time) and measurements.queue_time >= 0
+
+      refute_received %{}
+      register_telemetry()
+    end)
+
+    assert_received {measurements, %{params: [], result: {:ok, _res}}}
+    assert is_integer(measurements.query_time) and measurements.query_time >= 0
+    refute Map.has_key?(measurements, :queue_time)
+
+    assert PoolRepo.transaction(fn ->
+      refute_received %{}
+      register_telemetry()
+      PoolRepo.rollback(:log_rollback)
+    end) == {:error, :log_rollback}
+
+    assert_received {measurements, %{params: [], result: {:ok, _res}}}
+    assert is_integer(measurements.query_time) and measurements.query_time >= 0
+    refute Map.has_key?(measurements, :queue_time)
+  end
+
+  test "log queries inside transactions" do
+    PoolRepo.transaction(fn ->
+      register_telemetry()
+      assert [] = PoolRepo.all(Trans)
+
+      assert_received {measurements, %{params: [], result: {:ok, _res}}}
+      assert is_integer(measurements.query_time) and measurements.query_time >= 0
+      assert is_integer(measurements.decode_time) and measurements.query_time >= 0
+      refute Map.has_key?(measurements, :queue_time)
+    end)
+  end
+end