Moq: So gelangen Sie zu einem Parameter, der an eine Methode eines verspotteten Dienstes übergeben wird

Stellen Sie sich diese Klasse vor

public class Foo {

    private Handler _h;

    public Foo(Handler h)
    {
        _h = h;
    }

    public void Bar(int i)
    {
        _h.AsyncHandle(CalcOn(i));
    }

    private SomeResponse CalcOn(int i)
    {
        ...;
    }
}

Mo (q) cking Handler in einem Test von Foo, wie könnte ich überprüfen, was Bar()passiert ist _h.AsyncHandle?

Sie können die Mock.Callback-Methode verwenden:

var mock = new Mock<Handler>();
SomeResponse result = null;
mock.Setup(h => h.AnsyncHandle(It.IsAny<SomeResponse>()))
    .Callback<SomeResponse>(r => result = r);

// do your test
new Foo(mock.Object).Bar(22);
Assert.NotNull(result);

Wenn Sie nur etwas Einfaches an dem übergebenen Argument überprüfen möchten, können Sie dies auch direkt tun:

mock.Setup(h => h.AnsyncHandle(It.Is<SomeResponse>(response => response != null)));

Gamlors Antwort funktionierte für mich, aber ich dachte, ich würde John Carpenters Kommentar erweitern, weil ich nach einer Lösung suchte, die mehr als einen Parameter umfasste. Ich nahm an, dass andere Leute, die auf diese Seite stolpern, sich in einer ähnlichen Situation befinden könnten. Ich habe diese Informationen in der Moq-Dokumentation gefunden .

Ich werde Gamlors Beispiel verwenden, aber tun wir so, als ob die AsyncHandle-Methode zwei Argumente akzeptiert: a stringund ein SomeResponseObjekt.

var mock = new Mock<Handler>();
string stringResult = string.Empty;
SomeResponse someResponse = null;
mock.Setup(h => h.AsyncHandle(It.IsAny<string>(), It.IsAny<SomeResponse>()))
    .Callback<string, SomeResponse>((s, r) => 
    {
        stringResult = s;
        someResponse = r;
    });

// do your test
new Foo(mock.Object).Bar(22);
Assert.AreEqual("expected string", stringResult);
Assert.IsNotNull(someResponse);

Grundsätzlich müssen Sie nur It.IsAny<>()einen weiteren Typ mit dem entsprechenden Typ hinzufügen, der CallbackMethode einen weiteren Typ hinzufügen und den Lambda-Ausdruck entsprechend ändern.

Die Callback-Methode wird sicherlich funktionieren, aber wenn Sie dies mit einer Methode mit vielen Parametern tun, kann sie etwas ausführlich sein. Hier ist etwas, mit dem ich einen Teil der Kesselplatte entfernt habe.

var mock = new Mock<Handler>();

// do your test   
new Foo(mock.Object).Bar(22);

var arg = new ArgumentCaptor<SomeResponse>();
mock.Verify(h => h.AsyncHandle(arg.Capture()));
Assert.NotNull(arg.Value);

Hier ist die Quelle für ArgumentCaptor:

public class ArgumentCaptor<T>
{
    public T Capture()
    {
        return It.Is<T>(t => SaveValue(t));
    }

    private bool SaveValue(T t)
    {
        Value = t;
        return true;
    }

    public T Value { get; private set; }
}

Gamlors Antwort funktioniert, aber eine andere Möglichkeit (und eine, die ich im Test als aussagekräftiger betrachte) ist ...

var mock = new Mock<Handler>();
var desiredParam = 47; // this is what you want to be passed to AsyncHandle
new Foo(mock.Object).Bar(22);
mock.Verify(h => h.AsyncHandle(desiredParam), Times.Once());

Verify ist sehr leistungsfähig und es lohnt sich, sich daran zu gewöhnen.

Die Alternative ist auch die Verwendung der Capture.InFunktion des moq. Es ist die OOTB- moqFunktion, die die Erfassung von Argumenten in der Sammlung ermöglicht.

//Arrange
var args = new List<SomeResponse>();
mock.Setup(h => h.AnsyncHandle(Capture.In(args)));

//Act
new Foo(mock.Object).Bar(22);

//Assert
//... assert args.Single() or args.First()

Sie könnten It.Is<TValue>()Matcher verwenden.

var mock = new Mock<Handler>();
new Foo(mock.Object).Bar(22);
mock.Verify(h => h.AsyncHandle(It.Is<SomeResponse>(r => r != null )));

Das funktioniert auch:

Mock<InterfaceThing> mockedObject = new Mock<InterfaceThing>();
var objectParameter = mockedObject.Invocations[1].Arguments[0] as ObjectParameter;

Viele gute Antworten hier! Verwenden Sie den sofort einsatzbereiten Moq-Funktionsumfang, bis Sie Aussagen zu mehreren Klassenparametern treffen müssen, die an Ihre Abhängigkeiten übergeben werden. Wenn Sie jedoch in dieser Situation enden, kann die Moq Verify-Funktion mit It.Is-Matchern den Testfehler nicht gut isolieren, und die Methode Returns / Callback zum Erfassen von Argumenten fügt Ihrem Test unnötige Codezeilen hinzu (und lange Tests sind für mich ein No-Go).

Hier ist ein Kern: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b mit einer Moq (4.12) -Erweiterung, die ich geschrieben habe und die eine aussagekräftigere Möglichkeit bietet, Aussagen über Argumente zu machen, die an Mocks weitergegeben wurden, ohne die oben genannten Nachteile. So sieht der Abschnitt "Überprüfen" jetzt aus:

        mockDependency
            .CheckMethodWasCalledOnce(nameof(IExampleDependency.PersistThings))
            .WithArg<InThing2>(inThing2 =>
            {
                Assert.Equal("Input Data with Important additional data", inThing2.Prop1);
                Assert.Equal("I need a trim", inThing2.Prop2);
            })
            .AndArg<InThing3>(inThing3 =>
            {
                Assert.Equal("Important Default Value", inThing3.Prop1);
                Assert.Equal("I NEED TO BE UPPER CASED", inThing3.Prop2);
            });

Ich wäre begeistert, wenn Moq eine Funktion bereitstellen würde, die dasselbe erreicht, gleichzeitig deklarativ ist und die Fehlerisolation bietet, die dies bewirkt. Daumen drücken!