300-testing

Testing Strategies & Best Practices

Audience: engineers writing and reviewing tests across languages and frameworks Goal: Create reliable, maintainable test suites that provide fast feedback and high confidence

Testing Philosophy (Core Principles)

Core Principles:

• "Test pyramid, not test ice cream cone" - More unit tests, fewer integration tests, minimal E2E tests
• "Fast feedback loop" - Tests should run quickly and fail fast with clear error messages
• "Tests are documentation" - Tests describe how code should behave, make them readable
• "Isolation is essential" - Tests should be independent, repeatable, and not depend on each other
• "Quality over quantity" - 80% coverage is good, but meaningful tests matter more than coverage percentage
• "Test behavior, not implementation" - Test what the code does, not how it does it
• "Fail fast, fail clearly" - Tests should fail with actionable error messages
• "Maintainability matters" - Tests should be easy to update when requirements change

Applying Testing Principles:

// BAD: Testing implementation, unclear, slow
it('test1', () => {
  const result = service.process();
  expect(result).toBeTruthy();
});

// GOOD: Testing behavior, clear, fast
it('should calculate total price with 10% discount', () => {
  // Arrange
  const cart = new ShoppingCart();
  cart.addItem({ id: '1', price: 100 });
  cart.addItem({ id: '2', price: 50 });

  // Act
  const total = cart.calculateTotal(0.1);

  // Assert
  expect(total).toBe(135); // (100 + 50) * 0.9
});

Guiding Principles

1. Test Pyramid: More unit tests, fewer integration tests, minimal E2E tests
2. Fast Feedback: Tests should run quickly and fail fast
3. Isolation: Tests should be independent and repeatable
4. Clarity: Tests are documentation - make them readable
5. Coverage: Aim for 80%+ coverage, but quality > quantity

---

Test Pyramid

                    E2E Tests (Few)
                - Slow, brittle, expensive
                    - Test critical user journeys
      E2E           - 5-10% of tests

                    Integration Tests (Some)
   Integration     - Medium speed
    - Test component interactions
                    - 20-30% of tests

                    Unit Tests (Many)
       Unit         - Fast, focused, reliable
      - Test individual functions/classes
                    - 60-70% of tests