ai-devx 1.0.0 → 1.0.2

package/templates/.agent/skills/testing-patterns/SKILL.md

@@ -1,262 +1,178 @@
 ---
 name: testing-patterns
-description: Comprehensive testing strategies for unit, integration, and E2E tests
-version: "1.0.0"
-requires: []
-related:
-  - react-best-practices
-  - backend-specialist
+description: Testing patterns and principles. Unit, integration, mocking strategies.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
 ---
 
-# Testing Patterns Skill
+# Testing Patterns
 
-## Testing Pyramid
+> Principles for reliable test suites.
+
+---
+
+## 1. Testing Pyramid
 
 ```
-    /\
-   /  \  E2E Tests
-  /____\  (Slow, Expensive)
- /      \
-/________\ Integration Tests
-          (Medium Speed)
-____________
-Unit Tests
-(Fast, Cheap)
+        /\          E2E (Few)
+       /  \         Critical flows
+      /----\
+     /      \       Integration (Some)
+    /--------\      API, DB queries
+   /          \
+  /------------\    Unit (Many)
+                    Functions, classes
 ```
 
-## Unit Testing
+---
 
-### AAA Pattern
-```typescript
-// Arrange
-const user = { name: 'John', age: 30 };
+## 2. AAA Pattern
 
-// Act
-const result = calculateAgeGroup(user);
+| Step | Purpose |
+|------|---------|
+| **Arrange** | Set up test data |
+| **Act** | Execute code under test |
+| **Assert** | Verify outcome |
 
-// Assert
-expect(result).toBe('adult');
-```
+---
 
-### Test Naming
-```typescript
-describe('calculateAgeGroup', () => {
-  it('should return "child" when age is less than 13', () => {
-    // test
-  });
-  
-  it('should return "teen" when age is between 13 and 19', () => {
-    // test
-  });
-  
-  it('should return "adult" when age is 20 or greater', () => {
-    // test
-  });
-});
-```
+## 3. Test Type Selection
 
-### React Component Testing
-```tsx
-import { render, screen, fireEvent } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-
-describe('Button', () => {
-  it('should render button with text', () => {
-    render(<Button>Click me</Button>);
-    expect(screen.getByText('Click me')).toBeInTheDocument();
-  });
-  
-  it('should call onClick when clicked', async () => {
-    const handleClick = jest.fn();
-    render(<Button onClick={handleClick}>Click me</Button>);
-    
-    await userEvent.click(screen.getByText('Click me'));
-    expect(handleClick).toHaveBeenCalledTimes(1);
-  });
-  
-  it('should be disabled when disabled prop is true', () => {
-    render(<Button disabled>Click me</Button>);
-    expect(screen.getByText('Click me')).toBeDisabled();
-  });
-});
-```
+### When to Use Each
 
-### Mocking
-```typescript
-// Mock modules
-jest.mock('./api', () => ({
-  fetchUser: jest.fn()
-}));
-
-// Mock return value
-(fetchUser as jest.Mock).mockResolvedValue({ id: 1, name: 'John' });
-
-// Mock with implementation
-jest.mock('./logger', () => ({
-  log: jest.fn(),
-  error: jest.fn()
-}));
-```
+| Type | Best For | Speed |
+|------|----------|-------|
+| **Unit** | Pure functions, logic | Fast (<50ms) |
+| **Integration** | API, DB, services | Medium |
+| **E2E** | Critical user flows | Slow |
 
-## Integration Testing
-
-### API Testing
-```typescript
-import request from 'supertest';
-import { app } from './app';
-
-describe('Users API', () => {
-  it('should create a new user', async () => {
-    const response = await request(app)
-      .post('/users')
-      .send({ name: 'John', email: 'john@example.com' })
-      .expect(201);
-    
-    expect(response.body.data.name).toBe('John');
-  });
-  
-  it('should return 400 for invalid data', async () => {
-    await request(app)
-      .post('/users')
-      .send({ name: '' })
-      .expect(400);
-  });
-});
-```
+---
 
-### Database Testing
-```typescript
-import { prisma } from './db';
-
-describe('User Repository', () => {
-  beforeEach(async () => {
-    await prisma.user.deleteMany();
-  });
-  
-  it('should create user in database', async () => {
-    const user = await prisma.user.create({
-      data: { email: 'test@example.com', name: 'Test' }
-    });
-    
-    expect(user.email).toBe('test@example.com');
-    
-    const found = await prisma.user.findUnique({
-      where: { id: user.id }
-    });
-    expect(found).toBeTruthy();
-  });
-});
-```
+## 4. Unit Test Principles
 
-## E2E Testing
-
-### Playwright Example
-```typescript
-import { test, expect } from '@playwright/test';
-
-test('user can login', async ({ page }) => {
-  await page.goto('/login');
-  
-  await page.fill('[name="email"]', 'user@example.com');
-  await page.fill('[name="password"]', 'password123');
-  await page.click('button[type="submit"]');
-  
-  await expect(page).toHaveURL('/dashboard');
-  await expect(page.locator('h1')).toContainText('Welcome');
-});
-
-test('user can complete purchase flow', async ({ page }) => {
-  // Browse products
-  await page.goto('/products');
-  await page.click('text=Add to Cart');
-  
-  // Go to cart
-  await page.click('text=Cart');
-  await page.click('text=Checkout');
-  
-  // Fill checkout form
-  await page.fill('[name="address"]', '123 Main St');
-  await page.click('text=Place Order');
-  
-  // Verify success
-  await expect(page.locator('.success-message')).toBeVisible();
-});
-```
+### Good Unit Tests
 
-## Test Coverage
-
-### Coverage Thresholds
-```json
-{
-  "coverageThreshold": {
-    "global": {
-      "branches": 80,
-      "functions": 80,
-      "lines": 80,
-      "statements": 80
-    }
-  }
-}
-```
+| Principle | Meaning |
+|-----------|---------|
+| Fast | < 100ms each |
+| Isolated | No external deps |
+| Repeatable | Same result always |
+| Self-checking | No manual verification |
+| Timely | Written with code |
+
+### What to Unit Test
+
+| Test | Don't Test |
+|------|------------|
+| Business logic | Framework code |
+| Edge cases | Third-party libs |
+| Error handling | Simple getters |
+
+---
+
+## 5. Integration Test Principles
 
 ### What to Test
 
-**Always Test:**
-- Business logic
-- Edge cases
-- Error handling
-- User interactions
-- API contracts
-
-**Don't Test:**
-- Third-party libraries
-- Simple getters/setters
-- Implementation details
-- CSS/styling
-
-## TDD Workflow
-
-1. **Red**: Write failing test
-   ```typescript
-   it('should add two numbers', () => {
-     expect(add(1, 2)).toBe(3);
-   });
-   ```
-
-2. **Green**: Write minimal code
-   ```typescript
-   function add(a: number, b: number) {
-     return a + b;
-   }
-   ```
-
-3. **Refactor**: Improve code
-   ```typescript
-   // Add input validation
-   function add(a: number, b: number) {
-     if (typeof a !== 'number' || typeof b !== 'number') {
-       throw new Error('Inputs must be numbers');
-     }
-     return a + b;
-   }
-   ```
-
-## Testing Checklist
-
-### Before Writing Tests
-- [ ] Understand requirements
-- [ ] Identify edge cases
-- [ ] Plan test scenarios
-
-### While Writing Tests
-- [ ] Test happy path
-- [ ] Test error cases
-- [ ] Test boundary conditions
-- [ ] Use descriptive names
-- [ ] One concept per test
-
-### After Writing Tests
-- [ ] All tests pass
-- [ ] Coverage meets thresholds
-- [ ] Tests are maintainable
-- [ ] No test interdependencies
+| Area | Focus |
+|------|-------|
+| API endpoints | Request/response |
+| Database | Queries, transactions |
+| External services | Contracts |
+
+### Setup/Teardown
+
+| Phase | Action |
+|-------|--------|
+| Before All | Connect resources |
+| Before Each | Reset state |
+| After Each | Clean up |
+| After All | Disconnect |
+
+---
+
+## 6. Mocking Principles
+
+### When to Mock
+
+| Mock | Don't Mock |
+|------|------------|
+| External APIs | The code under test |
+| Database (unit) | Simple dependencies |
+| Time/random | Pure functions |
+| Network | In-memory stores |
+
+### Mock Types
+
+| Type | Use |
+|------|-----|
+| Stub | Return fixed values |
+| Spy | Track calls |
+| Mock | Set expectations |
+| Fake | Simplified implementation |
+
+---
+
+## 7. Test Organization
+
+### Naming
+
+| Pattern | Example |
+|---------|---------|
+| Should behavior | "should return error when..." |
+| When condition | "when user not found..." |
+| Given-when-then | "given X, when Y, then Z" |
+
+### Grouping
+
+| Level | Use |
+|-------|-----|
+| describe | Group related tests |
+| it/test | Individual case |
+| beforeEach | Common setup |
+
+---
+
+## 8. Test Data
+
+### Strategies
+
+| Approach | Use |
+|----------|-----|
+| Factories | Generate test data |
+| Fixtures | Predefined datasets |
+| Builders | Fluent object creation |
+
+### Principles
+
+- Use realistic data
+- Randomize non-essential values (faker)
+- Share common fixtures
+- Keep data minimal
+
+---
+
+## 9. Best Practices
+
+| Practice | Why |
+|----------|-----|
+| One assert per test | Clear failure reason |
+| Independent tests | No order dependency |
+| Fast tests | Run frequently |
+| Descriptive names | Self-documenting |
+| Clean up | Avoid side effects |
+
+---
+
+## 10. Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Test implementation | Test behavior |
+| Duplicate test code | Use factories |
+| Complex test setup | Simplify or split |
+| Ignore flaky tests | Fix root cause |
+| Skip cleanup | Reset state |
+
+---
+
+> **Remember:** Tests are documentation. If someone can't understand what the code does from the tests, rewrite them.

package/templates/.agent/skills/testing-patterns/scripts/test_runner.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Test Runner - Unified test execution and coverage reporting
+Runs tests and generates coverage report based on project type.
+
+Usage:
+    python test_runner.py <project_path> [--coverage]
+
+Supports:
+    - Node.js: npm test, jest, vitest
+    - Python: pytest, unittest
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Fix Windows console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def detect_test_framework(project_path: Path) -> dict:
+    """Detect test framework and commands."""
+    result = {
+        "type": "unknown",
+        "framework": None,
+        "cmd": None,
+        "coverage_cmd": None
+    }
+    
+    # Node.js project
+    package_json = project_path / "package.json"
+    if package_json.exists():
+        result["type"] = "node"
+        try:
+            pkg = json.loads(package_json.read_text(encoding='utf-8'))
+            scripts = pkg.get("scripts", {})
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            # Check for test script
+            if "test" in scripts:
+                result["framework"] = "npm test"
+                result["cmd"] = ["npm", "test"]
+                
+                # Try to detect specific framework for coverage
+                if "vitest" in deps:
+                    result["framework"] = "vitest"
+                    result["coverage_cmd"] = ["npx", "vitest", "run", "--coverage"]
+                elif "jest" in deps:
+                    result["framework"] = "jest"
+                    result["coverage_cmd"] = ["npx", "jest", "--coverage"]
+            elif "vitest" in deps:
+                result["framework"] = "vitest"
+                result["cmd"] = ["npx", "vitest", "run"]
+                result["coverage_cmd"] = ["npx", "vitest", "run", "--coverage"]
+            elif "jest" in deps:
+                result["framework"] = "jest"
+                result["cmd"] = ["npx", "jest"]
+                result["coverage_cmd"] = ["npx", "jest", "--coverage"]
+                
+        except:
+            pass
+    
+    # Python project
+    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
+        result["type"] = "python"
+        result["framework"] = "pytest"
+        result["cmd"] = ["python", "-m", "pytest", "-v"]
+        result["coverage_cmd"] = ["python", "-m", "pytest", "--cov", "--cov-report=term-missing"]
+    
+    return result
+
+
+def run_tests(cmd: list, cwd: Path) -> dict:
+    """Run tests and return results."""
+    result = {
+        "passed": False,
+        "output": "",
+        "error": "",
+        "tests_run": 0,
+        "tests_passed": 0,
+        "tests_failed": 0
+    }
+    
+    try:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=300  # 5 min timeout for tests
+        )
+        
+        result["output"] = proc.stdout[:3000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+        # Try to parse test counts from output
+        output = proc.stdout or ""
+        
+        # Jest/Vitest pattern: "Tests: X passed, Y failed, Z total"
+        if "passed" in output.lower() and "failed" in output.lower():
+            import re
+            match = re.search(r'(\d+)\s+passed', output, re.IGNORECASE)
+            if match:
+                result["tests_passed"] = int(match.group(1))
+            match = re.search(r'(\d+)\s+failed', output, re.IGNORECASE)
+            if match:
+                result["tests_failed"] = int(match.group(1))
+            result["tests_run"] = result["tests_passed"] + result["tests_failed"]
+        
+        # Pytest pattern: "X passed, Y failed"
+        if "pytest" in str(cmd):
+            import re
+            match = re.search(r'(\d+)\s+passed', output)
+            if match:
+                result["tests_passed"] = int(match.group(1))
+            match = re.search(r'(\d+)\s+failed', output)
+            if match:
+                result["tests_failed"] = int(match.group(1))
+            result["tests_run"] = result["tests_passed"] + result["tests_failed"]
+        
+    except FileNotFoundError:
+        result["error"] = f"Command not found: {cmd[0]}"
+    except subprocess.TimeoutExpired:
+        result["error"] = "Timeout after 300s"
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    with_coverage = "--coverage" in sys.argv
+    
+    print(f"\n{'='*60}")
+    print(f"[TEST RUNNER] Unified Test Execution")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Coverage: {'enabled' if with_coverage else 'disabled'}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Detect test framework
+    test_info = detect_test_framework(project_path)
+    print(f"Type: {test_info['type']}")
+    print(f"Framework: {test_info['framework']}")
+    print("-"*60)
+    
+    if not test_info["cmd"]:
+        print("No test framework found for this project.")
+        output = {
+            "script": "test_runner",
+            "project": str(project_path),
+            "type": test_info["type"],
+            "framework": None,
+            "passed": True,
+            "message": "No tests configured"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Choose command
+    cmd = test_info["coverage_cmd"] if with_coverage and test_info["coverage_cmd"] else test_info["cmd"]
+    
+    print(f"Running: {' '.join(cmd)}")
+    print("-"*60)
+    
+    # Run tests
+    result = run_tests(cmd, project_path)
+    
+    # Print output (truncated)
+    if result["output"]:
+        lines = result["output"].split("\n")
+        for line in lines[:30]:
+            print(line)
+        if len(lines) > 30:
+            print(f"... ({len(lines) - 30} more lines)")
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    if result["passed"]:
+        print("[PASS] All tests passed")
+    else:
+        print("[FAIL] Some tests failed")
+        if result["error"]:
+            print(f"Error: {result['error'][:200]}")
+    
+    if result["tests_run"] > 0:
+        print(f"Tests: {result['tests_run']} total, {result['tests_passed']} passed, {result['tests_failed']} failed")
+    
+    output = {
+        "script": "test_runner",
+        "project": str(project_path),
+        "type": test_info["type"],
+        "framework": test_info["framework"],
+        "tests_run": result["tests_run"],
+        "tests_passed": result["tests_passed"],
+        "tests_failed": result["tests_failed"],
+        "passed": result["passed"]
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0 if result["passed"] else 1)
+
+
+if __name__ == "__main__":
+    main()