Comment autoriser une implémentation à appeler une méthode Mock (Moq) avec ses propres arguments?

Question

Lors du test d'une classe utilisant une dépendance Moq, j'aimerais que la classe fournisse les arguments à une méthode Moq plutôt que de créer les arguments moi-même dans le scénario de test.

J'ai une interface, qui a une méthode, qui prend un argument.

public interface IMessageForwardProxy 
{ 
    IMessage Send(IMessage request); 
} 

J'ai une classe qui appelle cette méthode avec un certain nombre d'arguments différents selon la méthode dite de la classe. Par exemple:

public class Messenger 
{ 
    private IMessageForwardProxy _link; 

    public Messenger(IMessageForwardProxy proxy) { _link = proxy; } 

    public bool DeliverSomeMessage() { 
     IMessage m1 = new MessageOne(); 
     var response = _link.Send(m1); 
     return response.Succeeded; 
    } 

    public bool DeliverSomeOtherMessage() { 
     IMessage m2 = new MessageTwo(); 
     var response = _link.Send(m2); 
     return response.Succeeded; 
    } 
} 

Maintenant, comme vous pouvez le voir, la classe Messenger est chargé de créer les arguments qui sont passés à la méthode d'envoi de l'interface. Lorsque je teste cette classe Messenger, je voudrais simuler la méthode Send de IMessageForwardProxy, sans fournir l'argument dans mes tests. Je vois fournir l'argument en couplant mes tests à l'implémentation (et en dupliquant le travail).

Si je veux tester la méthode DeliverSomeOtherMessage sur la classe Messenger, comment puis-je me moquer de IMessageForwardProxy?

[Test] 
public void TestDeliverSomeOtherMessage() { 
    var mockProxy = new Mock<IMessageForwardProxy>(); 

    // This is what I want to avoid, since the method I'm testing creates this argument 
    IMessage m2 = new MessageTwo(); 
    mockProxy.Setup(m => m.Send(m2)).Returns(new ReturnMessageTwo()); 

    // Can I do something like this instead? Define the signature, but not the param? 
    mockProxy.Setup(m => m.Send(typeof(IMessage))).Returns(new ReturnMessageTwo()); 

    var messenger = new Messenger(mockProxy.Object); 
    Assert.True(messenger.DeliverSomeOtherMessage()); 

} 

Answer 1

Vous pouvez utiliser It.IsAny<IMessage>()

Comme ceci:

mockProxy.Setup(m => m.Send(It.IsAny<IMessage>())).Returns(new ReturnMessageTwo()); 

Answer 2

Dans ce cas, vous pouvez utiliser le match attente It.Is<IMessage>:

mockProxy.Setup(m => m.Send(It.Is<IMessage>(m => m is MessageTwo))) 
    .Returns(new ReturnMessageTwo()); 

Ce match est vrai que lorsque le prédicat transmis à la méthode It.Is est vrai, donc cet ensemble et la valeur de retour correspondante ne sera utilisée que lorsque vous appelez la méthode DeliverSomeOtherMessage.