moq
Anrufreihenfolge bestätigen

Anrufreihenfolge implizit überprüfen

Wenn eine zu testende Methode Informationen aus einem Aufruf verwendet, um sie an nachfolgende Aufrufe weiterzuleiten, können Sie sicherstellen, dass die Methoden in der erwarteten Reihenfolge aufgerufen werden.

In Anbetracht der zu testenden Methode:

public void MethodToTest()
{
    var str = _utility.GetInitialValue();

    str = _utility.PrefixString(str);
    str = _utility.ReverseString(str);

    _target.DoStuff(str);
}

Erwartungen können so eingestellt werden, dass Daten von GetInitialValue über PrefixString und ReverseString an DoStuff , wo die Informationen überprüft werden. Wenn eine der Methoden außerhalb der Reihenfolge aufgerufen wird, sind die Enddaten falsch und der Test schlägt fehl.

// Create mocks
var utilityMock = new Mock<IUtility>();
var targetMock = new Mock<ITarget>();

// Setup expectations, note that the returns value from one call matches the expected
// parameter for the next call in the sequence of calls we're interested in.
utilityMock.Setup(x => x.GetInitialValue()).Returns("string");
utilityMock.Setup(x => x.PrefixString("string")).Returns("Prefix:string");
utilityMock.Setup(x => x.ReverseString("Prefix:string")).Returns("gnirts:xiferP");

string expectedFinalInput = "gnirts:xiferP";

// Invoke the method to test
var sut = new SystemUnderTest(utilityMock.Object, targetMock.Object);
sut.MethodToTest();

// Validate that the final call was passed the expected value.
targetMock.Verify(x => x.DoStuff(expectedFinalInput));

Anrufreihenfolge mit Rückrufen prüfen

Wenn Sie Strict Mocks nicht verwenden können / möchten, können Sie die MockSequence nicht mit MockSequence . Ein alternativer Ansatz besteht darin, Rückrufe zu verwenden, um zu überprüfen, ob die Setup Erwartungen in der erwarteten Reihenfolge aufgerufen werden. Gegeben die folgende Testmethode:

public void MethodToTest()
{
    _utility.Operation1("1111");
    _utility.Operation3("3333");
    _utility.Operation2("2222");
}

Es kann wie folgt getestet werden:

// Create the mock (doesn't have to be in strict mode)
var utilityMock = new Mock<IUtility>();

// Create a variable to track the current call number
int callOrder = 1;

// Setup each call in the sequence to be tested.  Note that the callback validates that
// that callOrder has the expected value, then increments it in preparation for the next
// call.
utilityMock.Setup(x => x.Operation1(It.IsAny<string>()))
           .Callback(() => Assert.AreEqual(1, callOrder++, "Method called out of order") );
utilityMock.Setup(x => x.Operation2(It.IsAny<string>()))
           .Callback(() => Assert.AreEqual(2, callOrder++, "Method called out of order") );
utilityMock.Setup(x => x.Operation3(It.IsAny<string>()))
           .Callback(() => Assert.AreEqual(3, callOrder++, "Method called out of order") );


// Invoke the method to be tested
var sut = new SystemUnderTest(utilityMock.Object);
sut.MethodToTest();


// Validate any parameters that are important, note these Verifications can occur in any
// order.
utilityMock.Verify(x => x.Operation2("2222"));
utilityMock.Verify(x => x.Operation1("1111"));
utilityMock.Verify(x => x.Operation3("3333"));

Anrufreihenfolge mit MockSequence überprüfen

Moq bietet Unterstützung für die Überprüfung der MockSequence mit MockSequence , MockSequence jedoch nur, wenn Strict-Mocks verwendet werden. Also, die folgende Methode zu testen:

public void MethodToTest()
{
    _utility.Operation1("1111");
    _utility.Operation2("2222");
    _utility.Operation3("3333");
}

Es kann wie folgt getestet werden:

// Create the mock, not MockBehavior.Strict tells the mock how to behave
var utilityMock = new Mock<IUtility>(MockBehavior.Strict);

// Create the MockSequence to validate the call order
var sequence = new MockSequence();

// Create the expectations, notice that the Setup is called via InSequence
utilityMock.InSequence(sequence).Setup(x => x.Operation1(It.IsAny<string>()));
utilityMock.InSequence(sequence).Setup(x => x.Operation2(It.IsAny<string>()));
utilityMock.InSequence(sequence).Setup(x => x.Operation3(It.IsAny<string>()));

// Run the method to be tested
var sut = new SystemUnderTest(utilityMock.Object);
sut.MethodToTest();

// Verify any parameters that are cared about to the operation being orchestrated.
// Note that the Verify calls can be in any order
utilityMock.Verify(x => x.Operation2("2222"));
utilityMock.Verify(x => x.Operation1("1111"));
utilityMock.Verify(x => x.Operation3("3333"));

Das obige Beispiel verwendet It.IsAny<string> beim Einrichten der Erwartungen. Diese hätten relevante Zeichenketten ("1111", "2222", "3333") verwenden können, wenn genauere Übereinstimmungen erforderlich wären.

Der Fehler, der gemeldet wird, wenn Anrufe außerhalb der Reihenfolge ausgeführt werden, kann etwas irreführend sein.

Aufruf fehlgeschlagen mit falschem Verhalten Strict. Alle Aufrufe des Mock müssen über ein entsprechendes Setup verfügen.

Dies liegt daran, dass jede Setup Erwartung so behandelt wird, als wäre sie nicht vorhanden, bis die vorherige Erwartung in der Sequenz erfüllt wurde.