aiskillstore/marketplace / skills/0xdarkmatter/testing-patterns
testing-patterns
VerifiedCross-language testing strategies and patterns. Triggers on: test pyramid, unit test, integration test, e2e test, TDD, BDD, test coverage, mocking strategy, test doubles, test isolation.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 4.1 KB |
| references/ci-testing.md | markdown | 6.9 KB |
| references/mocking-strategies.md | markdown | 7.0 KB |
| references/tdd-workflow.md | markdown | 5.2 KB |
| references/test-data-patterns.md | markdown | 6.4 KB |
| scripts/coverage-check.sh | script | 762 B |
| skill-report.json | config | 39.5 KB |
references/test-data-patterns.md
View on GitHub# Test Data Patterns
Strategies for managing test data effectively.
## Fixtures
### Basic Fixture
```python
import pytest
@pytest.fixture
def user():
return User(id=1, name="Test User", email="test@example.com")
def test_user_greeting(user):
assert user.greeting() == "Hello, Test User!"
```
### Fixture with Cleanup
```python
@pytest.fixture
def temp_database():
db = create_test_database()
yield db
db.drop() # Cleanup after test
```
### Shared Fixtures (conftest.py)
```python
# tests/conftest.py
@pytest.fixture(scope="session")
def app():
"""Application shared across all tests."""
return create_app(testing=True)
@pytest.fixture(scope="function")
def client(app):
"""Fresh client for each test."""
return app.test_client()
```
## Factory Pattern
### Simple Factory
```python
def make_user(**overrides):
"""Factory function for creating test users."""
defaults = {
"id": 1,
"name": "Test User",
"email": "test@example.com",
"active": True,
}
return User(**{**defaults, **overrides})
def test_inactive_user():
user = make_user(active=False)
assert not user.can_login()
```
### Factory Fixture
```python
@pytest.fixture
def user_factory():
"""Factory fixture for creating multiple users."""
created = []
def _create(**overrides):
user = make_user(**overrides)
created.append(user)
return user
yield _create
# Cleanup
for user in created:
user.delete()
def test_user_comparison(user_factory):
user1 = user_factory(name="Alice")
user2 = user_factory(name="Bob")
assert user1 != user2
```
### Factory Boy (Python)
```python
import factory
from factory import Faker
class UserFactory(factory.Factory):
class Meta:
model = User
id = factory.Sequence(lambda n: n + 1)
name = Faker("name")
email = Faker("email")
created_at = Faker("date_time_this_year")
# Usage
def test_users():
user = UserFactory()
admin = UserFactory(role="admin")
users = UserFactory.create_batch(10)
```
## Builder Pattern
```python
class UserBuilder:
"""Fluent builder for test users."""
def __init__(self):
self._data = {
"id": 1,
"name": "Test User",
"email": "test@example.com",
"role": "user",
"active": True,
}
def with_name(self, name: str) -> "UserBuilder":
self._data["name"] = name
return self
def as_admin(self) -> "UserBuilder":
self._data["role"] = "admin"
return self
def inactive(self) -> "UserBuilder":
self._data["active"] = False
return self
def build(self) -> User:
return User(**self._data)
# Usage
def test_admin_access():
admin = UserBuilder().as_admin().build()
assert admin.can_access_admin_panel()
def test_inactive_user():
user = UserBuilder().inactive().build()
assert not user.can_login()
```
## Mother Pattern
```python
class ObjectMother:
"""Pre-configured test objects for common scenarios."""
@staticmethod
def valid_user() -> User:
return User(
id=1,
name="Valid User",
email="valid@example.com",
active=True
)
@staticmethod
def admin_user() -> User:
return User(
id=2,
name="Admin User",
email="admin@example.com",
role="admin",
active=True
)
@staticmethod
def expired_subscription() -> Subscription:
return Subscription(
user_id=1,
expires_at=datetime.now() - timedelta(days=30),
plan="basic"
)
# Usage
def test_admin_permissions():
admin = ObjectMother.admin_user()
assert admin.can_delete_users()
```
## Fixture Composition
```python
@pytest.fixture
def address():
return Address(street="123 Main St", city="Test City")
@pytest.fixture
def user(address):
return User(name="Test User", address=address)
@pytest.fixture
def order(user):
return Order(user=user, items=[])
def test_order_address(order):
assert order.shipping_address.city == "Test City"
```
## Data Files
### JSON Fixtures
```python
# tests/fixtures/users.json
[
{"id": 1, "name": "Alice", "role": "admin"},
{"id": 2, "name": "Bob", "role": "user"}
]
# tests/conftest.py
@pytest.fixture
def sample_users():
with open("tests/fixtures/users.json") as f:
return json.load(f)
```
### YAML Fixtures
```yaml
# tests/fixtures/config.yaml
database:
host: localhost
port: 5432
name: test_db
users:
- id: 1
name: Alice
- id: 2
name: Bob
```
```python
@pytest.fixture
def config():
with open("tests/fixtures/config.yaml") as f:
return yaml.safe_load(f)
```
## Randomized Data
```python
from faker import Faker
fake = Faker()
def test_user_email_validation():
# Random but valid email
email = fake.email()
user = User(email=email)
assert user.is_valid_email()
def test_with_seed():
# Reproducible random data
Faker.seed(12345)
user = make_user(name=fake.name())
# Same name every time with seed 12345
```
## Best Practices
### 1. Keep Fixtures Close to Tests
```
tests/
├── conftest.py # Shared fixtures
├── unit/
│ ├── conftest.py # Unit test fixtures
│ └── test_user.py
└── integration/
├── conftest.py # Integration fixtures
└── test_api.py
```
### 2. Use Descriptive Names
```python
# BAD
@pytest.fixture
def data():
return {...}
# GOOD
@pytest.fixture
def user_with_expired_subscription():
return {...}
```
### 3. Minimize Fixture Scope
```python
# Use function scope (default) unless you have a reason
@pytest.fixture(scope="function") # Default
def user(): ...
# Session scope only for expensive, read-only fixtures
@pytest.fixture(scope="session")
def database_schema(): ...
```
### 4. Avoid Test Data Dependencies
```python
# BAD - Tests depend on each other
def test_create_user():
user = create_user("test@example.com")
# User exists in DB after this test
def test_get_user():
user = get_user("test@example.com") # Depends on previous test!
# GOOD - Each test is independent
def test_create_user(db):
user = create_user("test@example.com")
assert user.email == "test@example.com"
def test_get_user(db, user_factory):
user_factory(email="test@example.com") # Create own data
found = get_user("test@example.com")
assert found is not None
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |