Moq基础

一、概念

　　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 = 1,
        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方法

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

2. MockFactory
   Mock工厂，构建MockFactory时传入MockBehavior，通过Create方法创建Mock，次方法类似Mock构造方法.
   

   MockFactory factory = new MockFactory(MockBehavior.Loose);
   Mock<IOrder> order = factory.Create<IOrder>();

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

   //模拟接口
   Mock<ICustomer> icustomer = new Mock<ICustomer>();
   //模拟普通方法
   icustomer.Setup(p => p.AddCall());
   icustomer.Setup(p => p.GetCall("Tom")).Returns("Hello");
   
   //模拟含有引用、输出参数方法
   string outString = "00";
   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(1)).Returns("2");
   Assert.AreEqual("2", customer.Object.GetNameById(1));

   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(100));
   
   customer.Setup(p => p.SelfMatch(It.Is<int>(i => i % 2 == 0))).Returns("偶数");
   Console.WriteLine(customer.Object.SelfMatch(6));
   
   customer.Setup(p => p.SelfMatch(It.IsInRange<int>(0, 10, Range.Inclusive))).Returns("10以内的数");
   Console.WriteLine(customer.Object.SelfMatch(8));
   
   Console.WriteLine(customer.Object.SelfMatch(18));
   Console.WriteLine(customer.Object.SelfMatch(99));
   
   customer.Setup(p => p.ShowException(It.IsRegex(@"^d+$"))).Throws(new Exception("不能是数字"));
   customer.Object.ShowException("e1");

4. 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");

5. Throws
   抛出异常，配合Setup使用
   

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

6. 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), "至少应被调用2次");
   
   //验证所有被模拟的动作是否都被执行，无论是否标记为Verifiable
   customer.VerifyAll();

7. 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(2);
   
   Mock<ISecondInterface> secondMock = firstMock.As<ISecondInterface>();
   secondMock.Setup(m => m.SomeMethodOnSecondInterface()).Returns(4);
   
   int returnValue = SomeClass.MultipleInterfaceUser<SomeClassImplementingInterfaces>(c.Object);
   
   Assert.AreEqual(returnValue, 6);

四、参考链接

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