Comment utiliser correctement Rhino.Mocks AssertWasCalled()?

Question

J'appelle _mocks.ReplayAll(), puis un ou plusieurs _mockedObject.AssertWasCalled() puis _mocks.VerifyAll(). Mais il me dit que "cette action est invalide lorsque l'objet simulé est en état d'enregistrement".

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

---

Quel est l'ordre correct d'appeler pour que ces méthodes fonctionnent correctement?

Answer 1

On dirait que j'ai trouvé la solution. C'est un peu bizarre, mais ça fonctionne. Il se trouve que je dois appeler ReplayAll() deux fois pour une raison quelconque ...

Cela fonctionne:

[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

Vous confondez l'ancien enregistrement/motif de relecture et la nouvelle AAA pattern.

La façon normale de mettre en place une attente « pas appelé à ces arguments » en mode enregistrement ressemble à ceci:

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

Ou bien, vous pouvez utiliser une maquette stricte qui ne permet tout simplement pas inattendu appels.

AssertWasCalled et AssertWasNotCalled sont destinés à AAA où vous mettez vos assertions à la fin. Avec la syntaxe Record/Replay, le comportement et les attentes doivent être configurés au début avant le passage en mode de relecture.

(AssertWasNotCalled peut effectivement travailler avec enregistrement/relecture aussi, mais je jamais essayé parce que je n'aime pas mélanger des éléments des deux approches. Cela complique inutilement les choses.)

Answer 3

post blog de Jon Kruger "How to use rhino mocks documented through tests" a simplement des exemples de tout ce que vous pouvez faire avec des méthodes de rhinocéros. Il montre aussi ce que vous ne pouvez pas faire et que j'ai trouvé très utile pour apprendre.

Comme mentionné précédemment, l'utilisation de la syntaxe Assigner, Agir, Affirmer avec les constructeurs statiques est plus facile à lire. Le billet de blog montre des exemples des deux méthodes.

Voici des exemples de code exemple de Jon:

Nouvelle syntaxe:

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

Ancien:

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