Refactor resource fixtures to enforce initialization checks

- Updated `XunitComposeFixture`, `XunitContainerFixture`, `XunitPodmanKubernetesFixture`, `XunitSwarmStackFixture`, `XunitResourceFixture`, and `XunitTopologyFixture` to ensure properties are only accessible after calling `InitializeAsync`, throwing `InvalidOperationException` otherwise.
- Modified tests in `XunitAdapterTests`, `XunitComposeTopologyFixtureTests`, and others to reflect the new behavior of throwing exceptions instead of returning null for uninitialized properties.
- Enhanced resource lifecycle management in `ResourceLifecycle` to handle exceptions during disposal more gracefully, ensuring proper cleanup.
- Added new tests in `BuilderCleanupTests` to verify that resources are cleaned up correctly during failed provisioning scenarios.
- Improved error handling in `Builder` and `ContainerBuilder` to prevent resource leaks during failures.

Author: mariotoffia

FluentDocker.Testing.Xunit/XunitComposeFixture.cs

@@ -18,26 +18,39 @@ namespace FluentDocker.Testing.Xunit
   /// Subclass it and override <see cref="XunitComposeFixtureBase.ConfigureCompose"/>
   /// — xUnit handles the async lifecycle automatically.</para>
   /// <para>Use this class only when you need programmatic control over
-  /// initialization (e.g., dynamic configuration, conditional setup).</para>
+  /// initialization (e.g., dynamic configuration, conditional setup).
+  /// You <b>must</b> call <see cref="InitializeAsync"/> before accessing
+  /// any properties — accessing them before initialization throws
+  /// <see cref="InvalidOperationException"/>.</para>
   /// </remarks>
   public class XunitComposeFixture : IAsyncDisposable
   {
     private ComposeResource _resource;
+    private FluentDockerKernel _kernel;
 
     /// <summary>
     /// The underlying compose resource.
     /// </summary>
-    public ComposeResource Resource => _resource;
+    public ComposeResource Resource
+    {
+      get { EnsureInitialized(); return _resource; }
+    }
 
     /// <summary>
     /// The running compose service, available after initialization.
     /// </summary>
-    public IComposeService Service => _resource?.Service;
+    public IComposeService Service
+    {
+      get { EnsureInitialized(); return _resource.Service; }
+    }
 
     /// <summary>
     /// The kernel managing drivers.
     /// </summary>
-    public FluentDockerKernel Kernel { get; private set; }
+    public FluentDockerKernel Kernel
+    {
+      get { EnsureInitialized(); return _kernel; }
+    }
 
     /// <summary>
     /// Configures and initializes the fixture.
@@ -57,7 +70,7 @@ public async Task InitializeAsync(
           kernelFactory,
           cancellationToken: cancellationToken);
 
-      Kernel = kernel;
+      _kernel = kernel;
       _resource = resource;
     }
 
@@ -66,16 +79,20 @@ public async ValueTask DisposeAsync()
     {
       try
       {
-        if (_resource != null)
-          await _resource.DisposeAsync();
+        await ResourceLifecycle.DisposeAsync(_resource, _kernel);
       }
       finally
       {
-        if (Kernel != null)
-          await Kernel.DisposeAsync();
         _resource = null;
-        Kernel = null;
+        _kernel = null;
       }
     }
+
+    private void EnsureInitialized()
+    {
+      if (_resource == null)
+        throw new InvalidOperationException(
+            "Fixture has not been initialized. Call InitializeAsync first.");
+    }
   }
 }

FluentDocker.Testing.Xunit/XunitContainerFixture.cs

@@ -18,26 +18,39 @@ namespace FluentDocker.Testing.Xunit
   /// Subclass it and override <see cref="XunitContainerFixtureBase.ConfigureContainer"/>
   /// — xUnit handles the async lifecycle automatically.</para>
   /// <para>Use this class only when you need programmatic control over
-  /// initialization (e.g., dynamic configuration, conditional setup).</para>
+  /// initialization (e.g., dynamic configuration, conditional setup).
+  /// You <b>must</b> call <see cref="InitializeAsync"/> before accessing
+  /// any properties — accessing them before initialization throws
+  /// <see cref="InvalidOperationException"/>.</para>
   /// </remarks>
   public class XunitContainerFixture : IAsyncDisposable
   {
     private ContainerResource _resource;
+    private FluentDockerKernel _kernel;
 
     /// <summary>
     /// The underlying container resource.
     /// </summary>
-    public ContainerResource Resource => _resource;
+    public ContainerResource Resource
+    {
+      get { EnsureInitialized(); return _resource; }
+    }
 
     /// <summary>
     /// The running container service, available after initialization.
     /// </summary>
-    public IContainerService Container => _resource?.Container;
+    public IContainerService Container
+    {
+      get { EnsureInitialized(); return _resource.Container; }
+    }
 
     /// <summary>
     /// The kernel managing drivers.
     /// </summary>
-    public FluentDockerKernel Kernel { get; private set; }
+    public FluentDockerKernel Kernel
+    {
+      get { EnsureInitialized(); return _kernel; }
+    }
 
     /// <summary>
     /// Configures and initializes the fixture.
@@ -61,7 +74,7 @@ public async Task InitializeAsync(
           kernelFactory,
           cancellationToken: cancellationToken);
 
-      Kernel = kernel;
+      _kernel = kernel;
       _resource = resource;
     }
 
@@ -70,16 +83,20 @@ public async ValueTask DisposeAsync()
     {
       try
       {
-        if (_resource != null)
-          await _resource.DisposeAsync();
+        await ResourceLifecycle.DisposeAsync(_resource, _kernel);
       }
       finally
       {
-        if (Kernel != null)
-          await Kernel.DisposeAsync();
         _resource = null;
-        Kernel = null;
+        _kernel = null;
       }
     }
+
+    private void EnsureInitialized()
+    {
+      if (_resource == null)
+        throw new InvalidOperationException(
+            "Fixture has not been initialized. Call InitializeAsync first.");
+    }
   }
 }

FluentDocker.Testing.Xunit/XunitPodmanKubernetesFixture.cs

@@ -16,25 +16,38 @@ namespace FluentDocker.Testing.Xunit
   /// <para>This fixture requires explicit initialization via
   /// <see cref="InitializeAsync"/>. No abstract fixture base is provided for
   /// Podman Kubernetes because it uses a config object rather than a builder.</para>
+  /// <para>You <b>must</b> call <see cref="InitializeAsync"/> before accessing
+  /// any properties — accessing them before initialization throws
+  /// <see cref="InvalidOperationException"/>.</para>
   /// </remarks>
   public class XunitPodmanKubernetesFixture : IAsyncDisposable
   {
     private PodmanKubernetesResource _resource;
+    private FluentDockerKernel _kernel;
 
     /// <summary>
     /// The underlying Podman Kubernetes resource.
     /// </summary>
-    public PodmanKubernetesResource Resource => _resource;
+    public PodmanKubernetesResource Resource
+    {
+      get { EnsureInitialized(); return _resource; }
+    }
 
     /// <summary>
     /// Path to the Kubernetes YAML file.
     /// </summary>
-    public string YamlPath => _resource?.YamlPath;
+    public string YamlPath
+    {
+      get { EnsureInitialized(); return _resource.YamlPath; }
+    }
 
     /// <summary>
     /// The kernel managing drivers.
     /// </summary>
-    public FluentDockerKernel Kernel { get; private set; }
+    public FluentDockerKernel Kernel
+    {
+      get { EnsureInitialized(); return _kernel; }
+    }
 
     /// <summary>
     /// Configures and initializes the fixture.
@@ -59,7 +72,7 @@ public async Task InitializeAsync(
           ResourceLifecycle.CreateDefaultPodmanKernelAsync,
           cancellationToken);
 
-      Kernel = kernel;
+      _kernel = kernel;
       _resource = resource;
     }
 
@@ -68,16 +81,20 @@ public async ValueTask DisposeAsync()
     {
       try
       {
-        if (_resource != null)
-          await _resource.DisposeAsync();
+        await ResourceLifecycle.DisposeAsync(_resource, _kernel);
       }
       finally
       {
-        if (Kernel != null)
-          await Kernel.DisposeAsync();
         _resource = null;
-        Kernel = null;
+        _kernel = null;
       }
     }
+
+    private void EnsureInitialized()
+    {
+      if (_resource == null)
+        throw new InvalidOperationException(
+            "Fixture has not been initialized. Call InitializeAsync first.");
+    }
   }
 }

FluentDocker.Testing.Xunit/XunitResourceFixture.cs

@@ -18,23 +18,32 @@ namespace FluentDocker.Testing.Xunit
   /// <see cref="XunitComposeFixtureBase"/>, <see cref="XunitTopologyFixtureBase"/>)
   /// which provide automatic async lifecycle via <c>IAsyncLifetime</c>.</para>
   /// <para>Use this class for custom or plugin resource types, or when you need
-  /// programmatic control over initialization.</para>
+  /// programmatic control over initialization. You <b>must</b> call
+  /// <see cref="InitializeAsync"/> before accessing any properties — accessing
+  /// them before initialization throws <see cref="InvalidOperationException"/>.</para>
   /// </remarks>
   /// <typeparam name="TResource">The resource type to manage.</typeparam>
   public class XunitResourceFixture<TResource> : IAsyncDisposable
       where TResource : class, ITestResource
   {
     private TResource _resource;
+    private FluentDockerKernel _kernel;
 
     /// <summary>
     /// The underlying resource.
     /// </summary>
-    public TResource Resource => _resource;
+    public TResource Resource
+    {
+      get { EnsureInitialized(); return _resource; }
+    }
 
     /// <summary>
     /// The kernel managing drivers.
     /// </summary>
-    public FluentDockerKernel Kernel { get; private set; }
+    public FluentDockerKernel Kernel
+    {
+      get { EnsureInitialized(); return _kernel; }
+    }
 
     /// <summary>
     /// Configures and initializes the fixture.
@@ -55,7 +64,7 @@ public async Task InitializeAsync(
           resourceFactory, kernelFactory,
           cancellationToken: cancellationToken);
 
-      Kernel = kernel;
+      _kernel = kernel;
       _resource = resource;
     }
 
@@ -64,16 +73,20 @@ public async ValueTask DisposeAsync()
     {
       try
       {
-        if (_resource != null)
-          await _resource.DisposeAsync();
+        await ResourceLifecycle.DisposeAsync(_resource, _kernel);
       }
       finally
       {
-        if (Kernel != null)
-          await Kernel.DisposeAsync();
         _resource = null;
-        Kernel = null;
+        _kernel = null;
       }
     }
+
+    private void EnsureInitialized()
+    {
+      if (_resource == null)
+        throw new InvalidOperationException(
+            "Fixture has not been initialized. Call InitializeAsync first.");
+    }
   }
 }

FluentDocker.Testing.Xunit/XunitSwarmStackFixture.cs

@@ -16,25 +16,38 @@ namespace FluentDocker.Testing.Xunit
   /// <para>This fixture requires explicit initialization via
   /// <see cref="InitializeAsync"/>. No abstract fixture base is provided for
   /// Swarm stacks because Swarm mode is not commonly used in unit tests.</para>
+  /// <para>You <b>must</b> call <see cref="InitializeAsync"/> before accessing
+  /// any properties — accessing them before initialization throws
+  /// <see cref="InvalidOperationException"/>.</para>
   /// </remarks>
   public class XunitSwarmStackFixture : IAsyncDisposable
   {
     private SwarmStackResource _resource;
+    private FluentDockerKernel _kernel;
 
     /// <summary>
     /// The underlying swarm stack resource.
     /// </summary>
-    public SwarmStackResource Resource => _resource;
+    public SwarmStackResource Resource
+    {
+      get { EnsureInitialized(); return _resource; }
+    }
 
     /// <summary>
     /// The stack name used for deployment.
     /// </summary>
-    public string StackName => _resource?.StackName;
+    public string StackName
+    {
+      get { EnsureInitialized(); return _resource.StackName; }
+    }
 
     /// <summary>
     /// The kernel managing drivers.
     /// </summary>
-    public FluentDockerKernel Kernel { get; private set; }
+    public FluentDockerKernel Kernel
+    {
+      get { EnsureInitialized(); return _kernel; }
+    }
 
     /// <summary>
     /// Configures and initializes the fixture.
@@ -58,7 +71,7 @@ public async Task InitializeAsync(
           kernelFactory,
           cancellationToken: cancellationToken);
 
-      Kernel = kernel;
+      _kernel = kernel;
       _resource = resource;
     }
 
@@ -67,16 +80,20 @@ public async ValueTask DisposeAsync()
     {
       try
       {
-        if (_resource != null)
-          await _resource.DisposeAsync();
+        await ResourceLifecycle.DisposeAsync(_resource, _kernel);
       }
       finally
       {
-        if (Kernel != null)
-          await Kernel.DisposeAsync();
         _resource = null;
-        Kernel = null;
+        _kernel = null;
       }
     }
+
+    private void EnsureInitialized()
+    {
+      if (_resource == null)
+        throw new InvalidOperationException(
+            "Fixture has not been initialized. Call InitializeAsync first.");
+    }
   }
 }