單元測試的兩種方式

在單元測試中，可通過兩種方式來驗證代碼是否正確地工作。一種是基於結果狀態的測試，一種是基於交互行為的測試。

測試結果與測試行為之間有什么區別呢？

基於結果狀態的測試，也就意味着我們需要驗證被測試代碼需要返回正確的結果。

    [TestMethod]
    public void TestSortNumberResult()
    {
      IShellSorter<int> shellSorter = new ShellSorter<int>();
      IBubbleSorter<int> bubbleSorter = new BubbleSorter<int>();

      NumberSorter numberSorter = new NumberSorter(shellSorter, bubbleSorter);
      int[] numbers = new int[] { 3, 1, 2 };
      numberSorter.Sort(numbers);

      // 驗證返回值是否已經被正確排序。
      // 只要返回值正確即可，並不關心使用了哪個算法。
      CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, numbers);
    }

基於交互行為的測試，也就意味着我們需要驗證被測試代碼是否正確合理地調用了某些方法。

    [TestMethod]
    public void TestUseCorrectSortingAlgorithm()
    {
      IShellSorter<int> mockShellSorter = Substitute.For<IShellSorter<int>>();
      IBubbleSorter<int> mockBubbleSorter = Substitute.For<IBubbleSorter<int>>();

      NumberSorter numberSorter = new NumberSorter(mockShellSorter, mockBubbleSorter);
      int[] numbers = new int[] { 3, 1, 2 };
      numberSorter.Sort(numbers);

      // 驗證排序器是否使用冒泡排序算法。
      // 如果排序器未使用冒泡排序算法，或者使用了該算法但傳遞了錯誤的參數，則驗證失敗。
      mockBubbleSorter.Received().Sort(Arg.Is<int[]>(numbers));
    }

第二種測試方法可能會得出較好的代碼覆蓋率，但它卻沒有告訴我們排序結果是否正確，而只是確認調用了 bubbleSorter.Sort() 方法。所以交互行為測試並不能證明代碼可以正確工作。這也就是在大多數情況下，我們需要測試結果和狀態，而不是測試交互和行為。

通常來說，如果程序的正確性不能僅僅靠程序的輸出結果來決定，而還需要判斷結果是怎么產生的，在這種條件下，我們就需要對交互和行為進行測試。在上面的示例中，你可能想在得到正確測試結果的前提下，額外的再測試下交互行為，因為可能確認正確地使用了某種算法非常重要，例如某些算法在給定條件下運行速度更快，否則的話測試交互行為的意義並不大。

通常在什么條件下需要對交互行為進行測試呢？

這里給出兩種較適合的場景：

• 假設被測試代碼需要調用了一個方法，但可能由於其被調用的次數不同，或者被調用的順序不同，而導致產生了不同的結果，或者出現了其他類似時間延遲、多線程死鎖等副作用。例如該方法負責發送郵件，我們需要確認只調用了一次郵件發送函數。或者例如該方法的不同調用順序會產生不同的線程鎖控制，導致死鎖。在類似這些情況下，測試交互行為可以有效地幫助你確認方法調用是否正確。
• 假設我們在測試一個UI程序，其中已經通過抽象將UI渲染部分與UI邏輯部分隔離，可以考慮是某種MVC或MVVM模式。那么在我們測試 Controller 或 ViewModel 層時，如果有的話，可能只關心 View 上的哪些方法被調用了，而並不關系具體該方法內部是如何渲染的，所以此處測試與 View 的交互就比較合適。類似的，對於 Model 層也一樣。

完整代碼

  [TestClass]
  public class UnitTestTwoWays
  {
    public interface IShellSorter<T> 
      where T : IComparable
    {
      void Sort(T[] list);
    }

    public interface IBubbleSorter<T> 
      where T : IComparable
    {
      void Sort(T[] list);
    }

    public class ShellSorter<T> : IShellSorter<T> 
      where T : IComparable
    {
      public void Sort(T[] list)
      {
        int inc;

        for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;

        for (; inc > 0; inc /= 3)
        {
          for (int i = inc + 1; i <= list.Length; i += inc)
          {
            T t = list[i - 1];
            int j = i;

            while ((j > inc) && (list[j - inc - 1].CompareTo(t) > 0))
            {
              list[j - 1] = list[j - inc - 1];
              j -= inc;
            }

            list[j - 1] = t;
          }
        }
      }
    }

    public class BubbleSorter<T> : IBubbleSorter<T> 
      where T : IComparable
    {
      public void Sort(T[] list)
      {
        int i, j;
        bool done = false;

        j = 1;
        while ((j < list.Length) && (!done))
        {
          done = true;

          for (i = 0; i < list.Length - j; i++)
          {
            if (list[i].CompareTo(list[i + 1]) > 0)
            {
              done = false;
              T t = list[i];
              list[i] = list[i + 1];
              list[i + 1] = t;
            }
          }

          j++;
        }
      }
    }

    public interface INumberSorter
    {
      void Sort(int[] numbers);
    }

    public class NumberSorter : INumberSorter
    {
      private IShellSorter<int> _shellSorter;
      private IBubbleSorter<int> _bubbleSorter;

      public NumberSorter(
        IShellSorter<int> shellSorter, 
        IBubbleSorter<int> bubbleSorter)
      {
        _shellSorter = shellSorter;
        _bubbleSorter = bubbleSorter;
      }

      public void Sort(int[] numbers)
      {
        _bubbleSorter.Sort(numbers);
      }
    }

    [TestMethod]
    public void TestSortNumberResult()
    {
      IShellSorter<int> shellSorter = new ShellSorter<int>();
      IBubbleSorter<int> bubbleSorter = new BubbleSorter<int>();

      NumberSorter numberSorter = new NumberSorter(shellSorter, bubbleSorter);
      int[] numbers = new int[] { 3, 1, 2 };
      numberSorter.Sort(numbers);

      // 驗證返回值是否已經被正確排序。
      // 只要返回值正確即可，並不關心使用了哪個算法。
      CollectionAssert.AreEqual(new int[] { 1, 2, 3 }, numbers);
    }

    [TestMethod]
    public void TestUseCorrectSortingAlgorithm()
    {
      IShellSorter<int> mockShellSorter = Substitute.For<IShellSorter<int>>();
      IBubbleSorter<int> mockBubbleSorter = Substitute.For<IBubbleSorter<int>>();

      NumberSorter numberSorter = new NumberSorter(mockShellSorter, mockBubbleSorter);
      int[] numbers = new int[] { 3, 1, 2 };
      numberSorter.Sort(numbers);

      // 驗證排序器是否使用冒泡排序算法。
      // 如果排序器未使用冒泡排序算法，或者使用了該算法但傳遞了錯誤的參數，則驗證失敗。
      mockBubbleSorter.Received().Sort(Arg.Is<int[]>(numbers));
    }
  }

關於單元測試 mocking 技術，請參考《NSubstitute完全手冊》。