[Test] 单元测试艺术(2) 打破依赖，使用模拟对象，桩对象，隔离框架

在上节中，完成了第一个单元测试，研究了各类特性，在本节，将介绍一些更实际的例子。SUT依赖于一个不可操控的对象，最多见的例子是文件系统，线程，内存和时间等。

 

本系列将分红3节：

1. 单元测试基础知识
2. 打破依赖，使用模拟对象，桩对象，隔离框架
3. 建立优秀的单元测试

 

本节索引：

• 伪对象、桩对象、 模拟对象
• 为何须要伪对象，如何处理
• 手工新建伪对象
• 使用隔离框架建立伪对象

 

 

伪对象(fake) 桩对象(stub) 模拟对象(mock)

伪对象是一个通用术语，它便可指桩对象，也可指模拟对象。

桩对象是指对系统中现有依赖项的一个替代品，可人为控制。

模拟对象是用来决定一个单元测试是经过仍是失败的伪对象。

 

说明：fake是stub和mock的统称，由于看起来都像是真的对象。若是是用来检查交互的就是模拟对象，不然就是桩对象

 

桩对象：

 

模拟对象：

 

为何须要伪对象

1. 外部依赖（系统中代码与其交互的对象，并且没法对其作人为控制）
2. 反测试（而一旦测试中存在外部依赖，那么这个测试就是一个集成测试。运行慢，须要配置，依赖异常）

 

如何处理？

本质上都是外部依赖致使的，因此要作的是消除依赖。

1. 分析接口
2. 实现可人为控制的接口 

 

注入桩对象

1. 在构造函数上接受一个接口，并保存在一个字段里，以备后用。
2. 保存在属性上
3. 在调用方法前，使用方法参数，工厂类，依赖注入等

 

隐藏桩对象（因为生产环境等其余缘由，咱们不但愿暴露桩对象）

1. 使用条件编译
2. 使用条件特性
3. 使用internal和[InternalVisibleTo]

 

 

手工新建伪对象

 

使用桩对象（适用于模拟返回值，不适用于检查对象间的交互状况。）

 

这是很是常见的方式，可是这种方式受限制不少，如文件须要配置，运行慢。

　　public class Config
    {
        public bool IsCheck(string name)
        {
            var str = File.ReadAllText("1.txt");
            return str == name;//此处多是大量的逻辑处理
        }
    }

 

改写注入

    public class Config
    {
        private IManager manager;
//提供注入接口
        public Config(IManager manager)
        {
            this.manager = manager;
        }
        public bool IsCheck(string name)
        {
            var str = manager.GetConfig();
            return str == name;
        }
    }
//真实的实现
    public class FileManager : IManager
    {
        public string GetConfig()
        {
            return File.ReadAllText("1.txt");
        }
    }
//测试使用的实现
    public class StubManager : IManager
    {
        public string GetConfig()
        {
            return "str";
        }
    }
//抽象出的接口
    public interface IManager
    {
        string GetConfig();
    }

 

测试代码

    [TestClass]
    public class ConfigTests
    {
        private Config config;

        [TestInitialize]
        public void Init()
        {
            config = new Config(new StubManager());
        }

        [TestMethod]
        public void IsCheckTest()
        {
            Assert.IsTrue(config.IsCheck("str"));
        }

        [TestCleanup]
        public void Clean()
        {
            config = null;
        }
    }

 

使用模拟对象（适用于对象之间的交互）

当上面的方法返回false的时候，须要调用别的web服务记录下。而web服务还未开发好，即便开发好了，测试的时间也会变长不少。

这里其实也体现了，stub的优势，能够任意的控制返回结果。

 

新建一个mock

    public class Config
    {
        private IManager manager;
        public IWeb Web { get; set; }
        public Config(IManager manager)
        {
            this.manager = manager;
        }
        public bool IsCheck(string name)
        {
            var str = manager.GetConfig();
            var rst = str == name;
            if (!rst)
                Web.Log("错误");
            return rst;
        }
    }
    /// <summary>
    /// 模拟对象
    /// </summary>
    public class MockWeb : IWeb
    {
        public string Erro { get; set; }
        public void Log(string erro)
        {
            Erro = erro;
        }
    }

    public interface IWeb
    {
        void Log(string erro);
    }

 

测试代码

    [TestClass]
    public class WebTests
    {
        [TestMethod]
        public void LogTest()
        {
            var web = new MockWeb();
            //注入的方式很是多
            var config = new Config(new StubManager()) { Web = web };
            config.IsCheck("s");
            //最终断言的是模拟对象。
            Assert.AreEqual("错误", web.Erro);
        }
    }

 

 

注意：一个测试只有一个mock，其余伪对象都是stub，若是存在多个mock，说明这个单元测试是在测多个事情，这样会让测试变得复杂和脆弱。

 

 

使用隔离框架建立伪对象

 

隔离框架简介

手写stub和mock很是麻烦耗时，并且不易看懂等缺点。

隔离框架是能够方便的新建stub和mock的一组可编程API。

.net下常见的有Rhino Mocks，Moq

 

这里使用RhinoMocks作示例（将使用录制回放模式和操做断言2种）

 

录制回放

 

新建mock对象

来实现一个和上面mock的例子

        [TestMethod]
        public void LogMockTest()
        {
            var mocks = new MockRepository();
　　　　　　//严格模拟对象
            var mockWeb = mocks.StrictMock<IWeb>();
            using (mocks.Record())//录制预期行为
            {
                mockWeb.Log("错误");
            }
            var config = new Config(new StubManager()) { Web = mockWeb };
            config.IsCheck("s");
            mocks.Verify(mockWeb);
        }

 

严格模拟对象：是指只要出现预期行为之外的状况，就报错。

非严格模拟对象：是指执行到最后一行，才会报错。

 

新建stub对象

        [TestMethod]
        public void LogStubTest()
        {
            var mocks = new MockRepository();
            //非严格对象
            var mockWeb = mocks.DynamicMock<IWeb>();
            //桩对象
            var stubManager = mocks.Stub<IManager>();
            using (mocks.Record())
            {
                mockWeb.Log("错误1");
                stubManager.GetConfig();
                LastCall.Return("str1");            //录制桩对象返回值
            }
            var config = new Config(stubManager) { Web = mockWeb };
            config.IsCheck("str");
            mocks.Verify(stubManager);          //桩对象不会致使测试失败
            mocks.VerifyAll();                  //启用非严格对象，测试直到这里才会确认是否报错
        }

 

 操做断言

        [TestMethod]
        public void LogReplayTest()
        {
            var mocks = new MockRepository();
            var mockWeb = mocks.DynamicMock<IWeb>();
            var config = new Config(new StubManager()) { Web = mockWeb };
            //开始操做模式
            mocks.ReplayAll();
            config.IsCheck("str1");
            //使用Rhino Mocks断言
            mockWeb.AssertWasCalled(o => o.Log("错误"));
        }

　　

 

 

 

注意：使用框架建立的动态伪对象，确定没手工编写的伪对象执行效率高。

 

本文做者：Never、C

本文连接：http://www.cnblogs.com/neverc/p/4749197.html