Verifica di un parametro specifico con 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();
}

Sto iniziando a usare Moq e lottando un po '. Sto cercando di verificare che messageServiceClient sta ricevendo il parametro giusto, che è un XmlElement, ma non riesco a trovare alcun modo per farlo funzionare. Funziona solo quando non controllo un determinato valore.

Qualche idea?

Risposta parziale: ho trovato un modo per testare che l'XML inviato al proxy è corretto, ma continuo a non pensare che sia il modo giusto di farlo.

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 proposito, come posso estrarre l'espressione dalla chiamata di verifica?

Se la logica di verifica non è banale, sarà complicato scrivere un metodo lambda di grandi dimensioni (come mostra l'esempio). Potresti mettere tutte le dichiarazioni di prova in un metodo separato, ma non mi piace farlo perché interrompe il flusso di lettura del codice di prova.

Un'altra opzione è utilizzare un callback nella chiamata di installazione per memorizzare il valore che è stato passato nel metodo deriso e quindi scrivere Assertmetodi standard per convalidarlo. Per esempio:

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

Ho verificato le chiamate nello stesso modo - credo che sia il modo giusto di farlo.

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

Se la tua espressione lambda diventa ingombrante, potresti creare una funzione che accetta MyObjectcome input e output 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";
}

Inoltre, tieni presente un bug con Mock in cui il messaggio di errore indica che il metodo è stato chiamato più volte quando non è stato chiamato affatto. Ormai potrebbero averlo corretto, ma se vedi quel messaggio potresti considerare di verificare che il metodo sia stato effettivamente chiamato.

EDIT: Ecco un esempio di chiamata verifica più volte per quegli scenari in cui si desidera verificare che si chiama una funzione per ciascun oggetto in un elenco (ad esempio).

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

Stesso approccio per l'installazione ...

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

Quindi ogni volta che GetStuff viene chiamato per quell'elemento ID, restituirà elementi specifici per quell'elemento. In alternativa, è possibile utilizzare una funzione che accetta itemId come input e restituisce elementi.

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

Un altro metodo che ho visto su un blog qualche tempo fa (Phil Haack forse?) Prevedeva che la configurazione tornasse da una sorta di oggetto dequeue - ogni volta che veniva chiamata la funzione si estraeva un oggetto da una coda.

Un modo più semplice sarebbe quello di fare:

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

Credo che il problema sia il fatto che Moq verificherà l'uguaglianza. E, dal momento che XmlElement non sostituisce Equals, la sua implementazione verificherà l'uguaglianza di riferimento.

Non puoi usare un oggetto personalizzato, quindi puoi sovrascrivere gli uguali?

Aveva anche uno di questi, ma il parametro dell'azione era un'interfaccia senza proprietà pubbliche. Ho finito per usare It.Is () con un metodo separato e all'interno di questo metodo ho dovuto fare qualche beffa dell'interfaccia

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
}