Fix: One Scope per seeder, instead of one scope per group

Author: AnnaSasDev

src/CodeOfChaos.Types.DataSeeder/ISeeder.cs

@@ -1,8 +1,6 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
-using Microsoft.Extensions.Logging;
-
 namespace CodeOfChaos.Types;
 // ---------------------------------------------------------------------------------------------------------------------
 // Code
@@ -12,21 +10,29 @@ namespace CodeOfChaos.Types;
 ///     and executes the seeding logic if required.
 /// </summary>
 public interface ISeeder {
+    bool ShouldSeed { get; }
+    
+    // -----------------------------------------------------------------------------------------------------------------
+    // Methods
+    // -----------------------------------------------------------------------------------------------------------------
     /// <summary>
-    ///     Initiates the seeding process for the implementing class.
+    /// Initiates the seeding process for the implementing class.
     /// </summary>
-    /// <param name="logger">An instance of <see cref="ILogger" /> for logging operations.</param>
+    /// <param name="serviceProvider">
+    /// An instance of <see cref="IServiceProvider" /> used to resolve dependencies during the seeding process.
+    /// </param>
     /// <param name="ct">
-    ///     A <see cref="CancellationToken" /> to observe while waiting for the task to complete. Defaults to
-    ///     <see cref="CancellationToken.None" />.
+    /// A <see cref="CancellationToken" /> to observe while waiting for the task to complete. Defaults to
+    /// <see cref="CancellationToken.None" />.
     /// </param>
     /// <returns>A <see cref="Task" /> that represents the asynchronous operation.</returns>
     /// <remarks>
-    ///     This method should first checks whether seeding should occur by calling <c>ShouldSeedAsync</c>. If seeding is not
-    ///     needed, it logs an informational message and returns.
-    ///     If seeding is required, the method executes <c>SeedAsync</c>, respecting the provided cancellation token.
+    /// This method orchestrates the seeding process, ensuring any required dependencies are resolved via the provided
+    /// <c>serviceProvider</c>. If the implementation detects that seeding is unnecessary,
+    /// it will gracefully conclude the operation. If any steps in the seeding process require cancellation,
+    /// they will respect the provided <c>CancellationToken</c>.
     /// </remarks>
-    Task StartAsync(ILogger logger, CancellationToken ct = default);
+    Task StartAsync(IServiceProvider serviceProvider, CancellationToken ct = default);
 
     /// Determines whether the seeding process should proceed or be skipped.
     /// <param name="ct">A cancellation token that can be used to cancel the operation.</param>

src/CodeOfChaos.Types.DataSeeder/OneTimeDataSeederService.cs

@@ -69,19 +69,27 @@ public async Task StartAsync(CancellationToken ct = default) {
                 continue;
             }
 
-            // Each group should have their own scope
-            await using AsyncServiceScope scope = serviceProvider.CreateAsyncScope();
-            IServiceProvider scopeProvider = scope.ServiceProvider;
-            List<ISeeder> seeders = [];
+            // Each SEEDER should have their own scope
+            List<(Task, AsyncServiceScope)> seederTasks = [];
 
             while (seederGroup.SeederTypes.TryDequeue(out Type? seederType)) {
-                var seeder = (ISeeder)scopeProvider.GetRequiredService(seederType);
-                seeders.Add(seeder);
-
+                AsyncServiceScope scope = serviceProvider.CreateAsyncScope();
+                IServiceProvider scopeProvider = scope.ServiceProvider;
+                // Because of checks by the SeederGroup struct we know that the seeder inherits from ISeeder and thus is not null
+                var seeder = (ISeeder) scopeProvider.GetRequiredService(seederType);
+                Task seederTask = seeder.StartAsync(scopeProvider, ct); 
+                
+                // Because our scope has to be gracefully disposed, we add the scope here
+                seederTasks.Add((seederTask, scope));
             }
 
-            logger.LogDebug("ExecutionStep {step} : {count} Seeder(s) found, executing...", i++, seeders.Count);
-            await Task.WhenAll(seeders.Select(seeder => seeder.StartAsync(logger, ct)));
+            logger.LogDebug("ExecutionStep {step} : {count} Seeder(s) found, executing...", i++, seederTasks.Count);
+            await Task.WhenAll(seederTasks.Select(t => t.Item1));
+            
+            // Gracefully dispose the scope
+            foreach (AsyncServiceScope scope in seederTasks.Select(t => t.Item2)) {
+                await scope.DisposeAsync();
+            }
         }
 
         logger.LogInformation("All seeders completed in {i} steps", i);

src/CodeOfChaos.Types.DataSeeder/Seeder.cs

@@ -1,6 +1,7 @@
 // ---------------------------------------------------------------------------------------------------------------------
 // Imports
 // ---------------------------------------------------------------------------------------------------------------------
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace CodeOfChaos.Types;
@@ -12,10 +13,14 @@ namespace CodeOfChaos.Types;
 ///     a base class for seeding operations with pre-seeding validation logic.
 /// </summary>
 public abstract class Seeder : ISeeder {
+    public bool ShouldSeed { get; private set; } = false;
+    
     /// <inheritdoc />
-    public async Task StartAsync(ILogger logger, CancellationToken ct = default) {
-        if (!await ShouldSeedAsync(ct)) {
-            logger.LogInformation("Skipping seeding");
+    public async Task StartAsync(IServiceProvider serviceProvider, CancellationToken ct = default) {
+        ShouldSeed = await ShouldSeedAsync(ct);
+        if (!ShouldSeed) {
+            var logger = serviceProvider.GetService<ILogger>();
+            logger?.LogInformation("Skipping seeding");
             return;
         }
 

tests/Tests.CodeOfChaos.Types.DataSeeder/SeederTests.cs

@@ -11,64 +11,48 @@ namespace Tests.CodeOfChaos.Types.DataSeeder;
 // ---------------------------------------------------------------------------------------------------------------------
 public class SeederTests {
     [Test]
-    public async Task StartAsync_ShouldLogAndReturn_WhenShouldSeedReturnsFalse() {
-        // Arrange
-        var loggerMock = new Mock<ILogger>();
-        var seeder = new TestSeeder {
-            ShouldSeedResult = false// Simulate ShouldSeedAsync returning false
-        };
+public async Task StartAsync_ShouldLogAndReturn_WhenShouldSeedReturnsFalse() {
+    // Arrange
+    var serviceProviderMock = new Mock<IServiceProvider>();
+    var seeder = new TestSeeder {
+        ShouldSeedResult = false // Simulate ShouldSeedAsync returning false
+    };
 
-        // Act
-        await seeder.StartAsync(loggerMock.Object);
+    // Act
+    await seeder.StartAsync(serviceProviderMock.Object);
 
-        // Assert
-        loggerMock.Verify(
-            expression: logger => logger.Log(
-                LogLevel.Information,
-                It.IsAny<EventId>(),
-                It.Is<It.IsAnyType>((state, _) => state.ToString()!.Contains("Skipping seeding")),
-                It.IsAny<Exception>(),
-                It.IsAny<Func<It.IsAnyType, Exception, string>>()!),
-            Times.Once);
-        await Assert.That(seeder.SeedWasCalled).IsFalse();
-    }
+    // Assert
+    await Assert.That(seeder.ShouldSeed).IsFalse();
+}
 
     [Test]
-    public async Task StartAsync_ShouldCallSeed_WhenShouldSeedReturnsTrue() {
-        // Arrange
-        var loggerMock = new Mock<ILogger>();
-        var seeder = new TestSeeder {
-            ShouldSeedResult = true// Simulate ShouldSeedAsync returning true
-        };
+public async Task StartAsync_ShouldCallSeed_WhenShouldSeedReturnsTrue() {
+    // Arrange
+    var serviceProviderMock = new Mock<IServiceProvider>();
+    var seeder = new TestSeeder {
+        ShouldSeedResult = true // Simulate ShouldSeedAsync returning true
+    };
 
-        // Act
-        await seeder.StartAsync(loggerMock.Object);
+    // Act
+    await seeder.StartAsync(serviceProviderMock.Object);
 
-        // Assert
-        loggerMock.Verify(
-            expression: logger => logger.Log(
-                It.IsAny<LogLevel>(),
-                It.IsAny<EventId>(),
-                It.IsAny<It.IsAnyType>(),
-                It.IsAny<Exception>(),
-                It.IsAny<Func<It.IsAnyType, Exception, string>>()!),
-            Times.Never);// No additional logging should occur during SeedAsync
-        await Assert.That(seeder.SeedWasCalled).IsTrue();
-    }
+    // Assert
+    await Assert.That(seeder.ShouldSeed).IsTrue();
+}
 
     [Test]
-    public async Task StartAsync_ShouldRespectCancellationToken() {
-        // Arrange
-        var loggerMock = new Mock<ILogger>();
-        var seeder = new TestSeeder();
-        using var cts = new CancellationTokenSource();
-        await cts.CancelAsync();// Simulate cancellation
+public async Task StartAsync_ShouldRespectCancellationToken() {
+    // Arrange
+    var serviceProviderMock = new Mock<IServiceProvider>();
+    var seeder = new TestSeeder();
+    using var cts = new CancellationTokenSource();
+    await cts.CancelAsync(); // Simulate cancellation
 
-        // Act & Assert
-        await Assert.ThrowsAsync<OperationCanceledException>(async () => {
-            await seeder.StartAsync(loggerMock.Object, cts.Token);
-        });
-    }
+    // Act & Assert
+    await Assert.ThrowsAsync<OperationCanceledException>(async () => {
+        await seeder.StartAsync(serviceProviderMock.Object, cts.Token);
+    });
+}
 
     // Test implementation of Seeder for unit tests
     public class TestSeeder : Seeder {