微服务环境下Asp.Net Core WebAPI契约测试依赖复用替换方案问询

我之前也碰到过一模一样的问题——不想复制Case.Api的Startup代码改来改去，又要在Provider测试里Mock指定依赖。这里有两个实用的方案，你可以根据能不能修改原API项目来选择：

方案1：给原Startup加扩展点（推荐，可维护性高） #

如果可以修改Case.Api的代码，最好的方式是把依赖注册逻辑拆成可扩展的部分，让测试项目能轻松重载替换。

步骤1：改造原Startup #

在Case.Api/Startup.cs里，把业务依赖的注册抽成一个可重载的虚方法：

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    // 核心配置（Mvc、基础服务等）保持不变，供测试复用
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        
        // 把需要Mock的依赖注册单独拎出来
        RegisterBusinessDependencies(services);
    }

    // 允许测试项目重载的虚方法，注册业务依赖
    protected virtual void RegisterBusinessDependencies(IServiceCollection services)
    {
        // 这里放原有的真实依赖注册，比如：
        // services.AddScoped<IOrderService, OrderService>();
        // services.AddDbContext<AppDbContext>(options => ...);
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 原有的中间件配置（比如路由、异常处理等）完全保留
    }
}

步骤2：在测试项目里创建TestStartup #

继承原Startup，重写RegisterBusinessDependencies方法替换成Mock依赖：

public class TestStartup : Case.Api.Startup
{
    public TestStartup(IConfiguration configuration) : base(configuration)
    {
    }

    protected override void RegisterBusinessDependencies(IServiceCollection services)
    {
        // 替换成Mock实现，比如用Moq创建实例：
        services.AddScoped(_ => Mock.Of<IOrderService>(s => 
            s.GetOrderById(It.IsAny<Guid>()) == Task.FromResult(new Order { Id = Guid.Empty })
        ));
        
        // 如果是数据库这类依赖，可以用内存数据库替代：
        // services.AddDbContext<AppDbContext>(options => 
        //     options.UseInMemoryDatabase("TestDb"));
    }
}

步骤3：在Provider测试里用TestStartup启动WebHost #

这样就能完全复用原API的所有配置，只替换需要Mock的部分：

public class ProviderApiTests : IDisposable
{
    private readonly IWebHost _webHost;

    public ProviderApiTests()
    {
        _webHost = new WebHostBuilder()
            .UseStartup<TestStartup>()
            // 添加测试专用配置（覆盖原配置）
            .ConfigureAppConfiguration(config =>
            {
                config.AddInMemoryCollection(new Dictionary<string, string>
                {
                    {"ApiSettings:Timeout", "5000"},
                    {"ConnectionStrings:Default", "InMemoryTestDb"}
                });
            })
            .Build();

        _webHost.Start();
    }

    // 你的Pact Provider测试方法，比如：
    [Fact]
    public void VerifyPact()
    {
        // 调用Pact的验证逻辑，比如：
        // var pactVerifier = new PactVerifier(new PactVerifierConfig());
        // pactVerifier.VerifyProvider();
    }

    public void Dispose()
    {
        _webHost?.StopAsync().Wait();
        _webHost?.Dispose();
    }
}

方案2：直接调用原Startup后替换依赖（无需修改原API） #

如果不能改动Case.Api的代码，那就先调用原Startup的配置，再手动替换已注册的服务。

步骤1：完善你的Replace扩展方法 #

确保能正确移除原有服务并添加Mock：

public static class ServiceCollectionExtensions
{
    // 替换为指定实例
    public static void Replace<TRegisteredType>(this IServiceCollection services, TRegisteredType replacement)
        where TRegisteredType : class
    {
        var existingDescriptor = services.FirstOrDefault(d => d.ServiceType == typeof(TRegisteredType));
        if (existingDescriptor != null)
        {
            services.Remove(existingDescriptor);
        }

        // 根据原服务的生命周期选择AddSingleton/AddScoped/AddTransient
        services.AddSingleton(replacement);
    }

    // 替换为指定类型
    public static void Replace<TRegisteredType, TImplementation>(this IServiceCollection services)
        where TRegisteredType : class
        where TImplementation : class, TRegisteredType
    {
        var existingDescriptor = services.FirstOrDefault(d => d.ServiceType == typeof(TRegisteredType));
        if (existingDescriptor != null)
        {
            services.Remove(existingDescriptor);
        }

        services.AddScoped<TRegisteredType, TImplementation>();
    }
}

步骤2：在测试里调用原Startup并替换依赖 #

public class ProviderApiTests : IDisposable
{
    private readonly IWebHost _webHost;

    public ProviderApiTests()
    {
        _webHost = new WebHostBuilder()
            .ConfigureServices(services =>
            {
                // 构建测试配置
                var testConfig = new ConfigurationBuilder()
                    .AddInMemoryCollection(new Dictionary<string, string>
                    {
                        {"SomeSetting", "TestValue"}
                    })
                    .Build();

                // 调用原Startup的ConfigureServices，复用所有基础配置
                var originalStartup = new Case.Api.Startup(testConfig);
                originalStartup.ConfigureServices(services);

                // 替换指定依赖
                services.Replace<IOrderService>(Mock.Of<IOrderService>());
            })
            .Configure(app =>
            {
                // 调用原Startup的Configure方法，复用中间件配置
                var env = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
                var config = app.ApplicationServices.GetRequiredService<IConfiguration>();
                var originalStartup = new Case.Api.Startup(config);
                originalStartup.Configure(app, env);
            })
            .Build();

        _webHost.Start();
    }

    // 测试方法...

    public void Dispose()
    {
        _webHost?.StopAsync().Wait();
        _webHost?.Dispose();
    }
}

注意事项 #

• 配置隔离：测试时用内存配置或测试专用的appsettings.Test.json，避免和生产配置冲突。
• 生命周期匹配：替换服务时要和原服务的生命周期一致（比如原先是Scoped，替换时也用AddScoped），避免出现意外问题。
• Mock逻辑准确：确保Mock的依赖能正确响应Pact交互里的请求，不然验证会失败。

内容的提问来源于stack exchange，提问作者terle