Menetapkan / ref parameter dalam Moq

Apakah mungkin untuk menetapkan parameter out/ refmenggunakan Moq (3.0+)?

Saya telah melihat menggunakan Callback(), tetapi Action<>tidak mendukung parameter ref karena didasarkan pada obat generik. Saya juga lebih suka meletakkan constraint ( It.Is) pada input refparameter, meskipun saya bisa melakukannya di callback.

Saya tahu bahwa Badak Mocks mendukung fungsi ini, tetapi proyek yang saya kerjakan sudah menggunakan Moq.

Moq versi 4.8 (atau lebih baru) memiliki banyak dukungan yang ditingkatkan untuk parameter by-ref:

public interface IGobbler
{
    bool Gobble(ref int amount);
}

delegate void GobbleCallback(ref int amount);     // needed for Callback
delegate bool GobbleReturns(ref int amount);      // needed for Returns

var mock = new Mock<IGobbler>();
mock.Setup(m => m.Gobble(ref It.Ref<int>.IsAny))  // match any value passed by-ref
    .Callback(new GobbleCallback((ref int amount) =>
     {
         if (amount > 0)
         {
             Console.WriteLine("Gobbling...");
             amount -= 1;
         }
     }))
    .Returns(new GobbleReturns((ref int amount) => amount > 0));

int a = 5;
bool gobbleSomeMore = true;
while (gobbleSomeMore)
{
    gobbleSomeMore = mock.Object.Gobble(ref a);
}

Pola yang sama berfungsi untuk outparameter.

It.Ref<T>.IsAnyjuga berfungsi untuk inparameter C # 7 (karena mereka juga by-ref).

Untuk 'keluar', berikut ini sepertinya berhasil untuk saya.

public interface IService
{
    void DoSomething(out string a);
}

[TestMethod]
public void Test()
{
    var service = new Mock<IService>();
    var expectedValue = "value";
    service.Setup(s => s.DoSomething(out expectedValue));

    string actualValue;
    service.Object.DoSomething(out actualValue);
    Assert.AreEqual(expectedValue, actualValue);
}

Saya menduga bahwa Moq melihat nilai 'expectedValue' ketika Anda memanggil Setup dan mengingatnya.

Sebab ref, saya juga mencari jawaban.

Saya menemukan panduan QuickStart berikut berguna: https://github.com/Moq/moq4/wiki/Quickstart

EDIT : Dalam Moq 4.10, Anda sekarang dapat melewati delegasi yang memiliki parameter keluar atau ref langsung ke fungsi Callback:

mock
  .Setup(x=>x.Method(out d))
  .Callback(myDelegate)
  .Returns(...); 

Anda harus mendefinisikan delegasi dan membuat instantiate:

...
.Callback(new MyDelegate((out decimal v)=>v=12m))
...

Untuk versi Moq sebelum 4.10:

Avner Kashtan menyediakan metode ekstensi di blog-nya yang memungkinkan pengaturan parameter keluar dari callback: Parameter Moq, Callbacks dan Out: kasus tepi yang sangat rumit

Solusinya elegan dan hacky. Elegan karena memberikan sintaks yang lancar yang terasa di rumah dengan panggilan balik Moq lainnya. Dan hacky karena mengandalkan memanggil beberapa API Moq internal melalui refleksi.

Metode ekstensi yang disediakan di tautan di atas tidak dapat dikompilasi untuk saya, jadi saya telah menyediakan versi yang diedit di bawah. Anda harus membuat tanda tangan untuk setiap jumlah parameter input yang Anda miliki; Saya telah memberikan 0 dan 1, tetapi memperluasnya harus sederhana:

public static class MoqExtensions
{
    public delegate void OutAction<TOut>(out TOut outVal);
    public delegate void OutAction<in T1,TOut>(T1 arg1, out TOut outVal);

    public static IReturnsThrows<TMock, TReturn> OutCallback<TMock, TReturn, TOut>(this ICallback<TMock, TReturn> mock, OutAction<TOut> action)
        where TMock : class
    {
        return OutCallbackInternal(mock, action);
    }

    public static IReturnsThrows<TMock, TReturn> OutCallback<TMock, TReturn, T1, TOut>(this ICallback<TMock, TReturn> mock, OutAction<T1, TOut> action)
        where TMock : class
    {
        return OutCallbackInternal(mock, action);
    }

    private static IReturnsThrows<TMock, TReturn> OutCallbackInternal<TMock, TReturn>(ICallback<TMock, TReturn> mock, object action)
        where TMock : class
    {
        mock.GetType()
            .Assembly.GetType("Moq.MethodCall")
            .InvokeMember("SetCallbackWithArguments", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock,
                new[] { action });
        return mock as IReturnsThrows<TMock, TReturn>;
    }
}

Dengan metode ekstensi di atas, Anda dapat menguji antarmuka tanpa parameter seperti:

public interface IParser
{
    bool TryParse(string token, out int value);
}

.. dengan pengaturan Moq berikut:

    [TestMethod]
    public void ParserTest()
    {
        Mock<IParser> parserMock = new Mock<IParser>();

        int outVal;
        parserMock
            .Setup(p => p.TryParse("6", out outVal))
            .OutCallback((string t, out int v) => v = 6)
            .Returns(true);

        int actualValue;
        bool ret = parserMock.Object.TryParse("6", out actualValue);

        Assert.IsTrue(ret);
        Assert.AreEqual(6, actualValue);
    }

Sunting : Untuk mendukung metode pengembalian kosong, Anda hanya perlu menambahkan metode kelebihan muatan baru:

public static ICallbackResult OutCallback<TOut>(this ICallback mock, OutAction<TOut> action)
{
    return OutCallbackInternal(mock, action);
}

public static ICallbackResult OutCallback<T1, TOut>(this ICallback mock, OutAction<T1, TOut> action)
{
    return OutCallbackInternal(mock, action);
}

private static ICallbackResult OutCallbackInternal(ICallback mock, object action)
{
    mock.GetType().Assembly.GetType("Moq.MethodCall")
        .InvokeMember("SetCallbackWithArguments", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock, new[] { action });
    return (ICallbackResult)mock;
}

Ini memungkinkan pengujian antarmuka seperti:

public interface IValidationRule
{
    void Validate(string input, out string message);
}

[TestMethod]
public void ValidatorTest()
{
    Mock<IValidationRule> validatorMock = new Mock<IValidationRule>();

    string outMessage;
    validatorMock
        .Setup(v => v.Validate("input", out outMessage))
        .OutCallback((string i, out string m) => m  = "success");

    string actualMessage;
    validatorMock.Object.Validate("input", out actualMessage);

    Assert.AreEqual("success", actualMessage);
}

Ini adalah dokumentasi dari situs Moq :

// out arguments
var outString = "ack";
// TryParse will return true, and the out argument will return "ack", lazy evaluated
mock.Setup(foo => foo.TryParse("ping", out outString)).Returns(true);


// ref arguments
var instance = new Bar();
// Only matches if the ref argument to the invocation is the same instance
mock.Setup(foo => foo.Submit(ref instance)).Returns(true);

Sepertinya itu tidak mungkin di luar kotak. Sepertinya seseorang mencoba solusi

Lihat posting forum ini http://code.google.com/p/moq/issues/detail?id=176

pertanyaan ini Verifikasi nilai parameter referensi dengan Moq

Untuk mengembalikan nilai bersama dengan pengaturan parameter ref, berikut adalah sepotong kode:

public static class MoqExtensions
{
    public static IReturnsResult<TMock> DelegateReturns<TMock, TReturn, T>(this IReturnsThrows<TMock, TReturn> mock, T func) where T : class
        where TMock : class
    {
        mock.GetType().Assembly.GetType("Moq.MethodCallReturn`2").MakeGenericType(typeof(TMock), typeof(TReturn))
            .InvokeMember("SetReturnDelegate", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Instance, null, mock,
                new[] { func });
        return (IReturnsResult<TMock>)mock;
    }
}

Kemudian nyatakan delegasi Anda sendiri yang cocok dengan tanda tangan metode yang akan diejek dan sediakan implementasi metode Anda sendiri.

public delegate int MyMethodDelegate(int x, ref int y);

    [TestMethod]
    public void TestSomething()
    {
        //Arrange
        var mock = new Mock<ISomeInterface>();
        var y = 0;
        mock.Setup(m => m.MyMethod(It.IsAny<int>(), ref y))
        .DelegateReturns((MyMethodDelegate)((int x, ref int y)=>
         {
            y = 1;
            return 2;
         }));
    }

Membangun pada awnser Billy Jakes, saya membuat metode tiruan yang sepenuhnya dinamis dengan parameter keluar. Saya memposting ini di sini untuk siapa saja yang merasa berguna (mungkin hanya masa depan saya).

// Define a delegate with the params of the method that returns void.
delegate void methodDelegate(int x, out string output);

// Define a variable to store the return value.
bool returnValue;

// Mock the method: 
// Do all logic in .Callback and store the return value.
// Then return the return value in the .Returns
mockHighlighter.Setup(h => h.SomeMethod(It.IsAny<int>(), out It.Ref<int>.IsAny))
  .Callback(new methodDelegate((int x, out int output) =>
  {
    // do some logic to set the output and return value.
    output = ...
    returnValue = ...
  }))
  .Returns(() => returnValue);

Saya yakin solusi Scott bekerja pada satu titik,

Tapi itu argumen yang bagus untuk tidak menggunakan refleksi untuk mengintip apis pribadi. Sudah rusak sekarang.

Saya dapat menetapkan parameter menggunakan delegasi

      delegate void MockOutDelegate(string s, out int value);

    public void SomeMethod()
    {
        ....

         int value;
         myMock.Setup(x => x.TryDoSomething(It.IsAny<string>(), out value))
            .Callback(new MockOutDelegate((string s, out int output) => output = userId))
            .Returns(true);
    }

Ini bisa menjadi solusi.

[Test]
public void TestForOutParameterInMoq()
{
  //Arrange
  _mockParameterManager= new Mock<IParameterManager>();

  Mock<IParameter > mockParameter= new Mock<IParameter >();
  //Parameter affectation should be useless but is not. It's really used by Moq 
  IParameter parameter= mockParameter.Object;

  //Mock method used in UpperParameterManager
  _mockParameterManager.Setup(x => x.OutMethod(out parameter));

  //Act with the real instance
  _UpperParameterManager.UpperOutMethod(out parameter);

  //Assert that method used on the out parameter of inner out method are really called
  mockParameter.Verify(x => x.FunctionCalledInOutMethodAfterInnerOutMethod(),Times.Once());

}

Saya bergumul dengan banyak saran di sini sebelum saya dengan sederhana membuat instance dari kelas 'Palsu' baru yang mengimplementasikan antarmuka apa pun yang Anda coba tiru. Kemudian Anda cukup mengatur nilai parameter keluar dengan metode itu sendiri.

Saya berjuang dengan ini selama satu jam sore ini dan tidak dapat menemukan jawaban di mana pun. Setelah bermain-main sendiri dengan itu saya bisa menemukan solusi yang bekerja untuk saya.

string firstOutParam = "first out parameter string";
string secondOutParam = 100;
mock.SetupAllProperties();
mock.Setup(m=>m.Method(out firstOutParam, out secondOutParam)).Returns(value);

Kuncinya di sini adalah mock.SetupAllProperties();yang akan mematikan semua properti untuk Anda. Ini mungkin tidak bekerja dalam setiap tes skenario, tetapi jika semua yang Anda pedulikan adalah mendapatkan return valuedari YourMethodmaka ini baik-baik saja kemauan kerja.