Problem running tests on my second pc and github actions

[Orholt]

First things first I want to point out that this is my first encounter with Testcontainers test writing, so I will appreciate any answers, pointing what in my test logic is bad etc. ( I want to learn how to write great tests ).

Description

But going back to the point, I would like to ask you for feedback why mine Testcontainers based integrations tests runs well locally on my primary machine, but when runned on github action throws errors als I have issues running them on my secondary PC (that I'm using right now while writing this question).

Architecture

My app architecture at this moment

flowchart LR
Web --> Api
Api <--> DatabaseApi
Api --> RabbitMQ
DatabaseApi <--> PostgreSQL

Loading

Code

ApiTestBase class

I'm writting mine tests in xUnit and I'm utilizing base class ApiTestBase.cs :

using Bogus;
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Containers;
using DotNet.Testcontainers.Images;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.AspNetCore.TestHost;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Diagnostics; // added for warning suppression
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using RestSharp;
using Serilog;
using System.Net;
using System.Net.Sockets;
using Testcontainers.RabbitMq;
using TLab.Database.Database;

namespace TLab.Tests;

/// <summary>
/// Shared base for API + Database integration tests.
/// Starts containers once per test run (static) to avoid churn & race conditions.
/// Parallelization disabled via assembly attribute.
/// </summary>
public abstract class ApiTestBase : IClassFixture<WebApplicationFactory<Api.Program>>, IDisposable
{
    protected readonly WebApplicationFactory<Api.Program> ApiFactory;
    protected readonly IRestClient ApiClient;

    protected static readonly Faker Faker = new("en");

    private static void EnsureEnvironment()
    {
        Environment.SetEnvironmentVariable("Security__SignignKey", "{EXAMPLE JWT SIGNING KEY}");
        Environment.SetEnvironmentVariable("FRONTEND_URL", "tlab.mwitek.pl");
        Environment.SetEnvironmentVariable("Rabbit__Host", "localhost");
        Environment.SetEnvironmentVariable("Rabbit__Username", "tlab");
        Environment.SetEnvironmentVariable("Rabbit__Password", "tlabpassword");
    }

    private WebApplicationFactory<Api.Program> CreateFactory(WebApplicationFactory<TLab.Api.Program> apiFactory)
    {
        var testConfig = new ConfigurationBuilder()
            .AddJsonFile("TestData/appsettings.json", optional: true)
            .AddJsonFile(Path.Combine("..", "..", "..", "TestData", "appsettings.json"), optional: true)
            .AddEnvironmentVariables()
            .Build();

        return apiFactory.WithWebHostBuilder(builder =>
        {
            builder.UseEnvironment("Development");
            builder.ConfigureAppConfiguration((_, config) => { config.AddConfiguration(testConfig); });
            builder.ConfigureLogging(l =>
            {
                l.AddSerilog();
                l.AddConsole();
                l.SetMinimumLevel(LogLevel.Information);
            });
        });
    }

    private IContainer _postgres;
    private IContainer _rabbitMQ;
    private IContainer _databaseApi;
    private IFutureDockerImage _databaseImage;

    protected ApiTestBase(WebApplicationFactory<TLab.Api.Program> apiFactory)
    {
        EnsureEnvironment();

        // Start Postgres with random host port
        int POSTGRES_CONTAINER_PORT = 5432;
        _postgres = new ContainerBuilder()
            .WithImage("postgres:16-alpine")
            .WithName($"tlab-tests-postgres-{Guid.NewGuid():N}")
            .WithEnvironment("POSTGRES_DB", "tlab")
            .WithEnvironment("POSTGRES_USER", "tlab")
            .WithEnvironment("POSTGRES_PASSWORD", "tlab")
            .WithPortBinding(POSTGRES_CONTAINER_PORT, true)
            .WithCleanUp(true)
            .Build();
        _postgres.StartAsync().GetAwaiter().GetResult();
        int POSTGRES_PORT = _postgres.GetMappedPublicPort(POSTGRES_CONTAINER_PORT);

        // Start RabbitMQ with random host port
        int RABBIT_MQ_CONTAINER_PORT = 5672;
        _rabbitMQ = new RabbitMqBuilder()
            .WithImage("rabbitmq:4")
            .WithName($"tlab-tests-rabbitmq-{Guid.NewGuid():N}")
            .WithUsername("tlab")
            .WithPassword("tlabpassword")
            .WithPortBinding(RABBIT_MQ_CONTAINER_PORT, true)
            .WithCleanUp(true)
            .Build();
        _rabbitMQ.StartAsync().GetAwaiter().GetResult();
        int RABBIT_MQ_PORT = _rabbitMQ.GetMappedPublicPort(RABBIT_MQ_CONTAINER_PORT);

        var directory = CommonDirectoryPath.GetSolutionDirectory();
        var databaseProjectDir = Path.Combine(directory.DirectoryPath, "TLab.Database");
        // FIX: Use full solution directory as build context so that project references (ServiceDefaults, Shared, etc.) are available during docker build.
        _databaseImage = new ImageFromDockerfileBuilder()
            .WithName("tlab-tests-database-image:latest") // explicit tag
            .WithDockerfileDirectory(databaseProjectDir)
            .WithDockerfile("Dockerfile")
            .WithContextDirectory(directory.DirectoryPath) // broaden context to include referenced project directories
            .Build();
        _databaseImage.CreateAsync().GetAwaiter().GetResult();

        // Start Database API with random host port, configured to reach Postgres via host mapped port
        int DATABASE_API_CONTAINER_PORT = 8088;
        _databaseApi = new ContainerBuilder()
            .WithImage(_databaseImage!)
            .WithName($"tlab-tests-databaseapi-{Guid.NewGuid():N}")
            .WithEnvironment("DATABASE_HOST", "host.docker.internal")
            .WithEnvironment("DATABASE_NAME", "tlab")
            .WithEnvironment("DATABASE_USER", "tlab")
            .WithEnvironment("DATABASE_PASSWORD", "tlab")
            .WithEnvironment("ASPNETCORE_FORWARDEDHEADERS_ENABLED", "true")
            .WithEnvironment("HTTP_PORTS", DATABASE_API_CONTAINER_PORT.ToString())
            .WithEnvironment("ConnectionStrings__DefaultConnection", $"Server=host.docker.internal;Database=tlab;User Id=tlab;Password=tlab;Port={POSTGRES_PORT}")
            .WithPortBinding(DATABASE_API_CONTAINER_PORT, true)
            .DependsOn(_postgres)
            .WithCleanUp(true)
            .Build();
        _databaseApi.StartAsync().GetAwaiter().GetResult();
        int DATABASEAPI_PORT = _databaseApi.GetMappedPublicPort(DATABASE_API_CONTAINER_PORT);

        Environment.SetEnvironmentVariable("Rabbit__Port", RABBIT_MQ_PORT.ToString());
        Environment.SetEnvironmentVariable("DATABASE_API_URL", $"http://localhost:{DATABASEAPI_PORT}");

        // Migrate Database
        var opt = new DbContextOptionsBuilder<TLabDbContext>()
            .UseNpgsql($"Server=localhost;Database=tlab;User Id=tlab;Password=tlab;Port={POSTGRES_PORT}")
            .Options;
        using var ctx = new TLabDbContext(opt);
        ctx.Database.Migrate();

        // create ApiFactory and ApiClient
        ApiFactory = CreateFactory(apiFactory);
        var client = ApiFactory.CreateClient();
        var restClient = new RestClient(client);
        restClient.AddDefaultHeader("Content-Type", "application/json");
        ApiClient = restClient;
    }

    public void Dispose()
    {
        _databaseApi?.DisposeAsync().GetAwaiter().GetResult();
        _rabbitMQ?.DisposeAsync().GetAwaiter().GetResult();
        _postgres?.DisposeAsync().GetAwaiter().GetResult();
    }
}

Now I also created 2 example test classes: AuthControllerTests.cs and ChatControllerTests.cs

ChatControllerTests

public class ChatControllerTests : ApiTestBase
{
    public ChatControllerTests(WebApplicationFactory<Api.Program> factory) : base(factory)
    {
    }

    [Fact]
    public async Task DeleteChat_ReturnsUnauthorized_WhenNoToken()
    {
        var response = await ApiClient.ExecuteAsync(new RestRequest("/api/Chat/1", Method.Delete));
        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }

    [Fact]
    public async Task GetChats_ReturnsUnauthorized_WhenNoToken()
    {
        var response = await ApiClient.ExecuteGetAsync(new RestRequest("/api/Chat"));
        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }
// [...] more tests

AuthControllerTests

public class AuthControllerTests : ApiTestBase
{
    public AuthControllerTests(WebApplicationFactory<Api.Program> factory) : base(factory)
    {
    }

    [Fact]
    public async Task Login_ReturnsBadRequest_WhenBodyIsNull()
    {
        var response = await ApiClient.ExecutePostAsync(new RestRequest("/api/Auth/login")); // empty body
        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
    }

    [Fact]
    public async Task Register_Then_Login_FullFlow_ReturnsToken()
    {
        // realistic user data via Bogus
        var uniqueSuffix = Faker.Random.AlphaNumeric(8).ToLower();
        var login = $"user_{uniqueSuffix}";
        var email = Faker.Internet.Email(uniqueSuffix, provider: "example.com");
        var password = Faker.Internet.Password(12, true, regexPattern: "[A-Za-z0-9]", prefix: "!");

        var registerRequest = new RestRequest("/api/Auth/register", Method.Post)
            .AddJsonBody(new AuthUserRegisterRequest
            {
                Login = login,
                Password = password,
                Email = email
            });

        var registerResponse = await ApiClient.ExecutePostAsync(registerRequest);
        Assert.Equal(HttpStatusCode.Created, registerResponse.StatusCode);

        var loginRequest = new RestRequest("/api/Auth/login", Method.Post)
            .AddJsonBody(new AuthLoginRequest
            {
                Login = login,
                Password = password
            });

        var loginResponse = await ApiClient.ExecutePostAsync<AuthLoginResponse>(loginRequest);
        Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
        Assert.False(string.IsNullOrWhiteSpace(loginResponse.Data?.AccessToken));
    }

// [..] more tests

There are more tests classes and facts but for simplicity I just providing those two

Results

Local run

Example local run result (runned from VS 2026, same result when runned from Github Actions pipeline)

Example errors

(From test preview)

  Message: 
System.IO.IOException : The process cannot access the file 'C:\Users\Michal\AppData\Local\Temp\tlab-tests-database-image-latest.tar' because it is being used by another process.

  Stack Trace: 
OSFileStreamStrategy.ctor(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 preallocationSize, Nullable`1 unixCreateMode)
DockerfileArchive.Tar(CancellationToken ct)
DockerImageOperations.BuildAsync(IImageFromDockerfileConfiguration configuration, ITarArchive dockerfileArchive, CancellationToken ct)
TestcontainersClient.BuildAsync(IImageFromDockerfileConfiguration configuration, CancellationToken ct)
FutureDockerImage.UnsafeCreateAsync(CancellationToken ct)
FutureDockerImage.CreateAsync(CancellationToken ct)

(From github actions)

[xUnit.net 00:00:33.05]     TLab.Tests.GradeControllerTests.EditGrade_ReturnsUnauthorized_WhenNoToken [FAIL]
[xUnit.net 00:00:33.11]     TLab.Tests.UsersControllerTests.UpdateProfile_ReturnsUnauthorized_WhenNoToken [FAIL]
  Failed TLab.Tests.UsersControllerTests.UpdateProfile_ReturnsUnauthorized_WhenNoToken [1 ms]
  Error Message:
   System.Net.Http.HttpRequestException : The requested failed, see inner exception for details.
---- System.Net.Http.HttpRequestException : Error while copying content to a stream.
-------- System.IO.IOException : Unable to write data to the transport connection: Broken pipe.
------------ System.Net.Sockets.SocketException : Broken pipe
  Stack Trace:
     at Microsoft.Net.Http.Client.HttpConnection.SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) in /_/src/Docker.DotNet/Microsoft.Net.Http.Client/HttpConnection.cs:line 49
   at Microsoft.Net.Http.Client.ManagedHandler.ProcessRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken) in /_/src/Docker.DotNet/Microsoft.Net.Http.Client/ManagedHandler.cs:line 182
   at Microsoft.Net.Http.Client.ManagedHandler.SendAsync(HttpRequestMessage httpRequestMessage, CancellationToken cancellationToken) in /_/src/Docker.DotNet/Microsoft.Net.Http.Client/ManagedHandler.cs:line 77
   at System.Net.Http.HttpClient.<SendAsync>g__Core|83_0(HttpRequestMessage request, HttpCompletionOption completio

  Failed TLab.Tests.ClassControllerTests.GetClasses_ReturnsUnauthorized_WhenNoToken [1 ms]
  Error Message:
   Npgsql.NpgsqlException : Failed to connect to [::1]:33218
---- System.Net.Sockets.SocketException : Cannot assign requested address [::1]:33218
  Stack Trace:
     at Npgsql.Internal.NpgsqlConnector.Connect(NpgsqlTimeout timeout)
   at Npgsql.Internal.NpgsqlConnector.RawOpen(SslMode sslMode, NpgsqlTimeout timeout, Boolean async, CancellationToken cancellationToken)
   at Npgsql.Internal.NpgsqlConnector.<Open>g__OpenCore|214_1(NpgsqlConnector conn, SslMode sslMode, NpgsqlTimeout timeout, Boolean async, CancellationToken cancellationToken)
   at Npgsql.Internal.NpgsqlConnector.Open(NpgsqlTimeout timeout, Boolean async, CancellationToken cancellationToken)
   at Npgsql.PoolingDataSource.OpenNewConnector(NpgsqlConnection conn, NpgsqlTimeout timeout, Boolean async, CancellationToken cancellationToken)

Pipeline

name: Backend Tests (manual)

on:
  workflow_dispatch:
  push:

jobs:
  test:
    name: Run Backend Tests
    runs-on: self-hosted

    defaults:
      run:
        working-directory: tlab-backend

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Ensure Docker is available
        run: |
          docker info

      - name: Setup .NET SDK
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: '10.0.x'

      - name: Restore dependencies
        run: dotnet restore TLab.Tests/TLab.Tests.csproj

      - name: Build solution
        run: dotnet build TLab.Tests/TLab.Tests.csproj --configuration Release --no-restore

      - name: Run tests
        timeout-minutes: 10
        run: dotnet test TLab.Tests/TLab.Tests.csproj --configuration Release --no-build --logger "trx;LogFileName=test-results.trx" --collect:"XPlat Code Coverage"

      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: backend-test-results
          path: TLab.Tests/TestResults

      - name: Parse Trx files
        uses: NasAmin/[email protected]
        id: trx-parser
        with:
          TRX_PATH: TLab.Tests/TestResults
          REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Dotnet Test Reporter
        uses: bibipkins/[email protected]
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          comment-title: 'Integration Test Results'
          results-path: TLab.Tests/TestResults/*.trx
          coverage-path: TLab.Tests/TestResults/coverage.xml
          coverage-threshold: 80

[HofmeisterAn]

There are a few issues in the configuration. I only took a quick look, but here's what I noticed:

• Don't block the thread. Use xUnit.net's IAsyncLifetime to build the image and start the containers.
• You're seeing The process cannot access the file because the class is being instantiated multiple times, causing the same image (with the same name) to be built repeatedly.
  Either build it once (singleton), make it thread-safe, or use unique image names.
• Avoid doing this: WithEnvironment("ConnectionStrings__DefaultConnection", $"Server=host.docker.internal;Database=tlab;User Id=tlab;Password=tlab;Port={POSTGRES_PORT}").
  Put the containers on the same network and use container-to-container communication instead of routing through the host.
• For container-to-container communication, use the network alias.
• For host-to-container communication, never hardcode localhost or similar. Use IContainer.Hostname so the correct hostname is always resolved.
• You shouldn't configure your test host (web app) using environment variables. If you run multiple tests at the same time (without a proper singleton setup), your tests will overwrite each other's configuration and fail.
  For WebApplicationFactory, configure the specific instance like in this example (there are several ways to do it).