Merge branch 'development'

Directory.Packages.props

@@ -9,11 +9,5 @@
     <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.7" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.7" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.7" />
-    <!-- Tests -->
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.7" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
   </ItemGroup>
 </Project>

HrynCo.DAL.EF.Tests/EfUnitOfWorkTests.cs

@@ -1,213 +0,0 @@
-namespace HrynCo.DAL.EF.Tests;
-
-using HrynCo.DAL.Abstract;
-using Microsoft.EntityFrameworkCore;
-using Xunit;
-
-public sealed class EfUnitOfWorkTests
-{
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task ActionFailure_ReportsBothExceptionsWhenRollbackFails(bool returnsResult)
-    {
-        var original = new InvalidOperationException("Action failed.");
-        var rollbackFailure = new InvalidOperationException("Transaction completed.");
-        var interceptor = new TransactionFailureInterceptor
-        {
-            RollbackException = rollbackFailure
-        };
-        await using DbContext context = await CreateContextAsync(interceptor);
-        var unitOfWork = new TestUnitOfWork(context);
-
-        AggregateException actual = await Assert.ThrowsAsync<AggregateException>(() =>
-            ExecuteAsync(unitOfWork, returnsResult, () => Task.FromException(original)));
-
-        Assert.Collection(actual.InnerExceptions,
-            error => Assert.Same(original, error),
-            error => Assert.Same(rollbackFailure, error));
-        Assert.Equal(1, interceptor.RollbackAttempts);
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-        Assert.Null(context.Database.CurrentTransaction);
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task CommitFailure_ReportsBothExceptionsWhenRollbackFails(bool returnsResult)
-    {
-        var original = new InvalidOperationException("Commit failed.");
-        var rollbackFailure = new InvalidOperationException("Transaction completed.");
-        var interceptor = new TransactionFailureInterceptor
-        {
-            CommitException = original,
-            RollbackException = rollbackFailure
-        };
-        await using DbContext context = await CreateContextAsync(interceptor);
-        var unitOfWork = new TestUnitOfWork(context);
-
-        AggregateException actual = await Assert.ThrowsAsync<AggregateException>(() =>
-            ExecuteAsync(unitOfWork, returnsResult, () => Task.CompletedTask));
-
-        Assert.Collection(actual.InnerExceptions,
-            error => Assert.Same(original, error),
-            error => Assert.Same(rollbackFailure, error));
-        Assert.Equal(1, interceptor.CommitAttempts);
-        Assert.Equal(1, interceptor.RollbackAttempts);
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-        Assert.Null(context.Database.CurrentTransaction);
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task CompletedTransaction_ReportsActionAndRollbackExceptions(bool returnsResult)
-    {
-        await using DbContext context = await CreateContextAsync();
-        var unitOfWork = new TestUnitOfWork(context);
-        var original = new InvalidOperationException("Action failed after the provider completed the transaction.");
-
-        AggregateException actual = await Assert.ThrowsAsync<AggregateException>(() =>
-            ExecuteAsync(unitOfWork, returnsResult, async () =>
-            {
-                await context.Database.CurrentTransaction!.CommitAsync();
-                throw original;
-            }));
-
-        Assert.Same(original, actual.InnerExceptions[0]);
-        Assert.IsType<InvalidOperationException>(actual.InnerExceptions[1]);
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-        Assert.Null(context.Database.CurrentTransaction);
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task ActionFailure_RollsBackWritesAndAllowsNextTransaction(bool returnsResult)
-    {
-        await using DbContext context = await CreateContextAsync();
-        var unitOfWork = new TestUnitOfWork(context);
-        var original = new InvalidOperationException("Action failed.");
-
-        Exception actual = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            ExecuteAsync(unitOfWork, returnsResult, async () =>
-            {
-                await context.Database.ExecuteSqlRawAsync("INSERT INTO records VALUES (1)");
-                throw original;
-            }));
-
-        Assert.Same(original, actual);
-        Assert.Equal(0, await CountRecordsAsync(context));
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-        await ExecuteAsync(unitOfWork, returnsResult,
-            () => context.Database.ExecuteSqlRawAsync("INSERT INTO records VALUES (2)"));
-        Assert.Equal(1, await CountRecordsAsync(context));
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task Success_CommitsWritesAndCreatesFreshTransactionForNextCall(bool returnsResult)
-    {
-        var interceptor = new TransactionFailureInterceptor();
-        await using DbContext context = await CreateContextAsync(interceptor);
-        var unitOfWork = new TestUnitOfWork(context);
-        ITransaction? first = null;
-
-        await ExecuteAsync(unitOfWork, returnsResult, async () =>
-        {
-            first = unitOfWork.GetCurrentTransaction();
-            await context.Database.ExecuteSqlRawAsync("INSERT INTO records VALUES (1)");
-        });
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-        Assert.Null(context.Database.CurrentTransaction);
-        await ExecuteAsync(unitOfWork, returnsResult, async () =>
-        {
-            Assert.NotSame(first, unitOfWork.GetCurrentTransaction());
-            await context.Database.ExecuteSqlRawAsync("INSERT INTO records VALUES (2)");
-        });
-
-        Assert.Equal(2, await CountRecordsAsync(context));
-        Assert.Equal(2, interceptor.CommitAttempts);
-        Assert.Equal(0, interceptor.RollbackAttempts);
-        Assert.Null(unitOfWork.GetCurrentTransaction());
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task CallerOwnedTransaction_SuccessLeavesLifecycleToCaller(bool returnsResult)
-    {
-        var interceptor = new TransactionFailureInterceptor();
-        await using DbContext context = await CreateContextAsync(interceptor);
-        var unitOfWork = new TestUnitOfWork(context);
-        await using ITransaction transaction = await unitOfWork.BeginTransactionAsync();
-
-        await ExecuteAsync(unitOfWork, returnsResult,
-            () => context.Database.ExecuteSqlRawAsync("INSERT INTO records VALUES (1)"));
-
-        Assert.Same(transaction, unitOfWork.GetCurrentTransaction());
-        Assert.NotNull(context.Database.CurrentTransaction);
-        Assert.Equal(0, interceptor.CommitAttempts);
-        Assert.Equal(0, interceptor.RollbackAttempts);
-        await transaction.RollbackAsync();
-        Assert.Equal(0, await CountRecordsAsync(context));
-    }
-
-    [Theory]
-    [InlineData(false)]
-    [InlineData(true)]
-    public async Task CallerOwnedTransaction_FailureLeavesLifecycleToCaller(bool returnsResult)
-    {
-        var interceptor = new TransactionFailureInterceptor();
-        await using DbContext context = await CreateContextAsync(interceptor);
-        var unitOfWork = new TestUnitOfWork(context);
-        await using ITransaction transaction = await unitOfWork.BeginTransactionAsync();
-        var original = new InvalidOperationException("Action failed.");
-
-        Exception actual = await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            ExecuteAsync(unitOfWork, returnsResult, () => Task.FromException(original)));
-
-        Assert.Same(original, actual);
-        Assert.Same(transaction, unitOfWork.GetCurrentTransaction());
-        Assert.NotNull(context.Database.CurrentTransaction);
-        Assert.Equal(0, interceptor.CommitAttempts);
-        Assert.Equal(0, interceptor.RollbackAttempts);
-        await transaction.RollbackAsync();
-    }
-
-    private static async Task ExecuteAsync(TestUnitOfWork unitOfWork, bool returnsResult, Func<Task> action)
-    {
-        if (returnsResult)
-        {
-            int result = await unitOfWork.ExecuteInTransactionAsync(async () =>
-            {
-                await action();
-                return 42;
-            });
-            Assert.Equal(42, result);
-            return;
-        }
-
-        await unitOfWork.ExecuteInTransactionAsync(action);
-    }
-
-    private static async Task<DbContext> CreateContextAsync(TransactionFailureInterceptor? interceptor = null)
-    {
-        var options = new DbContextOptionsBuilder().UseSqlite("Data Source=:memory:");
-        if (interceptor is not null)
-        {
-            options.AddInterceptors(interceptor);
-        }
-
-        var context = new DbContext(options.Options);
-        await context.Database.OpenConnectionAsync();
-        await context.Database.ExecuteSqlRawAsync("CREATE TABLE records (id INTEGER NOT NULL)");
-        return context;
-    }
-
-    private static Task<int> CountRecordsAsync(DbContext context)
-    {
-        return context.Database.SqlQueryRaw<int>("SELECT COUNT(*) AS Value FROM records").SingleAsync();
-    }
-}

HrynCo.DAL.EF.Tests/HrynCo.DAL.EF.Tests.csproj

@@ -1,20 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net10.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" />
-    <PackageReference Include="xunit" />
-    <PackageReference Include="xunit.runner.visualstudio">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <ProjectReference Include="..\HrynCo.DAL.EF\HrynCo.DAL.EF.csproj" />
-  </ItemGroup>
-</Project>

HrynCo.DAL.EF.Tests/TestUnitOfWork.cs

@@ -1,6 +0,0 @@
-namespace HrynCo.DAL.EF.Tests;
-
-using HrynCo.DAL.EF.Core;
-using Microsoft.EntityFrameworkCore;
-
-internal sealed class TestUnitOfWork(DbContext context) : EfUnitOfWork<DbContext>(context);

HrynCo.DAL.EF.Tests/TransactionFailureInterceptor.cs

@@ -1,42 +0,0 @@
-namespace HrynCo.DAL.EF.Tests;
-
-using System.Data.Common;
-using Microsoft.EntityFrameworkCore.Diagnostics;
-
-internal sealed class TransactionFailureInterceptor : DbTransactionInterceptor
-{
-    public Exception? CommitException { get; init; }
-    public Exception? RollbackException { get; init; }
-    public int CommitAttempts { get; private set; }
-    public int RollbackAttempts { get; private set; }
-
-    public override ValueTask<InterceptionResult> TransactionCommittingAsync(
-        DbTransaction transaction,
-        TransactionEventData eventData,
-        InterceptionResult result,
-        CancellationToken cancellationToken = default)
-    {
-        CommitAttempts++;
-        if (CommitException is not null)
-        {
-            throw CommitException;
-        }
-
-        return ValueTask.FromResult(result);
-    }
-
-    public override ValueTask<InterceptionResult> TransactionRollingBackAsync(
-        DbTransaction transaction,
-        TransactionEventData eventData,
-        InterceptionResult result,
-        CancellationToken cancellationToken = default)
-    {
-        RollbackAttempts++;
-        if (RollbackException is not null)
-        {
-            throw RollbackException;
-        }
-
-        return ValueTask.FromResult(result);
-    }
-}

HrynCo.DAL.EF/Core/EfUnitOfWork.cs

@@ -42,11 +42,11 @@ public class EfUnitOfWork<TDbContext> : IUnitOfWork
                 await tx.CommitAsync();
             }
         }
-        catch (Exception original)
+        catch
         {
             if (ownsTransaction)
             {
-                await RollbackPreservingFailureAsync(tx, original);
+                await tx.RollbackAsync();
             }
 
             throw;
@@ -55,14 +55,7 @@ public class EfUnitOfWork<TDbContext> : IUnitOfWork
         {
             if (ownsTransaction)
             {
-                try
+                await tx.DisposeAsync();
-                {
-                    await tx.DisposeAsync();
-                }
-                finally
-                {
-                    _currentTransaction = null;
-                }
             }
         }
     }
@@ -84,11 +77,11 @@ public class EfUnitOfWork<TDbContext> : IUnitOfWork
 
             return result;
         }
-        catch (Exception original)
+        catch
         {
             if (ownsTransaction)
             {
-                await RollbackPreservingFailureAsync(tx, original);
+                await tx.RollbackAsync();
             }
 
             throw;
@@ -97,30 +90,11 @@ public class EfUnitOfWork<TDbContext> : IUnitOfWork
         {
             if (ownsTransaction)
             {
-                try
+                await tx.DisposeAsync();
-                {
-                    await tx.DisposeAsync();
-                }
-                finally
-                {
-                    _currentTransaction = null;
-                }
             }
         }
     }
 
-    private static async Task RollbackPreservingFailureAsync(ITransaction transaction, Exception original)
-    {
-        try
-        {
-            await transaction.RollbackAsync();
-        }
-        catch (Exception rollbackFailure)
-        {
-            throw new AggregateException("The transaction and its rollback both failed.", original, rollbackFailure);
-        }
-    }
-
     public ITransaction? GetCurrentTransaction()
     {
         return _currentTransaction;

README.md

@@ -4,13 +4,12 @@ Reusable Entity Framework Core base library for HrynCo applications.
 
 ## Solution
 
-The solution (`hrynco-ef.slnx`) contains the following projects:
+The solution (`hrynco-ef.slnx`) contains two projects:
 
 | Project | Description |
 |---|---|
 | `HrynCo.DAL.Abstract` | Infrastructure-agnostic contracts: entities, repository interfaces, unit of work, transactions, pagination. No EF Core dependency. |
 | `HrynCo.DAL.EF` | Entity Framework Core implementations of the abstract contracts. Depends on `HrynCo.DAL.Abstract` and EF Core. |
-| `HrynCo.DAL.EF.Tests` | Transaction lifecycle regression tests using SQLite in memory. |
 
 The split allows consuming projects to reference only `HrynCo.DAL.Abstract` in domain/application layers, keeping those layers free of EF Core.
 
@@ -182,18 +181,6 @@ Entity Framework Core implementations of the abstract contracts.
 
 ## Usage
 
-### Transaction ownership and failures
-
-Both `ExecuteInTransactionAsync` overloads create, commit, and dispose a transaction when no transaction is already cached by the unit of work. After disposal, the cached reference is cleared, so a later call starts a fresh transaction.
-
-If the action or commit fails, the owned transaction is rolled back. If rollback also fails (including when the provider reports a completed transaction), an `AggregateException` contains the original failure first and the rollback failure second. Disposal still runs.
-
-When `BeginTransactionAsync` has already supplied a transaction to the caller, `ExecuteInTransactionAsync` runs the action inside that transaction and leaves commit, rollback, and disposal to the caller. Its cached reference is retained as before; the automatic cleanup above applies only to transactions owned by `ExecuteInTransactionAsync`.
-
-Run the regression suite with `dotnet test hrynco-ef.slnx`.
-
-### Package references
-
 Reference `HrynCo.DAL.Abstract` for contracts only (e.g. in domain/application layers).  
 Reference `HrynCo.DAL.EF` for the full EF Core implementation (infrastructure layer).
 

hrynco-ef.slnx

@@ -1,5 +1,4 @@
 <Solution>
   <Project Path="HrynCo.DAL.Abstract/HrynCo.DAL.Abstract.csproj" />
   <Project Path="HrynCo.DAL.EF/HrynCo.DAL.EF.csproj" />
-  <Project Path="HrynCo.DAL.EF.Tests/HrynCo.DAL.EF.Tests.csproj" />
 </Solution>