Moq: come arrivare a un parametro passato a un metodo di un servizio deriso

Immagina questa classe

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 un test di Foo, come potrei controllare a cosa Bar()è passato _h.AsyncHandle?

È possibile utilizzare il metodo Mock.Callback:

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

Se vuoi solo controllare qualcosa di semplice sull'argomento passato, puoi anche farlo direttamente:

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

La risposta di Gamlor ha funzionato per me, ma ho pensato di ampliare il commento di John Carpenter perché cercavo una soluzione che coinvolgesse più di un parametro. Ho pensato che altre persone che si imbattono in questa pagina potrebbero trovarsi in una situazione simile. Ho trovato queste informazioni nella documentazione di Moq .

Userò l'esempio di Gamlor, ma facciamo finta che il metodo AsyncHandle abbia due argomenti: a stringe un SomeResponseoggetto.

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

Fondamentalmente devi solo aggiungerne un altro It.IsAny<>()con il tipo appropriato, aggiungere un altro tipo al Callbackmetodo e modificare l'espressione lambda come appropriato.

Il metodo Callback funzionerà sicuramente, ma se lo stai facendo su un metodo con molti parametri può essere un po 'prolisso. Ecco qualcosa che ho usato per rimuovere parte della piastra della caldaia.

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

Ecco la fonte per 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; }
}

La risposta di Gamlor funziona, ma un altro modo di farlo (e uno che considero più espressivo nel test) è ...

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

Verifica è molto potente e vale la pena dedicare del tempo per abituarsi.

L'alternativa è anche quella di utilizzare la Capture.Infunzione di moq. È la moqfunzione OOTB che abilita la cattura degli argomenti nella raccolta.

//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()

Puoi usare il It.Is<TValue>()matcher.

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

Questo funziona anche:

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

Molte buone risposte qui! Vai con le funzionalità predefinite di Moq fino a quando non devi fare affermazioni su diversi parametri di classe passati alle tue dipendenze. Se ti trovi in ​​quella situazione, però, la funzione Moq Verify con It.Is Matchers non fa un buon lavoro per isolare l'errore del test, e il modo Returns / Callback di catturare argomenti aggiunge righe di codice non necessarie al tuo test (e i test lunghi sono un must per me).

Ecco un riassunto: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b con un'estensione Moq (4.12) che ho scritto che fornisce un modo più dichiarativo per fare affermazioni su argomenti passati a beffe, senza gli svantaggi summenzionati. Ecco come appare la sezione Verifica ora:

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

Sarei entusiasta se Moq fornisse una funzione che ha realizzato la stessa cosa pur essendo dichiarativa e fornendo l'isolamento di fallimento. Dita incrociate!