Support integration tests in .NET Core generic hosting

It doesn’t work for me either when using AutoFac Modules because they get called last even after ConfigureTestServices.

Workaround I am using is following.

public class Startup {
    //holds all overrides that might be defined (in tests for example)
    private readonly Queue<Action<ContainerBuilder>> m_AdditionalServiceRegistrations = new();

    public void ConfigureServices(IServiceCollection services) {
        //standard framework services....

       //register Startup class itself to be available in tests
       if (Environment.IsTest()) {
        services.AddSingleton(GetType(), this);
      }
    }

    public void ConfigureContainer(ContainerBuilder builder) {
      //standard module registrations
      builder.RegisterModule<ModuleA>();

      //as last dequeue all available overrides in order and apply them
      while (m_AdditionalServiceRegistrations.TryDequeue(out var registrations)) {
        registrations(builder);
      }
    }
   
    //method called in tests to register possible mock services
    public void AddServiceRegistrationOverrides(Action<ContainerBuilder> registration) {
      m_AdditionalServiceRegistrations.Enqueue(registration);
    }
}

Then define extension method similar to this one

  internal static class HostBuilderExtensions {
    internal static IWebHostBuilder UseAutofacTestServices(this IWebHostBuilder builder, Action<ContainerBuilder> containerBuilder) {
      builder.ConfigureTestServices(services => {
        //startup is registered only in test environment so we can be sure it's available here
        var startup = (Startup)services.Single(s => s.ServiceType == typeof(Startup)).ImplementationInstance!;

        startup.AddServiceRegistrationOverrides(containerBuilder);
      });

      return builder;
    }
}

And finally I can use it in XUnit test with ITestFixture

public class SomeTestClass: IClassFixture<WebApplicationFactory> {
    private readonly WebApplicationFactory m_Factory;

    public SomeTestClass(WebApplicationFactory factory) {
      m_Factory = factory;
    }

    [Fact]
    public async Task SomeTestMethod() {
        await using var updatedFactory = m_Factory.WithWebHostBuilder(builder => {
        builder.UseAutofacTestServices(containerBuilder => {
          containerBuilder.RegisterType<MockService>().As<IService>().SingleInstance();
        });
      });
    }
}

Disadvantage is that you “pollute” your Startup class a bit but I think if it’s a concern to you you can do these modifications in some derived TestStartup class for example.

I may be missing something here, but it should be possible to use a similar workaround without needing to override the ContainerBuilder. I just tried this:

/// <summary>
/// Based upon https://github.com/dotnet/AspNetCore.Docs/tree/master/aspnetcore/test/integration-tests/samples/3.x/IntegrationTestsSample
/// </summary>
/// <typeparam name="TStartup"></typeparam>
public class AutofacWebApplicationFactory<TStartup> : WebApplicationFactory<TStartup> where TStartup : class
{
    protected override IHost CreateHost(IHostBuilder builder)
    {
        builder.UseServiceProviderFactory(new CustomServiceProviderFactory());
        return base.CreateHost(builder);
    }
}

/// <summary>
/// Based upon https://github.com/dotnet/aspnetcore/issues/14907#issuecomment-620750841 - only necessary because of an issue in ASP.NET Core
/// </summary>
public class CustomServiceProviderFactory : IServiceProviderFactory<ContainerBuilder>
{
    private AutofacServiceProviderFactory _wrapped;
    private IServiceCollection _services;

    public CustomServiceProviderFactory()
    {
        _wrapped = new AutofacServiceProviderFactory();
    }

    public ContainerBuilder CreateBuilder(IServiceCollection services)
    {
        // Store the services for later.
        _services = services;

        return _wrapped.CreateBuilder(services);
    }

    public IServiceProvider CreateServiceProvider(ContainerBuilder containerBuilder)
    {
        var sp = _services.BuildServiceProvider();
#pragma warning disable CS0612 // Type or member is obsolete
        var filters = sp.GetRequiredService<IEnumerable<IStartupConfigureContainerFilter<ContainerBuilder>>>();
#pragma warning restore CS0612 // Type or member is obsolete

        foreach (var filter in filters)
        {
            filter.ConfigureContainer(b => { })(containerBuilder);
        }

        return _wrapped.CreateServiceProvider(containerBuilder);
    }        
}

This then works:

public async Task MyAsync()
{
    void ConfigureTestServices(IServiceCollection services)
    {
        services.AddSingleton("");
    }

    void ConfigureTestContainer(ContainerBuilder builder)
    {
        builder.RegisterInstance("hello world");
    }

    var factory = new AutofacWebApplicationFactory<DefaultStartup>();

    using var client = factory
        .WithWebHostBuilder(builder => {
            builder.ConfigureTestServices(ConfigureTestServices);
            builder.ConfigureTestContainer<ContainerBuilder>(ConfigureTestContainer);
        })
        .CreateClient();
}

@johnnyreilly, perhaps you could try out my alternate workaround and see if I’ve forgotten something?