Come utilizzare Rhino.Mocks AssertWasCalled() correttamente?

Question

Io chiamo _mocks.ReplayAll(), quindi uno o più _mockedObject.AssertWasCalled() e quindi _mocks.VerifyAll(). Ma mi dice che "Questa azione non è valida quando l'oggetto fittizio è in stato di registrazione".

[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(); 
} 

---

Qual è l'ordine corretto chiamare in modo che questi metodi funzionano correttamente?

Answer 1

Sembra che abbia trovato la soluzione. Sembra un po 'strano, ma funziona. Si scopre che ho bisogno di chiamare Replayall() due volte per qualche motivo ...

Questo funziona:

[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

si stia mescolando il vecchio schema di registrazione/riproduzione e la nuova AAA pattern.

Il modo normale per impostare un'aspettativa "Non chiamato con questi argomenti", mentre nella modalità di registrazione si presenta così:

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

Oppure, in alternativa, è possibile utilizzare un modello rigoroso, che semplicemente non permette inaspettata chiamate.

AssertWasCalled e AssertWasNotCalled sono destinati ad AAA dove si mettono le vostre affermazioni alla fine. Con la sintassi Record/Replay, sia il comportamento che le aspettative dovrebbero essere impostati all'inizio prima di passare alla modalità di riproduzione.

(AssertWasNotCalled potrebbe effettivamente lavorare con registrazione/riproduzione anche, ma non ho mai provato perché non mi piace mescolare elementi di entrambi gli approcci. Si complica inutilmente le cose.)

Answer 3

post sul blog di Jon Kruger "How to use rhino mocks documented through tests" ha semplice esempi di tutto ciò che puoi fare con i metodi del rinoceronte. Mostra anche ciò che non puoi fare e che ho trovato molto utile nell'apprendimento.

Come accennato in precedenza, è più facile leggere la sintassi Disponi, Agisci, Assert con i costruttori statici. Il post sul blog mostra esempi di entrambi i metodi.

Ecco alcuni esempi di codice di esempio di Jon:

Nuova sintassi:

[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)); 
    } 

Anziana:

[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")); 
    }