.net core 單元測試之 JustMock第一篇

前面介紹了單元測試的框架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);
        }

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