fix issue with lazy init

Author: pwelter34

src/TestHost.Abstracts/ITestHostApplication.cs

@@ -4,9 +4,9 @@
 namespace TestHost.Abstracts;
 
 /// <summary>
-/// An interface for a test host application.
+/// An interface for a hosting a test application.
 /// </summary>
-public interface ITestHostApplication
+public interface ITestHostApplication : IAsyncDisposable
 {
     /// <summary>
     /// Gets the host for the tests.

src/TestHost.Abstracts/Logging/MemoryLoggerExtensions.cs

@@ -13,53 +13,20 @@ public static class MemoryLoggerExtensions
     /// Adds a memory logger named 'MemoryLogger' to the factory.
     /// </summary>
     /// <param name="builder">The extension method argument.</param>
+    /// <param name="configure">Optional configuration action for the <see cref="MemoryLoggerSettings"/>.</param>
     /// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
-    public static ILoggingBuilder AddMemoryLogger(this ILoggingBuilder builder)
+    public static ILoggingBuilder AddMemoryLogger(this ILoggingBuilder builder, Action<MemoryLoggerSettings>? configure = null)
     {
         if (builder is null)
             throw new ArgumentNullException(nameof(builder));
 
-        var descriptor = ServiceDescriptor.Singleton<ILoggerProvider, MemoryLoggerProvider>();
+        builder.Services.AddOptions<MemoryLoggerSettings>();
 
-        builder.Services.TryAddEnumerable(descriptor);
+        builder.Services.TryAddSingleton<MemoryLoggerProvider>();
+        builder.Services.AddSingleton<ILoggerProvider>(sp => sp.GetRequiredService<MemoryLoggerProvider>());
 
-        return builder;
-    }
-
-    /// <summary>
-    /// Adds a memory logger. Use <paramref name="settings"/> to enable logging for specific <see cref="LogLevel"/>.
-    /// </summary>
-    /// <param name="builder">The extension method argument.</param>
-    /// <param name="settings">The <see cref="MemoryLoggerSettings"/> to use.</param>
-    /// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
-    public static ILoggingBuilder AddMemoryLogger(this ILoggingBuilder builder, MemoryLoggerSettings settings)
-    {
-        if (builder is null)
-            throw new ArgumentNullException(nameof(builder));
-        if (settings is null)
-            throw new ArgumentNullException(nameof(settings));
-
-        var logger = new MemoryLoggerProvider(settings);
-        var descriptor = ServiceDescriptor.Singleton<ILoggerProvider>(logger);
-
-        builder.Services.TryAddEnumerable(descriptor);
-
-        return builder;
-    }
-
-    /// <summary>
-    /// Adds a memory logger. Use <paramref name="configure"/> to enable logging for specific <see cref="LogLevel"/>.
-    /// </summary>
-    /// <param name="builder">The extension method argument.</param>
-    /// <param name="configure">A delegate to configure the <see cref="MemoryLoggerSettings"/>.</param>
-    /// <returns>The <see cref="ILoggingBuilder"/> so that additional calls can be chained.</returns>
-    public static ILoggingBuilder AddMemoryLogger(this ILoggingBuilder builder, Action<MemoryLoggerSettings> configure)
-    {
-        if (configure is null)
-            throw new ArgumentNullException(nameof(configure));
-
-        builder.AddMemoryLogger();
-        builder.Services.Configure(configure);
+        if (configure is not null)
+            builder.Services.Configure(configure);
 
         return builder;
     }

src/TestHost.Abstracts/Logging/MemoryLoggerProvider.cs

@@ -17,30 +17,13 @@ public class MemoryLoggerProvider : ILoggerProvider, ISupportExternalScope
     private readonly MemoryLoggerSettings _settings;
     private IExternalScopeProvider? _scopeProvider;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="MemoryLoggerProvider"/> class.
-    /// </summary>
-    public MemoryLoggerProvider()
-        : this(settings: null)
-    {
-    }
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="MemoryLoggerProvider"/> class.
-    /// </summary>
-    /// <param name="settings">The <see cref="MemoryLoggerSettings"/>.</param>
-    public MemoryLoggerProvider(MemoryLoggerSettings? settings)
-    {
-        _settings = settings ?? new MemoryLoggerSettings();
-    }
-
     /// <summary>
     /// Initializes a new instance of the <see cref="MemoryLoggerProvider"/> class.
     /// </summary>
     /// <param name="options">The <see cref="IOptions{MemoryLoggerSettings}"/>.</param>
     public MemoryLoggerProvider(IOptions<MemoryLoggerSettings> options)
-        : this(options.Value)
     {
+        _settings = options.Value ?? new MemoryLoggerSettings();
     }
 
     /// <inheritdoc />
@@ -72,6 +55,8 @@ public void Clear()
     public void Dispose()
     {
         Clear();
+
+        GC.SuppressFinalize(this);
     }
 
 
@@ -91,7 +76,9 @@ private void WriteLog(MemoryLogEntry logEntry)
 
         // ensure capacity
         while (_logEntries.Count > _settings.Capacity)
+        {
             if (!_logEntries.TryDequeue(out _))
                 break;
+        }
     }
 }

src/TestHost.Abstracts/TestHostApplication.cs

@@ -6,27 +6,37 @@
 namespace TestHost.Abstracts;
 
 /// <summary>
-/// XUnit collection fixture that supports <see cref="HostApplicationBuilder"/>
+/// A base class for hosting a test application.
 /// </summary>
 public abstract class TestHostApplication : ITestHostApplication
 {
-    private readonly Lazy<IHost> _host;
+#if NET9_0_OR_GREATER
+    private readonly Lock _lockObject = new();
+#else
+    private readonly object _lockObject = new();
+#endif
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="TestHostApplication"/> class.
-    /// </summary>
-    protected TestHostApplication()
-    {
-        _host = new Lazy<IHost>(CreateHost);
-    }
+    private IHost? _host;
 
     /// <summary>
     /// Gets the host for this test.
     /// </summary>
     /// <value>
     /// The host for this test.
     /// </value>
-    public IHost Host => _host.Value;
+    public IHost Host
+    {
+        get
+        {
+            if (_host != null)
+                return _host;
+
+            lock (_lockObject)
+                _host ??= CreateHost();
+
+            return _host;
+        }
+    }
 
     /// <summary>
     /// Gets the services configured for this test
@@ -73,4 +83,17 @@ protected virtual void ConfigureApplication(HostApplicationBuilder builder)
         builder.Logging.SetMinimumLevel(LogLevel.Debug);
         builder.Logging.AddMemoryLogger();
     }
+
+    public virtual async ValueTask DisposeAsync()
+    {
+        if (_host == null)
+            return;
+
+        await _host.StopAsync();
+
+        _host.Dispose();
+        _host = null;
+
+        GC.SuppressFinalize(this);
+    }
 }

test/TestHost.Abstracts.Tests/TestHostApplicationTests.cs

@@ -1,5 +1,4 @@
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 
 using TestHost.Abstracts.Logging;
 
@@ -21,15 +20,13 @@ public async Task GetService()
         await Assert.That(Service.IsRun).IsTrue();
         await Assert.That(ApplicationInitializer.IsStarted).IsTrue();
 
-        var memoryLogger = Application.Services
-            .GetServices<ILoggerProvider>()
-            .OfType<MemoryLoggerProvider>()
-            .FirstOrDefault();
-
+        var memoryLogger = Application.Services.GetService<MemoryLoggerProvider>();
         await Assert.That(memoryLogger).IsNotNull();
 
         var logs = memoryLogger?.GetEntries().ToList();
-
         await Assert.That(logs).IsNotEmpty();
+
+        await Assert.That(logs).Contains(match => match.Message.Contains("Service Run()"));
+        await Assert.That(logs).Contains(match => match.Message.Contains("Initialize Database StartAsync()"));
     }
 }