Использование Moq для проверки вызовов сделаны в правильном порядке

Question

мне нужно проверить следующий метод:

CreateOutput(IWriter writer) 
{ 
    writer.Write(type); 
    writer.Write(id); 
    writer.Write(sender); 

    // many more Write()s... 
} 

Я создал Moq'd IWriter, и я хочу, чтобы убедиться, что Write() методы называются в правильный порядок.

Я следующий код теста:

var mockWriter = new Mock<IWriter>(MockBehavior.Strict); 
var sequence = new MockSequence(); 
mockWriter.InSequence(sequence).Setup(x => x.Write(expectedType)); 
mockWriter.InSequence(sequence).Setup(x => x.Write(expectedId)); 
mockWriter.InSequence(sequence).Setup(x => x.Write(expectedSender)); 

Однако второй вызов Write() в CreateOutput() (чтобы записать значение id) бросает MockException с сообщением "IWriter.Write() вызов с неудачной макет поведения Строго. Все вызовы на макет должны иметь соответствующую настройку. ".

Мне также сложно найти окончательную, современную документацию/примеры последовательностей Moq.

Я делаю что-то неправильно, или я не могу настроить последовательность, используя тот же метод? Если нет, есть ли альтернатива, которую я могу использовать (желательно с использованием Moq/NUnit)?

Answer 1

Есть ошибка, когда using MockSequence on same mock. Это определенно будет исправлено в более поздних выпусках библиотеки Moq (вы также можете исправить это вручную, изменив реализацию Moq.MethodCall.Matches).

Если вы хотите использовать только Moq, то вы можете проверить метод заказ на вызов с помощью функции обратного вызова:

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

Answer 2

Я подозреваю, что ожидается, что это не то, что вы ожидаете.

Однако я бы просто написал свою собственную реализацию IWriter для проверки в этом случае ... возможно, намного проще (и легче изменить позже).

Извините за отсутствие совета Moq напрямую. Мне это нравится, но я не сделал этого.

Возможно, вам нужно добавить .Verify() в конце каждой настройки? (Это действительно догадка, хотя я боюсь).

Answer 3

мне удалось получить поведение я хочу, но это требует загрузки библиотеки третьей стороны от http://dpwhelan.com/blog/software-development/moq-sequences/

последовательность может быть проверена с помощью следующего:

var mockWriter = new Mock<IWriter>(MockBehavior.Strict); 
using (Sequence.Create()) 
{ 
    mockWriter.Setup(x => x.Write(expectedType)).InSequence(); 
    mockWriter.Setup(x => x.Write(expectedId)).InSequence(); 
    mockWriter.Setup(x => x.Write(expectedSender)).InSequence(); 
} 

Я добавили это как ответ частично, чтобы помочь документировать это решение, но меня все еще интересует, можно ли достичь чего-то подобного, используя только Moq 4.0.

Я не уверен, что Moq все еще находится в разработке, но исправление проблемы с помощью MockSequence или включение расширения moq-последовательностей в Moq было бы неплохо увидеть.

Answer 4

Недавно я собрал две функции для Moq: VerifyInSequence() и VerifyNotInSequence(). Они работают даже с Loose Mocks.Однако, они доступны только в хранилище вилки MOQ:

https://github.com/grzesiek-galezowski/moq4

и ждать больше комментариев и тестирование, прежде чем принять решение о том, могут ли они быть включены в официальном MOq releaase. Однако ничто не мешает вам загружать исходный код в ZIP, создавая его в dll и давая ему попробовать. Используя эти функции, проверка последовательности вам нужно может быть записано так:

 
var mockWriter = new Mock<IWriter>() { CallSequence = new LooseSequence() }; 

//perform the necessary calls 

mockWriter.VerifyInSequence(x => x.Write(expectedType)); 
mockWriter.VerifyInSequence(x => x.Write(expectedId)); 
mockWriter.VerifyInSequence(x => x.Write(expectedSender)); 

(обратите внимание, что вы можете использовать две другие последовательности, в зависимости от ваших потребностей Сыпучие последовательность позволит вызовы между теми, которые вы хотите проверить. StrictSequence не позволит этого, а StrictAnytimeSequence - как StrictSequence (нет вызовов метода между проверенными вызовами), но позволяет последовательности преследовать любое количество произвольных вызовов.

Если вы решите попробовать эту экспериментальную функцию, пожалуйста, прокомментируйте ваши мысли по: https://github.com/Moq/moq4/issues/21

Спасибо!

Answer 5

Я написал метод расширения, который будет утверждать на основании порядка вызова.

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

Он работает, используя преимущества работы затворов по отношению к переменным областям. Поскольку для sharedCallCount существует только одно объявление, все блокировки будут иметь ссылку на одну и ту же переменную. С expectedCallCount новый экземпляр создается каждой итерацией цикла (в отличие от простого использования i в закрытии). Таким образом, каждое закрытие имеет копию i, предназначенную только для сравнения с sharedCallCount при вызове выражений.

Вот небольшой блок для расширения. Обратите внимание, что этот метод вызывается в разделе настройки, а не в разделе вашего утверждения.

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

Answer 6

Самым простым решением было бы с помощью Queue:

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