omgkit 2.21.7 → 2.22.0

package/plugin/skills/testing/mutation-testing/SKILL.md

@@ -0,0 +1,335 @@
+---
+name: testing/mutation-testing
+description: Mutation testing with Stryker to verify test quality by introducing code mutations and measuring detection rates
+category: testing
+tags:
+  - testing
+  - mutation
+  - stryker
+  - quality
+  - coverage
+related_skills:
+  - testing/comprehensive-testing
+  - testing/vitest
+  - methodology/quality-gates
+---
+
+# Mutation Testing
+
+Measure test quality by introducing bugs (mutations) and verifying your tests catch them.
+
+## Quick Start
+
+```bash
+# Install Stryker
+npm install -D @stryker-mutator/core @stryker-mutator/vitest-runner
+
+# Initialize configuration
+npx stryker init
+
+# Run mutation testing
+npm run test:mutation
+```
+
+## Core Concept
+
+Mutation testing introduces small changes (mutations) to your code and runs your tests. If tests still pass, they're too weak.
+
+```javascript
+// Original code
+function isAdult(age) {
+  return age >= 18;
+}
+
+// Mutations Stryker creates:
+function isAdult(age) { return age > 18; }   // >= to >
+function isAdult(age) { return age <= 18; }  // >= to <=
+function isAdult(age) { return false; }      // return false
+function isAdult(age) { return true; }       // return true
+```
+
+A good test catches all mutations:
+
+```javascript
+describe('isAdult', () => {
+  it('returns true for age 18', () => {
+    expect(isAdult(18)).toBe(true);  // Catches >= to >
+  });
+
+  it('returns false for age 17', () => {
+    expect(isAdult(17)).toBe(false); // Catches >= to <=
+  });
+
+  it('returns true for age 100', () => {
+    expect(isAdult(100)).toBe(true); // Catches return false
+  });
+});
+```
+
+## Configuration
+
+### stryker.config.json
+
+```json
+{
+  "$schema": "https://raw.githubusercontent.com/stryker-mutator/stryker/master/packages/core/schema/stryker-schema.json",
+  "packageManager": "npm",
+  "testRunner": "vitest",
+  "mutate": [
+    "src/**/*.js",
+    "src/**/*.ts",
+    "!src/**/*.test.js",
+    "!src/**/*.spec.ts"
+  ],
+  "reporters": [
+    "progress",
+    "clear-text",
+    "html",
+    "json"
+  ],
+  "htmlReporter": {
+    "fileName": "reports/mutation/index.html"
+  },
+  "thresholds": {
+    "high": 80,
+    "low": 60,
+    "break": 50
+  },
+  "concurrency": 4,
+  "timeoutMS": 60000
+}
+```
+
+## Mutation Operators
+
+### Arithmetic Operators
+```javascript
+// Original: a + b
+a - b    // Plus to Minus
+a * b    // Plus to Times
+a / b    // Plus to Divide
+```
+
+### Comparison Operators
+```javascript
+// Original: a > b
+a >= b   // Greater to GreaterOrEqual
+a < b    // Greater to Less
+a <= b   // Greater to LessOrEqual
+a == b   // Greater to Equal
+```
+
+### Logical Operators
+```javascript
+// Original: a && b
+a || b   // And to Or
+
+// Original: !a
+a        // Negate removal
+```
+
+### Boundary Mutations
+```javascript
+// Original: i < 10
+i <= 10  // Less to LessOrEqual
+i < 11   // Boundary change
+i < 9    // Boundary change
+```
+
+### Return Value Mutations
+```javascript
+// Original: return value
+return undefined;  // Remove return
+return !value;     // Negate return
+return "";         // Empty string
+return 0;          // Zero
+return null;       // Null
+```
+
+## Understanding Results
+
+### Mutation States
+
+| State | Description | Action |
+|-------|-------------|--------|
+| **Killed** | Test failed = mutation caught | Good! |
+| **Survived** | Tests passed = mutation missed | Add tests |
+| **Timeout** | Tests took too long | Check infinite loops |
+| **No Coverage** | No tests cover this code | Add tests |
+| **Compile Error** | Mutation broke compilation | Ignore |
+
+### Mutation Score
+
+```
+Mutation Score = (Killed / Total) * 100%
+```
+
+- **80%+**: Excellent test quality
+- **60-80%**: Good, room for improvement
+- **40-60%**: Weak tests, many gaps
+- **<40%**: Critical test deficiency
+
+## Improving Mutation Score
+
+### 1. Boundary Testing
+
+```javascript
+// Weak: Only tests middle values
+it('validates age', () => {
+  expect(isValidAge(25)).toBe(true);
+});
+
+// Strong: Tests boundaries
+it('validates age boundaries', () => {
+  expect(isValidAge(0)).toBe(true);    // Min boundary
+  expect(isValidAge(-1)).toBe(false);  // Below min
+  expect(isValidAge(150)).toBe(true);  // Max boundary
+  expect(isValidAge(151)).toBe(false); // Above max
+});
+```
+
+### 2. Condition Coverage
+
+```javascript
+// Original
+function process(a, b) {
+  if (a > 0 && b > 0) {
+    return 'both positive';
+  }
+  return 'not both positive';
+}
+
+// Weak: Only tests one path
+it('processes positive', () => {
+  expect(process(1, 1)).toBe('both positive');
+});
+
+// Strong: Tests all conditions
+it('processes various combinations', () => {
+  expect(process(1, 1)).toBe('both positive');
+  expect(process(-1, 1)).toBe('not both positive'); // a negative
+  expect(process(1, -1)).toBe('not both positive'); // b negative
+  expect(process(0, 1)).toBe('not both positive');  // a zero
+});
+```
+
+### 3. Return Value Testing
+
+```javascript
+// Weak: Only tests truthy
+it('checks admin', () => {
+  expect(isAdmin(adminUser)).toBeTruthy();
+});
+
+// Strong: Tests exact values
+it('checks admin status', () => {
+  expect(isAdmin(adminUser)).toBe(true);
+  expect(isAdmin(regularUser)).toBe(false);
+  expect(isAdmin(null)).toBe(false);
+});
+```
+
+## Incremental Mutation Testing
+
+For large codebases, run mutations on changed files only:
+
+```bash
+# Only mutate changed files
+git diff --name-only origin/main | xargs npx stryker run --mutate
+```
+
+## CI Integration
+
+### GitHub Actions
+
+```yaml
+name: Mutation Testing
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  mutation:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - run: npm ci
+
+      - name: Run Mutation Tests
+        run: npm run test:mutation
+
+      - name: Upload Report
+        uses: actions/upload-artifact@v4
+        with:
+          name: mutation-report
+          path: reports/mutation/
+```
+
+## Performance Optimization
+
+### Reduce Mutation Scope
+
+```json
+{
+  "mutate": [
+    "src/core/**/*.js",
+    "!src/core/**/*.test.js",
+    "!src/core/generated/**"
+  ]
+}
+```
+
+### Increase Parallelism
+
+```json
+{
+  "concurrency": 8,
+  "testRunner": "vitest"
+}
+```
+
+### Filter Mutators
+
+```json
+{
+  "mutator": {
+    "excludedMutations": [
+      "StringLiteral",
+      "ObjectLiteral"
+    ]
+  }
+}
+```
+
+## When to Use
+
+### Good Candidates
+- Critical business logic
+- Security-sensitive code
+- Mathematical calculations
+- State machines
+- Validation logic
+
+### When to Skip
+- Generated code
+- Configuration files
+- Third-party wrappers
+- UI components
+- Test utilities
+
+## Anti-Patterns
+
+1. **Chasing 100%**: Diminishing returns above 90%
+2. **Ignoring Timeouts**: Fix infinite loop mutations
+3. **Testing Everything**: Focus on critical paths
+4. **No Baseline**: Establish baseline before improving
+5. **Infrequent Runs**: Run on every PR

package/plugin/skills/testing/performance-testing/SKILL.md

@@ -0,0 +1,361 @@
+---
+name: testing/performance-testing
+description: Performance testing patterns including load testing, stress testing, benchmarking, and profiling for optimal application performance
+category: testing
+tags:
+  - testing
+  - performance
+  - benchmarking
+  - load-testing
+  - profiling
+related_skills:
+  - testing/comprehensive-testing
+  - devops/observability
+  - backend/caching-strategies
+---
+
+# Performance Testing
+
+Comprehensive performance testing for speed, scalability, and resource efficiency.
+
+## Quick Start
+
+```bash
+# Run benchmarks
+npm run test:performance
+
+# Profile with Node.js
+node --prof app.js
+node --prof-process isolate-*.log > profile.txt
+
+# Load testing with k6
+k6 run load-test.js
+```
+
+## Types of Performance Tests
+
+### 1. Benchmark Tests
+
+Measure execution time of specific operations.
+
+```javascript
+import { describe, it, expect } from 'vitest';
+
+describe('Performance Benchmarks', () => {
+  function timeExecution(fn, iterations = 1000) {
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+      fn();
+    }
+    const end = performance.now();
+    return (end - start) / iterations;
+  }
+
+  it('sorts 1000 items under 1ms', () => {
+    const data = Array(1000).fill().map(() => Math.random());
+    const time = timeExecution(() => [...data].sort((a, b) => a - b), 100);
+    expect(time).toBeLessThan(1);
+  });
+
+  it('hashes string under 0.1ms', () => {
+    const time = timeExecution(() => hashString('test-string'), 10000);
+    expect(time).toBeLessThan(0.1);
+  });
+
+  it('parses JSON under 0.5ms', () => {
+    const json = JSON.stringify({ users: Array(100).fill({ name: 'test' }) });
+    const time = timeExecution(() => JSON.parse(json), 1000);
+    expect(time).toBeLessThan(0.5);
+  });
+});
+```
+
+### 2. Load Tests
+
+Simulate concurrent users to test scalability.
+
+```javascript
+// k6 load test script
+import http from 'k6/http';
+import { check, sleep } from 'k6';
+
+export const options = {
+  stages: [
+    { duration: '1m', target: 50 },   // Ramp up to 50 users
+    { duration: '3m', target: 50 },   // Stay at 50 users
+    { duration: '1m', target: 100 },  // Ramp up to 100
+    { duration: '3m', target: 100 },  // Stay at 100
+    { duration: '1m', target: 0 },    // Ramp down
+  ],
+  thresholds: {
+    http_req_duration: ['p(95)<200'], // 95% under 200ms
+    http_req_failed: ['rate<0.01'],   // Error rate < 1%
+  },
+};
+
+export default function () {
+  const res = http.get('https://api.example.com/users');
+
+  check(res, {
+    'status is 200': (r) => r.status === 200,
+    'response time < 200ms': (r) => r.timings.duration < 200,
+  });
+
+  sleep(1);
+}
+```
+
+### 3. Stress Tests
+
+Push system beyond normal limits.
+
+```javascript
+describe('Stress Tests', () => {
+  it('handles 10000 concurrent connections', async () => {
+    const connections = Array(10000).fill().map(async () => {
+      const ws = new WebSocket('ws://localhost:3000');
+      return new Promise((resolve, reject) => {
+        ws.onopen = () => resolve(ws);
+        ws.onerror = reject;
+        setTimeout(() => reject(new Error('timeout')), 5000);
+      });
+    });
+
+    const results = await Promise.allSettled(connections);
+    const successful = results.filter(r => r.status === 'fulfilled');
+    expect(successful.length).toBeGreaterThan(9000);
+  });
+
+  it('recovers after memory pressure', async () => {
+    const allocations = [];
+
+    // Allocate memory
+    for (let i = 0; i < 100; i++) {
+      allocations.push(new Array(1000000).fill('x'));
+    }
+
+    // Force GC and clear
+    allocations.length = 0;
+    if (global.gc) global.gc();
+
+    // System should still function
+    const result = await api.get('/health');
+    expect(result.status).toBe(200);
+  });
+});
+```
+
+### 4. Memory Tests
+
+Detect memory leaks and inefficiencies.
+
+```javascript
+describe('Memory Tests', () => {
+  it('does not leak memory on repeated operations', async () => {
+    const before = process.memoryUsage().heapUsed;
+
+    for (let i = 0; i < 10000; i++) {
+      await processRequest({ data: 'test' });
+    }
+
+    if (global.gc) global.gc();
+    await new Promise(r => setTimeout(r, 100));
+
+    const after = process.memoryUsage().heapUsed;
+    const leaked = after - before;
+
+    expect(leaked).toBeLessThan(10 * 1024 * 1024); // 10MB
+  });
+
+  it('releases event listeners', () => {
+    const emitter = new EventEmitter();
+    const before = emitter.listenerCount('event');
+
+    for (let i = 0; i < 100; i++) {
+      const handler = () => {};
+      emitter.on('event', handler);
+      emitter.off('event', handler);
+    }
+
+    const after = emitter.listenerCount('event');
+    expect(after).toBe(before);
+  });
+});
+```
+
+## API Response Time Tests
+
+```javascript
+describe('API Performance', () => {
+  const SLA = {
+    p50: 50,   // 50th percentile under 50ms
+    p95: 200,  // 95th percentile under 200ms
+    p99: 500,  // 99th percentile under 500ms
+  };
+
+  it('meets response time SLA', async () => {
+    const times = [];
+
+    for (let i = 0; i < 1000; i++) {
+      const start = performance.now();
+      await api.get('/users');
+      times.push(performance.now() - start);
+    }
+
+    times.sort((a, b) => a - b);
+
+    const p50 = times[Math.floor(times.length * 0.50)];
+    const p95 = times[Math.floor(times.length * 0.95)];
+    const p99 = times[Math.floor(times.length * 0.99)];
+
+    expect(p50).toBeLessThan(SLA.p50);
+    expect(p95).toBeLessThan(SLA.p95);
+    expect(p99).toBeLessThan(SLA.p99);
+  });
+});
+```
+
+## Database Performance Tests
+
+```javascript
+describe('Database Performance', () => {
+  it('query executes under 10ms', async () => {
+    const start = performance.now();
+    await db.query('SELECT * FROM users WHERE id = ?', [1]);
+    const duration = performance.now() - start;
+    expect(duration).toBeLessThan(10);
+  });
+
+  it('handles 100 concurrent queries', async () => {
+    const queries = Array(100).fill().map(() =>
+      db.query('SELECT * FROM users LIMIT 10')
+    );
+
+    const start = performance.now();
+    await Promise.all(queries);
+    const duration = performance.now() - start;
+
+    expect(duration).toBeLessThan(1000);
+  });
+
+  it('insert batch is efficient', async () => {
+    const records = Array(1000).fill().map((_, i) => ({
+      name: `User ${i}`,
+      email: `user${i}@test.com`,
+    }));
+
+    const start = performance.now();
+    await db.batchInsert('users', records);
+    const duration = performance.now() - start;
+
+    expect(duration).toBeLessThan(500);
+  });
+});
+```
+
+## Profiling Patterns
+
+### CPU Profiling
+
+```javascript
+const v8Profiler = require('v8-profiler-next');
+
+async function profileCPU(fn, name) {
+  v8Profiler.startProfiling(name);
+
+  await fn();
+
+  const profile = v8Profiler.stopProfiling(name);
+  profile.export((error, result) => {
+    fs.writeFileSync(`${name}.cpuprofile`, result);
+  });
+}
+```
+
+### Memory Profiling
+
+```javascript
+function takeHeapSnapshot(name) {
+  const snapshot = v8.writeHeapSnapshot();
+  console.log(`Heap snapshot written to ${snapshot}`);
+}
+
+// In test
+it('memory usage is stable', async () => {
+  takeHeapSnapshot('before');
+
+  for (let i = 0; i < 10000; i++) {
+    await processData();
+  }
+
+  if (global.gc) global.gc();
+  takeHeapSnapshot('after');
+});
+```
+
+## Performance Budgets
+
+```javascript
+const budgets = {
+  'First Contentful Paint': 1500,
+  'Time to Interactive': 3500,
+  'Total Bundle Size': 250 * 1024,
+  'API Response Time': 200,
+};
+
+describe('Performance Budgets', () => {
+  it('bundle size within budget', async () => {
+    const stats = require('./dist/stats.json');
+    const totalSize = stats.assets
+      .filter(a => a.name.endsWith('.js'))
+      .reduce((sum, a) => sum + a.size, 0);
+
+    expect(totalSize).toBeLessThan(budgets['Total Bundle Size']);
+  });
+});
+```
+
+## Continuous Performance Testing
+
+### GitHub Actions
+
+```yaml
+name: Performance Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  performance:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - run: npm ci
+      - run: npm run test:performance
+
+      - name: Compare with baseline
+        run: |
+          npm run benchmark:compare -- --baseline main
+```
+
+## When to Use
+
+- Before major releases
+- After performance-critical changes
+- During capacity planning
+- When SLA monitoring shows degradation
+- As part of CI/CD pipeline
+
+## Anti-Patterns
+
+1. **Testing on Development Hardware**: Use production-like environment
+2. **Ignoring Warmup**: JIT compilation affects first runs
+3. **Single Metric Focus**: Monitor multiple dimensions
+4. **No Baseline**: Always compare against baseline
+5. **Flaky Thresholds**: Use percentiles, not averages