Hi, I'm a blogger who loves Python. Today I want to talk about Python unit testing. To be honest, many developers have a natural resistance to testing. "Writing tests is too much trouble", "Test code is more than business code", "No time to write tests when rushing project deadlines"... Have you said these things before?

But do you know? According to the latest software engineering statistics, spending 20% of project time writing tests can reduce bug fixing time by 80% in later stages. A project with a comprehensive testing system has maintenance costs 40% lower than projects without tests. These numbers tell us that writing tests is really important.

Why Test

I remember when I first started writing Python, I always thought testing was optional. Until one time, I modified a core feature that caused the entire system to crash, and that's when I realized the importance of testing.

Have you encountered situations like this: made a tiny feature change, but accidentally affected other modules? Or when refactoring code, worried about breaking existing functionality? With comprehensive tests, these issues wouldn't trouble you.

Choosing a Framework

In the Python world, there are two mainstream testing frameworks: unittest and pytest. These two frameworks are like brushes of different styles, each with its own characteristics.

unittest is Python's built-in testing framework, with syntax borrowed from Java's JUnit, suitable for developers with Java backgrounds. pytest is the most popular third-party testing framework in the Python community, with more concise syntax and powerful features.

Let's look at a specific example. Suppose we want to test a simple calculator class:

import unittest

class TestCalculator(unittest.TestCase):
    def test_add(self):
        calc = Calculator()
        self.assertEqual(calc.add(3, 5), 8)


def test_add():
    calc = Calculator()
    assert calc.add(3, 5) == 8

See how much simpler pytest's syntax is? No need to inherit from TestCase class, just use assert statements directly. This is why I prefer using pytest.

Testing Techniques

When it comes to testing techniques, I think the most important thing is to master three principles: isolation, repeatability, and automation.

Isolation

Tests should be independent of each other, and the failure of one test case shouldn't affect others. This is where pytest's fixture functionality comes in handy:

import pytest

@pytest.fixture
def calculator():
    calc = Calculator()
    # Initialization work can be done here
    yield calc
    # Cleanup work can be done here

def test_add(calculator):
    assert calculator.add(3, 5) == 8

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

See, through fixtures, we can provide a new calculator object for each test case, so tests won't affect each other.

Repeatability

Test results should be stable, giving the same results no matter how many times they're run. This requires us to mock external dependencies in tests. For example, if our code needs to query a database:

from unittest.mock import Mock

def test_get_user():
    # Create a mock object to simulate the database
    mock_db = Mock()
    mock_db.query.return_value = {"name": "Zhang San", "age": 25}

    user_service = UserService(db=mock_db)
    user = user_service.get_user(1)

    assert user["name"] == "Zhang San"

Automation

The most important aspect of testing is automatic execution. I recommend using coverage.py to check test coverage:

coverage run -m pytest
coverage report

In my experience, test coverage should be above 80% to be considered passing. Of course, higher isn't always better - the key is covering core functionality and error-prone areas.

Practical Experience

In real projects, I've found that the hardest part isn't writing tests, but designing testable code. A good practice is following the "dependency injection" principle:

class UserService:
    def __init__(self):
        self.db = Database()  # Creating dependency directly


class UserService:
    def __init__(self, db):
        self.db = db  # Injecting dependency through parameters

Additionally, parameterized testing is a very practical technique:

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

This way you can test multiple scenarios at once, both saving code and improving test completeness.

Finally, I want to say that writing tests is actually an investment. Although it takes more time upfront, in the long run, this investment is very worthwhile. As a famous developer said: "Tests are like insurance - you might think you don't need them, but when you do, you'll be glad you have them."

What do you think? Feel free to share your testing insights and experiences in the comments.