Moq基础

2023-08-14 14:01:22

一、概念

　　Moq是利用诸如Linq表达式树和Lambda表达式等·NET 3.5的特性，为·NET设计和开发的Mocking库。Mock字面意思即模拟，模拟对象的行为已达到欺骗目标(待测试对象)的效果.
　　Moq模拟类类型时，不可模拟密封类，不可模拟静态方法(适配器可解决)，被模拟的方法及属性必须被virtual修饰.

二、示例

 //待模拟对象

 public interface ITaxCalculate

 {

     decimal GetTax(decimal rawPrice);

 }

 public class Product

 {

     public int Id { get; set; }

     public string Name { get; set; }

     public decimal RawPrice { get; set; }

     //目标方法

     public decimal GetPriceWithTax(ITaxCalculate calc)

     {

         return calc.GetTax(RawPrice) + RawPrice;

     }

 }

 //单元测试

 [TestMethod]

 public void TestGetTax()

 {

     Product product = new Product

     {

         Id = ,

         Name = "TV",

         RawPrice = 25.0M

     };

     //创建Mock对象，反射构建模拟对象空框架

     Mock<ITaxCalculate> fakeTaxCalculator = new Mock<ITaxCalculate>();

     //模拟对象行为

     fakeTaxCalculator.Setup(tax => tax.GetTax(25.0M)).Returns(5.0M);

     //调用目标方法

     decimal calcTax = product.GetPriceWithTax(fakeTaxCalculator.Object);

     //断言

     Assert.AreEqual(calcTax, 30.0M);

 }

三、Mock方法

Mock构造方法
Mock构造方法主要存在两种重载，无参以及传入参数MockBehavior，Mock默认行为：MockBehavior.Loose.
MockBehavior.Strict：对象行为未设置时调用抛出异常，示例如下.
MockBehavior.Loose：对象行为未设置时调用不抛出异常，如有必要返回控制，如：0,null.
MockBehavior.Default：等同于Loose.
```
 //构造方法

 public Mock();

 public Mock(MockBehavior behavior);

 //Strict示例

 Mock<IOrder> order = new Mock<IOrder>(MockBehavior.Strict);

 order.Object.ShowTitle(string.Empty);
```
MockFactory
Mock工厂，构建MockFactory时传入MockBehavior，通过Create方法创建Mock，次方法类似Mock构造方法.
```
 MockFactory factory = new MockFactory(MockBehavior.Loose);

 Mock<IOrder> order = factory.Create<IOrder>();
```

Setup
模拟对象行为方法，模拟出的方法与原有业务无关

 //模拟接口

 Mock<ICustomer> icustomer = new Mock<ICustomer>();

 //模拟普通方法

 icustomer.Setup(p => p.AddCall());

 icustomer.Setup(p => p.GetCall("Tom")).Returns("Hello");

 //模拟含有引用、输出参数方法

 string outString = "";

 icustomer.Setup(p => p.GetAddress("", out outString)).Returns("sz");

 icustomer.Setup(p => p.GetFamilyCall(ref outString)).Returns("xx");

 //模拟有返回值方法

 icustomer.Setup(p => p.GetCall(It.IsAny<string>())).Returns((string s) => "Hello " + s);

 //模拟类

 Mock<Customer> customer = new Mock<Customer>();

 //模拟属性

 customer.Setup(p => p.Name).Returns("Tom");

 Assert.AreEqual("Tom", customer.Object.Name);

 //另一种方法模拟属性

 customer.SetupProperty(p => p.Name, "Tom2");

 Assert.AreEqual("Tom2", customer.Object.Name);

 //模拟类方法

 customer.Setup(p => p.GetNameById()).Returns("");

 Assert.AreEqual("", customer.Object.GetNameById());

It用于添加参数约束，它有以下几个方法：
Is<T>：匹配给定符合规则的值
IsAny<T>：匹配给定类型的任何值
IsRegex<T>：正则匹配
IsInRange<T>：匹配给定类型的范围

 //对同一个动作可以模拟多个行为，执行动作时，从后往前依次匹配，直到匹配到为止

 var customer = new Mock<ICustomer>();

 customer.Setup(p => p.SelfMatch(It.IsAny<int>())).Returns((int k) => "任何数" + k);

 Console.WriteLine(customer.Object.SelfMatch());

 customer.Setup(p => p.SelfMatch(It.Is<int>(i => i %  == ))).Returns("偶数");

 Console.WriteLine(customer.Object.SelfMatch());

 customer.Setup(p => p.SelfMatch(It.IsInRange<int>(, , Range.Inclusive))).Returns("10以内的数");

 Console.WriteLine(customer.Object.SelfMatch());

 Console.WriteLine(customer.Object.SelfMatch());

 Console.WriteLine(customer.Object.SelfMatch());

 customer.Setup(p => p.ShowException(It.IsRegex(@"^\d+$"))).Throws(new Exception("不能是数字"));

 customer.Object.ShowException("e1");

Callback
该方法用于模拟方法执行后回调执行，配合Setup使用

 Mock<ICustomer> customer = new Mock<ICustomer>();

 customer.Setup(p => p.GetCall(It.IsAny<string>()))

     .Returns("方法调用")

     .Callback((string s) => Console.WriteLine("OK " + s));

 customer.Object.GetCall("x");

Throws
抛出异常，配合Setup使用

 Mock<ICustomer> customer = new Mock<ICustomer>();

 customer.Setup(p => p.ShowException(string.Empty)).Throws(new Exception("参数不能为空！"));

 customer.Object.ShowException("");

Verify、VerifyAll
验证模拟的方法是否被执行。示例中可通过Verify验证模拟的tax.GetTax(25.0M)是否在Product中被执行

 //Verifiable标记

 Mock<ICustomer> customer = new Mock<ICustomer>();

 customer.Setup(p => p.GetCall(It.IsAny<string>())).Returns("方法调用").Verifiable();

 //若不执行此句代码则验证失败

 customer.Object.GetCall("");

 customer.Verify();

 //Verify验证

 customer.Setup(p => p.GetCall());

 customer.Object.GetCall();

 //Verify方法表明该动作一定要在验证之前执行，若调用verify之前都没执行则抛出异常

 customer.Verify(p => p.GetCall());

 //添加次数验证

 customer.Object.GetCall();

 customer.Verify(p => p.GetCall(), Times.AtLeast(), "至少应被调用2次");

 //验证所有被模拟的动作是否都被执行，无论是否标记为Verifiable

 customer.VerifyAll();

As
向Mock中条件一个接口实现，只能在对象的属性、方法首次使用之前使用，且参数只能是接口，否则抛出异常。
之前一直不知道As方法存在有什么意义，虽然调试时监测对象信息可以看到两个Mock之间关联的痕迹，但是一直不知道有什么用，该怎么用，直到今天看到一篇博客...

 public interface IFirstInterface

 {

     int SomeMethodOnFirstInterface();

 }

 public interface ISecondInterface

 {

     int SomeMethodOnSecondInterface();

 }

 public interface SomeClassImplementingInterfaces : IFirstInterface, ISecondInterface

 {

 }

 public class SomeClass

 {

     public static int MultipleInterfaceUser<T>(T x)

         where T : IFirstInterface, ISecondInterface

     {

         IFirstInterface f = (IFirstInterface)x;

         ISecondInterface s = (ISecondInterface)x;

         return f.SomeMethodOnFirstInterface() + s.SomeMethodOnSecondInterface();

     }

 }

 //测试代码

 Mock<SomeClassImplementingInterfaces> c = new Mock<SomeClassImplementingInterfaces>();

 Mock<IFirstInterface> firstMock = c.As<IFirstInterface>();

 firstMock.Setup(m => m.SomeMethodOnFirstInterface()).Returns();

 Mock<ISecondInterface> secondMock = firstMock.As<ISecondInterface>();

 secondMock.Setup(m => m.SomeMethodOnSecondInterface()).Returns();

 int returnValue = SomeClass.MultipleInterfaceUser<SomeClassImplementingInterfaces>(c.Object);

 Assert.AreEqual(returnValue, );

四、参考链接

http://blog.csdn.net/alicehyxx/article/details/50667307
http://www.cnblogs.com/wintersun/archive/2010/09/04/1818092.html

码农公寓

一、概念

二、示例

三、Mock方法

四、参考链接

相关文章