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 = ,
         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 = "";
    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");

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次");
   
    //验证所有被模拟的动作是否都被执行，无论是否标记为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();
   
    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