testing-strategy

Files (1)

• SKILL.md

SKILL.md (first lines)

# Testing Strategy

## Test Pyramid

```
        /  E2E  \          ~10% — Slow, brittle, expensive
       /  Integ  \         ~20% — Medium speed, real dependencies
      /   Unit    \        ~70% — Fast, isolated, numerous
     /______________\
```

| Layer       | Count  | Speed     | Scope                        | Runs           |
|-------------|--------|-----------|------------------------------|----------------|
| Unit        | ~70%   | < 10ms   | Single function or class     | Every commit   |
| Integration | ~20%   | < 5s     | Multiple components together | Every push     |
| E2E         | ~10%   | < 60s    | Full user workflow           | Pre-merge, CI  |

If the pyramid inverts (more E2E than unit), treat it as a structural problem.

## Unit Test Principles

### FIRST Properties

| Property            | Rule                                                       |
|---------------------|------------------------------------------------------------|
| **Fast**            | Entire unit suite runs in under 30 seconds                 |
| **Isolated**        | No test depends on another test's execution or state       |
| **Repeatable**      | Same result every run, regardless of time, network, or OS  |
| **Self-validating** | Pass or fail with no manual inspection needed              |
| **Timely**          | Written before or alongside the production code            |

### What to Unit Test

- [ ] Pure functions and their edge cases
- [ ] Business logic and calculations
- [ ] State transitions and validation rules
- [ ] Data transformations and mappings
- [ ] Error handling paths
- [ ] Boundary conditions (empty, null, max, min, off-by-one)

### What NOT to Unit Test

- [ ] Framework configuration or boilerplate
- [ ] Simple getters/setters with no logic
- [ ] Third-party library internals
- [ ] Private methods directly (test through public interface)

### Arrange-Act-Assert

```typescript
describe("calculateDiscount", () => {
  it("applies 10% discount for orders over $100", () => {
    // Arrange
    const order = { items: [{ price: 120, quantity: 1 }] };
    // Act
    const result = calculateDiscount(order);
    // Assert
    expect(result.discount).toBe(12);
    expect(result.total).toBe(108);
  });
});
```

```python
class TestCalculateDiscount:
    def test_applies_10_percent_for_orders_over_100(self):
        order = Order(items=[Item(price=120, quantity=1)])
        result = calculate_discount(order)
        assert result.discount == 12
        assert result.total == 108
```

## Integration Test Scope

| Category            | Example                                               |
|---------------------|-------------------------------------------------------|
| Database queries    | Repository methods with a real (test) database        |
| API endpoints       | HTTP request through middleware, handler, and response |
| External services   | Calls to third-party APIs with sandboxed accounts     |
| Message queues      | Publish and consume cycle with real broker             |
| File system         | Read/write operations with temp directories           |
| Cache layers        | Cache set, get, invalidation with real cache           |

```typescript
describe("UserRepository", () => {
  let db: Database;
  beforeAll(async () => { db = await createTestDatabase(); await db.migrate(); });
  afterAll(async () => { await db.close(); });
  beforeEach(async () => { await db.truncateAll(); });

  it("finds user by email", async () => {
    await db.insert("users", { email: "test@example.com", name: "Test User" });
    const user = await userRepo.findByEmail("test@example.com");
    expect(user).not.toBeNull();
    expect(user.name).toBe("Test User");
  });
});
```

### Integration Test Rules

- [ ] Use a dedicated test database, never production data
- [ ] Reset state between tests (truncate tables, clear queues)
- [ ] Use test containers or in-memory databases where possible
- [ ] Test the happy path and the most critical error paths

## E2E Test Selection Criteria

**Include:** Critical revenue paths (signup, checkout, payment), authentication flows, core user journeys (3-5 things your product must do), cross-system workflows.

**Exclude:** Edge cases (cover in unit tests), UI-only validation, admin features, scenarios covered by lower-level tests.

```typescript
test("user can complete checkout", async ({ page }) => {
  await page.goto("/login");
  await page.fill('[name="email"]', "user@test.com");
  await page.fill('[name="password"]', "password123");
  await page.click('button[type="submit"]');
  await page.goto("/products/widget-1");

From Claude-Code-Community-Ireland/claude-code-resources, MIT.

More from Claude-Code-Community-Ireland/claude-code-resources