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

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