Zuweisen von Out / Ref-Parametern in Moq

Ist es möglich, einen out/ ref-Parameter mit Moq (3.0+) zuzuweisen?

Ich habe mir die Verwendung angesehen Callback(), unterstütze jedoch Action<>keine Ref-Parameter, da diese auf Generika basieren. Ich möchte auch vorzugsweise eine Einschränkung ( It.Is) für die Eingabe des refParameters setzen, obwohl ich dies im Rückruf tun kann.

Ich weiß, dass Rhino Mocks diese Funktionalität unterstützt, aber das Projekt, an dem ich arbeite, verwendet bereits Moq.

Moq Version 4.8 (oder höher) bietet eine deutlich verbesserte Unterstützung für By-Ref-Parameter:

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

Das gleiche Muster gilt für outParameter.

It.Ref<T>.IsAnyfunktioniert auch für C # 7- inParameter (da sie auch by-ref sind).

Für 'out' scheint das Folgende für mich zu funktionieren.

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

Ich vermute, dass Moq beim Aufrufen von Setup den Wert von 'expectedValue' überprüft und sich daran erinnert.

Denn refich suche auch nach einer Antwort.

Ich fand die folgende Kurzanleitung hilfreich: https://github.com/Moq/moq4/wiki/Quickstart

BEARBEITEN : In Moq 4.10 können Sie jetzt einen Delegaten mit einem out- oder ref-Parameter direkt an die Callback-Funktion übergeben:

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

Sie müssen einen Delegaten definieren und instanziieren:

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

Für die Moq-Version vor 4.10:

Avner Kashtan bietet in seinem Blog eine Erweiterungsmethode an, mit der der out-Parameter aus einem Rückruf festgelegt werden kann: Moq-, Callbacks- und Out-Parameter: ein besonders schwieriger Randfall

Die Lösung ist sowohl elegant als auch hackig. Elegant, da es eine fließende Syntax bietet, die sich bei anderen Moq-Rückrufen wie zu Hause fühlt. Und hacky, weil es darauf beruht, einige interne Moq-APIs über Reflection aufzurufen.

Die unter dem obigen Link angegebene Erweiterungsmethode wurde für mich nicht kompiliert, daher habe ich unten eine bearbeitete Version bereitgestellt. Sie müssen für jede Anzahl von Eingabeparametern eine Signatur erstellen. Ich habe 0 und 1 angegeben, aber die weitere Erweiterung sollte einfach sein:

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

Mit der obigen Erweiterungsmethode können Sie eine Schnittstelle ohne Parameter testen, z.

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

.. mit folgendem Moq-Setup:

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

Bearbeiten : Um Void-Return-Methoden zu unterstützen, müssen Sie lediglich neue Überladungsmethoden hinzufügen:

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

Dies ermöglicht das Testen von Schnittstellen wie:

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

Dies ist eine Dokumentation von der Moq-Site :

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

Scheint, als sei es nicht sofort möglich. Sieht so aus, als hätte jemand eine Lösung versucht

Siehe diesen Forumsbeitrag http://code.google.com/p/moq/issues/detail?id=176

diese Frage Überprüfen Sie den Wert des Referenzparameters mit Moq

Um einen Wert zusammen mit dem Einstellen des Ref-Parameters zurückzugeben, finden Sie hier einen Code:

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

Deklarieren Sie dann Ihren eigenen Delegaten, der mit der Signatur der zu verspottenden Methode übereinstimmt, und stellen Sie Ihre eigene Methodenimplementierung bereit.

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

Aufbauend auf Billy Jakes awnser habe ich eine volldynamische Mock-Methode mit einem out-Parameter erstellt. Ich poste dies hier für jeden, der es nützlich findet (wahrscheinlich nur für mich in der Zukunft).

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

Ich bin sicher, dass Scotts Lösung an einem Punkt funktioniert hat.

Aber es ist ein gutes Argument dafür, keine Reflexion zu verwenden, um einen Blick auf private Apis zu werfen. Es ist jetzt kaputt.

Ich konnte Parameter mit einem Delegaten festlegen

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

Dies kann eine Lösung sein.

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

}

Ich hatte mit vielen der Vorschläge hier zu kämpfen, bevor ich einfach eine Instanz einer neuen 'Fake'-Klasse erstellte, die jede Schnittstelle implementiert, die Sie verspotten möchten. Dann können Sie einfach den Wert des out-Parameters mit der Methode selbst festlegen.

Ich hatte heute Nachmittag eine Stunde damit zu kämpfen und konnte nirgendwo eine Antwort finden. Nachdem ich alleine damit herumgespielt hatte, konnte ich eine Lösung finden, die für mich funktionierte.

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

Der Schlüssel hier ist, mock.SetupAllProperties();der alle Eigenschaften für Sie auslöscht. Dies funktioniert möglicherweise nicht in jedem Testfallszenario, aber wenn Sie sich nur darum kümmern, das return valuezu erhalten YourMethod, funktioniert dies einwandfrei.