我需要测试以下方法:
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)?
答案 0 :(得分:56)
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)));
答案 1 :(得分:10)
我设法获得了我想要的行为,但它需要从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-sequences扩展名将很有用。
答案 2 :(得分:8)
我编写了一个基于调用顺序断言的扩展方法。
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);
}
答案 3 :(得分:4)
最近,我为Moq编写了两个功能:VerifyInSequence()和VerifyNotInSequence()。他们甚至可以使用Loose Mocks。但是,这些仅在moq存储库fork中可用:
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
谢谢!
答案 4 :(得分:3)
最简单的解决方案是使用Queue:
var expectedParameters = new Queue<string>(new[]{expectedType,expectedId,expectedSender});
mockWriter.Setup(x => x.Write(expectedType))
.Callback((string s) => Assert.AreEqual(expectedParameters.Dequeue(), s));
答案 5 :(得分:0)
我怀疑expectId不是你所期望的。
但是我可能只是编写自己的IWriter实现来验证这种情况......可能更容易(以后更容易更改)。
很抱歉没有直接的Moq建议。我喜欢它,但还没有这样做。
你可能需要在每个设置结束时添加.Verify()吗? (虽然我很害怕,这真是猜)。
答案 6 :(得分:0)
我的情况是没有参数的方法:
public interface IWriter
{
void WriteA ();
void WriteB ();
void WriteC ();
}
因此我在Invocations
上使用了Mock
属性来比较所谓的内容:
var writer = new Mock<IWriter> ();
new SUT (writer.Object).Run ();
Assert.Equal (
writer.Invocations.Select (invocation => invocation.Method.Name),
new[]
{
nameof (IWriter.WriteB),
nameof (IWriter.WriteA),
nameof (IWriter.WriteC),
});
您还可以附加invocation.Arguments
来检查带有参数的方法调用。
同样,失败消息比expected 1 but was 5
更清楚:
expected
["WriteB", "WriteA", "WriteC"]
but was
["WriteA", "WriteB"]
答案 7 :(得分:0)
我参加这个聚会很晚,但是我想分享一个对我有用的解决方案,因为似乎所有引用的解决方案都无法验证 相同 方法调用(具有相同的参数)依次进行多次。另外,引用的错误Moq Issue #478已关闭,没有解决方案。
提出的解决方案利用MockObject.Invocations
列表来确定顺序和相同性。
public static void VerifyInvocations<T>(this Mock<T> mock, params Expression<Action<T>>[] expressions) where T : class
{
Assert.AreEqual(mock.Invocations.Count, expressions.Length,
$"Number of invocations did not match expected expressions! Actual invocations: {Environment.NewLine}" +
$"{string.Join(Environment.NewLine, mock.Invocations.Select(i => i.Method.Name))}");
for (int c = 0; c < mock.Invocations.Count; c++)
{
IInvocation expected = mock.Invocations[c];
MethodCallExpression actual = expressions[c].Body as MethodCallExpression;
// Verify that the same methods were invoked
Assert.AreEqual(expected.Method, actual.Method, $"Did not invoke the expected method at call {c + 1}!");
// Verify that the method was invoked with the correct arguments
CollectionAssert.AreEqual(expected.Arguments.ToList(),
actual.Arguments
.Select(arg =>
{
// Expressions treat the Argument property as an Expression, do this to invoke the getter and get the actual value.
UnaryExpression objectMember = Expression.Convert(arg, typeof(object));
Expression<Func<object>> getterLambda = Expression.Lambda<Func<object>>(objectMember);
Func<object> objectValueGetter = getterLambda.Compile();
return objectValueGetter();
})
.ToList(),
$"Did not invoke step {c + 1} method '{expected.Method.Name}' with the correct arguments! ");
}
}
答案 8 :(得分:0)
我刚刚遇到了类似的情况,并受到公认答案的启发,我使用了以下方法:
//arrange
var someServiceToTest = new SomeService();
var expectedCallOrder = new List<string>
{
"WriteA",
"WriteB",
"WriteC"
};
var actualCallOrder = new List<string>();
var mockWriter = new Mock<IWriter>();
mockWriter.Setup(x => x.Write("A")).Callback(() => { actualCallOrder.Add("WriteA"); });
mockWriter.Setup(x => x.Write("B")).Callback(() => { actualCallOrder.Add("WriteB"); });
mockWriter.Setup(x => x.Write("C")).Callback(() => { actualCallOrder.Add("WriteC"); });
//act
someServiceToTest.CreateOutput(_mockWriter.Object);
//assert
Assert.AreEqual(expectedCallOrder, actualCallOrder);
答案 9 :(得分:0)
Moq
有一个鲜为人知的特性,称为 Capture.In
,它可以捕获传递给方法的参数。有了它,您可以像这样验证调用顺序:
var calls = new List<string>();
var mockWriter = new Mock<IWriter>();
mockWriter.Setup(x => x.Write(Capture.In(calls)));
CollectionAssert.AreEqual(calls, expectedCalls);
如果您有不同类型的重载,您也可以为重载运行相同的设置。