Moq: Comment accéder à un paramètre passé à une méthode d'un service simulé

Imaginez cette classe

public class Foo {

    private Handler _h;

    public Foo(Handler h)
    {
        _h = h;
    }

    public void Bar(int i)
    {
        _h.AsyncHandle(CalcOn(i));
    }

    private SomeResponse CalcOn(int i)
    {
        ...;
    }
}

Mo (q) cking Handler dans un test de Foo, comment pourrais-je vérifier ce qui Bar()est passé _h.AsyncHandle?

Vous pouvez utiliser la méthode Mock.Callback:

var mock = new Mock<Handler>();
SomeResponse result = null;
mock.Setup(h => h.AnsyncHandle(It.IsAny<SomeResponse>()))
    .Callback<SomeResponse>(r => result = r);

// do your test
new Foo(mock.Object).Bar(22);
Assert.NotNull(result);

Si vous voulez seulement vérifier quelque chose de simple sur l'argument passé, vous pouvez également le faire directement:

mock.Setup(h => h.AnsyncHandle(It.Is<SomeResponse>(response => response != null)));

La réponse de Gamlor a fonctionné pour moi, mais j'ai pensé développer le commentaire de John Carpenter car je cherchais une solution impliquant plus d'un paramètre. J'ai pensé que d'autres personnes qui tombaient sur cette page pourraient être dans une situation similaire. J'ai trouvé cette information dans la documentation Moq .

Je vais utiliser l'exemple de Gamlor, mais faisons comme si la méthode AsyncHandle prend deux arguments: un stringet un SomeResponseobjet.

var mock = new Mock<Handler>();
string stringResult = string.Empty;
SomeResponse someResponse = null;
mock.Setup(h => h.AsyncHandle(It.IsAny<string>(), It.IsAny<SomeResponse>()))
    .Callback<string, SomeResponse>((s, r) => 
    {
        stringResult = s;
        someResponse = r;
    });

// do your test
new Foo(mock.Object).Bar(22);
Assert.AreEqual("expected string", stringResult);
Assert.IsNotNull(someResponse);

Fondamentalement, il vous suffit d'en ajouter un autre It.IsAny<>()avec le type approprié, d'ajouter un autre type à la Callbackméthode et de modifier l'expression lambda le cas échéant.

La méthode Callback fonctionnera certainement, mais si vous faites cela sur une méthode avec beaucoup de paramètres, cela peut être un peu verbeux. Voici quelque chose que j'ai utilisé pour retirer une partie du passe-partout.

var mock = new Mock<Handler>();

// do your test   
new Foo(mock.Object).Bar(22);

var arg = new ArgumentCaptor<SomeResponse>();
mock.Verify(h => h.AsyncHandle(arg.Capture()));
Assert.NotNull(arg.Value);

Voici la source d'ArgumentCaptor:

public class ArgumentCaptor<T>
{
    public T Capture()
    {
        return It.Is<T>(t => SaveValue(t));
    }

    private bool SaveValue(T t)
    {
        Value = t;
        return true;
    }

    public T Value { get; private set; }
}

La réponse de Gamlor fonctionne, mais une autre façon de le faire (et que je considère plus expressive dans le test) est ...

var mock = new Mock<Handler>();
var desiredParam = 47; // this is what you want to be passed to AsyncHandle
new Foo(mock.Object).Bar(22);
mock.Verify(h => h.AsyncHandle(desiredParam), Times.Once());

Vérifier est très puissant et vaut la peine de prendre le temps de s'y habituer.

L'alternative consiste également à utiliser la Capture.Infonctionnalité du moq. C'est la moqfonction OOTB qui permet la capture d'arguments dans la collection.

//Arrange
var args = new List<SomeResponse>();
mock.Setup(h => h.AnsyncHandle(Capture.In(args)));

//Act
new Foo(mock.Object).Bar(22);

//Assert
//... assert args.Single() or args.First()

Vous pourriez utiliser It.Is<TValue>() matcher.

var mock = new Mock<Handler>();
new Foo(mock.Object).Bar(22);
mock.Verify(h => h.AsyncHandle(It.Is<SomeResponse>(r => r != null )));

Cela fonctionne également:

Mock<InterfaceThing> mockedObject = new Mock<InterfaceThing>();
var objectParameter = mockedObject.Invocations[1].Arguments[0] as ObjectParameter;

Beaucoup de bonnes réponses ici! Optez pour l'ensemble de fonctionnalités Moq prêt à l'emploi jusqu'à ce que vous ayez besoin de faire des affirmations sur plusieurs paramètres de classe passés à vos dépendances. Si vous vous retrouvez dans cette situation, la fonction de vérification Moq avec les correspondants It.Is ne fait pas un bon travail pour isoler l'échec du test, et la méthode de retour / rappel des arguments ajoute des lignes de code inutiles à votre test (et les longs tests sont interdits pour moi).

Voici l'essentiel: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b avec une extension Moq (4.12) que j'ai écrite qui donne une manière plus déclarative de faire des affirmations sur les arguments passés aux mocks, sans les inconvénients mentionnés ci-dessus. Voici à quoi ressemble la section Vérifier maintenant:

        mockDependency
            .CheckMethodWasCalledOnce(nameof(IExampleDependency.PersistThings))
            .WithArg<InThing2>(inThing2 =>
            {
                Assert.Equal("Input Data with Important additional data", inThing2.Prop1);
                Assert.Equal("I need a trim", inThing2.Prop2);
            })
            .AndArg<InThing3>(inThing3 =>
            {
                Assert.Equal("Important Default Value", inThing3.Prop1);
                Assert.Equal("I NEED TO BE UPPER CASED", inThing3.Prop2);
            });

Je serais ravi si Moq fournissait une fonctionnalité qui accomplissait la même chose tout en étant aussi déclarative et en fournissant l'isolement d'échec que cela permet. Doigts croisés!