Cómo usar Rhino.Mocks AssertWasCalled() correctamente?

Question

llamo _mocks.ReplayAll(), luego uno o más _mockedObject.AssertWasCalled() y luego _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 llamar para que estos métodos funcionan correctamente?

Answer 1

Parece que encontré la solución. Parece un poco raro, pero funciona. Resulta que tengo que llamar 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(); 
} 

Answer 2

está mezclando el viejo patrón de grabación/reproducción y la nueva AAA pattern.

La forma más habitual establecer una expectativa "no se llama a estos argumentos", mientras que el modo de grabación se ve así:

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

O, alternativamente, se puede usar una maqueta estricta, que simplemente no permite inesperada llamadas.

AssertWasCalled y AssertWasNotCalled están destinados para AAA donde pone sus afirmaciones al final. Con la sintaxis Record/Replay, tanto el comportamiento como las expectativas deben configurarse al inicio antes de pasar al modo de reproducción.

(AssertWasNotCalled en realidad podría trabajar con grabación/reproducción también, pero nunca he probado porque no me gusta mezclar elementos de ambos enfoques. Se innecesariamente complica las cosas.)

Answer 3

el blog de Jon Kruger "How to use rhino mocks documented through tests" tiene sencillo ejemplos de todo lo que puedes hacer con los métodos de rinocerontes. Él también muestra lo que no puedes hacer, lo cual me pareció muy útil para aprender.

Como se mencionó anteriormente, el uso de Arrange, Act, Assert Syntax con los constructores estáticos es más fácil de leer. La entrada del blog muestra ejemplos de ambos métodos.

Éstos son ejemplos de 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")); 
    }