对 Autofac 模块进行单元测试以达到 100% 的代码覆盖率

Question

我们有一个可以进行复杂计算的核心库，我们认为它至关重要，我们希望该库的代码覆盖率达到 100%。我们现在有 96%，这很好，但由于这个类，我们无法达到 100%：

public class IoCModule : Autofac.Module
{
    protected override void Load(Autofac.ContainerBuilder builder)
    {
        builder.RegisterType<SomeMathServiceA>().As<ISomeMathServiceA>();
        builder.RegisterType<SomeMathServiceB>().As<ISomeMathServiceB>(); 

        //... more registrations
    }
 }

我不知道如何测试它，或者我们是否真的需要测试它。

我已经尝试了一个单元测试，它采用这个模块并创建一个 IContainer 并解决每个寄存器依赖项，但一些服务访问数据库和配置文件，在这种情况下模拟起来非常复杂。

完成！！！！

Answer 1

免责声明：类级单元测试不合理

（作者）

我猜你所说的单元测试是指“类级别的单元测试”，其中单元是一个类。如果您想测试IoCModule，您应该使用组件/库级别测试来测试整个库是否正常工作。这（应该）包括IoCModule - 以及库中的所有其他内容。使用这个级别的测试达到 100% 的分支覆盖率通常是不可行的，但是这个级别的测试 + 类级别的单元测试的组合使得测试可靠性非常好。 我还要说达到 80% 的综合覆盖率比只进行类级别的单元测试要好。虽然每个类本身都可以完全按照测试工作，但整体可能无法按预期工作。这就是您应该执行组件级测试的原因。

如何验证类型是否注册：

现在，如果您仍然坚持执行测试，请不要再观望，您可以这样做：

public class MyModuleTest
{
    private IContainer container;

    [TestFixtureSetUp]
    public void TestFixtureSetUp()
    {
        var containerBuilder = new ContainerBuilder();

        // register module to test
        containerBuilder.RegisterModule<MyModule>(); 

        // don't start startable components - 
        // we don't need them to start for the unit test
        this.container = containerBuilder.Build(
            ContainerBuildOptions.IgnoreStartableComponents);
    }

    [TestCaseSource(typeof(TypesExpectedToBeRegisteredTestCaseSource))]
    public void ShouldHaveRegistered(Type type)
    {
        this.container.IsRegistered(type).Should().BeTrue();
    }

    [TestFixtureTearDown]
    public void TestFixtureTearDown()
    {
        this.container.Dispose();
    }

    private class TypesExpectedToBeRegisteredTestCaseSource : IEnumerable<object[]>
    {
        private IEnumerable<Type> Types()
        {
            // whatever types you're registering..
            yield return typeof(string);
            yield return typeof(int);
            yield return typeof(float);
        }

        public IEnumerator<object[]> GetEnumerator()
        {
            return this.Types()
                .Select(type => new object[] { type })
                .GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

这会给出如下测试输出：

所以每种类型都是单独报告的。

哇，这很容易 - 那么又是什么问题？

现在在上面的示例中，您可以看到single (=float) 的测试通过了。现在看模块：

public class MyModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<float>();
    }
}

当我们实际尝试通过以下方式解决 float 时：

container.Resolve<float>();

这就是发生的事情：

Autofac.Core.DependencyResolutionException : 在构造函数查找器“Autofac.Core.Activators.Reflection.DefaultConstructorFinder”中找不到类型为“System.Single”的构造函数。

当然，我们可以调整测试以执行 Resolve(Type t) 而不是使用 IsRegistered(Type t) - 但是还有很多其他方法可以使测试通过 - 但实现失败。例如：

• 绑定类型以使用builder.RegisterInstance<IFoo>(null)
• 更改生命周期/范围，使其不再正常工作。

Answer 2

我终于找到了测试它的方法。 autofac 模块有一个方法 Configure 来注册组件。我就是这样做的：

public class CheckRegistrations
{
    [Test]
    public void Should_Have_Register_Types()
    {
        //Arrange
        var typesToCheck = new List<Type>
        {
            typeof (ISomeMathServiceA),
            typeof (ISomeMathServiceB)
        };

        //Act
        var typesRegistered = this.GetTypesRegisteredInModule(new IoCModule());

        //Arrange
        Assert.AreEqual(typesToCheck.Count, typesRegistered.Count());

        foreach (var typeToCheck in typesToCheck)
        {
            Assert.IsTrue(typesRegistered.Any(x => x == typeToCheck), typeToCheck.Name + " was not found in module");
        }
    }

    private IEnumerable<Type> GetTypesRegisteredInModule(Module module)
    {
        IComponentRegistry componentRegistry = new ComponentRegistry();

        module.Configure(componentRegistry);

        var typesRegistered =
            componentRegistry.Registrations.SelectMany(x => x.Services)
                .Cast<TypedService>()
                .Select(x => x.ServiceType);

        return typesRegistered;
    }
}