Moq: como chegar a um parâmetro passado para um método de um serviço simulado

Imagine essa aula

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 em um teste de Foo, como eu seria capaz de verificar o que Bar()passou _h.AsyncHandle?

Você pode usar o 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);

Se você quiser apenas verificar algo simples no argumento passado, também poderá fazê-lo diretamente:

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

A resposta de Gamlor funcionou para mim, mas pensei em expandir o comentário de John Carpenter porque estava procurando uma solução que envolvesse mais de um parâmetro. Imaginei que outras pessoas que tropeçam nessa página podem estar em uma situação semelhante. Encontrei essas informações na documentação do Moq .

Usarei o exemplo de Gamlor, mas vamos fingir que o método AsyncHandle usa dois argumentos: a stringe um 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);

Basicamente, você só precisa adicionar outro It.IsAny<>()com o tipo apropriado, adicionar outro tipo ao Callbackmétodo e alterar a expressão lambda conforme apropriado.

O método de retorno de chamada certamente funcionará, mas se você estiver fazendo isso em um método com muitos parâmetros, pode ser um pouco detalhado. Aqui está algo que eu usei para remover parte do clichê.

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

Aqui está a fonte do 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; }
}

A resposta de Gamlor funciona, mas outra maneira de fazê-lo (e uma que considero mais expressiva no teste) é ...

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

A verificação é muito poderosa e vale a pena se acostumar.

A alternativa é também usar o Capture.Inrecurso do moq. É o moqrecurso OOTB que permite a captura de argumentos na coleção.

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

Você poderia usar o 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 )));

Isso também funciona:

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

Muitas boas respostas aqui! Vá com o conjunto de recursos Moq pronto para uso até precisar fazer afirmações sobre vários parâmetros de classe passados ​​para suas dependências. No entanto, se você acabar nessa situação, o recurso Moq Verify com It.Is não faz um bom trabalho em isolar a falha do teste, e a maneira de capturar retornos / retorno de chamada adiciona linhas de código desnecessárias ao seu teste (e testes longos não são para mim).

Aqui está uma síntese: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b com uma extensão do Moq (4.12) que eu escrevi, que fornece uma maneira mais declarativa de fazer afirmações sobre argumentos passados ​​para zombarias, sem os inconvenientes mencionados acima. Aqui está a aparência da seção Verificar agora:

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

Eu ficaria feliz se o Moq fornecesse um recurso que realizasse a mesma coisa, sendo tão declarativo e fornecendo o isolamento de falhas que isso faz. Dedos cruzados!