Vérification d'un paramètre spécifique avec 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();
}

Je commence à utiliser Moq et j'ai un peu de mal. J'essaie de vérifier que messageServiceClient reçoit le bon paramètre, qui est un XmlElement, mais je ne trouve aucun moyen de le faire fonctionner. Cela ne fonctionne que lorsque je ne vérifie pas une valeur particulière.

Des idées?

Réponse partielle: j'ai trouvé un moyen de tester que le XML envoyé au proxy est correct, mais je ne pense toujours pas que ce soit la bonne façon de le faire.

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

À propos, comment pourrais-je extraire l'expression de l'appel de vérification?

Si la logique de vérification n'est pas triviale, il sera compliqué d'écrire une grande méthode lambda (comme le montre votre exemple). Vous pouvez placer toutes les instructions de test dans une méthode distincte, mais je n'aime pas faire cela car cela perturbe le flux de lecture du code de test.

Une autre option consiste à utiliser un rappel sur l'appel du programme d'installation pour stocker la valeur qui a été transmise à la méthode simulée, puis à écrire des Assertméthodes standard pour la valider. Par exemple:

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

J'ai vérifié les appels de la même manière - je pense que c'est la bonne façon de le faire.

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

Si votre expression lambda devient peu maniable, vous pouvez créer une fonction qui prend MyObjectcomme entrée et sorties 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";
}

Aussi, soyez conscient d'un bogue avec Mock où le message d'erreur indique que la méthode a été appelée plusieurs fois alors qu'elle ne l'était pas du tout. Ils l'ont peut-être déjà résolu - mais si vous voyez ce message, vous pouvez envisager de vérifier que la méthode a été effectivement appelée.

EDIT: Voici un exemple d'appels à verify plusieurs fois pour les scénarios où vous souhaitez vérifier que vous appelez une fonction pour chaque objet d'une liste (par exemple).

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

Même approche pour la configuration ...

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

Ainsi, chaque fois que GetStuff est appelé pour cet itemId, il renverra des éléments spécifiques à cet élément. Vous pouvez également utiliser une fonction qui prend itemId comme entrée et renvoie des éléments.

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

Une autre méthode que j'ai vue sur un blog il y a quelque temps (Phil Haack peut-être?) Avait une configuration retournant d'une sorte d'objet de file d'attente - chaque fois que la fonction était appelée, elle tirait un élément d'une file d'attente.

Une manière plus simple serait de faire:

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

Je pense que le problème réside dans le fait que Moq vérifiera l'égalité. Et, étant donné que XmlElement ne remplace pas Equals, son implémentation vérifiera l'égalité des références.

Ne pouvez-vous pas utiliser un objet personnalisé pour pouvoir remplacer les égaux?

Il y en avait aussi un, mais le paramètre de l'action était une interface sans propriétés publiques. J'ai fini par utiliser It.Is () avec une méthode distincte et dans cette méthode a dû se moquer de l'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
}