前面介紹了單元測試的框架NUnit，它可以很好的幫助我們建立測試，檢驗我們的程式碼是否正確。但這還不夠，有時候我們的業務比較重，會依賴其它的類。基於隔離測試的原則，我們不希望依賴的其它類影響到我們的測試目標。這時候Mock就顯得十分重要了。當然還有其它因素使得我們必須Mock物件，比如配置檔案，DB等。

提供Mock技術的工具很多：Moq，NSubstitute，RhinoMocks，TypeMock，JustMock等。開源免費的工具功能侷限，像Moq，草根專欄 的部落格寫得很好。這裡我選擇JustMock，付費版本可以使用高階功能。

JustMock 開始

安裝 JustMock ，從官網下載，預設安裝。

新增 Telerik.JustMock.dll 引用，在安裝目錄下，預設為：C:\Program Files (x86)\Progress\Telerik JustMock\Libraries 。

開啟使用高階功能

為什麼需要Mock

先看我們需要測試的一個方法：

        /// <summary>
        /// 轉賬
        /// </summary>
        /// <param name="accountA"></param>
        /// <param name="accountB"></param>
        /// <param name="money"></param>
        /// <returns></returns>
        public double TransferAccounts(BankAccount accountA, BankAccount accountB, double money)
        {
            double transferLimit = 50000.0;//轉賬最高限制
            try
            {
                var balanceA = accountA.DrawMoney(money);
                accountB.SaveMoney(money);
                return balanceA;
            }
            catch (Exception ex)
            {
                throw new Exception($"轉賬失敗，{ex.Message}");
            }
        }
 

測試這個方法的邏輯，只需要下面這段程式碼就可以了：

        private BankAccount bankAccountA;
        private BankAccount bankAccountB;
        [SetUp]
        public void Setup()
        {
            bankAccountA = new BankAccount(1000);
            bankAccountB = new BankAccount(1000);
        }

        [Test]
        public void Transfer_Test()
        {
            IBankService bankService = new BankService();
            bankService.TransferAccounts(bankAccountA, bankAccountB, 500);
            Assert.AreEqual(500, bankAccountA.GetBalance());
            Assert.AreEqual(1500, bankAccountB.GetBalance());
        }
 

但，如果轉賬的邏輯變了，需要判斷是否超過當日限制，那麼使用者的轉賬總額就得從資料庫或者其它途徑獲得了，那麼可能程式碼變成這樣子：

        private readonly IBankLimitDao _bankLimitDao;//獲取限制條件的類

        public BankService(IBankLimitDao bankLimitDao)
        {
            _bankLimitDao = bankLimitDao;
        }

        /// <summary>
        /// 轉賬
        /// </summary>
        /// <param name="accountA"></param>
        /// <param name="accountB"></param>
        /// <param name="money"></param>
        /// <returns></returns>
        public double TransferAccounts(BankAccount accountA, BankAccount accountB, double money)
        {
            double transferLimit = 50000.0;//轉賬最高限制
            try
            {
                //判斷A是否能轉賬
                var total = _bankLimitDao.TotalTransferTotal(accountA.AccountId);//獲得限制金額
                if (total >= transferLimit)
                {
                    throw new Exception($"超過當日轉賬限額{transferLimit}");
                }
                var balanceA = accountA.DrawMoney(money);
                accountB.SaveMoney(money);
                return balanceA;
            }
            catch (Exception ex)
            {
                throw new Exception($"轉賬失敗，{ex.Message}");
            }
        }

這個時候再用真實物件來測試就有點麻煩了。根據隔離原則，我們不希望測試 TotalTransferTotal 方法裡的邏輯和它的正確性，它應該在其它地方測試。這時候Mock就顯得重要了，我們可以模擬這個物件，並且給它一個恰當的值，讓它“正確”執行。

所以，測試程式碼變成這樣子：

        [Test]
        public void Transfer_Test()
        {
            var bankLimit = Mock.Create<IBankLimitDao>();//模擬物件
            Mock.Arrange(() => bankLimit.TodalDrawTotal(Arg.IsAny<string>())).Returns(500);//設定一個返回值
            IBankService bankService = new BankService(bankLimit);
            bankService.TransferAccounts(bankAccountA, bankAccountB, 500);
            Mock.Assert(bankLimit);
            Assert.AreEqual(500, bankAccountA.GetBalance());
            Assert.AreEqual(1500, bankAccountB.GetBalance());
        }

AAA

什麼是AAA？Arrange、Act和Assert。AAA是單元測試中編寫程式碼的模式。

• Arrange：準備，設定需要測試的物件。
  
• Act：執行測試的實際程式碼。
  
• Assert：驗證結果。

一個簡單的例子：
這個例子包括建立模擬物件，標記為InOrder()，意為必須呼叫，執行方法，最後用Mock.Assert驗證。

public interface IFoo 
{ 
    void Submit(); 
    void Echo(); 
} 

[Test]
public void ShouldVerifyCallsOrder()
{
    // Arrange 模擬物件，並且設定條件
    var foo = Mock.Create<IFoo>();

    Mock.Arrange(() => foo.Submit()).InOrder();
    Mock.Arrange(() => foo.Echo()).InOrder();

    // Act 執行程式碼
    foo.Submit();
    foo.Echo();

    // Assert 驗證結果
    Mock.Assert(foo);
} 

編寫測試方法的時候儘量遵循AAA的模式編寫，可以讓測試程式碼更清晰可讀。

Mock Behaviors

JustMock 在Mock物件的時候有四種不同的行為可以選擇。

• RecursiveLoose Behavior
  預設的選項。模擬的物件不會出現null物件，遞迴呼叫也將建立一個預設的物件、預設值或者空值。
• Loose Behavior
  除了設定值，否則Loose建立的物件將是預設值。
• CallOriginal Behavior
  將會採用最初的模擬物件。
• Strict Behavior
  採用此行為，模擬物件必須設定值，否則會出現 MockException異常。

下面程式碼展示不同型別的結果：

        [Test]
        public void Test()
        {
            // Arrange 
            var rlFoo = Mock.Create<FooBase>(Behavior.RecursiveLoose);
            var lFoo = Mock.Create<FooBase>(Behavior.Loose);
            var coFoo = Mock.Create<FooBase>(Behavior.CallOriginal);
            var sFoo = Mock.Create<FooBase>(Behavior.Strict);

            Mock.Arrange(() => rlFoo.GetString("y")).Returns("z");
            Mock.Arrange(() => lFoo.GetString("y")).Returns("z");
            Mock.Arrange(() => coFoo.GetString("y")).Returns("z");
            Mock.Arrange(() => sFoo.GetString("y")).Returns("z");

            // Act 
            var rlactualX = rlFoo.GetString("x"); // 結果：""
            var rlactualY = rlFoo.GetString("y"); // 結果："z"

            var lactualX = lFoo.GetString("x"); // 結果：null
            var lactualY = lFoo.GetString("y"); // 結果："z"

            var coactualX = coFoo.GetString("x"); // 結果："x"
            var coactualY = coFoo.GetString("y"); // 結果："z"
            var coactualA = coFoo.GetString("a"); // 結果："a"

            //var sactualX = sFoo.GetString("x"); // 結果：出現異常
            var sactualY = sFoo.GetString("y"); // 結果："z"  

            var expectedX = "x";
            var expectedY = "z";

            // Assert 
            Assert.AreEqual(expectedX, rlactualX);
            Assert.AreEqual(expectedY, rlactualY);
        }

本篇到這，下篇再記錄一些其它用法。