Moq: Cara mendapatkan parameter yang diteruskan ke metode layanan yang diejek

Bayangkan kelas ini

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 dalam ujian Foo, bagaimana saya bisa mengecek apa yang Bar()telah diteruskan _h.AsyncHandle?

Anda dapat menggunakan metode 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);

Jika Anda hanya ingin memeriksa sesuatu yang sederhana pada argumen yang diteruskan, Anda juga dapat melakukannya secara langsung:

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

Jawaban Gamlor bekerja untuk saya, tetapi saya pikir saya akan memperluas komentar John Carpenter karena saya sedang mencari solusi yang melibatkan lebih dari satu parameter. Saya pikir orang lain yang tersandung ke halaman ini mungkin berada dalam situasi yang sama. Saya menemukan info ini di dokumentasi Moq .

Saya akan menggunakan contoh Gamlor, tapi mari kita anggap metode AsyncHandle membutuhkan dua argumen: a stringdan SomeResponseobjek.

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

Pada dasarnya Anda hanya perlu menambahkan yang lain It.IsAny<>()dengan tipe yang sesuai, menambahkan tipe lain ke Callbackmetode, dan mengubah ekspresi lambda yang sesuai.

Metode Callback pasti akan bekerja, tetapi jika Anda melakukan ini pada metode dengan banyak parameter itu bisa sedikit bertele-tele. Berikut adalah sesuatu yang saya gunakan untuk menghapus beberapa boilerplate.

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

Berikut adalah sumber untuk 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; }
}

Jawaban Gamlor bekerja, tetapi cara lain untuk melakukannya (dan yang saya anggap lebih ekspresif dalam tes) adalah ...

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

Verifikasi sangat kuat, dan layak meluangkan waktu untuk membiasakan diri.

Alternatifnya adalah dengan menggunakan Capture.Infitur moq. Ini adalah moqfitur OOTB yang memungkinkan pengambilan argumen dalam koleksi.

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

Anda bisa menggunakan It.Is<TValue>()pencocokan.

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

Ini juga berfungsi:

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

Banyak jawaban bagus di sini! Pergilah dengan set fitur yang ada di luar kotak Moq sampai Anda perlu membuat pernyataan tentang beberapa parameter kelas yang diteruskan ke dependensi Anda. Jika Anda berakhir dalam situasi itu, fitur Verifikasi Moq dengan It. Pencocokan tidak melakukan pekerjaan yang baik untuk mengisolasi kegagalan tes, dan cara Pengembalian / Panggilan Balik untuk menangkap argumen menambahkan baris kode yang tidak perlu ke pengujian Anda (dan tes panjang adalah jalan keluar bagi saya).

Berikut adalah intinya: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b dengan ekstensi Moq (4,12) yang saya tulis yang memberikan cara yang lebih deklaratif untuk membuat pernyataan tentang argumen yang dilontarkan ke ejek, tanpa kekurangan yang disebutkan di atas. Berikut ini bagian Verify sekarang:

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

Saya akan terpacu jika Moq menyediakan fitur yang melakukan hal yang sama sementara menjadi deklaratif dan menyediakan isolasi kegagalan ini. Semoga saja!