@vodailoc/kilo-kit-mcp 1.1.0

package/skills/kilo-kit/quality/testing/SKILL.md

@@ -0,0 +1,540 @@
+---
+name: testing-strategy
+description: >-
+  Comprehensive testing skill covering unit, integration, and e2e testing with TDD.
+  Use when writing tests, improving coverage, or setting up testing infrastructure.
+  Keywords: test, TDD, unit test, integration, e2e, coverage, mock, jest, vitest
+version: 1.0.0
+behaviors: [generate_with_validation, run_command, review_and_suggest]
+dependencies: []
+token_estimate:
+  min: 1500
+  typical: 3500
+  max: 8000
+---
+
+# 🧪 Testing Strategy Skill
+
+> **Philosophy:** If it's not tested, it's broken. You just don't know it yet.
+
+## When to Use
+
+Use this skill when:
+- Writing new code (TDD approach)
+- Adding tests to existing code
+- Improving test coverage
+- Fixing flaky tests
+- Setting up testing infrastructure
+- Debugging test failures
+
+**Do NOT use this skill when:**
+- Just running existing tests
+- Quick syntax check
+
+---
+
+## The Testing Pyramid
+
+```
+                 ╱╲
+                ╱  ╲
+               ╱ E2E╲           Few, slow, expensive
+              ╱──────╲          Full system tests
+             ╱        ╲
+            ╱Integration╲       Medium amount
+           ╱────────────╲       Component interaction
+          ╱              ╲
+         ╱   Unit Tests   ╲     Many, fast, cheap
+        ╱──────────────────╲    Single unit isolation
+```
+
+---
+
+## TDD Workflow: RED → GREEN → REFACTOR
+
+### Step 1: RED (Write Failing Test)
+
+```typescript
+// Write the test BEFORE the implementation
+describe('calculateDiscount', () => {
+  it('should apply 10% discount for orders over $100', () => {
+    // This test will FAIL because function doesn't exist yet
+    const result = calculateDiscount(150);
+    expect(result).toBe(135);
+  });
+});
+```
+
+**Run test → Should FAIL (RED)**
+
+### Step 2: GREEN (Minimal Implementation)
+
+```typescript
+// Write the MINIMUM code to pass the test
+function calculateDiscount(amount: number): number {
+  if (amount > 100) {
+    return amount * 0.9;
+  }
+  return amount;
+}
+```
+
+**Run test → Should PASS (GREEN)**
+
+### Step 3: REFACTOR (Improve)
+
+```typescript
+// Improve code while keeping tests green
+const DISCOUNT_THRESHOLD = 100;
+const DISCOUNT_RATE = 0.1;
+
+function calculateDiscount(amount: number): number {
+  if (amount > DISCOUNT_THRESHOLD) {
+    return amount * (1 - DISCOUNT_RATE);
+  }
+  return amount;
+}
+```
+
+**Run test → Should still PASS**
+
+---
+
+## Unit Testing Patterns
+
+### Basic Structure (AAA Pattern)
+
+```typescript
+describe('UserService', () => {
+  describe('createUser', () => {
+    it('should create user with valid data', async () => {
+      // Arrange
+      const userData = { email: 'test@example.com', name: 'Test' };
+      const mockRepo = { create: jest.fn().mockResolvedValue({ id: '1', ...userData }) };
+      const service = new UserService(mockRepo);
+      
+      // Act
+      const result = await service.createUser(userData);
+      
+      // Assert
+      expect(result.id).toBe('1');
+      expect(result.email).toBe(userData.email);
+      expect(mockRepo.create).toHaveBeenCalledWith(userData);
+    });
+  });
+});
+```
+
+### Testing Error Cases
+
+```typescript
+describe('createUser', () => {
+  it('should throw on duplicate email', async () => {
+    // Arrange
+    const mockRepo = {
+      findByEmail: jest.fn().mockResolvedValue({ id: 'existing' }),
+    };
+    const service = new UserService(mockRepo);
+    
+    // Act & Assert
+    await expect(
+      service.createUser({ email: 'exists@example.com' })
+    ).rejects.toThrow('Email already registered');
+  });
+});
+```
+
+### Testing Async Code
+
+```typescript
+describe('fetchUserData', () => {
+  it('should fetch and transform user data', async () => {
+    // Arrange
+    const mockApi = {
+      get: jest.fn().mockResolvedValue({ data: { name: 'John' } }),
+    };
+    
+    // Act
+    const result = await fetchUserData(mockApi, 'user-id');
+    
+    // Assert
+    expect(result).toEqual({ name: 'John' });
+    expect(mockApi.get).toHaveBeenCalledWith('/users/user-id');
+  });
+  
+  it('should handle API errors gracefully', async () => {
+    const mockApi = {
+      get: jest.fn().mockRejectedValue(new Error('Network error')),
+    };
+    
+    await expect(fetchUserData(mockApi, 'user-id'))
+      .rejects.toThrow('Failed to fetch user');
+  });
+});
+```
+
+---
+
+## Mocking Strategies
+
+### Mock Functions
+
+```typescript
+// Create mock function
+const mockFn = jest.fn();
+
+// Define return value
+mockFn.mockReturnValue('static value');
+mockFn.mockResolvedValue('async value');
+mockFn.mockRejectedValue(new Error('error'));
+
+// Implementation
+mockFn.mockImplementation((x) => x * 2);
+
+// Verify calls
+expect(mockFn).toHaveBeenCalled();
+expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');
+expect(mockFn).toHaveBeenCalledTimes(3);
+```
+
+### Mock Modules
+
+```typescript
+// Mock entire module
+jest.mock('./database', () => ({
+  connect: jest.fn(),
+  query: jest.fn(),
+}));
+
+// Mock with factory
+jest.mock('./config', () => ({
+  get: (key: string) => {
+    const config = { API_URL: 'http://test-api.com' };
+    return config[key];
+  },
+}));
+```
+
+### Spying
+
+```typescript
+// Spy on existing method
+const spy = jest.spyOn(userService, 'sendEmail');
+
+// Call the code
+await userService.createUser({ email: 'test@example.com' });
+
+// Verify the spy
+expect(spy).toHaveBeenCalled();
+
+// Restore original
+spy.mockRestore();
+```
+
+---
+
+## Integration Testing
+
+### API Integration Tests
+
+```typescript
+describe('POST /users', () => {
+  let app: Express;
+  let db: Database;
+  
+  beforeAll(async () => {
+    db = await Database.connect(TEST_DB_URL);
+    app = createApp(db);
+  });
+  
+  afterAll(async () => {
+    await db.disconnect();
+  });
+  
+  beforeEach(async () => {
+    await db.clear('users');
+  });
+  
+  it('should create user and return 201', async () => {
+    const response = await request(app)
+      .post('/users')
+      .send({ email: 'test@example.com', password: 'Password123!' })
+      .expect(201);
+    
+    expect(response.body.email).toBe('test@example.com');
+    expect(response.body.password).toBeUndefined();
+    
+    // Verify in database
+    const user = await db.users.findOne({ email: 'test@example.com' });
+    expect(user).toBeDefined();
+  });
+  
+  it('should return 400 for invalid email', async () => {
+    const response = await request(app)
+      .post('/users')
+      .send({ email: 'invalid', password: 'Password123!' })
+      .expect(400);
+    
+    expect(response.body.errors).toContainEqual(
+      expect.objectContaining({ field: 'email' })
+    );
+  });
+});
+```
+
+### Database Integration Tests
+
+```typescript
+describe('UserRepository', () => {
+  let db: Database;
+  let repo: UserRepository;
+  
+  beforeAll(async () => {
+    db = await Database.connect(TEST_DB_URL);
+    repo = new UserRepository(db);
+  });
+  
+  beforeEach(async () => {
+    await db.clear('users');
+    await db.seed('users', testUsers);
+  });
+  
+  it('should find user by email', async () => {
+    const user = await repo.findByEmail('john@example.com');
+    expect(user?.name).toBe('John Doe');
+  });
+  
+  it('should return null for non-existent email', async () => {
+    const user = await repo.findByEmail('nobody@example.com');
+    expect(user).toBeNull();
+  });
+});
+```
+
+---
+
+## E2E Testing
+
+### Playwright Example
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('User Registration', () => {
+  test('should complete registration flow', async ({ page }) => {
+    // Navigate to registration
+    await page.goto('/register');
+    
+    // Fill form
+    await page.fill('[data-testid="email"]', 'newuser@example.com');
+    await page.fill('[data-testid="password"]', 'SecurePassword123!');
+    await page.fill('[data-testid="name"]', 'New User');
+    
+    // Submit
+    await page.click('[data-testid="submit"]');
+    
+    // Verify redirect to dashboard
+    await expect(page).toHaveURL('/dashboard');
+    await expect(page.locator('[data-testid="welcome-message"]'))
+      .toContainText('Welcome, New User');
+  });
+  
+  test('should show validation errors', async ({ page }) => {
+    await page.goto('/register');
+    
+    await page.fill('[data-testid="email"]', 'invalid-email');
+    await page.click('[data-testid="submit"]');
+    
+    await expect(page.locator('[data-testid="email-error"]'))
+      .toBeVisible();
+  });
+});
+```
+
+---
+
+## Test Coverage
+
+### Coverage Targets
+
+```yaml
+coverage_targets:
+  statements: 80%
+  branches: 80%
+  functions: 80%
+  lines: 80%
+
+priority_areas:
+  critical: 95%+  # Auth, payments, core business logic
+  high: 85%+      # API endpoints, services
+  medium: 70%+    # Utilities, helpers
+  low: 50%+       # UI components, config
+```
+
+### Coverage Configuration
+
+```javascript
+// jest.config.js
+module.exports = {
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/**/*.d.ts',
+    '!src/**/*.stories.{ts,tsx}',
+    '!src/test/**/*',
+  ],
+};
+```
+
+---
+
+## Fixing Flaky Tests
+
+### Common Causes & Solutions
+
+| Cause | Symptom | Solution |
+|-------|---------|----------|
+| Race conditions | Fails randomly | Add proper waits, use async/await correctly |
+| Shared state | Fails when run together | Isolate test data, proper cleanup |
+| Time-dependent | Fails at certain times | Mock Date/time |
+| External dependencies | Fails intermittently | Mock external services |
+| Order dependency | Fails when run in different order | Make tests independent |
+
+### Debugging Flaky Tests
+
+```typescript
+// Add retries for known flaky tests (use sparingly!)
+test('flaky network test', { retry: 2 }, async () => {
+  // ...
+});
+
+// Log more info on failure
+afterEach(function() {
+  if (this.currentTest?.state === 'failed') {
+    console.log('Test state:', JSON.stringify(testState, null, 2));
+  }
+});
+
+// Increase timeout if needed
+test('slow test', async () => {
+  // ...
+}, 30000); // 30 second timeout
+```
+
+---
+
+## Test Organization
+
+### File Structure
+
+```
+src/
+├── users/
+│   ├── users.service.ts
+│   ├── users.service.spec.ts      # Unit tests
+│   └── users.controller.ts
+│
+tests/
+├── unit/                          # Additional unit tests
+├── integration/
+│   ├── api/
+│   │   └── users.api.spec.ts
+│   └── db/
+│       └── users.repo.spec.ts
+├── e2e/
+│   └── user-registration.spec.ts
+├── fixtures/
+│   └── users.fixture.ts
+└── helpers/
+    ├── database.helper.ts
+    └── auth.helper.ts
+```
+
+### Test Naming Conventions
+
+```typescript
+// Use descriptive names
+describe('UserService')
+describe('createUser method')
+
+// "should" format
+it('should create user with valid data')
+it('should throw when email is duplicate')
+it('should hash password before saving')
+
+// Given-When-Then for complex scenarios
+it('given authenticated admin, when deleting user, should succeed')
+```
+
+---
+
+## Guidelines
+
+### DO ✅
+- Write tests before code (TDD)
+- Test behavior, not implementation
+- Keep tests independent
+- Use descriptive test names
+- Test edge cases and errors
+- Clean up after tests
+
+### DON'T ❌
+- Test private methods directly
+- Share state between tests
+- Test framework/library code
+- Write tests that always pass
+- Ignore flaky tests
+- Mock everything
+
+---
+
+## Test Quality Checklist
+
+```yaml
+test_quality:
+  - Tests run independently in any order
+  - Tests don't depend on external services
+  - Tests are deterministic (not flaky)
+  - Tests are fast (<100ms for unit tests)
+  - Tests have meaningful assertions
+  - Tests cover happy path AND error cases
+  - Tests are readable and maintainable
+  - Tests use realistic data
+```
+
+---
+
+## Success Criteria
+
+Before considering testing complete:
+
+- [ ] All new code has tests
+- [ ] Coverage meets targets
+- [ ] All tests pass consistently
+- [ ] No flaky tests
+- [ ] Edge cases covered
+- [ ] Error conditions tested
+- [ ] Tests run in CI pipeline
+- [ ] Tests are maintainable
+
+---
+
+## Related Skills
+
+- `skills/kilo-kit/quality/code-review/` - For reviewing test quality
+- `skills/kilo-kit/debugging/verification/` - For verifying fixes
+- `skills/kilo-kit/development/backend/` - For testing APIs
+
+---
+
+*Testing Strategy Skill v1.0.0 — Test it or regret it*