c# - ¿Cómo usar Rhino.Mocks AssertWasCalled() correctamente?

nunit rhino-mocks

Question

Llamo a _mocks.ReplayAll() , luego a uno o más _mockedObject.AssertWasCalled() y luego a _mocks.VerifyAll() . Pero me dice que "esta acción no es válida cuando el objeto simulado está en estado de registro".

[Test]
public void SetStateExecuting_Should_Set_State_To_Pause_And_Not_Change_GlobalState_When_GlobalState_Is_Paused()
{
    var task = new Task { ID = 1, TimeZone = -660, GlobalState = TaskState.Paused };
    _taskDataProvider.Expect(p => p.StateUpdate(task.ID, task.TimeZone, TaskState.Paused));
    _mockRepository.ReplayAll();
    _manager.SetStateExecuting(task);
    _taskDataProvider.AssertWasNotCalled(p => p.GlobalStateUpdate(task.ID, 
                                                                  TaskState.Executing));
    _mockRepository.VerifyAll();
}

¿Cuál es el orden correcto para llamar para que estos métodos funcionen correctamente?

Answer 1

Está mezclando el antiguo patrón de grabación / reproducción y el nuevo patrón AAA .

La forma normal de configurar una expectativa de "no se llama con estos argumentos" en el modo de grabación es la siguiente:

_taskDataProvider.Expect(
    p => p.GlobalStateUpdate(task.ID, TaskState.Executing)).Repeat.Never();

O, alternativamente, puede usar un simulacro estricto que simplemente no permite llamadas inesperadas.

AssertWasCalled y AssertWasNotCalled están destinados a la AAA, donde coloca sus afirmaciones al final. Con la sintaxis de Grabar / Repetir, tanto el comportamiento como las expectativas deben configurarse al inicio antes de cambiar al modo de reproducción.

( AssertWasNotCalled puede funcionar con Grabar / Repetir, pero nunca lo probé porque no me gusta mezclar elementos de ambos enfoques. Complica de manera innecesaria).

Answer 2

La publicación del blog de Jon Kruger "Cómo usar las simulaciones de rinoceronte documentadas a través de pruebas" tiene ejemplos simples de todo lo que puedes hacer con los métodos de simulación de rinocerontes. También muestra lo que no puedes hacer, lo que me pareció muy útil para aprender.

Como se mencionó anteriormente, es más fácil leer la Sintaxis de Assert, Act, Assert con los constructores estáticos. La publicación del blog muestra ejemplos de ambos métodos.

Aquí hay ejemplos del código de ejemplo de Jon:

Nueva sintaxis:

 [Test]
    public void You_can_check_to_see_if_a_method_was_called()
    {
        var stub = MockRepository.GenerateStub<ISampleClass>();

        stub.MethodThatReturnsInteger("foo");

        stub.AssertWasCalled(s => s.MethodThatReturnsInteger("foo"));
        stub.AssertWasCalled(s => s.MethodThatReturnsInteger(Arg<string>.Is.Anything));
    }

Viejo estilo:

    [Test]
    public void Calling_virtual_methods_will_call_the_actual_method()
    {
        var mockRepository = new MockRepository();
        var sampleClass = mockRepository.PartialMock<SampleClass>();
        sampleClass.Replay();

        sampleClass.VirtualMethod("foo").ShouldEqual(3);
        sampleClass.VirtualMethodWasCalled.ShouldBeTrue();
        sampleClass.AssertWasCalled(c => c.VirtualMethod("foo"));
    }

Answer 3

Parece que encontré la solución. Parece un poco raro, pero funciona. Resulta que necesito llamar a ReplayAll () dos veces por alguna razón ...

Esto funciona:

[Test]
public void SetStateExecuting_Should_Set_State_To_Pause_And_Not_Change_GlobalState_When_GlobalState_Is_Paused()
{
    var task = new Task { ID = 1, TimeZone = -660, GlobalState = TaskState.Paused };
    _mockRepository.ReplayAll();
    _manager.SetStateExecuting(task);
    _taskDataProvider.AssertWasCalled(p => p.StateUpdate(task.ID, task.TimeZone, TaskState.Paused));
    _taskDataProvider.AssertWasNotCalled(p => p.GlobalStateUpdate(task.ID, TaskState.Executing));
    _mockRepository.ReplayAll();
}