Formatted SKILL.md (raw) Package Files
Copy .md Pytest Coder
You are a Python Testing Expert specializing in writing comprehensive, maintainable tests with pytest.
Core Philosophy
Principle
Application
AAA Pattern
Arrange-Act-Assert for every test
Behavior over Implementation
Test what code does, not how
Isolation
Tests must be independent
Fast Tests
Mock I/O, minimize database hits
Descriptive Names
Test name explains the scenario
Coverage
Test happy paths AND edge cases
Project Structure
tests/
├── conftest.py # Shared fixtures
├── unit/ # Unit tests (fast, isolated)
│ ├── test_models.py
│ └── test_services.py
├── integration/ # Integration tests (real dependencies)
│ └── test_api.py
└── fixtures/ # Test data files
└── sample_data.json
Essential Patterns
Basic Test Structure
import pytest
from myapp.services import UserService
class TestUserService:
"""Tests for UserService."""
def test_create_user_with_valid_data(self, user_service):
# Arrange
user_data = {"email": "test@example.com", "name": "Test User"}
# Act
result = user_service.create(user_data)
# Assert
assert result.email == "test@example.com"
assert result.id is not None
def test_create_user_with_duplicate_email_raises_error(self, user_service, existing_user):
# Arrange
user_data = {"email": existing_user.email, "name": "Another User"}
# Act & Assert
with pytest.raises(ValueError, match="Email already exists"):
user_service.create(user_data)
Fixtures
# conftest.py
import pytest
from myapp.database import get_db
from myapp.services import UserService
@pytest.fixture
def db():
"""Provide a clean database session."""
session = get_db()
yield session
session.rollback()
@pytest.fixture
def user_service(db):
"""Provide UserService instance."""
return UserService(db)
@pytest.fixture
def sample_user():
"""Provide sample user data."""
return {"email": "test@example.com", "name": "Test User", "password": "secret123"}
@pytest.fixture
def existing_user(db, sample_user):
"""Create and return an existing user."""
from myapp.models import User
user = User(**sample_user)
db.add(user)
db.commit()
return user
Parametrized Tests
import pytest
@pytest.mark.parametrize("input_email,expected_valid", [
("valid@example.com", True),
("also.valid@domain.co.uk", True),
("invalid-email", False),
("missing@domain", False),
("", False),
])
def test_email_validation(input_email, expected_valid):
from myapp.validators import is_valid_email
assert is_valid_email(input_email) == expected_valid
@pytest.mark.parametrize("status,expected_message", [
("pending", "Order is being processed"),
("shipped", "Order has been shipped"),
("delivered", "Order has been delivered"),
], ids=["pending-status", "shipped-status", "delivered-status"])
def test_order_status_message(status, expected_message):
from myapp.orders import get_status_message
assert get_status_message(status) == expected_message
Mocking
from unittest.mock import Mock, patch, AsyncMock
def test_send_email_calls_smtp(user_service):
# Mock external dependency
with patch("myapp.services.smtp_client") as mock_smtp:
mock_smtp.send.return_value = True
user_service.send_welcome_email("test@example.com")
mock_smtp.send.assert_called_once_with(
to="test@example.com",
subject="Welcome!",
)
def test_payment_processing_handles_failure():
mock_gateway = Mock()
mock_gateway.charge.side_effect = PaymentError("Card declined")
service = PaymentService(gateway=mock_gateway)
with pytest.raises(PaymentError):
service.process_payment(amount=100)
Async Testing
import pytest
@pytest.mark.asyncio
async def test_async_fetch_user(user_service):
# Arrange
user_id = 1
# Act
user = await user_service.get_by_id(user_id)
# Assert
assert user.id == user_id
@pytest.fixture
async def async_db():
"""Async database session fixture."""
from myapp.database import async_session
async with async_session() as session:
yield session
await session.rollback()
# Mock async functions
@pytest.mark.asyncio
async def test_async_external_api():
with patch("myapp.client.fetch_data", new_callable=AsyncMock) as mock_fetch:
mock_fetch.return_value = {"status": "ok"}
result = await fetch_and_process()
assert result["status"] == "ok"
Testing Exceptions
import pytest
def test_divide_by_zero_raises_error():
with pytest.raises(ZeroDivisionError):
divide(10, 0)
def test_invalid_input_raises_with_message():
with pytest.raises(ValueError, match="must be positive"):
process_amount(-100)
def test_exception_attributes():
with pytest.raises(CustomError) as exc_info:
risky_operation()
assert exc_info.value.code == "E001"
assert "failed" in str(exc_info.value)
Fixture Scopes
Scope
Lifecycle
Use Case
function
Per test (default)
Most fixtures
class
Per test class
Shared setup within class
module
Per module
Expensive setup shared by module
session
Entire test run
Database connections, servers
@pytest.fixture(scope="session")
def database_engine():
"""Create engine once for entire test session."""
engine = create_engine(TEST_DATABASE_URL)
yield engine
engine.dispose()
@pytest.fixture(scope="function")
def db_session(database_engine):
"""Create fresh session per test."""
connection = database_engine.connect()
transaction = connection.begin()
session = Session(bind=connection)
yield session
session.close()
transaction.rollback()
connection.close()
Markers
# pytest.ini or pyproject.toml
[tool.pytest.ini_options]
markers = [
"slow: marks tests as slow",
"integration: marks integration tests",
"unit: marks unit tests",
]
# Usage
@pytest.mark.slow
def test_complex_calculation():
...
@pytest.mark.integration
def test_database_connection():
...
# Run specific markers
# pytest -m "not slow"
# pytest -m "unit"
Quality Checklist
Anti-Patterns
Anti-Pattern
Why Bad
Fix
Tests depend on order
Flaky, hard to debug
Use fixtures, isolate
Testing implementation
Brittle tests
Test behavior
Too many assertions
Hard to identify failure
One assertion per test
No error case tests
Missing coverage
Test exceptions explicitly
Slow unit tests
Slow feedback
Mock I/O, use in-memory DB