Verificando um parâmetro específico com Moq

public void SubmitMessagesToQueue_OneMessage_SubmitSuccessfully()
{
    var messageServiceClientMock = new Mock<IMessageServiceClient>();
    var queueableMessage = CreateSingleQueueableMessage();
    var message = queueableMessage[0];
    var xml = QueueableMessageAsXml(queueableMessage);
    messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(xml)).Verifiable();
    //messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(It.IsAny<XmlElement>())).Verifiable();

    var serviceProxyFactoryStub = new Mock<IMessageServiceClientFactory>();
    serviceProxyFactoryStub.Setup(proxyFactory => proxyFactory.CreateProxy()).Returns(essageServiceClientMock.Object);
    var loggerStub = new Mock<ILogger>();

    var client = new MessageClient(serviceProxyFactoryStub.Object, loggerStub.Object);
    client.SubmitMessagesToQueue(new List<IMessageRequestDTO> {message});

    //messageServiceClientMock.Verify(proxy => proxy.SubmitMessage(xml), Times.Once());
    messageServiceClientMock.Verify();
}

Estou começando a usar o Moq e lutando um pouco. Estou tentando verificar se messageServiceClient está recebendo o parâmetro correto, que é um XmlElement, mas não consigo encontrar nenhuma maneira de fazê-lo funcionar. Funciona apenas quando não verifico um valor específico.

Alguma ideia?

Resposta parcial: Encontrei uma maneira de testar se o xml enviado ao proxy está correto, mas ainda não acho que seja a maneira correta de fazê-lo.

public void SubmitMessagesToQueue_OneMessage_SubmitSuccessfully()
{
    var messageServiceClientMock = new Mock<IMessageServiceClient>();
    messageServiceClientMock.Setup(proxy => proxy.SubmitMessage(It.IsAny<XmlElement>())).Verifiable();
    var serviceProxyFactoryStub = new Mock<IMessageServiceClientFactory>();
    serviceProxyFactoryStub.Setup(proxyFactory => proxyFactory.CreateProxy()).Returns(messageServiceClientMock.Object);
    var loggerStub = new Mock<ILogger>();

    var client = new MessageClient(serviceProxyFactoryStub.Object, loggerStub.Object);
    var message = CreateMessage();
    client.SubmitMessagesToQueue(new List<IMessageRequestDTO> {message});

    messageServiceClientMock.Verify(proxy => proxy.SubmitMessage(It.Is<XmlElement>(xmlElement => XMLDeserializer<QueueableMessage>.Deserialize(xmlElement).Messages.Contains(message))), Times.Once());
}

A propósito, como eu poderia extrair a expressão da chamada Verificar?

Se a lógica de verificação não for trivial, será complicado escrever um método lambda grande (como mostra o exemplo). Você pode colocar todas as instruções de teste em um método separado, mas eu não gosto de fazer isso porque isso interrompe o fluxo de leitura do código de teste.

Outra opção é usar um retorno de chamada na instalação para armazenar o valor que foi passado para o método simulado e, em seguida, escrever Assertmétodos padrão para validá-lo. Por exemplo:

// Arrange
MyObject saveObject;
mock.Setup(c => c.Method(It.IsAny<int>(), It.IsAny<MyObject>()))
        .Callback<int, MyObject>((i, obj) => saveObject = obj)
        .Returns("xyzzy");

// Act
// ...

// Assert
// Verify Method was called once only
mock.Verify(c => c.Method(It.IsAny<int>(), It.IsAny<MyObject>()), Times.Once());
// Assert about saveObject
Assert.That(saveObject.TheProperty, Is.EqualTo(2));

Venho verificando as chamadas da mesma maneira - acredito que é a maneira correta de fazer isso.

mockSomething.Verify(ms => ms.Method(
    It.IsAny<int>(), 
    It.Is<MyObject>(mo => mo.Id == 5 && mo.description == "test")
  ), Times.Once());

Se sua expressão lambda se tornar pesada, você poderá criar uma função que assume MyObjectcomo entrada e saída true/ false...

mockSomething.Verify(ms => ms.Method(
    It.IsAny<int>(), 
    It.Is<MyObject>(mo => MyObjectFunc(mo))
  ), Times.Once());

private bool MyObjectFunc(MyObject myObject)
{
  return myObject.Id == 5 && myObject.description == "test";
}

Além disso, esteja ciente de um bug no Mock, no qual a mensagem de erro informa que o método foi chamado várias vezes quando não foi chamado. Eles podem ter corrigido isso agora - mas se você vir essa mensagem, poderá verificar se o método foi realmente chamado.

EDIT: Aqui está um exemplo de chamada verificar várias vezes para os cenários em que você deseja verificar se você chama uma função para cada objeto em uma lista (por exemplo).

foreach (var item in myList)
  mockRepository.Verify(mr => mr.Update(
    It.Is<MyObject>(i => i.Id == item.Id && i.LastUpdated == item.LastUpdated),
    Times.Once());

A mesma abordagem para a instalação ...

foreach (var item in myList) {
  var stuff = ... // some result specific to the item
  this.mockRepository
    .Setup(mr => mr.GetStuff(item.itemId))
    .Returns(stuff);
}

Portanto, toda vez que o GetStuff for chamado para esse itemId, ele retornará itens específicos para esse item. Como alternativa, você pode usar uma função que tome itemId como entrada e retorne itens.

this.mockRepository
    .Setup(mr => mr.GetStuff(It.IsAny<int>()))
    .Returns((int id) => SomeFunctionThatReturnsStuff(id));

Um outro método que eu vi em um blog algum tempo atrás (Phil Haack talvez?) Tinha a configuração retornando de algum tipo de objeto de desenfileiramento - cada vez que a função era chamada, ele puxava um item de uma fila.

Uma maneira mais simples seria fazer:

ObjectA.Verify(
    a => a.Execute(
        It.Is<Params>(p => p.Id == 7)
    )
);

Eu acredito que o problema no fato de que Moq irá verificar a igualdade. E, como XmlElement não substitui Equals, sua implementação verificará a igualdade de referência.

Você não pode usar um objeto personalizado para substituir os iguais?

Tinha um desses também, mas o parâmetro da ação era uma interface sem propriedades públicas. Acabou usando It.Is () com um método separado e, dentro desse método, foi necessário zombar da interface

public interface IQuery
{
    IQuery SetSomeFields(string info);
}

void DoSomeQuerying(Action<IQuery> queryThing);

mockedObject.Setup(m => m.DoSomeQuerying(It.Is<Action<IQuery>>(q => MyCheckingMethod(q)));

private bool MyCheckingMethod(Action<IQuery> queryAction)
{
    var mockQuery = new Mock<IQuery>();
    mockQuery.Setup(m => m.SetSomeFields(It.Is<string>(s => s.MeetsSomeCondition())
    queryAction.Invoke(mockQuery.Object);
    mockQuery.Verify(m => m.SetSomeFields(It.Is<string>(s => s.MeetsSomeCondition(), Times.Once)
    return true
}