最小起订量 IServiceProvider / IServiceScope

Question

我正在尝试为IServiceProvider创建一个 Mock（使用 Moq），以便我可以测试我的存储库类：

public class ApiResourceRepository : IApiResourceRepository
{
    private readonly IServiceProvider _serviceProvider;

    public ApiResourceRepository(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
        _dbSettings = dbSettings;
    }

    public async Task<ApiResource> Get(int id)
    {
        ApiResource result;

        using (var serviceScope = _serviceProvider.
            GetRequiredService<IServiceScopeFactory>().CreateScope())
        {
            var context = serviceScope.ServiceProvider.GetRequiredService<ConfigurationDbContext>();
            result = await
                context.ApiResources
                .Include(x => x.Scopes)
                .Include(x => x.UserClaims)
                .FirstOrDefaultAsync(x => x.Id == id);
        }

        return result;
    }
}

我创建 Mock 对象的尝试如下：

Mock<IServiceProvider> serviceProvider = new Mock<IServiceProvider>();

serviceProvider.Setup(x => x.GetRequiredService<ConfigurationDbContext>())
    .Returns(new ConfigurationDbContext(Options, StoreOptions));

Mock<IServiceScope> serviceScope = new Mock<IServiceScope>();

serviceScope.Setup(x => x.ServiceProvider).Returns(serviceProvider.Object);

serviceProvider.Setup(x => x.CreateScope()).Returns(serviceScope.Object);

我收到以下错误：

System.NotSupportedException：表达式引用了一个不属于模拟对象的方法：x => x.GetRequiredService()

Answer 1

如前所述，Moq 不允许设置扩展方法。

然而，在这种情况下，上述扩展方法的源代码可在 Github 上找到

服务提供者服务扩展。

解决此类问题的常用方法是找出扩展方法的作用，并通过其执行安全地模拟路径。

所有这些中的基本类型是IServiceProvider及其object Getservice(Type type)方法。 这个方法是解析服务类型时最终调用的方法。 而且我们只处理抽象（接口），这使得使用 moq 变得更加容易。

//Arrange
var serviceProvider = new Mock<IServiceProvider>();
serviceProvider
    .Setup(x => x.GetService(typeof(ConfigurationDbContext)))
    .Returns(new ConfigurationDbContext(Options, StoreOptions));

var serviceScope = new Mock<IServiceScope>();
serviceScope.Setup(x => x.ServiceProvider).Returns(serviceProvider.Object);

var serviceScopeFactory = new Mock<IServiceScopeFactory>();
serviceScopeFactory
    .Setup(x => x.CreateScope())
    .Returns(serviceScope.Object);

serviceProvider
    .Setup(x => x.GetService(typeof(IServiceScopeFactory)))
    .Returns(serviceScopeFactory.Object);

var sut = new ApiResourceRepository(serviceProvider.Object);

//Act
var actual = sut.Get(myIntValue);

//Asssert
//...

查看上面的代码，您将看到这种安排如何满足扩展方法的预期行为以及被测试方法的扩展（无双关语）。

Answer 2

一般规则是您不要模拟您不拥有的类型。 除非您需要验证对服务提供者的调用，否则只需在您的测试中从ServiceCollection构建IServiceProvider 。

Answer 3

我想争辩说，当您需要添加那么多仪式只是为了模拟一个简单的方法时，那么您的代码可能不是很可测试。 所以另一种选择是将服务定位器隐藏在一个更测试和模拟友好的界面后面（在我看来也是一个更好的界面）：

public interface IServiceLocator : IDisposable
{
    T Get<T>();
}

public class ScopedServiceLocator : IServiceLocator
{
    private readonly IServiceScopeFactory _factory;
    private IServiceScope _scope;

    public ScopedServiceLocator(IServiceScopeFactory factory)
    {
        _factory = factory;
    }

    public T Get<T>()
    {
        if (_scope == null)
            _scope = _factory.CreateScope();

        return _scope.ServiceProvider.GetService<T>();
    }


    public void Dispose()
    {
        _scope?.Dispose();
        _scope = null;
    }
}

我在这里只实现了GetService<T>方法，但您可以轻松添加/删除，以便定位器更好地满足您的需求。 以及如何使用它的示例；

public class ALongRunningTask : IRunForALongTime
{
    private readonly IServiceLocator _serviceLocator;

    public ALongRunningTask(IServiceLocator serviceLocator)
    {
        _serviceLocator = serviceLocator;
    }

    public void Run()
    {
        using (_serviceLocator)
        {
            var repository = _serviceLocator.Get<IRepository>();
        }
    }
}

Answer 4

我也在寻找这个，但我只需要模拟 GetService。 我总是使用 AutoFac 来自动生成模拟。 在这个例子中，'GetService' 总是返回一个模拟实例。 之后您可以使用 freeze 方法更改模拟行为。

例子：

要测试的类：

public class ApiResourceRepository : ApiResourceRepository {
            private readonly IServiceProvider _serviceProvider;

            public ApiResourceRepository(IServiceProvider serviceProvider) {
                _serviceProvider = serviceProvider;
            }

            public object Get(int id) {
                using (var serviceScope = _serviceProvider.CreateScope()) {
                    var repo = serviceScope.ServiceProvider.GetService<IPersonRepository>();
                    return repo.GetById(id);
                }
            }
        }

单元测试：

 [Fact]
        public void Test() {
            // arrange
            var fixture = new Fixture()
             .Customize(new AutoMoqCustomization())
             .Customize(new ServiceProviderCustomization());

            fixture.Freeze<Mock<IPersonRepository>>()
                .Setup(m => m.GetById(It.IsAny<int>()))
                .Returns(new Person(Name = "John"));

            // Act
            var apiResource = _fixture.Create<ApiResourceRepository>();
            var person = apiResource.Get(1);

            // Assert
            ...
        }

自定义 AutoFac 提供程序

public class ServiceProviderCustomization : ICustomization {

        public void Customize(IFixture fixture) {
            var serviceProviderMock = fixture.Freeze<Mock<IServiceProvider>>();

            // GetService
            serviceProviderMock
               .Setup(m => m.GetService(It.IsAny<Type>()))
               .Returns((Type type) => {
                   var mockType = typeof(Mock<>).MakeGenericType(type);
                   var mock = fixture.Create(mockType, new SpecimenContext(fixture)) as Mock;

                   // Inject mock again, so the behavior can be changed with _fixture.Freeze()
                   MethodInfo method = typeof(FixtureRegistrar).GetMethod("Inject");
                   MethodInfo genericMethod = method.MakeGenericMethod(mockType);
                   genericMethod.Invoke(null, new object[] { fixture, mock });

                   return mock.Object;
               });

            // Scoped
            var serviceScopeMock = fixture.Freeze<Mock<IServiceScope>>();
            serviceProviderMock
               .As<IServiceScopeFactory>()
               .Setup(m => m.CreateScope())
               .Returns(serviceScopeMock.Object);

            serviceProviderMock.As<ISupportRequiredService>()
                .Setup(m => m.GetRequiredService(typeof(IServiceScopeFactory)))
                .Returns(serviceProviderMock.Object);
        }
    }

Answer 5

免责声明：嵌入的链接指向我的 GitHub 和 NuGet 页面的子页面。 但我希望它可以帮助你或其他人，永远不会少。

---

我刚刚创建了这样的东西，因为我找不到任何东西。 它实现了 IServiceCollection 和 IServiceProvider 来测试我的启动配置，特别是所有类型是否都正确注册到 DI-Container。 它是这些接口的通用替代品，为每个注册类型提供 Mocks (Moq) 作为单例。 Foo<Bar> 与 Foo<Bus> 不同。

GitHub 上有一个 readme.md，代码库不是很大。

还有一个名为 MockProvider的nuget 包- 如前所述 -代码在 GitHub 上。 我把它放在麻省理工学院，所以用它做你想做的。 它可以免费使用和贡献。

将其视为一种回馈方式。

Answer 6

我使用 Moq 和 xUnit 进行测试。 我以前遇到过类似的问题，我的解决方案是将数据事务提取到带有接口的 SqlExecuter 类中，以便我可以直接模拟来自数据库的响应。 这简化了一切，足以构建服务提供者并将其传入。您将需要 xUnit、Moq 和一些 Microsoft 包（Microsoft.EntityFrameworkCore 和 Microsoft.EntityFrameworkCore.InMemory）。

SqlExecuter.cs

public interface ISqlExecuter
{
    Task<List<SqlParameter>> FirstOrDefaultApiResource(ConfigurationDbContext context, int id);
}

public class SqlExecuter : ISqlExecuter
{
    public async Task<ApiResource> FirstOrDefaultApiResource(ConfigurationDbContext context, int id) =>
        return await context.ApiResources
            .Include(x => x.Scopes)
            .Include(x => x.UserClaims)
            .FirstOrDefaultAsync(x => x.Id == id);
} 

ApiResourceRepository.cs

public class ApiResourceRepository : IApiResourceRepository
{
    private readonly IServiceProvider _serviceProvider;
    private readonly ISqlExecuter _sqlExecuter;

    public ApiResourceRepository(IServiceProvider serviceProvider, ISqlExecuter sqlExecuter)
    {
        _serviceProvider = serviceProvider;
        _sqlExecuter = sqlExecuter;
        _dbSettings = dbSettings;
    }

    public async Task<ApiResource> Get(int id)
    {
        ApiResource result;

        using (var serviceScope = _serviceProvider.GetRequiredService<IServiceScopeFactory>().CreateScope())
        {
            var context = serviceScope.ServiceProvider.GetRequiredService<ConfigurationDbContext>();
            result = await _sqlExecuter.FirstOrDefaultApiResource(context, id);
        }

        return result;
    }
}

ApiResourceRepositoryTests.cs

[Fact]
public async Task Get_Success()
{
    // Arrange
    var id = 42069;
    var scope = "Scope";
    var claim = "UserClaims";
    var services = new ServiceCollection();
    services.AddDbContext<ConfigurationDbContext>(opt => opt
            .UseInMemoryDatabase(databaseName: $"ConfigurationDbContext-{ DateTime.Now.ToString() }")
            .ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning)),
        ServiceLifetime.Singleton, ServiceLifetime.Singleton);
    var serviceProvider = services.BuildServiceProvider();
    var mockSqlExecuter = new Mock<SqlExecuter>();
    mockSqlExecuter.Setup(x => x.FirstOrDefaultApiResource(It.IsAny<ConfigurationDbContext>(), It.IsAny<int>()))
        .Returns(new ApiResource() { Id = id , Scope = scope, UserClaims = claim })
    var mockApiResourceRepository = new Mock<ApiResourceRepository>(serviceProvider, mockSqlExecuter.Object);

    // Act
    var result = await mockApiResourceRepository.Object.Get(id);

    
    // Assert
    Assert.NotNull(response);
    Assert.Equal(id, result.Id);
    Assert.Equal(scope, result.Scope);
    Assert.Equal(claim, result.UserClaims);
}

或者，在其他情况下，我不使用 SqlExecuter 类，而是为服务提供者中设置的上下文设置种子。

// Arrange
var id = 42069;
var scope = "Scope";
var claim = "UserClaims";
var services = new ServiceCollection();
services.AddDbContext<ConfigurationDbContext>(opt => opt
        .UseInMemoryDatabase(databaseName: $"ConfigurationDbContext-{DateTime.Now.ToString()}")
        .ConfigureWarnings(x => x.Ignore(InMemoryEventId.TransactionIgnoredWarning)),
    ServiceLifetime.Singleton, ServiceLifetime.Singleton);
var serviceProvider = services.BuildServiceProvider();
var context = Interfaces.ServiceProvider.GetService<ComQueMDSContext>();
context.ApiResources.RemoveRange(context.ApiResources);
context.ApiResources.AddRange(new List<ApiResource>(){ new ApiResource(){ Id = id, Scope = scope, UserClaims = claim } });
context.SaveChanges();
var mockApiResourceRepository = new Mock<ApiResourceRepository>(serviceProvider);

我还按照 xUnit 的建议将大部分工作提取到了 Fixture 类和集合中，以集中上下文并减少测试时间。

https://xunit.net/docs/shared-context

Answer 7

以防万一它对某人有用，这里有一个示例，说明我如何按照此处的建议为我的单元测试创​​建自己的 ServiceProvider。 我还添加了 ServiceScope 和 ServiceScopeFactory 模拟来提供所有服务。

这是我的单元测试中的代码：

var serviceCollection = new ServiceCollection();

// Add any DI stuff here:
serviceCollection.AddSingleton<ILogger>(loggerMock.Object);

// Create the ServiceProvider
var serviceProvider = serviceCollection.BuildServiceProvider();

// serviceScopeMock will contain my ServiceProvider
var serviceScopeMock = new Mock<IServiceScope>();
serviceScopeMock.SetupGet<IServiceProvider>(s => s.ServiceProvider)
    .Returns(serviceProvider);

// serviceScopeFactoryMock will contain my serviceScopeMock
var serviceScopeFactoryMock = new Mock<IServiceScopeFactory>();
serviceScopeFactoryMock.Setup(s => s.CreateScope())
    .Returns(serviceScopeMock.Object);
    

然后我可以将我的 serviceScopeFactoryMock 传递给我的 sut 构造函数。

这是正在测试的代码：

using (var scope = _serviceScopeFactory.CreateScope())
{
    var logger = scope.ServiceProvider.GetRequiredService<ILogger>();
    ...
}

Answer 8

这是我在范围服务提供者内部模拟的片段。 用于测试 IHostedService 等：

Mock<IServiceProvider> CreateScopedServicesProvider(params (Type @interface, Object service)[] services)
{
    var scopedServiceProvider = new Mock<IServiceProvider>();

    foreach (var (@interfcae, service) in services)
    {
        scopedServiceProvider
            .Setup(s => s.GetService(@interfcae))
            .Returns(service);
    }

    var scope = new Mock<IServiceScope>();
    scope
        .SetupGet(s => s.ServiceProvider)
        .Returns(scopedServiceProvider.Object);

    var serviceScopeFactory = new Mock<IServiceScopeFactory>();
    serviceScopeFactory
        .Setup(x => x.CreateScope())
        .Returns(scope.Object);

    var serviceProvider = new Mock<IServiceProvider>();
    serviceProvider
        .Setup(s => s.GetService(typeof(IServiceScopeFactory)))
        .Returns(serviceScopeFactory.Object);

    return serviceProvider;
}

用法：

var service = new Mock<IMyService>();
var serviceProvider = CreateScopedServicesProvider((typeof(IMyService), scopedService.Object));
var sut = new ServiceThatUsesScopes(serviceProvider.Object)