IntegrationTestBase.cs

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Configurations;
using DotNet.Testcontainers.Containers;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using ParcelTracking.Infrastructure.Data;
using Xunit;

namespace ParcelTracking.API.IntegrationTests
{
    /// <summary>
    /// Shared setup/teardown for integration tests that require a Postgres database.
    ///
    /// - will honour the PARCELTRACK_TEST_DB environment variable if set,
    ///   otherwise it will start a disposable postgres container using
    ///   <see cref="DotNet.Testcontainers"/>.
    /// - exposes <see cref="Client"/>, <see cref="Factory"/>, and
    ///   <see cref="ConnectionString"/> to derived tests.
    /// </summary>
    public abstract class IntegrationTestBase : IAsyncLifetime
    {
        protected WebApplicationFactory<Program>? Factory;
        protected HttpClient? Client;
        protected string? ConnectionString;

        private PostgreSqlTestcontainer? _postgresContainer;

        public virtual async Task InitializeAsync()
        {
            // check for an explicit connection string first
            var env = Environment.GetEnvironmentVariable("PARCELTRACK_TEST_DB");
            if (string.IsNullOrWhiteSpace(env))
            {
                try
                {
                    // create and start a temporary postgres container
                    var builder = new TestcontainersBuilder<PostgreSqlTestcontainer>()
                        .WithDatabase(new PostgreSqlTestcontainerConfiguration
                        {
                            Database = "parceltracking_test",
                            Username = "test",
                            Password = "test"
                        })
                        .WithImage("postgres:15")
                        .WithCleanUp(true)
                        .WithPortBinding(5432, true);

                    _postgresContainer = builder.Build();
                    await _postgresContainer.StartAsync();
                    ConnectionString = _postgresContainer.ConnectionString;
                }
                catch
                {
                    // Docker not available, skip tests
                    ConnectionString = null;
                    _postgresContainer = null;
                }
            }
            else
            {
                ConnectionString = env;
            }

            if (ConnectionString == null)
                return; // will cause tests to be skipped

            // build the web app factory pointing at the test database
            Factory = new WebApplicationFactory<Program>()
                .WithWebHostBuilder(builder =>
                {
                    builder.ConfigureAppConfiguration((context, cfg) =>
                    {
                        var inMemConfig = new Dictionary<string, string?>
                        {
                            { "ConnectionStrings:DefaultConnection", ConnectionString }
                        };
                        cfg.AddInMemoryCollection(inMemConfig);
                    });
                });

            Client = Factory.CreateClient();

            // ensure the database exists/migrated
            var options = new DbContextOptionsBuilder<ParcelTrackingDbContext>()
                .UseNpgsql(ConnectionString)
                .Options;

            await using var db = new ParcelTrackingDbContext(options);
            await db.Database.EnsureCreatedAsync();
        }

        public virtual async Task DisposeAsync()
        {
            Client?.Dispose();
            Factory?.Dispose();

            if (_postgresContainer != null)
            {
                await _postgresContainer.StopAsync();
                await _postgresContainer.DisposeAsync();
            }
        }
    }


}