断言一个方法只被调用一次

Question

我想断言一个方法只被调用了一次。我正在使用 RhinoMocks 3.5。

以下是我认为可行的方法：

[Test]
public void just_once()
{
    var key = "id_of_something";

    var source = MockRepository.GenerateStub<ISomeDataSource>();
    source.Expect(x => x.GetSomethingThatTakesALotOfResources(key))
        .Return(new Something())
        .Repeat.Once();

    var client = new Client(soure);

    // the first call I expect the client to use the source
    client.GetMeMyThing(key);

    // the second call the result should be cached
    // and source is not used
    client.GetMeMyThing(key);
}

如果GetMeMyThing() 的第二次调用调用source.GetSomethingThatTakesALotOfResources()，我希望此测试失败。

Answer 1

这是我验证方法是否被调用一次的方式。

[Test]
public void just_once()
{
    // Arrange (Important to GenerateMock not GenerateStub)
    var a = MockRepository.GenerateMock<ISomeDataSource>();
    a.Expect(x => x.GetSomethingThatTakesALotOfResources()).Return(new Something()).Repeat.Once();

    // Act
    // First invocation should call GetSomethingThatTakesALotOfResources
    a.GetMeMyThing();

    // Second invocation should return cached result
    a.GetMeMyThing();

    // Assert
    a.VerifyAllExpectations();
}

Answer 2

如果你想确保一个方法只被调用一次，你可以创建严格的模拟。

var mock = MockRepository.GenerateStrictMock<IMustOnlyBeCalledOnce>();
mock.Expect(a => a.Process()).Repeat.Once();
var helloWorld= new HelloWorld(mock);

helloworld.Process()

mock.VerifyAllExpectations();

Answer 3

您可以将委托传递给 WhenCalled 以计算调用次数：

...
uint callCount = 0;
source.Expect(x => x.GetSomethingThatTakesALotOfResources(key))
    .Return(new Something())
    .WhenCalled((y) => { callCount++; });
...
Assert.AreEqual(1, callCount);

此外，您应该使用模拟而不是存根，并验证对模拟的期望。

Answer 4

我一直在使用 AssertWasCalled 扩展来解决这个问题。这是我能找到/想出的最好的方法，但如果我不必指定两次调用会更好。

    [Test]
    public void just_once()
    {
        var key = "id_of_something";

        var source = MockRepository.GenerateStub<ISomeDataSource>();

        // set a positive expectation
        source.Expect(x => x.GetSomethingThatTakesALotOfResources(key))
            .Return(new Something())
            .Repeat.Once();

        var client = new Client(soure);
        client.GetMeMyThing(key);
        client.GetMeMyThing(key);

        source.AssertWasCalled(x => x.GetSomethingThatTakesALotOfResources(key),
                               x => x.Repeat.Once());
        source.VerifyAllExpectations();
    }

Answer 5

拥有一个名为“Exactly”的功能可以方便地对可能陷入无限循环的代码编写测试。我很想编写一个测试，这样对方法的第二次调用就会引发异常。

一些 Python 库允许您对期望进行排序，因此第一个返回 false，第二个引发异常。

Rhino 不会那样做。带有 .Once 的部分模拟将拦截第一个调用，其余的将传递给原始方法。所以这很糟糕，但这是真的。

您必须创建一个手模。派生一个“可测试”类，并赋予它在第一次跟注后加注的能力。

Answer 6

您可能对 Rhino Mocks 3.5 文档中的this bit 感兴趣（引用如下）。看起来你需要模拟这个类，而不是存根它，它才能以你期望的方式工作。

存根和模拟之间的区别

...

模拟是我们可以设置的对象 期望，这将验证 预期的行动确实 发生了。存根是一个对象 使用以传递给下的代码 测试。您可以设置期望 它，所以它会以某种方式行动， 但那些期望永远不会 已验证。存根的属性将 自动表现得像平常一样 属性，你不能设置 对他们的期望。

如果你想验证的行为 被测代码，您将使用 以适当的期望模拟， 并验证。如果你只想 传递一个可能需要在 某种方式，但不是重点 这个测试，你将使用一个存根。

重要提示：存根永远不会导致 测试失败。

Answer 7

这是我刚刚做的（由Ray Houston 推荐）。我仍然希望有一个更优雅的解决方案...

[Test]
public void just_once()
{
    var key = "id_of_something";

    var source = MockRepository.GenerateStub<ISomeDataSource>();

    // set a positive expectation
    source.Expect(x => x.GetSomethingThatTakesALotOfResources(key))
        .Return(new Something())
        .Repeat.Once();

    var client = new Client(soure);

    client.GetMeMyThing(key);

    // set a negative expectation
    source.Expect(x => x.GetSomethingThatTakesALotOfResources(key))
        .Return(new Something())
        .Repeat.Never();

    client.GetMeMyThing(key);
}