.net core 单元测试之 JustMock第二篇
JustMock标记方法
上篇文章在举例子的时候使用了returns的标记方法，JustMock还有很多标记方法：
- CallOriginal
跟Behaviors里的CallOriginal差不多意思，被调用时执行原始的方法和属性的实现。 - DoNothing
忽略对方法或者属性的调用。 - DoInstead
替换原来方法的调用，或者属性的设置。 - MustBeCalled
被标记的方法必须调用，否则会抛出异常。 - Raise
当我们需要测试Event是否执行时，我们可以使用Raise来引发Events。
例子：
public delegate void CustomEvent(string value);
public interface IFoo
{
event CustomEvent CustomEvent;
}
//测试方法：
[Test]
public void ShouldInvokeMethodForACustomEventWhenRaised()
{
string expected = "ping";
string actual = string.Empty;
var foo = Mock.Create<IFoo>();
foo.CustomEvent += delegate (string s)
{
actual = s;
};
//引发事件，并传递参数
Mock.Raise(() => foo.CustomEvent += null, expected);
Assert.AreEqual(expected, actual);
}
- Raises
Raises用在调用方法后出发事件。
例子：
//使用的接口
public delegate void CustomEvent(string value, bool called);
public delegate void EchoEvent(bool echoed);
public delegate void ExecuteEvent();
public interface IFoo
{
event CustomEvent CustomEvent;
event EchoEvent EchoEvent;
event ExecuteEvent ExecuteEvent;
void RaiseMethod();
string Echo(string arg);
void Execute();
void Execute(string arg);
}
当调用方法时触发：
//测试方法
[Test]
public void ShouldRaiseCustomEventOnMethodCall()
{
string actual = string.Empty;
bool isCalled = false;
var foo = Mock.Create<IFoo>();
foo.CustomEvent += (s, c) => { actual = s; isCalled = c; };
Mock.Arrange(() => foo.RaiseMethod()).Raises(() => foo.CustomEvent += null, "ping", true);
foo.RaiseMethod();//调用方法，触发事件
Assert.AreEqual("ping", actual);
Assert.IsTrue(isCalled);
}
另外还可以设置参数满足条件时调用的方法触发，设置延时触发。
- Returns
设置返回结果。 - Throws
当一个方法调用时，抛出异常。
例子：
[Test]
public void ShouldThrowExceptionOnMethodCall()
{
// Arrange
var foo = Mock.Create<IFoo>();
Mock.Arrange(() => foo.Execute(string.Empty)).Throws<ArgumentException>();
Assert.Throws<ArgumentException>(() => foo.Execute(string.Empty));
}
- ThrowsAsync
调用异步方法时抛出异常。（官方文档有这个标记，貌似使用21912071版本时没有这个标记了） - When
当满足条件时执行某操作。
例子：
public interface IFoo
{
bool IsCalled();
string Prop { get; set; }
}
[Test]
public void IsCalled_ShouldReturnTrue_WithMockedDependencies()
{
var foo = Mock.Create<IFoo>();
Mock.Arrange(() => foo.Prop).Returns("test");//设置Prop返回"Test"
Mock.Arrange(() => foo.IsCalled()).When(() => foo.Prop == "test").Returns(true);
Assert.IsTrue(foo.IsCalled());
}
JustMock模拟属性
上面的例子中已经用到Returns来模拟属性的值了，这里再看看还有其它的用法：
- 根据索引模拟值
假设一个类的属性是数组或者链表等，我们需要模拟其中某个索引下的值：
//indexedFoo是一个数组
Mock.Arrange(() => indexedFoo[1]).Returns("pong"); //Mock indexedFoo 下标1的值为“pong”
- 设置属性
我们需要验证一个属性是否被正确赋值时，可以用ArrangeSet来模拟设置属性并验证。
[Test]
public void ShouldAssertPropertySet()
{
var foo = Mock.Create<IFoo>();
Mock.ArrangeSet(() => foo.Value = 1);
foo.Value = 1; //执行赋值
Mock.AssertSet(() => foo.Value = 1);
}
Matchers 匹配参数
我们模拟有参数的方法时，要根据不同的参数设置不同的返回值，Matchers可以做到这些。
- Arg.AnyBool，Arg.AnyDouble，Arg.AnyFloat, Arg.AnyGuid, Arg.AnyInt, Arg.AnyLong, Arg.AnyObject, Arg.AnyShort, Arg.AnyString, Arg.NullOrEmpty
- Arg.IsAny
() - Arg.IsInRange([FromValue : int], [ToValue : int], [RangeKind])
- Arg.Matches
(Expression<Predicate > expression) - Arg.Ref()
- Args.Ignore()
我们可以利用Arg.Matches<T>(Expression<Predicate<T>> expression) 生成我们想要的数据条件。
Arg.Ref() 是C#里的ref 参数。
Args.Ignore() 可以忽略参数，同标记方法IgnoreArguments()。
Matchers 不仅在构造参数中使用，还可以在Assert中使用：
[Test]
public void ShouldUseMatchersInAssert()
{
var paymentService = Mock.Create<IPaymentService>();
paymentService.ProcessPayment(DateTime.Now, 54.44M);
// 断言：不管DateTime什么时间，Payment amount都是54.44.
Mock.Assert(() => paymentService.ProcessPayment(
Arg.IsAny<DateTime>(),
Arg.Matches<decimal>(paymentAmount => paymentAmount == 54.44M)));
}
Sequential Mocking 连续模拟
Sequential mocking 允许我们多次执行代码返回不一样的值，具体代码理解：
[TestMethod]
public void ShouldArrangeAndAssertInASequence()
{
var foo = Mock.Create<IFoo>();
//只需要在Arrange()后面加上InSequence()
Mock.Arrange(() => foo.GetIntValue()).Returns(0).InSequence();
Mock.Arrange(() => foo.GetIntValue()).Returns(1).InSequence();
Mock.Arrange(() => foo.GetIntValue()).Returns(2).InSequence();
int actualFirstCall = foo.GetIntValue(); //结果是：0
int actualSecondCall = foo.GetIntValue(); //结果是：1
int actualThirdCall = foo.GetIntValue(); //结果是：2
int actualFourthCall = foo.GetIntValue(); // 注意这是第四次调用，因为没有设置结果，实际上他应当是上次调用的结果：2
}
配合Matcher使用：
Mock.Arrange(() => foo.Echo(Arg.Matches<int>(x => x > 10))).Returns(10).InSequence();
Mock.Arrange(() => foo.Echo(Arg.Matches<int>(x => x > 20))).Returns(20).InSequence();
int actualFirstCall = foo.Echo(11); //结果10
int actualSecondCall = foo.Echo(21); //结果20
还可以多次返回：
Mock.Arrange(() => foo.Echo(Arg.AnyInt)).Returns(10).Returns(11).MustBeCalled();
Assert.AreEqual(10, foo.Echo(1));
Assert.AreEqual(11, foo.Echo(2));
或者以数组方式返回：
int[] returnValues = new int[3] { 1, 2, 3 };
Mock.Arrange(() => foo.Echo(Arg.AnyInt)).ReturnsMany(returnValues);
var actualFirstCall = foo.Echo(10); // 结果：1
var actualSecondCall = foo.Echo(10); // 结果：2
var actualThirdCall = foo.Echo(10); // 结果：3
Recursive Mocking 递归模拟
递归Mock。有时候我们需要取值像这样的：foo.Bar.Baz.Do("x")，我们可以不用一个一个对象去模拟，我们只需要Mock 第一个，然后设置值就可以了。
像这样：
var foo = Mock.Create<IFoo>(); // mock 第一个对象
Mock.Arrange(() => foo.Bar.Do("x")).Returns("xit"); //设置某次调用的值
Mock.Arrange(() => foo.Bar.Baz.Do("y")).Returns("yit");
最后
这里涉及到的都是是JustMock的免费版功能。在工作中遇到一些问题，我们需要测试的目标方法中混有静态类提供的逻辑，免费的框架都不支持Mock静态类，需要用到付费版的高级功能。更好的时候，我们应该避免这些依赖，以方便我们测试。
