testing

name	testing
description	Comprehensive testing best practices for test strategies, test writing, and testing infrastructure

Testing Patterns Skill

Instructions for AI

Apply comprehensive testing best practices. Use this skill when designing test strategies, writing tests, or setting up testing infrastructure.

Test Pyramid

         /\
        / E2E \          ~5%  — Critical user journeys
       /--------\
      / Contract  \      ~10% — API contracts
     /--------------\
    /  Integration    \  ~25% — DB, queues, external APIs
   /--------------------\
  /     Unit Tests       \ ~60% — Business logic, pure functions
 /------------------------\

Unit Testing Patterns

Arrange-Act-Assert

class TestPriceCalculator:
    def test_applies_percentage_discount(self):
        # Arrange
        calculator = PriceCalculator()
        product = Product(price=100.0)
        discount = PercentageDiscount(rate=0.2)

        # Act
        result = calculator.calculate(product, discount)

        # Assert
        assert result == 80.0

Parameterized Tests

import pytest

@pytest.mark.parametrize("input_price,discount_rate,expected", [
    (100.0, 0.0, 100.0),
    (100.0, 0.1, 90.0),
    (100.0, 0.5, 50.0),
    (100.0, 1.0, 0.0),
    (0.0, 0.5, 0.0),
])
def test_discount_calculation(input_price, discount_rate, expected):
    result = calculate_discount(input_price, discount_rate)
    assert result == expected

Fakes over Mocks

class FakeEmailSender:
    """In-memory fake — captures sent emails for verification."""

    def __init__(self):
        self.sent_emails: list[Email] = []

    async def send(self, email: Email) -> None:
        self.sent_emails.append(email)

# In tests
async def test_order_confirmation_sends_email(fake_email_sender):
    service = OrderService(email_sender=fake_email_sender)
    await service.place_order(sample_order)
    
    assert len(fake_email_sender.sent_emails) == 1
    assert fake_email_sender.sent_emails[0].subject == "Order Confirmation"

Factory Pattern for Test Data

from polyfactory.factories.pydantic_factory import ModelFactory

class UserFactory(ModelFactory):
    __model__ = User
    
    @classmethod
    def admin(cls) -> User:
        return cls.build(role=UserRole.ADMIN)
    
    @classmethod
    def with_orders(cls, count: int = 3) -> User:
        user = cls.build()
        user.orders = OrderFactory.batch(count)
        return user

Integration Testing Patterns

Testcontainers

import pytest
from testcontainers.postgres import PostgresContainer

@pytest.fixture(scope="session")
def db_container():
    with PostgresContainer("postgres:16-alpine") as pg:
        yield pg

@pytest.fixture
async def db_session(db_container):
    engine = create_async_engine(db_container.get_connection_url())
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    async with AsyncSession(engine) as session:
        yield session
        await session.rollback()

API Testing (httpx)

from httpx import AsyncClient, ASGITransport

@pytest.fixture
async def api_client(app):
    transport = ASGITransport(app=app)
    async with AsyncClient(transport=transport, base_url="http://test") as client:
        yield client

async def test_create_user_returns_201(api_client):
    response = await api_client.post("/users", json={"name": "Alice", "email": "[e-mail]"})
    assert response.status_code == 201
    data = response.json()
    assert data["name"] == "Alice"
    assert "id" in data

Quality Gates

quality_gates:
  unit_tests:
    coverage: ">= 80%"
    max_duration: "120s"
    blocking: true
    
  integration_tests:
    coverage: ">= 60%"
    max_duration: "300s"
    blocking: true
    
  security_scan:
    tool: "bandit"
    severity: "medium"
    blocking: true
    
  type_checking:
    tool: "mypy --strict"
    blocking: true
    
  linting:
    tool: "ruff check"
    blocking: true

Test Fixture Organization

tests/
├── conftest.py           # Shared fixtures
├── factories.py          # Test data factories
├── fakes.py              # Fake implementations
├── unit/
│   ├── conftest.py       # Unit-specific fixtures
│   ├── test_models.py
│   ├── test_services.py
│   └── test_validators.py
├── integration/
│   ├── conftest.py       # DB, containers
│   ├── test_repositories.py
│   └── test_api.py
└── e2e/
    ├── conftest.py       # Full stack setup
    └── test_user_journey.py

Best Practices

✅ Name tests: test_<action>_<scenario>_<expected> ✅ One logical assertion per test ✅ Use conftest.py for shared fixtures ✅ Prefer fakes over mocks for domain dependencies ✅ Run unit tests in parallel (pytest-xdist) ✅ Tag slow tests: @pytest.mark.slow ✅ Keep test code clean — it's production code too

Anti-Patterns

❌ Testing implementation details instead of behavior ❌ Shared mutable state between tests ❌ Ignoring flaky tests ❌ Over-mocking (if everything is mocked, what are you testing?) ❌ Missing error path tests ❌ Hard-coded test data (use factories) ❌ Skipping tests that "take too long"

Example Prompts

• "Write unit tests for this OrderService using fakes and factories"
• "Set up integration tests with testcontainers and PostgreSQL"
• "Design a quality gate configuration for our CI/CD pipeline"
• "Refactor these tests to eliminate shared state and improve isolation"

Related Skills

• Test Strategist Agent
• Testing Strategies
• Python Patterns
• Golang Patterns
• Flutter Patterns