3

我正在尝试使用SUT 工厂“模式”来创建我的 SUT。

给定 SUT 结构：

namespace MySut
{
    public class Dep1
    {
    }

    public class Dep2
    {
    }

    public class Sut
    {
        public Sut( Dep1 dep1, Dep2 dep2 )
        {
        }
    }
}

我正在使用AutoFixture，并且想知道折叠以下规范和相关 SUT 工厂方法 [有价值但] 忙碌工作的最佳方法是什么：

namespace MySpecifications
{
    using MySut;
    public class MySpecification
    {
        public void TestCore()
        {
            // Dont care about dependencies, testing core functionality
            var sut = CreateSut();
        }

        public void TestDep1Interaction()
        {
            // Dont care about Dep2, want to observe stuff on the Dep1 dependent object
            var sut = CreateSut( new Mock<Dep1>().Object );
        }

        public void TestDep2Interaction()
        {
            // Dont care about Dep1, want to observe stuff on the Dep2 dependent object
            var sut = CreateSut( new Mock<Dep2>().Object );
        }

        private object CreateSut( )
        {
            return CreateSut( CreateDep1(), CreateDep2() );
        }

        private object CreateSut( Dep1 dep1 )
        {
            return CreateSut( dep1, CreateDep2() );
        }

        private object CreateSut( Dep2 dep2 )
        {
            return CreateSut( CreateDep1(), dep2 );
        }

        private Sut CreateSut( Dep1 dep1, Dep2 dep2 )
        {
            return new Sut( dep1, dep2 );
        }

        private static Dep1 CreateDep1()
        {
            return new Fixture().CreateAnonymous<Dep1>();
        }

        private static Dep2 CreateDep2()
        {
            return new Fixture().CreateAnonymous<Dep2>();
        }
    }
}

类似于：

    public class MyAutoFixturedSpecification
    {
        public void TestCore()
        {
            // Dont care about dependencies, testing core functionality
            var sut = CreateSut();
        }

        public void TestDep1Interaction()
        {
            // Dont care about Dep2, want to observe stuff on the Dep1 dependent object
            var sut = CreateSut( new Mock<Dep1>().Object );
        }

        public void TestDep2Interaction()
        {
            // Dont care about Dep1, want to observe stuff on the Dep2 dependent object
            var sut = CreateSut( new Mock<Dep2>().Object );
        }

        private object CreateSut( params object[] injectedNonAnonymouses )
        {
            return new Fixture(  ).Build<Sut>(  )./*??????*/;
        }
    }

或者：

    public class MyAnticipatedAutoFixturedSpecification
    {
        public void TestCore()
        {
            // Dont care about dependencies, testing core functionality
            var sut = new Fixture(  ).Build<Sut>().CreateAnonymous(  );
        }

        public void TestDep1Interaction()
        {
            // Dont care about Dep2, want to observe stuff on the Dep1 dependent object
            var sut = new Fixture().Build<Sut>()/*.With( new Mock<Dep1>().Object )*/.CreateAnonymous();
        }

        public void TestDep2Interaction()
        {
            // Dont care about Dep1, want to observe stuff on the Dep2 dependent object
            var sut = new Fixture().Build<Sut>()/*.With( new Mock<Dep2>().Object )*/.CreateAnonymous();
        }
    }

即，删除所有工厂垃圾，以便我的规范可以轻松应对过渡到：

namespace MySutWithNewDependency
{
    public class Dep1
    {
    }

    public class Dep2
    {
    }

    public class Dep3
    {
    }

    public class Sut
    {
        public Sut( Dep1 dep1, Dep2 dep2, Dep3 dep3 )
        {
        }
    }
}

虽然与自动模拟容器的概念有重叠，但我仍然不是在寻找金锤 - 只是一种能够一次模拟 0 或 1 个事物并且能够自定义创建依赖对象而无需每当其依赖关系集发生变化时，重新访问对 Sut 构造函数的显式调用。

（也使用 xUnit.net（SubSpec 风格）、Moq、Ninject2（虽然我不想在我的规范中使用 DI））

4

1 回答 1

4

AutoFixture 可以或多或少地为您完成所有这些工作，而无需所有额外的脚手架。我将从一个基本的 Fixture 开始并使用它来解决Sut：

var fixture = new Fixture();
var sut = fixture.CreateAnonymous<Sut>();

这假设Dep1并且Dep2可以由 AutoFixture 自动创建，但正如所展示的，它们可以，因为它们具有默认构造函数。

当您想要覆盖特定类型时，可以使用 Register 方法，如下所示：

var fixture = new Fixture();

var mock = new Mock<Dep1>();
fixture.Register(mock.Object);
// Setup mock if necessary...

var sut = fixture.CreateAnonymous<Sut>();

这将导致fixture使用mock.Object任何Dep1需要的时间，包括Sut调用构造函数时。这绝对符合您在面对不断变化的构造函数时保持稳健的要求，也是 AutoFixture 如此构建的主要原因之一。

在更现实的情况下，Dep1 和 Dep2 可能是接口，在这种情况下，您可能希望将它们注册为“默认夹具”的一部分。这当然也可能是因为最后一次调用 Register 获胜。这意味着您可以使用一些好的默认值配置 Fixture 实例，并且在需要时仍然可以覆盖特定类型。

我个人使用 AutoFixture 作为自动模拟容器。这个讨论提供了关于 AutoFixture 1.1 API 如何实现这一点的提示，但 AutoFixture 2.0 的新内核将提供更好的可扩展性选项。当我谈到它时，我会写一篇关于这个主题的博客文章。

PS对不起，回复晚了，但我之前没有看到你的问题。将来，请随时 ping 我（例如在 Twitter 上）以获得更快的回复。

于 2010-07-07T03:24:01.083 回答