Python单元测试（pycharm单元测试）

off999 2025-07-28 19:38 35 浏览 0 评论

1. 单元测试概述

1.1 什么是单元测试

单元测试(Unit Testing)是指对软件中的最小可测试单元进行检查和验证的过程。在Python中，最小单元通常指函数、方法或类。

1.2 单元测试的特性

独立性：每个测试用例应该独立运行，不依赖其他测试
自动化：测试应该能够自动执行和验证
快速性：测试执行速度要快
可重复性：测试结果应该稳定可重复
及时性：测试应该在代码编写的同时或之后立即编写

1.3 单元测试的应用场景举例

场景	说明
开发阶段	确保每个单元功能正确
重构代码	保证重构不引入新错误
持续集成	作为CI/CD流程的一部分
文档补充	作为代码功能的活文档

2. Python单元测试框架

2.1 unittest模块

Python内置的单元测试框架，基于JUnit设计。

2.1.1 基本结构

import unittest

class TestStringMethods(unittest.TestCase):
    
    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')
    
    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

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

2.1.2 常用断言方法

表1 unittest常用断言方法

方法	说明
assertEqual(a, b)	a == b
assertNotEqual(a, b)	a != b
assertTrue(x)	bool(x) is True
assertFalse(x)	bool(x) is False
assertIs(a, b)	a is b
assertIsNot(a, b)	a is not b
assertIsNone(x)	x is None
assertIsNotNone(x)	x is not None
assertIn(a, b)	a in b
assertNotIn(a, b)	a not in b
assertRaises(exc, fun, args, *kwargs)	fun(args, *kwargs) raises exc

2.1.3 测试固件(Test Fixtures)

class TestDatabase(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        # 整个测试类执行前运行一次
        cls.db = connect_to_database()
    
    def setUp(self):
        # 每个测试方法执行前运行
        self.cursor = self.db.cursor()
    
    def test_query(self):
        self.cursor.execute("SELECT 1")
        result = self.cursor.fetchone()
        self.assertEqual(result, (1,))
    
    def tearDown(self):
        # 每个测试方法执行后运行
        self.cursor.close()
    
    @classmethod
    def tearDownClass(cls):
        # 整个测试类执行后运行一次
        cls.db.close()

2.2 pytest框架

第三方测试框架，比unittest更简洁强大。

2.2.1 安装与基本使用

pip install pytest

# test_sample.py
def func(x):
    return x + 1

def test_answer():
    assert func(3) == 4

运行测试：

pytest test_sample.py

2.2.2 pytest特性

自动发现：自动发现以test_开头的文件和函数
丰富的断言：直接使用assert语句
fixture系统：更灵活的测试固件
参数化测试：轻松实现多组数据测试
插件系统：丰富的插件生态

2.2.3 pytest fixture

import pytest

@pytest.fixture
def db_connection():
    conn = connect_to_database()
    yield conn  # 测试执行时返回连接
    conn.close()  # 测试完成后清理

def test_query(db_connection):
    cursor = db_connection.cursor()
    cursor.execute("SELECT 1")
    result = cursor.fetchone()
    assert result == (1,)

2.2.4 参数化测试

import pytest

@pytest.mark.parametrize("input,expected", [
    (3, 4),
    (5, 6),
    (-1, 0),
])
def test_increment(input, expected):
    assert input + 1 == expected

3. 单元测试实践

3.1 测试编写原则

FIRST原则：
Fast(快速)
Independent(独立)
Repeatable(可重复)
Self-Validating(自我验证)
Timely(及时)
AAA模式：
Arrange(准备测试环境)
Act(执行被测代码)
Assert(验证结果)

3.2 测试覆盖率

使用coverage.py测量测试覆盖率：

pip install coverage
coverage run -m pytest
coverage report -m

表2 覆盖率指标

指标	说明
语句覆盖率	测试执行的代码行比例
分支覆盖率	测试执行的分支路径比例
条件覆盖率	测试执行的布尔子表达式比例
函数覆盖率	测试调用的函数比例

3.3 测试替身(Test Doubles)

Dummy：仅用于填充参数，不参与实际逻辑
Fake：简化功能的实现，如内存数据库
Stub：提供预设的固定响应
Mock：记录调用信息并验证行为
Spy：记录调用信息，但执行真实逻辑

3.3.1 unittest.mock模块

from unittest.mock import Mock, patch

def test_mocking():
    # 创建mock对象
    mock = Mock()
    mock.method.return_value = 42
    
    # 使用mock
    assert mock.method() == 42
    mock.method.assert_called_once()
    
    # 上下文管理器方式mock
    with patch('module.function') as mock_func:
        mock_func.return_value = 'mocked'
        result = module.function()
        assert result == 'mocked'

4. 实战举例

4.1 测试一个简单的计算器类

# calculator.py
class Calculator:
    """简单的计算器类"""
    
    def add(self, a, b):
        """加法"""
        return a + b
    
    def subtract(self, a, b):
        """减法"""
        return a - b
    
    def multiply(self, a, b):
        """乘法"""
        return a * b
    
    def divide(self, a, b):
        """除法"""
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

4.1.1 使用unittest测试

# test_calculator_unittest.py
import unittest
from calculator import Calculator

class TestCalculator(unittest.TestCase):
    
    def setUp(self):
        self.calc = Calculator()
    
    def test_add(self):
        self.assertEqual(self.calc.add(2, 3), 5)
        self.assertEqual(self.calc.add(-1, 1), 0)
    
    def test_subtract(self):
        self.assertEqual(self.calc.subtract(5, 3), 2)
    
    def test_multiply(self):
        self.assertEqual(self.calc.multiply(3, 4), 12)
    
    def test_divide(self):
        self.assertEqual(self.calc.divide(6, 3), 2)
        with self.assertRaises(ValueError):
            self.calc.divide(6, 0)

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

4.1.2 使用pytest测试

# test_calculator_pytest.py
import pytest
from calculator import Calculator

@pytest.fixture
def calculator():
    return Calculator()

def test_add(calculator):
    assert calculator.add(2, 3) == 5
    assert calculator.add(-1, 1) == 0

def test_subtract(calculator):
    assert calculator.subtract(5, 3) == 2

def test_multiply(calculator):
    assert calculator.multiply(3, 4) == 12

def test_divide(calculator):
    assert calculator.divide(6, 3) == 2
    with pytest.raises(ValueError):
        calculator.divide(6, 0)

4.2 测试一个Flask Web应用

# app.py
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/add/<int:a>/<int:b>')
def add(a, b):
    return jsonify({'result': a + b})

@app.route('/api/subtract/<int:a>/<int:b>')
def subtract(a, b):
    return jsonify({'result': a - b})

4.2.1 使用pytest测试Flask应用

# test_app.py
import pytest
from app import app

@pytest.fixture
def client():
    app.config['TESTING'] = True
    with app.test_client() as client:
        yield client

def test_add(client):
    response = client.get('/api/add/2/3')
    assert response.status_code == 200
    assert response.json == {'result': 5}

def test_subtract(client):
    response = client.get('/api/subtract/5/3')
    assert response.status_code == 200
    assert response.json == {'result': 2}

5. 进阶主题

5.1 参数化测试进阶

import pytest
from calculator import Calculator

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add_parametrized(a, b, expected):
    calc = Calculator()
    assert calc.add(a, b) == expected

5.2 测试标记与筛选

@pytest.mark.slow
def test_slow_operation():
    import time
    time.sleep(2)
    assert True

@pytest.mark.skip(reason="Not implemented yet")
def test_unimplemented():
    assert False

@pytest.mark.xfail
def test_expected_failure():
    assert False

运行指定标记的测试：

pytest -m slow

5.3 测试数据库应用

# test_db.py
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

@pytest.fixture(scope="module")
def db_engine():
    engine = create_engine("sqlite:///:memory:")
    yield engine
    engine.dispose()

@pytest.fixture
def db_session(db_engine):
    connection = db_engine.connect()
    transaction = connection.begin()
    session = sessionmaker(bind=connection)()
    
    yield session
    
    session.close()
    transaction.rollback()
    connection.close()

def test_user_model(db_session):
    from models import User
    user = User(name="Test User")
    db_session.add(user)
    db_session.commit()
    
    fetched = db_session.query(User).first()
    assert fetched.name == "Test User"