test(integration): Seed write/UoW/audit/delete tests via a separate DbContext (#87)

kploch · claude · web-flow · commit efe9bcd17ecc · 2026-05-20T22:36:09.000+02:00
* test(integration): Seed write/UoW/audit/delete tests via a separate DbContext Convert Arrange-phase fixture seeding in the remaining integration-test classes from the repository / UnitOfWork write path to a separate DbContext (RepositoryHelper.Add...(CreateRootDbContext)), completing the work begun for ReadRepositoryTests. Seeding through a separate context keeps the seeded entities out of the code-under-test's change tracker, so reads genuinely re-hydrate from the database and the fixture setup no longer depends on the write path it is meant to be independent of. Per-test classification (Arrange converted, Act left in place): - ReadWriteRepositoryAsyncTests: all 9 read-test seedings converted. - ReadWriteRepositoryDeleteByIdTests: 3 Arrange seedings converted. - UnitOfWorkRepositoryAsyncSQLiteInMemoryTests: 3 update/delete-test Arrange seedings converted; the add+commit calls in the add-and-query and AddAsync tests left repository-based (the add IS the test) with explanatory comments. - ReadWriteRepositoryAsyncAuditTests: both seedings left repository-based (the class verifies the repository write path's audit behaviour) with explanatory comments. Add DbContext and Func<DbContext> overloads to RepositoryHelper's AddTestBlogEntities helper. Fix UpdateAsync_entity, which was a vacuous self-comparison (seed and read shared one change-tracker instance) until the seed context was separated; exclude the audit columns it does not assert on. Refs: #85 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(integration): Use fetch-modify-update in UpdateAsync_entity Address PR #87 review feedback (gemini-code-assist, codeant-ai): the previous UpdateAsync_entity built a partial Blog (Id + Name only), and ReadWriteRepositoryAsync.UpdateAsync applies it via CurrentValues.SetValues, which blanks every unsupplied column — including CreatedTime. Excluding CreatedTime from the assertion masked that. Switch to the idiomatic fetch-modify-update pattern so the update payload carries every column; CreatedTime is now preserved and asserted rather than excluded. Only ModifiedTime stays excluded (UpdateAsync legitimately changes it). Refs: #85 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(integration): Deconstruct seeding tuple in FindFirstAsync test Address the SonarCloud IDE0042 finding on PR #87: the FindFirstAsync seeding result was bound to a named variable when only one element was used. Deconstruct the tuple directly (`var (_, blogPost1, _)`). Refs: #85 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(integration): Add DbContext seed overloads for the UserIdea helper Address PR #87 review feedback (@kploch): issue #85's acceptance criteria lists the UserIdea helpers among those needing DbContext / Func<DbContext> seed overloads. Add them to AddAsyncTestUserIdeasEntitiesAsync (real logic in the DbContext overload; the Func<DbContext> overload wraps it with await using) so future Arrange-phase UserIdea tests can seed via a separate context without falling back to the repository write path. Refs: #85 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(solution): Fix editorconfig test glob and clear SonarCloud findings The `[*Tests/**/*.cs]` editorconfig section header never matched any file. The section is anchored to the repository root and requires the first path segment to end in literal `Tests`, but test projects live under the lowercase `tests/` directory and editorconfig globs are case-sensitive. As a result the `IDE0058` ("Expression value is never used") suppression intended for test code never took effect, leaving SonarCloud to import the diagnostic for every idiomatic discard of an `EntityEntry` returned by `AddAsync`. Corrected the header to `[tests/**/*.cs]`. Also cleared the remaining SonarCloud findings on PR #87: - Renamed the new async seeding overloads `AddTestBlogEntities` to `AddTestBlogEntitiesAsync` (CC0061). - Simplified the `UserIdea` array returns to collection expressions (IDE0300). Refs: #85 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/.editorconfig b/.editorconfig
@@ -707,7 +707,7 @@ resharper_wrap_before_first_type_parameter_constraint = false
 dotnet_diagnostic.CC0067.severity = none
 
 # Test project overrides
-[*Tests/**/*.cs]
+[tests/**/*.cs]
 # IDE0058: Expression value is never used — test assertions and fluent API chains
 # intentionally discard return values.
 dotnet_diagnostic.IDE0058.severity = none
diff --git a/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryAsyncAuditTests.cs b/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryAsyncAuditTests.cs
@@ -9,6 +9,10 @@ public class ReadWriteRepositoryAsyncAuditTests : GenericRepositoryDataIntegrati
     public async Task Update_and_CommitAsync_should_set_modified_time_audit_property()
     {
         var unitOfWork = CreateUnitOfWork();
+
+        // Seeded through the repository on purpose: this class verifies the audit behaviour of the
+        // repository write path, and the assertion below checks that a repository Add leaves
+        // ModifiedTime unset. A separate-context seed would make that assertion vacuous.
         var (blog, _, _) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
         await unitOfWork.CommitAsync();
 
@@ -29,6 +33,9 @@ public async Task Add_and_CommitAsync_should_update_created_time_audit_property(
     {
         var unitOfWork = CreateUnitOfWork();
         var createdTime = DateTimeOffset.UtcNow;
+
+        // Adding through the repository and committing IS the operation under test here, so this
+        // seeding deliberately stays repository-based.
         var (blog, _, _) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
         await unitOfWork.CommitAsync();
 
diff --git a/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryAsyncTests.cs b/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryAsyncTests.cs
@@ -31,11 +31,9 @@ public async Task ApplySqLiteDateTimeOffsetPropertiesFix_should_handle_DateTimeO
     [Fact]
     public async Task CountAsync_should_return_entity_count()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
         var count = await repository.CountAsync();
@@ -46,11 +44,9 @@ public async Task CountAsync_should_return_entity_count()
     [Fact]
     public async Task GetAllAsync_should_return_entities_with_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, blogPost1, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, blogPost1, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadWriteRepositoryAsync<BlogPost, int>();
         var blogPosts = await repository.GetAllAsync(onDbSet: query => query.Include(e => e.Tags));
@@ -70,11 +66,9 @@ public async Task GetAllAsync_should_return_entities_with_includes()
     [Fact]
     public async Task GetAllAsync_should_return_entities_without_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, blogPost1, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, blogPost1, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadWriteRepositoryAsync<BlogPost, int>();
         var blogPosts = await repository.GetAllAsync();
@@ -86,18 +80,16 @@ public async Task GetAllAsync_should_return_entities_without_includes()
                  .ContainEquivalentOf(blogPost2,
                                       options => options.Excluding(p => p.Categories).Excluding(p => p.Tags).Excluding(p => p.CreatedTime).Excluding(p => p.ModifiedTime));
 
-        // Categories and Tags are not included in the query but they will not be empty because they are already loaded in the context.
-        // This is why I don't check for emptiness here.
+        // GetAllAsync() without an Include does not load Categories or Tags, so they are excluded
+        // from the comparison.
     }
 
     [Fact]
     public async Task GetPageAsync_should_return_a_page_of_entities_with_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(unitOfWork.Repository<Blog, int>(), 20);
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(CreateRootDbContext, 20);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
 
@@ -121,11 +113,9 @@ public async Task GetPageAsync_should_return_a_page_of_entities_with_includes()
     [Fact]
     public async Task GetPageAsync_should_return_a_page_of_entities_with_includes_using_query()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(unitOfWork.Repository<Blog, int>(), 20);
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(CreateRootDbContext, 20);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
 
@@ -156,11 +146,9 @@ public async Task GetPageAsync_should_return_a_page_of_entities_with_includes_us
     [Fact]
     public async Task GetPageAsync_should_return_a_page_of_entities_without_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(unitOfWork.Repository<Blog, int>(), 20);
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, posts) = await RepositoryHelper.AddAsyncTestBlogEntitiesWithManyPostsAsync(CreateRootDbContext, 20);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
 
@@ -182,11 +170,9 @@ public async Task GetPageAsync_should_return_a_page_of_entities_without_includes
     [Fact]
     public async Task GetByIdAsync_should_return_entity_with_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, _, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, _, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
         var blogPost = await repository.GetByIdAsync(blogPost2.Id, query => query.Include(e => e.Tags));
@@ -197,11 +183,9 @@ public async Task GetByIdAsync_should_return_entity_with_includes()
     [Fact]
     public async Task GetByIdAsync_with_object_key_should_return_entity_with_includes()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var (_, _, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, _, blogPost2) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadRepositoryAsync<BlogPost, int>();
         var blogPost = await repository.GetByIdAsync([ blogPost2.Id ]);
@@ -275,18 +259,16 @@ public async Task UpdateAsync_should_throw_if_updated_entity_doesnt_exist()
     [Fact]
     public async Task FindFirstAsync_should_execute_query_and_return_the_first_hit()
     {
-        using var unitOfWork = CreateUnitOfWork();
-
-        var testBlogEntities = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(unitOfWork.Repository<Blog, int>());
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the seeded entities are not in the read
+        // context's change tracker; the query below genuinely round-trips through the database.
+        var (_, blogPost1, _) = await RepositoryHelper.AddAsyncTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadWriteRepositoryAsync<BlogPost, int>();
         var blogPost = await repository.FindFirstAsync(post => post.Name.Contains("Blog post 1"));
 
         blogPost.Should().NotBeNull();
         blogPost.Should()
-                .BeEquivalentTo(testBlogEntities.blogPost1,
+                .BeEquivalentTo(blogPost1,
                                 options => options.Excluding(p => p.Categories)
                                                   .Excluding(p => p.Tags)
                                                   .WithEntityEquivalencyOptions());
diff --git a/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryDeleteByIdTests.cs b/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/ReadWriteRepositoryDeleteByIdTests.cs
@@ -12,11 +12,15 @@ public async Task Delete_by_id_should_remove_entity()
     {
         const int idToDelete = 10;
 
-        using var unitOfWork = CreateUnitOfWork();
-        var asyncRepo = unitOfWork.Repository<TestEntity, int>();
-        await asyncRepo.AddAsync(new() { Id = idToDelete, Name = "ToDelete" });
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the entity is not tracked by the unit of
+        // work that performs the delete; the delete then genuinely round-trips through the database.
+        await using (var seedContext = CreateRootDbContext())
+        {
+            await seedContext.TestEntities.AddAsync(new() { Id = idToDelete, Name = "ToDelete" });
+            await seedContext.SaveChangesAsync();
+        }
 
+        using var unitOfWork = CreateUnitOfWork();
         var repository = unitOfWork.Repository<TestEntity, int>();
         await repository.DeleteAsync(idToDelete);
 
@@ -52,11 +56,9 @@ public void GetById_should_return_null_when_entity_does_not_exist()
     [Fact]
     public async Task GetById_with_onDbSet_should_return_entity()
     {
-        using var unitOfWork = CreateUnitOfWork();
-        var blogRepository1 = unitOfWork.Repository<Blog, int>();
-        var (blog, blogPost1, _) = await RepositoryHelper.AddTestBlogEntities(blogRepository1);
-
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the read below re-hydrates from the database
+        // rather than being served the seeded entities from the read context's change tracker.
+        var (blog, blogPost1, _) = await RepositoryHelper.AddTestBlogEntitiesAsync(CreateRootDbContext);
 
         var repository = CreateReadRepository<Blog, int>();
         var result = repository.GetById(blog.Id, q => q.Include(q => q.BlogPosts).ThenInclude(bp => bp.Tags).Include(q => q.BlogPosts).ThenInclude(bp => bp.Categories));
@@ -83,10 +85,12 @@ public async Task GetById_with_onDbSet_should_return_entity()
     [Fact]
     public async Task GetById_with_onDbSet_should_return_null_when_filter_excludes_entity()
     {
-        using var unitOfWork = CreateUnitOfWork();
-        var asyncRepo = unitOfWork.Repository<TestEntity, int>();
-        await asyncRepo.AddAsync(new() { Id = 1, Name = "Excluded" });
-        await unitOfWork.CommitAsync();
+        // Arrange — seed via a separate context so the read genuinely queries the database.
+        await using (var seedContext = CreateRootDbContext())
+        {
+            await seedContext.TestEntities.AddAsync(new() { Id = 1, Name = "Excluded" });
+            await seedContext.SaveChangesAsync();
+        }
 
         var repository = CreateReadRepository<TestEntity, int>();
         var result = repository.GetById(1, q => q.Where(e => e.Name == "NonExistent"));
diff --git a/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/RepositoryHelper.cs b/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/RepositoryHelper.cs
@@ -54,14 +54,60 @@ public static (Blog, BlogPost, BlogPost) AddTestBlogEntities(IReadWriteRepositor
         return (blog, blogPost1, blogPost2);
     }
 
+    /// <summary>
+    /// Seeds a blog with two blog posts directly via the <see cref="DbContext" /> and returns the seeded entities.
+    /// </summary>
+    /// <remarks>
+    /// Use this overload in the Arrange phase of an integration test. Seeding through the plain
+    /// <see cref="DbContext" /> — rather than through a repository — keeps the test's fixture setup
+    /// independent of the Generic Repository write path, which is itself code under test.
+    /// </remarks>
+    /// <param name="dbContext">The <see cref="DbContext" /> to add the blog to.</param>
+    /// <returns>
+    /// A task that resolves to a tuple of the seeded <see cref="Blog" /> and the two <see cref="BlogPost" />
+    /// instances attached to it.
+    /// </returns>
+    public static async Task<(Blog, BlogPost, BlogPost)> AddTestBlogEntitiesAsync(DbContext dbContext)
+    {
+        var (blog, blogPost1, blogPost2) = EntitiesBuilder.BuildBlogEntity();
+
+        await dbContext.AddAsync(blog);
+        await dbContext.SaveChangesAsync();
+
+        return (blog, blogPost1, blogPost2);
+    }
+
+    /// <summary>
+    /// Seeds a blog with two blog posts via a short-lived <see cref="DbContext" /> obtained from
+    /// <paramref name="dbContextFactory" /> and returns the seeded entities.
+    /// </summary>
+    /// <remarks>
+    /// The context produced by <paramref name="dbContextFactory" /> is created, used, and disposed
+    /// inside this method. Pass <c>CreateRootDbContext</c> so the fixture is seeded through a context
+    /// separate from the one the code under test reads through — this keeps the seeded entities out
+    /// of the read context's change tracker without the caller managing a context's lifetime or
+    /// remembering to clear the tracker.
+    /// </remarks>
+    /// <param name="dbContextFactory">A factory that produces a new <see cref="DbContext" /> to seed through.</param>
+    /// <returns>
+    /// A task that resolves to a tuple of the seeded <see cref="Blog" /> and the two <see cref="BlogPost" />
+    /// instances attached to it.
+    /// </returns>
+    public static async Task<(Blog, BlogPost, BlogPost)> AddTestBlogEntitiesAsync(Func<DbContext> dbContextFactory)
+    {
+        await using var dbContext = dbContextFactory();
+
+        return await AddTestBlogEntitiesAsync(dbContext);
+    }
+
     public static IEnumerable<UserIdea> AddTestUserIdeasEntities(IReadWriteRepository<UserIdea, int> userIdeasRepository)
     {
         var (userIdea1, userIdea2) = EntitiesBuilder.BuildUserIdeaEntities();
 
         userIdeasRepository.Add(userIdea1);
         userIdeasRepository.Add(userIdea2);
 
-        return new[] { userIdea1, userIdea2 };
+        return [userIdea1, userIdea2];
     }
 
     public static async Task<(Blog blog, BlogPost[] blogPosts)> AddAsyncTestBlogEntitiesWithManyPostsAsync(IReadWriteRepositoryAsync<Blog, int> blogReadWriteRepository,
@@ -206,7 +252,46 @@ public static async Task<IEnumerable<UserIdea>> AddAsyncTestUserIdeasEntitiesAsy
         await userIdeasReadWriteRepository.AddAsync(userIdea1);
         await userIdeasReadWriteRepository.AddAsync(userIdea2);
 
-        return new[] { userIdea1, userIdea2 };
+        return [userIdea1, userIdea2];
+    }
+
+    /// <summary>
+    /// Seeds two user-idea entities directly via the <see cref="DbContext" /> and returns them.
+    /// </summary>
+    /// <remarks>
+    /// Use this overload in the Arrange phase of an integration test. Seeding through the plain
+    /// <see cref="DbContext" /> — rather than through a repository — keeps the test's fixture setup
+    /// independent of the Generic Repository write path, which is itself code under test.
+    /// </remarks>
+    /// <param name="dbContext">The <see cref="DbContext" /> to add the user ideas to.</param>
+    /// <returns>A task that resolves to the two seeded <see cref="UserIdea" /> entities.</returns>
+    public static async Task<IEnumerable<UserIdea>> AddAsyncTestUserIdeasEntitiesAsync(DbContext dbContext)
+    {
+        var (userIdea1, userIdea2) = EntitiesBuilder.BuildUserIdeaEntities();
+
+        await dbContext.AddAsync(userIdea1);
+        await dbContext.AddAsync(userIdea2);
+        await dbContext.SaveChangesAsync();
+
+        return [userIdea1, userIdea2];
+    }
+
+    /// <summary>
+    /// Seeds two user-idea entities via a short-lived <see cref="DbContext" /> obtained from
+    /// <paramref name="dbContextFactory" /> and returns them.
+    /// </summary>
+    /// <remarks>
+    /// The context produced by <paramref name="dbContextFactory" /> is created, used, and disposed
+    /// inside this method. Pass <c>CreateRootDbContext</c> to seed through a context separate from
+    /// the one the code under test reads through.
+    /// </remarks>
+    /// <param name="dbContextFactory">A factory that produces a new <see cref="DbContext" /> to seed through.</param>
+    /// <returns>A task that resolves to the two seeded <see cref="UserIdea" /> entities.</returns>
+    public static async Task<IEnumerable<UserIdea>> AddAsyncTestUserIdeasEntitiesAsync(Func<DbContext> dbContextFactory)
+    {
+        await using var dbContext = dbContextFactory();
+
+        return await AddAsyncTestUserIdeasEntitiesAsync(dbContext);
     }
 
     public static async Task<BlogPostTag[]> AddBlogPostTagsAsync(IReadWriteRepositoryAsync<BlogPostTag, int> repository, int tagCount)
diff --git a/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/UnitOfWorkRepositoryAsyncSQLiteInMemoryTests.cs b/tests/Data.GenericRepository/Data.GenericRepository.EFCore.IntegrationTests/UnitOfWorkRepositoryAsyncSQLiteInMemoryTests.cs
