avoiding-testing-anti-patterns

AI代理识别并修复导致测试套件不稳定、缓慢或难以维护的常见测试反模式。在审查测试、调试测试失败或提高测试质量时使用。

📖 中文导读:AI代理识别并修复导致测试套件不稳定、缓慢或难以维护的常见测试反模式。在审查测试、调试测试失败或提高测试质量时使用。 以下正文为该技能的原始 SKILL.md 内容(英文),上方安装命令可直接使用。

name: avoiding-testing-anti-patterns description: AI agent identifies and fixes common testing anti-patterns that lead to flaky, slow, or unmaintainable test suites. Use when reviewing tests, debugging test failures, or improving test quality.

Avoiding Testing Anti-Patterns

Quick Start

  1. Identify - Recognize anti-pattern category (flaky, implementation, over-mocking)
  2. Assess Severity - Critical (fix now), High (fix soon), Medium (plan to fix)
  3. Apply Fix - Use proper async handling, test behavior not implementation
  4. Verify - Run tests in random order, ensure independence
  5. Prevent - Add test smell detection to CI

Features

Feature Description Guide
Flaky Tests Random failures destroying trust Use waitFor, not sleep; deterministic data
Implementation Testing Breaks on every refactor Test behavior through public interface
Over-Mocking Tests pass but bugs slip through Mock boundaries only, not your own code
Slow Tests Hurt development velocity Right test layer, shared setup, mock network
Test Interdependence Can't run tests in isolation Fresh state in beforeEach, no shared mutation
Poor Design Hard to understand/maintain Descriptive names, focused tests, clear values

Common Patterns

// FLAKY: Timing-dependent
await sleep(100);  // May not be enough
expect(result).toBe('processed');

// FIXED: Wait for condition
await waitFor(() => {
  expect(result).toBe('processed');
}, { timeout: 5000 });

// FLAKY: Shared state between tests
let sharedState = [];
it('test1', () => { sharedState.push('a'); });
it('test2', () => { expect(sharedState).toHaveLength(1); }); // Order-dependent!

// FIXED: Fresh state each test
beforeEach(() => { sharedState = []; });

// IMPLEMENTATION: Testing private state
expect(counter._count).toBe(1);

// BEHAVIOR: Testing public interface
expect(counter.getValue()).toBe(1);

// OVER-MOCKING: Everything mocked
const mockDb = { save: jest.fn() };
const mockPayment = { charge: jest.fn() };
// Only testing that mocks were called

// FIXED: Mock boundaries only
const testDb = await createTestDatabase();  // Real
const mockPayment = createMockPaymentProvider();  // External only
# Anti-Pattern Severity Guide
CRITICAL (fix immediately):
- Flaky tests - Random failures destroy trust
- Testing implementation - Breaks on every refactor
- Hidden dependencies - Tests fail mysteriously

HIGH (fix soon):
- Slow tests - Hurt development velocity
- Test interdependence - Can't run in isolation
- Over-mocking - Tests pass but bugs slip through

MEDIUM (plan to fix):
- Poor naming - Tests don't document behavior
- Magic values - Unclear expected values
- Giant tests - Hard to understand

LOW (fix when touching):
- Commented tests - Remove or fix
- Duplicate tests - Consolidate

Best Practices

Do Avoid
Test behavior, not implementation Accessing private properties
Use factories for test data Random/inconsistent test data
Write descriptive test names Generic names like "test1", "should work"
Keep tests independent Shared mutable state between tests
Mock only external boundaries Mocking your own code extensively
Use waitFor, not sleep setTimeout/sleep in tests
Make assertions specific toBeDefined() for everything
Run tests in random order Assuming test execution order
  • developing-test-driven - TDD with proper patterns
  • testing-with-vitest - Vitest testing framework
  • testing-with-playwright - E2E testing patterns
  • debugging-systematically - Debug flaky test failures