Moq: cómo llegar a un parámetro pasado a un método de un servicio simulado

Imagina esta clase

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 en una prueba de Foo, ¿cómo podría verificar qué Bar()ha pasado _h.AsyncHandle?

Puede usar el método 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);

Si solo desea verificar algo simple en el argumento pasado, también puede hacerlo directamente:

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

La respuesta de Gamlor funcionó para mí, pero pensé que podría ampliar el comentario de John Carpenter porque estaba buscando una solución que involucrara más de un parámetro. Me imaginé que otras personas que se topan con esta página pueden estar en una situación similar. Encontré esta información en la documentación de Moq .

Usaré el ejemplo de Gamlor, pero supongamos que el método AsyncHandle toma dos argumentos: ay stringun SomeResponseobjeto.

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

Básicamente, solo necesita agregar otro It.IsAny<>()con el tipo apropiado, agregar otro tipo al Callbackmétodo y cambiar la expresión lambda según corresponda.

El método de devolución de llamada ciertamente funcionará, pero si está haciendo esto en un método con muchos parámetros, puede ser un poco detallado. Aquí hay algo que he usado para eliminar parte de la placa repetitiva.

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

Aquí está la fuente de 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 respuesta de Gamlor funciona, pero otra forma de hacerlo (y una que considero más expresiva en la prueba) es ...

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 es muy poderoso y vale la pena tomarse el tiempo para acostumbrarse.

La alternativa también es utilizar la Capture.Infunción de moq. Es la moqcaracterística OOTB que permite capturar argumentos en la colección.

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

Podrías usar 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 )));

Esto también funciona:

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

Muchas buenas respuestas aquí! Vaya con el conjunto de características Moq listo para usar hasta que necesite hacer afirmaciones sobre varios parámetros de clase pasados ​​a sus dependencias. Sin embargo, si termina en esa situación, la función de verificación de Moq con It. Sus coincidencias no hace un buen trabajo al aislar la falla de la prueba, y la forma de devolución / devolución de llamada de capturar argumentos agrega líneas de código innecesarias a su prueba (y las pruebas largas son un no-go para mí).

Aquí hay una idea general: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b con una extensión Moq (4.12) que escribí que ofrece una forma más declarativa de hacer afirmaciones sobre los argumentos pasados ​​a los simulacros, sin los inconvenientes mencionados anteriormente. Así es como se ve la sección Verificar ahora:

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

Me entusiasmaría si Moq proporcionara una función que lograra lo mismo mientras fuera declarativa y proporcionara el aislamiento de falla que esto hace. ¡Dedos cruzados!