Adedi: Alaycı hizmet yöntemine iletilen bir parametreye nasıl gidilir

Bu sınıfı hayal edin

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) Hando'yu bir Foo testinde cking, neyin Bar()geçtiğini nasıl kontrol edebilirdim _h.AsyncHandle?

Mock.Callback yöntemini kullanabilirsiniz:

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

Eğer sadece argümandaki basit bir şeyi kontrol etmek istiyorsanız, bunu doğrudan da yapabilirsiniz:

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

Gamlor'un yanıtı benim için çalıştı, ama John Carpenter'ın yorumunu genişleteceğimi düşündüm çünkü birden fazla parametre içeren bir çözüm arıyordum. Bu sayfaya rastlayan diğer kişilerin de benzer bir durumda olabileceğini düşündüm. Bu bilgiyi Adedi belgelerinde buldum .

Gamlor örneğini kullanacağım, ancak AsyncHandle yönteminin iki argüman aldığını varsayalım: a stringve bir SomeResponsenesne.

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

Temel olarak It.IsAny<>(), uygun tipte başka bir tane eklemeniz, Callbackyönteme başka bir tür eklemeniz ve lambda ifadesini uygun şekilde değiştirmeniz gerekir.

Geri Arama yöntemi kesinlikle işe yarayacaktır, ancak bunu çok sayıda parametreye sahip bir yöntemle yapıyorsanız, biraz ayrıntılı olabilir. İşte kazanın bir kısmını çıkarmak için kullandığım bir şey.

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

İşte ArgumentCaptor kaynağı:

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

Gamlor'un cevabı işe yarıyor, ancak bunu yapmanın başka bir yolu (ve testte daha anlamlı olduğunu düşündüğüm bir yöntem) ...

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

Doğrulama çok güçlüdür ve alışmak için zaman ayırmaya değer.

Alternatif de Capture.Inözelliğini kullanmaktır moq. moqKoleksiyonda argüman yakalamayı sağlayan OOTB özelliğidir.

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

It.Is<TValue>()Eşleştirici kullanabilirsiniz .

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

Bu ayrıca işe yarar:

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

Burada çok iyi cevaplar var! Bağımlılıklarınıza iletilen çeşitli sınıf parametreleri hakkında iddialarda bulunmanız gerekene kadar kutunun dışında Moq özellik setiyle devam edin. Yine de bu durumda sonuç verirseniz, Eşitleme ile ilgili Adedi Doğrulama özelliği. uzun testler benim için uygun değildir).

İşte bir özeti: https://gist.github.com/Jacob-McKay/8b8d41ebb9565f5fca23654fd944ac6b Bir Moq (4.12) uzantısı ile, yukarıda belirtilen dezavantajlar olmadan, alaylara aktarılan argümanlar hakkında daha beyan edici bir yol veren yazdım. Doğrula bölümü şu şekilde görünüyor:

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

Moq deklaratif ve aynı şekilde başarısızlık izolasyonu sağlarken aynı şeyi başaran bir özellik sağlamış olsaydı stoklanacaktır. Parmaklar geçti!