Comment puis-je Moq une méthode qui a un argument facultatif dans sa signature sans le spécifier explicitement ou en utilisant une surcharge?

Compte tenu de l'interface suivante:

public interface IFoo
{
    bool Foo(string a, bool b = false);
}

Tentative de se moquer en utilisant Moq:

var mock = new Mock<IFoo>();
mock.Setup(mock => mock.Foo(It.IsAny<string>())).Returns(false);

donne l'erreur suivante au moment de la compilation:

Une arborescence d'expression ne peut pas contenir un appel ou une invocation qui utilise des arguments facultatifs

J'ai trouvé le problème ci-dessus soulevé comme une amélioration dans la liste des problèmes de Moq et il semble être attribué à la version 4.5 (quand c'est le cas).

Ma question est la suivante: que dois-je faire étant donné que ce qui précède ne sera pas corrigé de sitôt? Mes options sont-elles uniquement pour définir explicitement la valeur par défaut du paramètre facultatif à chaque fois que je me moque de lui (ce qui va à l'encontre du point d'en spécifier un en premier lieu) ou pour créer une surcharge sans le booléen (comme ce que j'aurais fait avant C # 4)?

Ou est-ce que quelqu'un a trouvé un moyen plus intelligent de résoudre ce problème?

Je pense que votre seul choix pour le moment est d'inclure explicitement le boolparamètre dans la configuration pourFoo .

Je ne pense pas que cela va à l'encontre de l'objectif de spécifier une valeur par défaut. La valeur par défaut est pratique pour appeler du code, mais je pense que vous devriez être explicite dans vos tests. Supposons que vous puissiez omettre de spécifier le boolparamètre. Que se passe-t-il si, à l'avenir, quelqu'un change la valeur par défaut de ben true? Cela conduira à des tests échoués (et à juste titre), mais ils seront plus difficiles à corriger en raison de l'hypothèse cachée qui best false. La spécification explicite du boolparamètre présente un autre avantage: elle améliore la lisibilité de vos tests. Quelqu'un qui les traversera saura rapidement qu'il y en a unFoo fonction qui accepte deux paramètres. C'est mes 2 cents, au moins :)

Quant à le spécifier à chaque fois que vous le moquez, ne dupliquez pas le code: créez et / ou initialisez le simulacre dans une fonction, de sorte que vous n'ayez qu'un seul point de changement. Si vous le souhaitez vraiment, vous pouvez ici surmonter le manque apparent de Moq en dupliquant Fooles paramètres de cette fonction d'initialisation:

public void InitFooFuncOnFooMock(Mock<IFoo> fooMock, string a, bool b = false)
{
    if(!b)
    {
        fooMock.Setup(mock => mock.Foo(a, b)).Returns(false);
    }
    else
    {
        ...
    }
}

Je viens de rencontrer ce problème aujourd'hui, Moq ne prend pas en charge ce cas d'utilisation. Donc, il semble que la substitution de la méthode serait suffisante dans ce cas.

public interface IFoo
{
    bool Foo(string a);

    bool Foo(string a, bool b);
}

Maintenant, les deux méthodes sont disponibles et cet exemple fonctionnerait:

var mock = new Mock<IFoo>();
mock.Setup(mock => mock.Foo(It.IsAny<string>())).Returns(false);

En utilisant la version 4.10.1 de Moq, j'ai pu faire ce qui suit

Avec interface:

public interface IFoo
{
    bool Foo(string a, bool b = false);
}

Et Mock

var mock = new Mock<IFoo>();
mock.Setup(mock => mock.Foo(It.IsAny<string>(), It.IsAny<bool>())).Returns(false);

Résout un appel à Foo avec le premier paramètre ok