1

所以基本上,我有一个抽象类,它有一个唯一的增量 ID - Primitive。当 a Primitive(或更准确地说,是 的继承者Primitive)被实例化时,ID 会递增 - 直到 ID 溢出的点 - 在这一点上,我向异常添加一条消息并重新抛出。

好的,一切都很好......但我正在尝试测试这个功能,我以前从未使用过模拟。我只需要制作足够的 Primitives 以使 ID 溢出并断言它在正确的时间抛出。

  • 实例化 20 亿个对象来做到这一点是不合理的!但是我没有看到另一种方式。
  • 我不知道我是否正确使用了模拟?(我正在使用Moq。)

这是我的测试(xUnit):

[Fact(DisplayName = "Test Primitive count limit")]
public void TestPrimitiveCountLimit()
{
    Assert.Throws(typeof(OverflowException), delegate()
    {
        for (; ; )
        {
            var mock = new Mock<Primitive>();
        }
    });
}

和:

public abstract class Primitive
{
    internal int Id { get; private set; }
    private static int? _previousId;

    protected Primitive()
    {
        try
        {
            _previousId = Id = checked (++_previousId) ?? 0;
        }
        catch (OverflowException ex)
        {
            throw new OverflowException("Cannot instantiate more than (int.MaxValue) unique primitives.", ex);
        }
    }
}

我认为我做错了 - 那么我该如何正确测试呢?

4

4 回答 4

5

你不需要为此嘲笑。当两个类一起工作并且你想用一个模拟(假的)类替换一个类时,你使用模拟,所以你只需要测试另一个类。在您的示例中不是这种情况。

但是,有一种方法可以使用模拟,并且可以解决 2bln 实例的问题。如果将 ID 生成与Primitive类分开并使用生成器,则可以模拟生成器。一个例子:

我已更改Primitive为使用提供的生成器。在这种情况下,它被设置为一个静态变量,并且有更好的方法,但作为一个例子:

public abstract class Primitive
{
    internal static IPrimitiveIDGenerator Generator;

    protected Primitive()
    {
        Id = Generator.GetNext();
    }

    internal int Id { get; private set; }
}

public interface IPrimitiveIDGenerator
{
    int GetNext();
}

public class PrimitiveIDGenerator : IPrimitiveIDGenerator
{
    private int? _previousId;

    public int GetNext()
    {
        try
        {
            _previousId = checked(++_previousId) ?? 0;

            return _previousId.Value;
        }
        catch (OverflowException ex)
        {
            throw new OverflowException("Cannot instantiate more than (int.MaxValue) unique primitives.", ex);
        }
    }
}

然后,您的测试用例变为:

[Fact(DisplayName = "Test Primitive count limit")]
public void TestPrimitiveCountLimit()
{
    Assert.Throws(typeof(OverflowException), delegate()
    {
        var generator = new PrimitiveIDGenerator();

        for (; ; )
        {
            generator.GetNext();
        }
    });
}

这将运行得更快,现在您只测试 ID 生成器是否工作。

现在,当您想测试创建新原语实际上是否需要 ID 时,您可以尝试以下操作:

public void Does_primitive_ask_for_an_ID()
{
    var generator = new Mock<IPrimitiveIDGenerator>();

    // Set the expectations on the mock so that it checks that
    // GetNext is called. How depends on what mock framework you're using.

    Primitive.Generator = generator;

    new ChildOfPrimitive();
}

现在您已经分离了不同的关注点并可以分别测试它们。

于 2010-11-07T13:29:41.903 回答
1

模拟的重点是模拟外部资源。这不是你想要的,你想测试你的对象,在这个场景中不需要模拟。如果您愿意,只需实例化 20 亿个对象,这不会有什么坏处,因为 GC 会丢弃旧实例(但可能需要一段时间才能完成)。

Id' 实际上添加了另一个构造函数,该构造函数接受标识计数器的起始值,以便您实际上可以开始接近int.MaxValue,因此不需要实例化尽可能多的对象。

此外,仅从阅读源代码中我就可以看出您的对象将无法通过测试。;-)

于 2010-11-07T13:28:31.640 回答
1

其他答案中都说了。我只是想向您展示一个替代方案,也许这对您来说有点有趣。

如果您创建了类的 _previousId字段(当然还包含了相应的属性),那么您的测试可以像使用Typemock Isolator工具一样简单:PrimitiveinternalInternalsVisibleTo

[Fact(DisplayName = "Test Primitive count limit"), Isolated]
public void TestPrimitiveCountLimit()
{
    Primitive._previousId = int.MaxValue;

    Assert.Throws<OverflowException>(() => 
        Isolate.Fake.Instance<Primitive>(Members.CallOriginal, ConstructorWillBe.Called));
}

当然,Typemock 会带来一些许可成本,但如果您必须编写大量测试代码,它肯定会让生活变得更轻松并节省大量时间 - 特别是在不易测试甚至无法测试的系统上一个免费的模拟框架。

托马斯

于 2010-11-07T15:14:31.967 回答
1

这个问题有两个问题:

  1. 如何对无法实例化的抽象类进行单元测试。
  2. 如何有效地对需要创建和销毁 20 亿个实例的功能进行单元测试。

我认为解决方案非常简单,即使您必须稍微重新考虑对象的结构。

对于第一个问题,解决方案很简单Primitive,只需在您的测试项目中添加一个继承的 fake,但不添加任何功能。然后,您可以实例化您的假类,并且您仍将测试Primitive.

public class Fake : Primitive { }

// and in your test...
Assert.Throws(typeof(OverflowException), delegate() { var f = new Fake(int.MaxValue); });

对于第二个问题,我将添加一个构造函数,该构造函数接受int前一个 ID,并使用构造函数链接在您的实际代码中“不需要它”。(但是你怎么知道以前的 id ?你不能int.MaxValue-1在你的测试设置中设置它吗?)把它想象成依赖注入,但你没有注入任何复杂的东西;你只是注入一个简单的int. 可能是这样的:

public abstract class Primitive
{
internal int Id { get; private set; }
private static int? _previousId;

protected Primitive() : Primitive([some way you get your previous id now...])
protected Primitive(int previousId)
{
    _previousId = previousId;
    try
    {
        _previousId = Id = checked (++_previousId) ?? 0;
    }
    catch (OverflowException ex)
    {
        throw new OverflowException("Cannot instantiate more than (int.MaxValue) unique primitives.", ex);
    }
}
于 2010-11-07T13:43:13.620 回答