What is testing-strategy?

This Claude skill empowers developers to design and implement robust testing strategies across any codebase. It offers expert guidance on the testing pyramid, framework selection for multiple languages (JavaScript, Python, Go), and provides actionable templates for unit, integration, and E2E tests to maximize code reliability and coverage.

When should I use testing-strategy?

testing-strategy is useful in the following scenarios: • Architecting a balanced testing infrastructure using the testing pyramid approach for new or existing software projects. • Selecting and configuring the most effective testing frameworks (e.g., Vitest, Pytest, Playwright) based on the specific programming language and project requirements. • Developing comprehensive test suites including isolated unit tests for business logic, integration tests for API contracts, and E2E tests for critical user journeys. • Establishing code coverage thresholds and advanced mocking strategies to ensure high-quality software delivery and prevent regressions.

name	testing-strategy
description	Designs comprehensive testing strategies for any codebase. Use when adding tests, improving coverage, setting up testing infrastructure, or when asked about testing approaches.

Testing Strategy Skill

Testing Pyramid Approach

Apply the testing pyramid for balanced coverage:

        /\
       /  \     E2E Tests (10%)
      /----\    - Critical user journeys
     /      \   - Slow but comprehensive
    /--------\  Integration Tests (20%)
   /          \ - Component interactions
  /------------\ - API contracts
 /              \ Unit Tests (70%)
/________________\ - Fast, isolated
                   - Business logic focus

Framework Selection by Language

JavaScript/TypeScript

Type	Recommended	Alternative
Unit	Vitest	Jest
Integration	Vitest + MSW	Jest + SuperTest
E2E	Playwright	Cypress
Component	Testing Library	Enzyme

Python

Type	Recommended	Alternative
Unit	pytest	unittest
Integration	pytest + httpx	pytest + requests
E2E	Playwright	Selenium
API	pytest + FastAPI TestClient	-

Go

Type	Recommended
Unit	testing + testify
Integration	testing + httptest
E2E	testing + chromedp

Test Structure Templates

Unit Test

describe('[Unit] ComponentName', () => {
  describe('methodName', () => {
    it('should [expected behavior] when [condition]', () => {
      // Arrange
      const input = createTestInput();
      
      // Act
      const result = methodName(input);
      
      // Assert
      expect(result).toEqual(expectedOutput);
    });
    
    it('should throw error when [invalid condition]', () => {
      expect(() => methodName(invalidInput)).toThrow(ExpectedError);
    });
  });
});

Integration Test

describe('[Integration] API /users', () => {
  beforeAll(async () => {
    await setupTestDatabase();
  });
  
  afterAll(async () => {
    await teardownTestDatabase();
  });
  
  it('should create user and return 201', async () => {
    const response = await request(app)
      .post('/users')
      .send({ name: 'Test', email: 'test@example.com' });
    
    expect(response.status).toBe(201);
    expect(response.body.id).toBeDefined();
  });
});

E2E Test

describe('[E2E] User Registration Flow', () => {
  it('should complete registration successfully', async ({ page }) => {
    await page.goto('/register');
    
    await page.fill('[data-testid="email"]', 'new@example.com');
    await page.fill('[data-testid="password"]', 'SecurePass123!');
    await page.click('[data-testid="submit"]');
    
    await expect(page.locator('.welcome-message')).toBeVisible();
    await expect(page).toHaveURL('/dashboard');
  });
});

Coverage Strategy

What to Cover

✅ Business logic (100%)
✅ Edge cases and error handling (90%+)
✅ API contracts (100%)
✅ Critical user paths (E2E)
⚠️ UI components (snapshot + interaction)
❌ Third-party library internals
❌ Simple getters/setters

Coverage Thresholds

{
  "coverageThreshold": {
    "global": {
      "branches": 80,
      "functions": 80,
      "lines": 80,
      "statements": 80
    },
    "src/core/": {
      "branches": 95,
      "functions": 95
    }
  }
}

Test Data Management

Factories/Builders

// factories/user.js
export const userFactory = (overrides = {}) => ({
  id: faker.string.uuid(),
  name: faker.person.fullName(),
  email: faker.internet.email(),
  createdAt: new Date(),
  ...overrides,
});

// Usage
const admin = userFactory({ role: 'admin' });

Fixtures

// fixtures/users.json
{
  "validUser": { "name": "Test", "email": "test@example.com" },
  "invalidUser": { "name": "", "email": "invalid" }
}

Mocking Strategy

When to Mock

✅ External APIs and services
✅ Database in unit tests
✅ Time/Date for determinism
✅ Random values
❌ Internal modules (usually)
❌ The code under test

Mock Examples

// API mocking with MSW
import { http, HttpResponse } from 'msw';

export const handlers = [
  http.get('/api/users', () => {
    return HttpResponse.json([
      { id: 1, name: 'John' },
    ]);
  }),
];

// Time mocking
vi.useFakeTimers();
vi.setSystemTime(new Date('2024-01-01'));

testing-strategy

When & Why to Use This Skill

Use Cases