ReusableResourceTest.cs

namespace Testcontainers.Tests;

public sealed class ReusableResourceTest : IAsyncLifetime, IDisposable
{
    private readonly DockerClient _dockerClient = TestcontainersSettings.OS.DockerEndpointAuthConfig.GetDockerClientConfiguration(Guid.NewGuid()).CreateClient();

    private readonly FilterByProperty _filters = new FilterByProperty();

    private readonly IList<IAsyncDisposable> _disposables = new List<IAsyncDisposable>();

    private readonly string _labelKey = Guid.NewGuid().ToString("D");

    private readonly string _labelValue = Guid.NewGuid().ToString("D");

    public ReusableResourceTest()
    {
        _filters.Add("label", string.Join("=", _labelKey, _labelValue));
    }

    public async Task InitializeAsync()
    {
        for (var _ = 0; _ < 3; _++)
        {
            // We are running in a single session, we do not need to disable the cleanup feature.
            var container = new ContainerBuilder()
                .WithImage(CommonImages.Alpine)
                .WithEntrypoint("sleep")
                .WithCommand("infinity")
                .WithLabel(_labelKey, _labelValue)
                .WithReuse(true)
                .Build();

            var network = new NetworkBuilder()
                .WithName(_labelKey)
                .WithLabel(_labelKey, _labelValue)
                .WithReuse(true)
                .Build();

            var volume = new VolumeBuilder()
                .WithName(_labelKey)
                .WithLabel(_labelKey, _labelValue)
                .WithReuse(true)
                .Build();

            await Task.WhenAll(container.StartAsync(), network.CreateAsync(), volume.CreateAsync())
                .ConfigureAwait(false);

            _disposables.Add(container);
            _disposables.Add(network);
            _disposables.Add(volume);
        }
    }

    public Task DisposeAsync()
    {
        return Task.WhenAll(_disposables.Select(disposable => disposable.DisposeAsync().AsTask()));
    }

    public void Dispose()
    {
        _dockerClient.Dispose();
    }

    [Fact]
    public async Task ShouldReuseExistingResource()
    {
        var containers = await _dockerClient.Containers.ListContainersAsync(new ContainersListParameters { Filters = _filters })
            .ConfigureAwait(false);

        var networks = await _dockerClient.Networks.ListNetworksAsync(new NetworksListParameters { Filters = _filters })
            .ConfigureAwait(false);

        var response = await _dockerClient.Volumes.ListAsync(new VolumesListParameters { Filters = _filters })
            .ConfigureAwait(false);

        Assert.Single(containers);
        Assert.Single(networks);
        Assert.Single(response.Volumes);
    }
}