Verwenden von moq, um nur einige Methoden zu verspotten

Ich habe die folgende Methode:

public CustomObect MyMethod()
{
    var lUser = GetCurrentUser();
    if (lUser.HaveAccess)
    {
        //One behavior
    }
    else 
    {
        //Other behavior
    }

    //return CustomObject
}

Ich möchte verspotten IMyInterface.GetCurrentUser, damit MyMethodich beim Aufrufen zu einem der Codepfade gelangen kann, um ihn zu überprüfen. Wie macht man das mit Moq?

Ich mache folgendes:

var moq = new Mock<IMyInterface>();            
moq.Setup(x => x.GetCurrentUser()).Returns(lUnauthorizedUser);

//act
var lResult = moq.Object.MyMethod();

Aber aus irgendeinem Grund lResultist es immer so nullund wenn ich versuche, mich MyMethodauf das Debuggen einzulassen, springe ich immer zur nächsten Anweisung.

Dies wird als Teil-Mock bezeichnet, und wie ich es in moq kenne, muss die Klasse und nicht die Schnittstelle verspottet und dann die Eigenschaft "Callbase" für Ihr verspottetes Objekt auf "true" gesetzt werden.

Dazu müssen alle Methoden und Eigenschaften der Klasse, die Sie testen, virtuell gemacht werden. Angenommen, dies ist kein Problem, können Sie einen Test wie folgt schreiben:

 var mock = new Mock<YourTestClass>();
 mock.CallBase = true;
 mock.Setup(x => x.GetCurrentUser()).Returns(lUnauthorizedUser);
 mockedTest.Object.MyMethod();

Die Antwort von Lee erweitern ,

Sie müssen nicht alle Methoden und Eigenschaften Ihrer Klasse virtuell machen, sondern nur die, die Sie verspotten möchten.

Es sollte auch beachtet werden, dass Sie sich über die konkrete Implementierung Ihrer Klasse lustig machen sollten.

var mock = new Mock<YourTestClass>(); // vs. var mock = new Mock<IYourTestInterface>();

Wenn Ihre Klasse keinen Standardkonstruktor hat, müssen Sie auch Argumente angeben, die an sie übergeben werden sollen über:

var mock = new Mock<YourTestClass>(x, y, z);
// or
var mock = new Mock<YourTestClass>(MockBehavior.Default, x, y, z);

Wo x, y, zsind die ersten, zweiten und dritten Parameter für Ihren Konstruktor?

Und schließlich müssen Sie einschließen, wenn die Methode, die Sie verspotten möchten, geschützt ist Moq.Protected

using Moq.Protected;

TReturnType returnValue = default(TReturnType);

mock.Protected()
    .Setup<TReturnType>("YourMockMethodName", It.IsAny<int>()) // methodname followed by arguments
    .Returns(returnValue);

Ich hatte einen ähnlichen Fall. Ich fand, dass der folgende Code mir mehr Flexibilität gab, sowohl verspottete als auch tatsächliche Methoden aus einer bestimmten Implementierung einer Schnittstelle zu verwenden:

var mock = new Mock<ITestClass>(); // Create Mock of interface

// Create instance of ITestClass implementation you want to use
var inst = new ActualTestClass();

// Setup to call method of an actual instance
// if method returns void use mock.Setup(...).Callback(...)
mock.Setup(m => m.SomeMethod(It.IsAny<int>())
    .Returns((int x) => inst.SomeMethod(x));

Jetzt können Sie die eigentliche Methode verwenden, aber auch Dinge wie Verifysehen, wie oft sie aufgerufen wurde.