Menu
Defines patterns for writing tests, including subsection tests for incremental development and acceptance criteria verification. Use when writing any tests to ensure consistent naming, structure, and coverage patterns.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Defines patterns for implementing FastAPI REST endpoints, including route definition, request/response models, error handling, and integration tests. Use when implementing any API endpoint to ensure consistency and best practices across endpoints.
Ensures all git commits follow the Conventional Commits specification with consistent types and scopes. Use this skill when making any commit to maintain consistent commit message format, improve git history readability, and enable automatic changelog generation.
Defines error handling patterns using custom error codes, result wrappers, and HTTP status code mapping. Use when implementing error handling in services, business logic, or API endpoints to ensure consistent error responses.
Enforce feature work on a dedicated git branch and submission via pull request. Use when implementing any feature, fix, or refactor so work is isolated, reviewed, and merged via PR.
Defines the pattern for updating project documentation when completing features. Use when marking features as complete to ensure consistent documentation of implementation status, test coverage, and deliverables.
Guides implementation of features following an established workflow pattern. Use when implementing any feature to ensure consistent process: read requirements, create todos, implement code, write tests, update documentation, commit and push.
| name | test-writing |
| description | Defines patterns for writing tests, including subsection tests for incremental development and acceptance criteria verification. Use when writing any tests to ensure consistent naming, structure, and coverage patterns. |
| license | MIT |
| metadata | {"version":"1.0.0","framework":"pytest","conventions":"subsection tests, AC verification, type annotations"} |
This skill defines how to write tests following established patterns and best practices.
tests/unit/<module>/test_<component>.pytests/integration/test_<feature>.pytests/integration/api/test_api_<endpoint>.py"""Tests for <component>: <description>.
Tests verify:
- <key requirement 1>
- <key requirement 2>
- <key requirement 3>
"""
import pytest
from <appropriate imports>
@pytest.fixture
def <fixture_name>():
"""Fixture description."""
# Setup
yield <value>
# Cleanup (if needed)
class Test<ComponentName>:
"""Test <component>: <description>."""
def test_feature_description(self, fixture) -> None:
"""Test specific feature requirement."""
# Arrange
# Act
# Assert
For incremental development during phase implementation:
def test_subsection_X_Y_Z_requirement_description(self) -> None:
"""Test subsection X.Y.Z requirement."""
Examples:
test_subsection_1_2_3_validates_input_boundstest_subsection_2_1_1_returns_200_with_healthy_statustest_subsection_3_2_1_enforces_timeoutFor official verification (AC-X.Y.Z format):
def test_ac_X_Y_Z_requirement_description(self) -> None:
"""Test AC-X.Y.Z: requirement description."""
Examples:
test_ac_2_1_1_returns_200_with_health_statustest_ac_3_2_1_response_completes_within_100msFor other test cases:
def test_feature_description(self) -> None:
"""Test that feature works correctly."""
Always include return type annotations:
def test_something(self) -> None:
"""Test description."""
pass
Test individual components in isolation:
def test_component_behavior(self) -> None:
"""Test component does X."""
# Create component
component = Component()
# Call method
result = component.method()
# Assert behavior
assert result.expected_property == expected_value
Test interactions between components:
@pytest.fixture
def service():
"""Create service for testing."""
return Service()
def test_service_pipeline_integration(self, service) -> None:
"""Test full service pipeline."""
# Set up test data
test_data = create_test_data()
# Run pipeline
result = service.process(test_data)
# Verify result
assert result.success is True
assert result.data is not None
Test FastAPI endpoints:
from fastapi.testclient import TestClient
@pytest.fixture
def client():
"""Create test client."""
return TestClient(app)
def test_get_endpoint_returns_200(self, client: TestClient) -> None:
"""Test GET endpoint returns 200."""
response = client.get("/endpoint")
assert response.status_code == 200
data = response.json()
assert data["expected_field"] == expected_value
assert result.success is True
assert result.data is not None
assert result.data.expected_property == expected_value
assert result.success is False
assert result.error_code == "E_ERROR_CODE"
assert result.error_message is not None
assert response.status_code == 200 # Success
assert response.status_code == 400 # Bad Request
assert response.status_code == 404 # Not Found
assert response.status_code == 500 # Internal Error
assert response.status_code == 503 # Service Unavailable
@pytest.fixture
def sample_data():
"""Create sample test data."""
return {
"id": "test-id",
"name": "Test Item",
"status": "active"
}
@pytest.fixture
def service():
"""Create service instance."""
return Service()
For setup/teardown needed for all tests:
@pytest.fixture(autouse=True)
def reset_state():
"""Reset state before each test."""
# Setup
yield
# Cleanup
def test_returns_correct_error_code(self) -> None:
"""Test returns correct error code."""
result = component.method(invalid_input)
assert result.success is False
assert result.error_code == "E_ERROR_CODE"
def test_enforces_timeout(self) -> None:
"""Test timeout is enforced."""
start_time = time.time()
result = slow_operation()
elapsed_time = time.time() - start_time
assert result.error_code == "E_TIMEOUT"
# Note: Don't assert exact timing, just that timeout occurred
def test_updates_state_correctly(self) -> None:
"""Test state is updated correctly."""
initial_state = get_state()
operation()
updated_state = get_state()
assert updated_state.property != initial_state.property