À l'aide de Moq pour vérifier les appels sont effectués dans l'ordre correct

Il y a un bug lors de l' à l'aide de MockSequence sur la même maquette. Il sera certainement corrigé dans les versions ultérieures de Moq bibliothèque (vous pouvez aussi le faire manuellement en modifiant Moq.Appel de méthode.Correspond à la mise en œuvre).

Si vous souhaitez utiliser Moq seul, alors vous pouvez vérifier l'ordre d'appel de méthode via les rappels:

int callOrder = 0;
writerMock.Setup(x => x.Write(expectedType)).Callback(() => Assert.That(callOrder++, Is.EqualTo(0)));
writerMock.Setup(x => x.Write(expectedId)).Callback(() => Assert.That(callOrder++, Is.EqualTo(1)));
writerMock.Setup(x => x.Write(expectedSender)).Callback(() => Assert.That(callOrder++, Is.EqualTo(2)));

J'ai écrit une méthode d'extension qui affirmera selon l'ordre d'invocation.

public static class MockExtensions
{
  public static void ExpectsInOrder<T>(this Mock<T> mock, params Expression<Action<T>>[] expressions) where T : class
  {
    //All closures have the same instance of sharedCallCount
    var sharedCallCount = 0;
    for (var i = 0; i < expressions.Length; i++)
    {
      //Each closure has it's own instance of expectedCallCount
      var expectedCallCount = i;
      mock.Setup(expressions[i]).Callback(
        () =>
          {
            Assert.AreEqual(expectedCallCount, sharedCallCount);
            sharedCallCount++;
          });
    }
  }
}

Il fonctionne en profitant de la manière que la fermeture de travail à l'égard de l'étendue des variables. Depuis il y a une seule déclaration pour sharedCallCount, toutes les fermetures permettront d'avoir une référence à la même variable. Avec expectedCallCount, une nouvelle instance est instancié à chaque itération de la boucle (par opposition à l'utilisation je la fermeture). De cette façon, chaque fermeture a une copie de j'ai configuré uniquement pour lui-même à comparer avec la sharedCallCount lorsque les expressions sont invoquées.

Voici un petit test unitaire pour l'extension. Notez que cette méthode est appelée dans votre section d'installation, pas votre affirmation section.

[TestFixture]
public class MockExtensionsTest
{
  [TestCase]
  {
    //Setup
    var mock = new Mock<IAmAnInterface>();
    mock.ExpectsInOrder(
      x => x.MyMethod("1"),
      x => x.MyMethod("2"));

    //Fake the object being called in order
    mock.Object.MyMethod("1");
    mock.Object.MyMethod("2");
  }

  [TestCase]
  {
    //Setup
    var mock = new Mock<IAmAnInterface>();
    mock.ExpectsInOrder(
      x => x.MyMethod("1"),
      x => x.MyMethod("2"));

    //Fake the object being called out of order
    Assert.Throws<AssertionException>(() => mock.Object.MyMethod("2"));
  }
}

public interface IAmAnInterface
{
  void MyMethod(string param);
}

La solution la plus simple serait d'utiliser un La file d'attente:

var expectedParameters = new Queue<string>(new[]{expectedType,expectedId,expectedSender});
mockWriter.Setup(x => x.Write(expectedType))
          .Callback((string s) => Assert.AreEqual(expectedParameters.Dequeue(), s));