Wie benutze ich Rhino.Mocks AssertWasCalled () korrekt?

Nenne ich _mocks.ReplayAll(), dann ein oder mehrere _mockedObject.AssertWasCalled() und dann _mocks.VerifyAll(). Aber es sagt mir, dass "Diese Aktion ist ungültig, wenn das mock-Objekt ist im Aufnahme-Staat".

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

Was ist die richtige Reihenfolge zu nennen, so dass diese Methoden funktionieren, richtig?

InformationsquelleAutor der Frage HiveHicks | 2010-06-25

  1. 16

    Jon Kruger ' s blog-post "So verwenden Sie die rhino mocks, dokumentiert durch tests" hat einfache Beispiele von alles, was Sie tun können, mit rhino mocks Methoden. Er zeigt auch, was Sie nicht tun können, das fand ich sehr hilfreich beim lernen.

    Wie bereits erwähnt, mit dem Arrange, Act, Assert-Syntax mit dem statischen Konstruktoren ist einfacher zu Lesen. Der blog-Beitrag zeigt Beispiele für beide Methoden.

    Hier sind Beispiele von Jon ' s Beispielcode:

    Neue syntax:

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

    Alten Stil:

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

    InformationsquelleAutor der Antwort Maggie

  2. 12

    Mischen Sie die alte Record/Replay Muster und die neuen AAA-Muster.

    Dem normalen Weg "nicht genannt, mit diesen Argumenten" die Erwartung, während Sie im Aufnahme-Modus sieht wie folgt aus:

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

    Oder alternativ, Sie verwenden können, eine strenge mock, welches einfach nicht zulässt, dass unerwartete Anrufe.

    AssertWasCalled und AssertWasNotCalled sind bestimmt für AAA, wo Sie Ihre Aussagen am Ende. Mit dem Record/Replay-syntax, Verhalten und expecations sollte eingerichtet werden, an den start, bevor Sie den Schalter auf Wiedergabe-Modus.

    (AssertWasNotCalled könnte in der Tat Arbeit mit der Aufzeichnung/Wiedergabe auch, aber ich habe es auch nie probiert weil ich nicht gerne zum mischen von Elementen aus beiden Ansätzen. Es unnötigerweise verkompliziert die Dinge.)

    InformationsquelleAutor der Antwort Wim Coenen

  3. -1

    Scheint, wie ich die Lösung gefunden. Es scheint ein wenig seltsam, aber es funktioniert. Es stellt sich heraus, dass ich brauche zu nennen ReplayAll() zweimal für einige Grund...

    Dies funktioniert:

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

    InformationsquelleAutor der Antwort HiveHicks

Schreibe einen Kommentar