Moq: jak dostać się do parametru przekazanego do metody usługi mockowanej

Wyobraź sobie tę klasę

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 w teście Foo, w jaki sposób mógłbym sprawdzić, co Bar()przeszło _h.AsyncHandle?

Możesz użyć metody 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);

Jeśli chcesz sprawdzić tylko coś prostego w przekazanym argumencie, możesz to również zrobić bezpośrednio:

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

Odpowiedź Gamlora zadziałała dla mnie, ale pomyślałem, że rozszerzę komentarz Johna Carpentera, ponieważ szukałem rozwiązania obejmującego więcej niż jeden parametr. Pomyślałem, że inni ludzie, którzy natkną się na tę stronę, mogą być w podobnej sytuacji. Znalazłem te informacje w dokumentacji Moq .

Posłużę się przykładem Gamlora, ale załóżmy, że metoda AsyncHandle przyjmuje dwa argumenty: stringai SomeResponseobiekt.

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

Zasadniczo wystarczy dodać inny It.IsAny<>()z odpowiednim typem, dodać inny typ do Callbackmetody i odpowiednio zmienić wyrażenie lambda.

Metoda Callback z pewnością zadziała, ale jeśli robisz to na metodzie z wieloma parametrami, może to być nieco rozwlekłe. Tutaj jest coś, czego użyłem do usunięcia części gotówki.

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

Oto źródło 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; }
}

Odpowiedź Gamlora działa, ale inny sposób (i który uważam za bardziej wyrazisty w teście) to ...

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

Weryfikacja jest bardzo potężna i warto poświęcić trochę czasu na przyzwyczajenie się.

Alternatywą jest również użycie Capture.Infunkcji moq. Jest to moqfunkcja OOTB, która umożliwia przechwytywanie argumentów w kolekcji.

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

Możesz użyć It.Is<TValue>()dopasowania.

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

Działa to również:

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

Wiele dobrych odpowiedzi tutaj! Idź z gotowym zestawem funkcji Moq, aż będziesz musiał dokonać asercji dotyczących kilku parametrów klas przekazanych do twoich zależności. Jeśli jednak znajdziesz się w takiej sytuacji, funkcja Moq Verify with It. Is matchers nie radzi sobie dobrze z izolowaniem błędu testu, a sposób Returns / Callback przechwytywania argumentów dodaje niepotrzebne wiersze kodu do twojego testu (i długie testy są dla mnie nie do przyjęcia).

Oto sedno: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b z rozszerzeniem Moq (4.12), które napisałem, które daje bardziej deklaratywny sposób tworzenia twierdzeń o argumentach przekazywanych do kpiny, bez wspomnianych powyżej wad. Oto, jak teraz wygląda sekcja Weryfikuj:

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

Byłbym podekscytowany, gdyby Moq dostarczył funkcję, która osiągnęła to samo, będąc deklaratywną i zapewniając izolację awarii. Skrzyżowane palce!