Affectation des paramètres de sortie / référence dans Moq

Est-il possible d'assigner un paramètre out/ en refutilisant Moq (3.0+)?

J'ai regardé l'utilisation Callback(), mais Action<>ne prend pas en charge les paramètres ref car il est basé sur des génériques. J'aimerais aussi de préférence mettre une contrainte ( It.Is) sur l'entrée du refparamètre, bien que je puisse le faire dans le rappel.

Je sais que Rhino Mocks prend en charge cette fonctionnalité, mais le projet sur lequel je travaille utilise déjà Moq.

La version 4.8 (ou ultérieure) de Moq offre une prise en charge améliorée des paramètres 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);
}

Le même modèle fonctionne pour les outparamètres.

It.Ref<T>.IsAnyfonctionne également pour les inparamètres C # 7 (car ils sont également by-ref).

Pour 'out', ce qui suit semble fonctionner pour moi.

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

J'imagine que Moq regarde la valeur de 'expectValue' lorsque vous appelez le programme d'installation et s'en souvient.

Car ref, je cherche aussi une réponse.

J'ai trouvé le guide de démarrage rapide suivant utile: https://github.com/Moq/moq4/wiki/Quickstart

EDIT : Dans Moq 4.10, vous pouvez maintenant passer un délégué qui a un paramètre out ou ref directement à la fonction de rappel:

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

Vous devrez définir un délégué et l'instancier:

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

Pour la version Moq avant 4.10:

Avner Kashtan fournit une méthode d'extension dans son blog qui permet de définir le paramètre de sortie à partir d'un rappel: Moq, Callbacks et Out paramètres: un cas de bord particulièrement délicat

La solution est à la fois élégante et hacky. Élégant en ce qu'il fournit une syntaxe fluide qui se sent chez soi avec d'autres rappels Moq. Et hacky car il repose sur l'appel à certaines API Moq internes via la réflexion.

La méthode d'extension fournie sur le lien ci-dessus n'a pas été compilée pour moi, j'ai donc fourni une version modifiée ci-dessous. Vous devrez créer une signature pour chaque nombre de paramètres d'entrée dont vous disposez; J'ai fourni 0 et 1, mais le prolonger devrait être simple:

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

Avec la méthode d'extension ci-dessus, vous pouvez tester une interface sans paramètres tels que:

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

.. avec la configuration Moq suivante:

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

Edit : Pour prendre en charge les méthodes de retour vide, vous devez simplement ajouter de nouvelles méthodes de surcharge:

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

Cela permet de tester des interfaces telles que:

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

Voici la documentation du site 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);

Il semble que ce ne soit pas possible hors de la boîte. On dirait que quelqu'un a tenté une solution

Voir ce post sur le forum http://code.google.com/p/moq/issues/detail?id=176

cette question Vérifier la valeur du paramètre de référence avec Moq

Pour renvoyer une valeur avec la définition du paramètre ref, voici un morceau de 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;
    }
}

Déclarez ensuite votre propre délégué correspondant à la signature de la méthode à simuler et fournissez votre propre implémentation de méthode.

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

En s'appuyant sur Billy Jakes, j'ai fait une méthode de simulation entièrement dynamique avec un paramètre out. Je poste ceci ici pour quiconque le trouve utile (probablement juste pour moi).

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

Je suis sûr que la solution de Scott a fonctionné à un moment donné,

Mais c'est un bon argument pour ne pas utiliser la réflexion pour jeter un œil aux API privées. C'est cassé maintenant.

J'ai pu définir des paramètres à l'aide d'un délégué

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

Cela peut être une solution.

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

}

J'ai eu du mal avec de nombreuses suggestions ici avant de créer simplement une instance d'une nouvelle classe «Fake» qui implémente l'interface que vous essayez de Mock out. Ensuite, vous pouvez simplement définir la valeur du paramètre out avec la méthode elle-même.

J'ai lutté avec cela pendant une heure cet après-midi et je n'ai trouvé aucune réponse nulle part. Après avoir joué seul avec, j'ai pu trouver une solution qui fonctionnait pour moi.

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

La clé ici est de mock.SetupAllProperties();déterminer toutes les propriétés pour vous. Cela peut ne pas fonctionner dans tous les scénarios de cas de test, mais si tout ce que vous soucier de l'obtenir est return valued' YourMethodalors cela fonctionnera bien.