Moq : Configurer une méthode fantaisie pour qu'elle échoue au premier appel et réussisse au second.

Question

Quelle est la manière la plus succincte d'utiliser Moq pour simuler une méthode qui lèvera une exception la première fois qu'elle sera appelée, puis réussira la deuxième fois qu'elle sera appelée ?

Answer 1

J'utiliserais Callback et incrémenter un compteur pour déterminer s'il faut ou non lever une exception à partir de Callback .

[Test]
public void TestMe()
{
    var count = 0;
    var mock = new Mock<IMyClass>();
    mock.Setup(a => a.MyMethod()).Callback(() =>
        {
            count++;
            if(count == 1)
                throw new ApplicationException();
        });
    Assert.Throws(typeof(ApplicationException), () => mock.Object.MyMethod());
    Assert.DoesNotThrow(() => mock.Object.MyMethod());
}

public interface IMyClass
{
    void MyMethod();
}

Answer 2

À partir de Moq 4.2, vous pouvez simplement utiliser la méthode intégrée SetupSequence() (comme indiqué dans le commentaire de @RichardBarnett).

Exemple :

var mock = new Mock<IMyClass>();
mock.SetupSequence(x => x.MyMethod("param1"))
    .Throws<MyException>()
    .Returns("test return");

Answer 3

La meilleure solution que j'ai trouvée jusqu'à présent est la suivante :

interface IFoo
{
    void Bar();
}

[Test]
public void TestBarExceptionThenSuccess()
{
    var repository = new MockRepository(MockBehavior.Default);
    var mock = repository.Create<IFoo>();

    mock.Setup(m => m.Bar()).
        Callback(() => mock.Setup(m => m.Bar())). // Setup() replaces the initial one
        Throws<Exception>();                      // throw an exception the first time

    ...
}

Answer 4

Phil Haack a une intéressante article de blog sur la configuration d'une méthode pour retourner une séquence particulière de résultats. Il semble que ce serait un bon point de départ, avec un peu de travail, car au lieu d'une séquence de valeurs d'un certain type, il faudrait maintenant avoir une séquence de résultats qui pourrait être de type T, ou une exception.