Python單元測試模擬與覆寫率技術實踐

– 6 分鐘閱讀

在 Python 開發中，撰寫單元測試對於確保程式碼品質至關重要。unittest.mock 模組提供強大的模擬功能，讓開發者能隔離外部依賴，專注測試單元本身的邏輯。文章首先介紹 unittest.mock 的基本用法，包含模擬傳回值、模擬異常以及模擬複雜行為。接著，文章深入探討如何使用 @patch 和 @patch.object 隔離同步依賴，以及使用 AsyncMock 隔離非同步依賴，確保測試案例的穩定性與可靠性。此外，文章也強調了測試覆寫率的重要性，說明如何使用 coverage.py 統計測試覆寫率，並結合持續整合工具，例如 GitHub Actions，自動化執行測試與覆寫率分析，及早發現程式碼缺陷。最後，文章介紹了 Python 內建的 pdb 除錯器，讓開發者能逐步執行程式碼、檢視變數狀態，有效提升除錯效率。

基本概念

模擬是一種技術，用於在測試中替換依賴項，以便我們可以控制其行為並確保測試的可靠性。在 Python 中，我們可以使用unittest.mock模組來實作模擬。

範例 1：模擬資料函式庫查詢

import unittest
from unittest.mock import patch

def process_data(query):
    # 這裡模擬資料函式庫查詢
    return 42

class TestDataProcessor(unittest.TestCase):
    @patch('my_module.database_query')
    def test_process_data(self, mock_db_query):
        mock_db_query.return_value = 42
        value = process_data("SELECT * FROM data")
        self.assertEqual(value, 42)
        mock_db_query.assert_called_once_with("SELECT * FROM data")

if __name__ == '__main__':
    unittest.main()

在這個範例中，我們使用@patch裝飾器來模擬database_query函式。這樣，我們就可以控制其傳回值和呼叫次數。

範例 2：模擬異常情況

import unittest
from unittest.mock import patch

def process_data(query):
    # 這裡模擬資料函式庫查詢
    raise Exception("DB failure")

class TestDataProcessor(unittest.TestCase):
    @patch('my_module.database_query', side_effect=Exception("DB failure"))
    def test_process_data_failure(self, mock_db_query):
        with self.assertRaises(Exception) as context:
            process_data("SELECT * FROM data")
        self.assertEqual(str(context.exception), "DB failure")

if __name__ == '__main__':
    unittest.main()

在這個範例中，我們使用side_effect引數來模擬異常情況。這樣，我們就可以測試被測試的單元在異常情況下的行為。

範例 3：模擬複雜行為

import unittest
from unittest.mock import patch

def calculate_discounted_price(price, discount):
    factor = get_discount_factor()
    return price * factor

def get_discount_factor():
    # 這裡模擬遠端定價服務
    pass

class TestDiscountedPrice(unittest.TestCase):
    def test_calculate_discounted_price(self):
        def discount_factor_side_effect():
            return 0.8
        with patch('my_module.get_discount_factor', side_effect=discount_factor_side_effect):
            final_price = calculate_discounted_price(100, 10)
            self.assertEqual(final_price, 80)

if __name__ == '__main__':
    unittest.main()

在這個範例中，我們使用side_effect引數來模擬複雜行為。這樣，我們就可以測試被測試的單元在不同情況下的行為。

高階測試技術：隔離依賴關係和非同步操作

在單元測試中，隔離依賴關係是一個至關重要的概念。透過隔離依賴關係，可以確保測試的可靠性和穩定性。Python 的 unittest.mock 模組提供了一種強大的方式來隔離依賴關係。

隔離同步依賴關係

下面的例子展示瞭如何使用 @patch.object 來隔離同步依賴關係：

import unittest
from unittest.mock import patch

class DataProcessor:
    def process(self, data):
        processed = self._preprocess(data)
        return self._calculate(processed)

    def _preprocess(self, data):
        # Complex logic to clean and segment data.
        return data.strip()

    def _calculate(self, data):
        # More intricate calculations.
        return len(data)

class TestDataProcessor(unittest.TestCase):
    @patch.object(DataProcessor, '_preprocess', return_value='cleaned data')
    @patch.object(DataProcessor, '_calculate', return_value=42)
    def test_process(self, mock_calculate, mock_preprocess):
        processor = DataProcessor()
        result = processor.process(" raw data ")
        self.assertEqual(result, 42)
        mock_preprocess.assert_called_once_with(" raw data ")
        mock_calculate.assert_called_once_with('cleaned data')

if __name__ == '__main__':
    unittest.main()

在這個例子中，內部方法 _preprocess 和 _calculate 被模擬以隔離邏輯在 process 方法中。這使得測試可以驗證內部呼叫的順序，與實際實作無關。

隔離非同步依賴關係

當依賴關係涉及非同步呼叫時，模擬會稍微複雜一些。Python 的 AsyncMock（在 Python 3.8 及後版本中可用）旨在模擬非同步行為。這個物件支援非同步迭代和等待原始語法，使開發人員可以無縫地替換非同步依賴關係：

import unittest
from unittest.mock import patch, AsyncMock

import asyncio

async def async_fetch_data(url):
    # Simulate an asynchronous network call.
    pass

async def process_async_data(url):
    data = await async_fetch_data(url)
    return data['key']

class TestAsyncDataProcessing(unittest.IsolatedAsyncioTestCase):
    async def test_process_async_data(self):
        # 使用 AsyncMock 來模擬非同步依賴關係
        with patch('async_fetch_data', new=AsyncMock(return_value={'key': 'value'})):
            result = await process_async_data('https://example.com')
            self.assertEqual(result, 'value')

在這個例子中，async_fetch_data 函式被模擬以隔離非同步邏輯在 process_async_data 函式中。這使得測試可以驗證非同步呼叫的順序，與實際實作無關。

測試覆寫率和持續整合

確保軟體品質需要系統地測量測試覆寫率並將自動化測試整合到持續整合（CI）工作流程中。對於高階開發人員，挑戰不僅在於執行測試，而是實施全面性的策略來監控覆寫率指標，找出未經測試的程式碼路徑，並強制執行最低門檻以防止迴歸。

測試覆寫率測量

測試覆寫率的測量是一種關鍵的實踐，用於找出程式碼函式庫中未被測試的部分。像 coverage.py 這樣的工具提供了詳細的報告，既有終端輸出，也有 HTML 格式，突出了漏掉的行、分支，甚至是測試執行期間未評估的條件邏輯。高階使用者通常將這些工具整合到測試例行程式中，以強制執行覆寫率門檻。這強制實施了測試書寫中的紀律，並防止了程式碼驗證的逐漸衰退。

組態和報告

高階組態需要測試報告包含分支覆寫率指標，這對於確保複雜邏輯得到充分鍛煉至關重要。一個典型的組態可能使用 pytest 和 coverage.py 的命令列選項。以下命令執行測試套件並在覆寫率審查下產生一個 HTML 報告：

pytest --maxfail=1 --disable-warnings -q
coverage run -m pytest
coverage report -m --fail-under=90

持續整合工作流程

持續整合工作流程設計用於提供快速反饋和強制執行品質門檻。透過將測試覆寫率工具和 CI 工具（如 Jenkins、Travis CI 或 GitHub Actions）整合起來，開發人員可以確保其軟體系統隨著時間的推移保持可維護性和可擴充套件性。

高階測試覆寫率與除錯技術

在軟體開發中，測試覆寫率是評估程式碼品質的重要指標。透過將測試覆寫率整合到持續整合（CI）管道中，開發團隊可以確保每次構建都符合預定的品質門檻。在本文中，我們將探討如何使用 Python 和相關工具來實作高階測試覆寫率和除錯技術。

測試覆寫率與持續整合

測試覆寫率是指程式碼中被測試的部分佔總程式碼的比例。透過設定一個最低的測試覆寫率門檻，開發團隊可以確保每次提交的程式碼都符合一定的品質標準。例如，使用coverage工具可以設定一個最低的測試覆寫率門檻，如果測試覆寫率低於這個門檻，則會觸發一個錯誤。

# 設定最低測試覆寫率門檻
coverage run -m pytest --fail-under=90

使用 GitHub Actions 實作持續整合

GitHub Actions 是一種流行的持續整合工具，可以用於自動化測試、構建和佈署程式碼。以下是一個使用 GitHub Actions 實作持續整合的範例：

name: CI Pipeline
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: "3.9"
      - name: Install Dependencies
        run: |
          python -m pip install --upgrade pip
          pip install pytest coverage
      - name: Run Tests with Coverage
        run: |
          coverage run -m pytest
          coverage report -m --fail-under=90
      - name: Upload Coverage Report
        uses: actions/upload-artifact@v2
        with:
          name: coverage-report
          path: htmlcov

高階除錯技術

除了測試覆寫率外，除錯技術也是軟體開發中的一個重要方面。Python 提供了多種除錯工具，包括pdb模組和日誌框架。以下是一個使用pdb模組進行除錯的範例：

import pdb

def compute_stats(data):
    # 故意複雜的邏輯用於統計措施
    pdb.set_trace()
    #...

透過使用pdb模組，開發人員可以逐步執行程式碼，檢查執行時狀態，並找到缺陷的根源。

使用 Python 的 pdb 模組進行互動式除錯

在 Python 中，pdb模組是一種強大的互動式除錯工具。它允許開發者在程式執行過程中設定斷點，檢視變數的值，單步執行程式，甚至可以對變數進行修改。以下是使用pdb模組的範例：

import pdb

def compute_stats(data):
    total = sum(data)
    count = len(data)

    # 設定斷點
    pdb.set_trace()

    average = total / count
    variance = sum((x - average) ** 2 for x in data) / count
    return average, variance

if __name__ == '__main__':
    dataset = [10, 20, 30, 40, 50]
    stats = compute_stats(dataset)
    print("Average and Variance:", stats)

當程式執行到pdb.set_trace()時，會進入互動式除錯模式。這時可以使用pdb的各種命令來除錯程式，例如：

  • n(ext): 執行下一行程式碼
  • s(tep): 進入函式
  • c(ontinue): 繼續執行程式碼直到下一個斷點
  • b(reak): 設定斷點
  • p expression: 評估表示式並印出結果
  • q(uit): 結束除錯會話

從效能最佳化視角來看，Python 的 unittest.mock 模組為隔離依賴關係、模擬複雜行為以及提升測試效率提供了強大的工具。透過模擬資料函式庫查詢、網路請求或其他外部服務，開發者得以專注於測試單元本身的邏輯，而無需擔心外部因素的幹擾。深度分析 @patch、side_effect 和 AsyncMock 等功能的運用，可以發現 unittest.mock 不僅簡化了測試流程，更提升了測試的可靠性和速度，尤其在處理非同步操作和複雜依賴關係時更顯優勢。然而，過度使用模擬也可能掩蓋真實的整合問題。因此，除了單元測試外，整合測試仍然是不可或缺的環節。展望未來，隨著 Python 生態系統的持續發展，預計 unittest.mock 將持續演進，提供更豐富的功能和更便捷的使用體驗，進一步強化 Python 在測試驅動開發領域的優勢。對於追求程式碼品質和開發效率的團隊而言，深入理解和靈活運用 unittest.mock 模組將是提升軟體工程實踐的關鍵策略。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。