python-testing

仓库: affaan-m/everything-claude-code
安装量: 1.4K
排名: #1045

安装

npx skills add https://github.com/affaan-m/everything-claude-code --skill python-testing
Python Testing Patterns
Comprehensive testing strategies for Python applications using pytest, TDD methodology, and best practices.
When to Activate
Writing new Python code (follow TDD: red, green, refactor)
Designing test suites for Python projects
Reviewing Python test coverage
Setting up testing infrastructure
Core Testing Philosophy
Test-Driven Development (TDD)
Always follow the TDD cycle:
RED
Write a failing test for the desired behavior
GREEN
Write minimal code to make the test pass
REFACTOR
Improve code while keeping tests green

Step 1: Write failing test (RED)

def test_add_numbers ( ) : result = add ( 2 , 3 ) assert result == 5

Step 2: Write minimal implementation (GREEN)

def add ( a , b ) : return a + b

Step 3: Refactor if needed (REFACTOR)

Coverage Requirements
Target
80%+ code coverage
Critical paths
100% coverage required Use pytest --cov to measure coverage pytest --cov = mypackage --cov-report = term-missing --cov-report = html pytest Fundamentals Basic Test Structure import pytest def test_addition ( ) : """Test basic addition.""" assert 2 + 2 == 4 def test_string_uppercase ( ) : """Test string uppercasing.""" text = "hello" assert text . upper ( ) == "HELLO" def test_list_append ( ) : """Test list append.""" items = [ 1 , 2 , 3 ] items . append ( 4 ) assert 4 in items assert len ( items ) == 4 Assertions

Equality

assert result == expected

Inequality

assert result != unexpected

Truthiness

assert result

Truthy

assert not result

Falsy

assert result is True

Exactly True

assert result is False

Exactly False

assert result is None

Exactly None

Membership

assert item in collection assert item not in collection

Comparisons

assert result

0 assert 0 <= result <= 100

Type checking

assert isinstance ( result , str )

Exception testing (preferred approach)

with pytest . raises ( ValueError ) : raise ValueError ( "error message" )

Check exception message

with pytest . raises ( ValueError , match = "invalid input" ) : raise ValueError ( "invalid input provided" )

Check exception attributes

with pytest . raises ( ValueError ) as exc_info : raise ValueError ( "error message" ) assert str ( exc_info . value ) == "error message" Fixtures Basic Fixture Usage import pytest @pytest . fixture def sample_data ( ) : """Fixture providing sample data.""" return { "name" : "Alice" , "age" : 30 } def test_sample_data ( sample_data ) : """Test using the fixture.""" assert sample_data [ "name" ] == "Alice" assert sample_data [ "age" ] == 30 Fixture with Setup/Teardown @pytest . fixture def database ( ) : """Fixture with setup and teardown."""

Setup

db

Database ( ":memory:" ) db . create_tables ( ) db . insert_test_data ( ) yield db

Provide to test

Teardown

db . close ( ) def test_database_query ( database ) : """Test database operations.""" result = database . query ( "SELECT * FROM users" ) assert len ( result )

0 Fixture Scopes

Function scope (default) - runs for each test

@pytest . fixture def temp_file ( ) : with open ( "temp.txt" , "w" ) as f : yield f os . remove ( "temp.txt" )

Module scope - runs once per module

@pytest . fixture ( scope = "module" ) def module_db ( ) : db = Database ( ":memory:" ) db . create_tables ( ) yield db db . close ( )

Session scope - runs once per test session

@pytest . fixture ( scope = "session" ) def shared_resource ( ) : resource = ExpensiveResource ( ) yield resource resource . cleanup ( ) Fixture with Parameters @pytest . fixture ( params = [ 1 , 2 , 3 ] ) def number ( request ) : """Parameterized fixture.""" return request . param def test_numbers ( number ) : """Test runs 3 times, once for each parameter.""" assert number

0 Using Multiple Fixtures @pytest . fixture def user ( ) : return User ( id = 1 , name = "Alice" ) @pytest . fixture def admin ( ) : return User ( id = 2 , name = "Admin" , role = "admin" ) def test_user_admin_interaction ( user , admin ) : """Test using multiple fixtures.""" assert admin . can_manage ( user ) Autouse Fixtures @pytest . fixture ( autouse = True ) def reset_config ( ) : """Automatically runs before every test.""" Config . reset ( ) yield Config . cleanup ( ) def test_without_fixture_call ( ) :

reset_config runs automatically

assert Config . get_setting ( "debug" ) is False Conftest.py for Shared Fixtures

tests/conftest.py

import pytest @pytest . fixture def client ( ) : """Shared fixture for all tests.""" app = create_app ( testing = True ) with app . test_client ( ) as client : yield client @pytest . fixture def auth_headers ( client ) : """Generate auth headers for API testing.""" response = client . post ( "/api/login" , json = { "username" : "test" , "password" : "test" } ) token = response . json [ "token" ] return { "Authorization" : f"Bearer { token } " } Parametrization Basic Parametrization @pytest . mark . parametrize ( "input,expected" , [ ( "hello" , "HELLO" ) , ( "world" , "WORLD" ) , ( "PyThOn" , "PYTHON" ) , ] ) def test_uppercase ( input , expected ) : """Test runs 3 times with different inputs.""" assert input . upper ( ) == expected Multiple Parameters @pytest . mark . parametrize ( "a,b,expected" , [ ( 2 , 3 , 5 ) , ( 0 , 0 , 0 ) , ( - 1 , 1 , 0 ) , ( 100 , 200 , 300 ) , ] ) def test_add ( a , b , expected ) : """Test addition with multiple inputs.""" assert add ( a , b ) == expected Parametrize with IDs @pytest . mark . parametrize ( "input,expected" , [ ( "valid@email.com" , True ) , ( "invalid" , False ) , ( "@no-domain.com" , False ) , ] , ids = [ "valid-email" , "missing-at" , "missing-domain" ] ) def test_email_validation ( input , expected ) : """Test email validation with readable test IDs.""" assert is_valid_email ( input ) is expected Parametrized Fixtures @pytest . fixture ( params = [ "sqlite" , "postgresql" , "mysql" ] ) def db ( request ) : """Test against multiple database backends.""" if request . param == "sqlite" : return Database ( ":memory:" ) elif request . param == "postgresql" : return Database ( "postgresql://localhost/test" ) elif request . param == "mysql" : return Database ( "mysql://localhost/test" ) def test_database_operations ( db ) : """Test runs 3 times, once for each database.""" result = db . query ( "SELECT 1" ) assert result is not None Markers and Test Selection Custom Markers

Mark slow tests

@pytest . mark . slow def test_slow_operation ( ) : time . sleep ( 5 )

Mark integration tests

@pytest . mark . integration def test_api_integration ( ) : response = requests . get ( "https://api.example.com" ) assert response . status_code == 200

Mark unit tests

@pytest . mark . unit def test_unit_logic ( ) : assert calculate ( 2 , 3 ) == 5 Run Specific Tests

Run only fast tests

pytest -m "not slow"

Run only integration tests

pytest -m integration

Run integration or slow tests

pytest -m "integration or slow"

Run tests marked as unit but not slow

pytest -m "unit and not slow" Configure Markers in pytest.ini [ pytest ] markers = slow: marks tests as slow integration: marks tests as integration tests unit: marks tests as unit tests django: marks tests as requiring Django Mocking and Patching Mocking Functions from unittest . mock import patch , Mock @patch ( "mypackage.external_api_call" ) def test_with_mock ( api_call_mock ) : """Test with mocked external API.""" api_call_mock . return_value = { "status" : "success" } result = my_function ( ) api_call_mock . assert_called_once ( ) assert result [ "status" ] == "success" Mocking Return Values @patch ( "mypackage.Database.connect" ) def test_database_connection ( connect_mock ) : """Test with mocked database connection.""" connect_mock . return_value = MockConnection ( ) db = Database ( ) db . connect ( ) connect_mock . assert_called_once_with ( "localhost" ) Mocking Exceptions @patch ( "mypackage.api_call" ) def test_api_error_handling ( api_call_mock ) : """Test error handling with mocked exception.""" api_call_mock . side_effect = ConnectionError ( "Network error" ) with pytest . raises ( ConnectionError ) : api_call ( ) api_call_mock . assert_called_once ( ) Mocking Context Managers @patch ( "builtins.open" , new_callable = mock_open ) def test_file_reading ( mock_file ) : """Test file reading with mocked open.""" mock_file . return_value . read . return_value = "file content" result = read_file ( "test.txt" ) mock_file . assert_called_once_with ( "test.txt" , "r" ) assert result == "file content" Using Autospec @patch ( "mypackage.DBConnection" , autospec = True ) def test_autospec ( db_mock ) : """Test with autospec to catch API misuse.""" db = db_mock . return_value db . query ( "SELECT * FROM users" )

This would fail if DBConnection doesn't have query method

db_mock . assert_called_once ( ) Mock Class Instances class TestUserService : @patch ( "mypackage.UserRepository" ) def test_create_user ( self , repo_mock ) : """Test user creation with mocked repository.""" repo_mock . return_value . save . return_value = User ( id = 1 , name = "Alice" ) service = UserService ( repo_mock . return_value ) user = service . create_user ( name = "Alice" ) assert user . name == "Alice" repo_mock . return_value . save . assert_called_once ( ) Mock Property @pytest . fixture def mock_config ( ) : """Create a mock with a property.""" config = Mock ( ) type ( config ) . debug = PropertyMock ( return_value = True ) type ( config ) . api_key = PropertyMock ( return_value = "test-key" ) return config def test_with_mock_config ( mock_config ) : """Test with mocked config properties.""" assert mock_config . debug is True assert mock_config . api_key == "test-key" Testing Async Code Async Tests with pytest-asyncio import pytest @pytest . mark . asyncio async def test_async_function ( ) : """Test async function.""" result = await async_add ( 2 , 3 ) assert result == 5 @pytest . mark . asyncio async def test_async_with_fixture ( async_client ) : """Test async with async fixture.""" response = await async_client . get ( "/api/users" ) assert response . status_code == 200 Async Fixture @pytest . fixture async def async_client ( ) : """Async fixture providing async test client.""" app = create_app ( ) async with app . test_client ( ) as client : yield client @pytest . mark . asyncio async def test_api_endpoint ( async_client ) : """Test using async fixture.""" response = await async_client . get ( "/api/data" ) assert response . status_code == 200 Mocking Async Functions @pytest . mark . asyncio @patch ( "mypackage.async_api_call" ) async def test_async_mock ( api_call_mock ) : """Test async function with mock.""" api_call_mock . return_value = { "status" : "ok" } result = await my_async_function ( ) api_call_mock . assert_awaited_once ( ) assert result [ "status" ] == "ok" Testing Exceptions Testing Expected Exceptions def test_divide_by_zero ( ) : """Test that dividing by zero raises ZeroDivisionError.""" with pytest . raises ( ZeroDivisionError ) : divide ( 10 , 0 ) def test_custom_exception ( ) : """Test custom exception with message.""" with pytest . raises ( ValueError , match = "invalid input" ) : validate_input ( "invalid" ) Testing Exception Attributes def test_exception_with_details ( ) : """Test exception with custom attributes.""" with pytest . raises ( CustomError ) as exc_info : raise CustomError ( "error" , code = 400 ) assert exc_info . value . code == 400 assert "error" in str ( exc_info . value ) Testing Side Effects Testing File Operations import tempfile import os def test_file_processing ( ) : """Test file processing with temp file.""" with tempfile . NamedTemporaryFile ( mode = 'w' , delete = False , suffix = '.txt' ) as f : f . write ( "test content" ) temp_path = f . name try : result = process_file ( temp_path ) assert result == "processed: test content" finally : os . unlink ( temp_path ) Testing with pytest's tmp_path Fixture def test_with_tmp_path ( tmp_path ) : """Test using pytest's built-in temp path fixture.""" test_file = tmp_path / "test.txt" test_file . write_text ( "hello world" ) result = process_file ( str ( test_file ) ) assert result == "hello world"

tmp_path automatically cleaned up

Testing with tmpdir Fixture
def
test_with_tmpdir
(
tmpdir
)
:
"""Test using pytest's tmpdir fixture."""
test_file
=
tmpdir
.
join
(
"test.txt"
)
test_file
.
write
(
"data"
)
result
=
process_file
(
str
(
test_file
)
)
assert
result
==
"data"
Test Organization
Directory Structure
tests/
├── conftest.py # Shared fixtures
├── init.py
├── unit/ # Unit tests
│ ├── init.py
│ ├── test_models.py
│ ├── test_utils.py
│ └── test_services.py
├── integration/ # Integration tests
│ ├── init.py
│ ├── test_api.py
│ └── test_database.py
└── e2e/ # End-to-end tests
├── init.py
└── test_user_flow.py
Test Classes
class
TestUserService
:
"""Group related tests in a class."""
@pytest
.
fixture
(
autouse
=
True
)
def
setup
(
self
)
:
"""Setup runs before each test in this class."""
self
.
service
=
UserService
(
)
def
test_create_user
(
self
)
:
"""Test user creation."""
user
=
self
.
service
.
create_user
(
"Alice"
)
assert
user
.
name
==
"Alice"
def
test_delete_user
(
self
)
:
"""Test user deletion."""
user
=
User
(
id
=
1
,
name
=
"Bob"
)
self
.
service
.
delete_user
(
user
)
assert
not
self
.
service
.
user_exists
(
1
)
Best Practices
DO
Follow TDD
Write tests before code (red-green-refactor)
Test one thing
Each test should verify a single behavior
Use descriptive names
:
test_user_login_with_invalid_credentials_fails
Use fixtures
Eliminate duplication with fixtures
Mock external dependencies
Don't depend on external services
Test edge cases
Empty inputs, None values, boundary conditions
Aim for 80%+ coverage
Focus on critical paths
Keep tests fast
Use marks to separate slow tests
DON'T
Don't test implementation
Test behavior, not internals
Don't use complex conditionals in tests
Keep tests simple
Don't ignore test failures
All tests must pass
Don't test third-party code
Trust libraries to work
Don't share state between tests
Tests should be independent
Don't catch exceptions in tests
Use
pytest.raises
Don't use print statements
Use assertions and pytest output
Don't write tests that are too brittle
Avoid over-specific mocks Common Patterns Testing API Endpoints (FastAPI/Flask) @pytest . fixture def client ( ) : app = create_app ( testing = True ) return app . test_client ( ) def test_get_user ( client ) : response = client . get ( "/api/users/1" ) assert response . status_code == 200 assert response . json [ "id" ] == 1 def test_create_user ( client ) : response = client . post ( "/api/users" , json = { "name" : "Alice" , "email" : "alice@example.com" } ) assert response . status_code == 201 assert response . json [ "name" ] == "Alice" Testing Database Operations @pytest . fixture def db_session ( ) : """Create a test database session.""" session = Session ( bind = engine ) session . begin_nested ( ) yield session session . rollback ( ) session . close ( ) def test_create_user ( db_session ) : user = User ( name = "Alice" , email = "alice@example.com" ) db_session . add ( user ) db_session . commit ( ) retrieved = db_session . query ( User ) . filter_by ( name = "Alice" ) . first ( ) assert retrieved . email == "alice@example.com" Testing Class Methods class TestCalculator : @pytest . fixture def calculator ( self ) : return Calculator ( ) def test_add ( self , calculator ) : assert calculator . add ( 2 , 3 ) == 5 def test_divide_by_zero ( self , calculator ) : with pytest . raises ( ZeroDivisionError ) : calculator . divide ( 10 , 0 ) pytest Configuration pytest.ini [ pytest ] testpaths = tests python_files = test_.py python_classes = Test python_functions = test_ addopts = --strict-markers --disable-warnings --cov = mypackage --cov-report = term-missing --cov-report = html markers = slow: marks tests as slow integration: marks tests as integration tests unit: marks tests as unit tests pyproject.toml [ tool.pytest.ini_options ] testpaths = [ "tests" ] python_files = [ "test_.py" ] python_classes = [ "Test" ] python_functions = [ "test_" ] addopts = [ "--strict-markers" , "--cov=mypackage" , "--cov-report=term-missing" , "--cov-report=html" , ] markers = [ "slow: marks tests as slow" , "integration: marks tests as integration tests" , "unit: marks tests as unit tests" , ] Running Tests

Run all tests

pytest

Run specific file

pytest tests/test_utils.py

Run specific test

pytest tests/test_utils.py::test_function

Run with verbose output

pytest -v

Run with coverage

pytest --cov = mypackage --cov-report = html

Run only fast tests

pytest -m "not slow"

Run until first failure

pytest -x

Run and stop on N failures

pytest --maxfail = 3

Run last failed tests

pytest --lf

Run tests with pattern

pytest -k "test_user"

Run with debugger on failure

pytest
--pdb
Quick Reference
Pattern
Usage
pytest.raises()
Test expected exceptions
@pytest.fixture()
Create reusable test fixtures
@pytest.mark.parametrize()
Run tests with multiple inputs
@pytest.mark.slow
Mark slow tests
pytest -m "not slow"
Skip slow tests
@patch()
Mock functions and classes
tmp_path
fixture
Automatic temp directory
pytest --cov
Generate coverage report
assert
Simple and readable assertions
Remember
Tests are code too. Keep them clean, readable, and maintainable. Good tests catch bugs; great tests prevent them.
← 返回排行榜