Testing Expert

// Bad: Repetitive setup
beforeEach(() => {
  mockDatabase.clear();
  mockAuth.login({ id: 1, role: 'user' });
});

// Good: Shared test utilities
// tests/utils/setup.js
export const setupTestUser = (overrides = {}) => ({
  id: 1,
  role: 'user',
  ...overrides
});

export const cleanDatabase = () => mockDatabase.clear();

// Bad: Implementation-focused names
test('getUserById returns user', () => {});
test('getUserById throws error', () => {});

// Good: Behavior-focused organization
describe('User retrieval', () => {
  describe('when user exists', () => {
    test('should return user data with correct fields', () => {});
  });
  
  describe('when user not found', () => {
    test('should throw NotFoundError with helpful message', () => {});
  });
});

# Clear test type boundaries
tests/
├── unit/           # Fast, isolated tests
├── integration/    # Component interaction tests  
├── e2e/           # Full user journey tests
└── utils/         # Shared test utilities

// Jest
beforeEach(() => {
  jest.clearAllMocks();
});

// Vitest
beforeEach(() => {
  vi.clearAllMocks();
});

// Manual cleanup pattern
afterEach(() => {
  // Reset any global state
  // Clear test databases
  // Reset environment variables
});

// Good: Mock only external boundaries
jest.mock('./api/userService', () => ({
  fetchUser: jest.fn(),
  updateUser: jest.fn(),
}));

// Avoid: Over-mocking internal logic
// Don't mock every function in the module under test

# Run tests serially to identify timing issues
npm test -- --runInBand

# Multiple runs to catch intermittent failures  
for i in {1..10}; do npm test && echo "Run $i passed" || echo "Run $i failed"; done

# Memory leak detection
npm test -- --detectLeaks --logHeapUsage

// Bad: Missing await
test('user creation', () => {
  const user = createUser(userData); // Returns promise
  expect(user.id).toBeDefined(); // Will fail
});

// Good: Proper async handling
test('user creation', async () => {
  const user = await createUser(userData);
  expect(user.id).toBeDefined();
});

// Testing Library async patterns
test('loads user data', async () => {
  render(<UserProfile userId="123" />);
  
  // Wait for async loading to complete
  const userName = await screen.findByText('John Doe');
  expect(userName).toBeInTheDocument();
});

// Jest timer mocking
beforeEach(() => {
  jest.useFakeTimers();
});

afterEach(() => {
  jest.runOnlyPendingTimers();
  jest.useRealTimers();
});

test('delayed action', async () => {
  const callback = jest.fn();
  setTimeout(callback, 1000);
  
  jest.advanceTimersByTime(1000);
  expect(callback).toHaveBeenCalled();
});

// jest.config.js
{
  "collectCoverageFrom": [
    "src/**/*.{js,ts}",
    "!src/**/*.d.ts",
    "!src/**/*.stories.*",
    "!src/**/index.ts"
  ],
  "coverageThreshold": {
    "global": {
      "branches": 80,
      "functions": 80,
      "lines": 80,
      "statements": 80
    }
  }
}

# Generate detailed coverage reports
npm test -- --coverage --coverageReporters=text --coverageReporters=html

# Focus on uncovered branches
npm test -- --coverage | grep -A 10 "Uncovered"

# Identify critical paths without coverage
grep -r "throw\|catch" src/ | wc -l  # Count error paths
npm test -- --coverage --collectCoverageFrom="src/critical/**"

// Bad: Testing implementation details for coverage
test('internal calculation', () => {
  const calculator = new Calculator();
  expect(calculator._privateMethod()).toBe(42); // Brittle
});

// Good: Testing behavior and edge cases
test('calculation handles edge cases', () => {
  expect(() => calculate(null)).toThrow('Invalid input');
  expect(() => calculate(Infinity)).toThrow('Cannot calculate infinity');
  expect(calculate(0)).toBe(0);
});

// Database transaction pattern
beforeEach(async () => {
  await db.beginTransaction();
});

afterEach(async () => {
  await db.rollback();
});

// Docker test containers (if available)
beforeAll(async () => {
  container = await testcontainers
    .GenericContainer('postgres:13')
    .withExposedPorts(5432)
    .withEnv('POSTGRES_PASSWORD', 'test')
    .start();
});

// Page Object Model pattern
class LoginPage {
  constructor(page) {
    this.page = page;
    this.emailInput = page.locator('[data-testid="email"]');
    this.passwordInput = page.locator('[data-testid="password"]');
    this.submitButton = page.locator('button[type="submit"]');
  }

  async login(email, password) {
    await this.emailInput.fill(email);
    await this.passwordInput.fill(password);
    await this.submitButton.click();
  }
}

# Environment variable consistency
CI_ENV=true npm test  # Simulate CI environment

# Docker for environment consistency
docker-compose -f test-compose.yml up -d
npm test
docker-compose -f test-compose.yml down

// Jest parallelization
{
  "maxWorkers": "50%",
  "testTimeout": 10000,
  "setupFilesAfterEnv": ["<rootDir>/tests/setup.js"]
}

// Vitest performance config  
export default {
  test: {
    threads: true,
    maxThreads: 4,
    minThreads: 2,
    isolate: false // For faster execution, trade isolation
  }
}

# Test sharding for large suites
npm test -- --shard=1/4  # Run 1 of 4 shards

# Caching strategies
npm ci --cache .npm-cache
npm test -- --cache --cacheDirectory=.test-cache

# Retry configuration for flaky tests
npm test -- --retries=3

# Run tests multiple times to identify patterns
npm test -- --runInBand --verbose 2>&1 | tee test-output.log
grep -i "timeout\|error\|fail" test-output.log