Vérification d'un paramètre spécifique avec Moq

Question

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 fonctionne uniquement 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 procéder.

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

Au fait, comment puis-je extraire l'expression de l'appel Verify ?

Answer 1

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 pourriez mettre toutes les déclarations de test dans une méthode séparée, mais je n'aime pas faire cela car cela perturbe le flux de lecture du code de test.

Une autre option est d'utiliser un callback sur l'appel Setup pour stocker la valeur qui a été passée dans la méthode fantaisie, puis d'écrire le standard Assert des méthodes pour le 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));

Answer 2

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

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 difficile à manier, vous pouvez créer une fonction qui prend MyObject comme entrées 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";
}

De plus, soyez conscient d'un bug avec Mock où le message d'erreur indique que la méthode a été appelée plusieurs fois alors qu'elle n'a pas été appelée du tout. Il est possible qu'il ait été corrigé depuis - mais si vous voyez ce message, vous pouvez envisager de vérifier que la méthode a bien été appelée.

EDIT : Voici un exemple d'appel multiple de verify pour les scénarios où vous voulez 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 renvoie des éléments spécifiques à cet item. Vous pouvez également utiliser une fonction qui prend l'itemId en 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 qui retournait une sorte d'objet dequeue - à chaque fois que la fonction était appelée, elle tirait un élément d'une file d'attente.

Answer 3

Une façon plus simple serait de faire :

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

Answer 4

J'en ai eu un aussi, 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 séparée et, dans cette méthode, j'ai dû faire une simulation 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
}

Answer 5

Je pense que le problème réside dans le fait que Moq vérifie l'égalité. Et, puisque XmlElement ne surcharge 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 égalités ?