Testing

Testing Domain Skill

TDD Cycle: RED -> GREEN -> REFACTOR

1. RED - Write a failing test. Must fail for the right reason.
2. GREEN - Write minimum code to pass. No gold plating.
3. REFACTOR - Improve design. Tests stay green.

# RED
def test_user_full_name():
    user = User(first="Jane", last="Doe")
    assert user.full_name() == "Jane Doe"

# GREEN
class User:
    def __init__(self, first, last):
        self.first = first
        self.last = last
    def full_name(self):
        return f"{self.first} {self.last}"

# REFACTOR: tests pass, clean up if needed

See: references/tdd-deep-dive.md for advanced TDD techniques.

What to Test / What NOT to Test

DO test (behavior):

• Public API contracts
• Edge cases and boundaries
• Error conditions
• State transitions
• Business logic

DON'T test (implementation):

• Private methods (test through public API)
• Language features
• Third-party libraries (only verify integration)
• Trivial getters/setters
• Generated code, migrations, static config

Test Types

Unit Tests

• Run in milliseconds, no I/O, no external dependencies
• Deterministic, parallelizable
• Test single units of behavior

Integration Tests

• Seconds to run, may involve I/O
• Test real component boundaries
• Run sequentially if stateful

E2E Tests

• Slowest (seconds to minutes)
• Test complete user flows from user perspective
• Run against staging/test environment

Characterization Tests

• Capture existing behavior of legacy code before refactoring
• Document current behavior (even if wrong), then refactor against it

See: references/test-patterns-by-language.md for language-specific frameworks and idioms.

Test Structure: Arrange-Act-Assert

def test_shopping_cart_total():
    # Arrange
    cart = ShoppingCart()
    cart.add_item(Item("Book", 10.00))

    # Act
    total = cart.calculate_total()

    # Assert
    assert total == 10.00

Prefer one assertion per test. Exception: related assertions on the same object.

Coverage Requirements

Coverage Commands

See: references/coverage-strategies.md for branch coverage, mutation testing, and coverage-driven development.

Mocking Strategy

When to Mock

Mock Types

• Stub - Returns predefined values. Use for simple dependency replacement.
• Spy - Records calls for verification. Use when you need to assert interactions.
• Fake - Simplified working implementation (e.g., in-memory repository). Use for complex dependencies.

Cross-Language Mocking

See: references/mocking-strategies.md for comprehensive patterns and anti-patterns.

Anti-Patterns

Test Organization

• Structure: Separate unit/, integration/, e2e/ directories
• Naming conventions: test_*.py, *.test.js, *_test.go, tests.rs
• Function names: Descriptive -- test_user_login_with_invalid_password_returns_error() not test_case_1()

Quick Reference

Remember

1. RED -> GREEN -> REFACTOR is mandatory
2. Test behavior, not implementation
3. 80% coverage minimum, critical paths 100%
4. Mock external boundaries only
5. Fast, isolated, deterministic tests
6. One clear assertion per test (when practical)
7. Arrange-Act-Assert for clarity
8. Descriptive test names document behavior
9. Fix flaky tests immediately (never ignore)
10. Tests are first-class code (refactor them too)

Additional Resources

• references/tdd-deep-dive.md - Advanced TDD techniques and when to break rules
• references/mocking-strategies.md - Comprehensive mocking patterns and anti-patterns
• references/test-patterns-by-language.md - Language-specific testing patterns
• references/coverage-strategies.md - Advanced coverage techniques and mutation testing