@neyugn/agent-kits 0.1.0

package/kits/coder/skills/testing-patterns/SKILL.md

@@ -0,0 +1,285 @@
+---
+name: testing-patterns
+description: Testing patterns and principles. Unit, integration, mocking strategies. Use when writing tests, reviewing test coverage, or establishing testing conventions.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+version: 2.0
+---
+
+# Testing Patterns - Principles & Best Practices
+
+> **Philosophy:** Tests are documentation. Write tests that explain behavior, not implementation.
+
+---
+
+## Test Pyramid
+
+```
+          /\            E2E (5-10%)
+         /  \           Critical user flows
+        /----\
+       /      \         Integration (20-30%)
+      /--------\        API, DB, services
+     /          \
+    /------------\      Unit (60-70%)
+                        Functions, classes, logic
+```
+
+**Rule:** More tests at the base, fewer at the top. Fast, cheap, reliable tests first.
+
+---
+
+## Test Type Selection
+
+```
+What are you testing?
+│
+├─ Pure function / business logic?
+│  └─ → Unit test
+│
+├─ API endpoint / database query?
+│  └─ → Integration test
+│
+├─ Critical user journey?
+│  └─ → E2E test
+│
+├─ External service interaction?
+│  └─ → Integration test with mocks
+│
+└─ UI component rendering?
+   └─ → Component test (unit-like)
+```
+
+---
+
+## AAA Pattern (Arrange-Act-Assert)
+
+```typescript
+// ✅ Clear AAA structure
+describe("UserService", () => {
+  it("should return user by ID", async () => {
+    // Arrange
+    const userId = "123";
+    const expectedUser = { id: userId, name: "John" };
+    mockDb.users.findById.mockResolvedValue(expectedUser);
+
+    // Act
+    const result = await userService.getById(userId);
+
+    // Assert
+    expect(result).toEqual(expectedUser);
+  });
+});
+```
+
+---
+
+## Unit Test Principles (FIRST)
+
+| Principle           | Meaning            | Example                  |
+| ------------------- | ------------------ | ------------------------ |
+| **F**ast            | < 100ms each       | No I/O, no network       |
+| **I**solated        | No dependencies    | Mock external calls      |
+| **R**epeatable      | Same result always | No random, no time       |
+| **S**elf-validating | Boolean pass/fail  | No manual verification   |
+| **T**imely          | Written with code  | TDD or immediately after |
+
+### What to Unit Test
+
+| ✅ Test        | ❌ Don't Test            |
+| -------------- | ------------------------ |
+| Business logic | Framework code           |
+| Edge cases     | Third-party libraries    |
+| Error handling | Simple getters/setters   |
+| Calculations   | Constructor-only classes |
+| Validations    | Private methods directly |
+
+---
+
+## Integration Test Principles
+
+### What to Integration Test
+
+| Area         | Focus                 | Example              |
+| ------------ | --------------------- | -------------------- |
+| **API**      | Request/Response      | Correct status codes |
+| **Database** | Queries, transactions | Data persistence     |
+| **Services** | Inter-service calls   | Message passing      |
+| **Auth**     | Token validation      | Protected routes     |
+
+### Setup/Teardown Pattern
+
+```typescript
+describe("UserAPI", () => {
+  beforeAll(async () => {
+    // Connect to test database
+    await db.connect();
+  });
+
+  beforeEach(async () => {
+    // Reset state before each test
+    await db.clear();
+    await seedTestData();
+  });
+
+  afterEach(async () => {
+    // Clean up test artifacts
+    await cleanupFiles();
+  });
+
+  afterAll(async () => {
+    // Disconnect resources
+    await db.disconnect();
+  });
+});
+```
+
+---
+
+## Mocking Strategy
+
+### When to Mock
+
+| ✅ Mock                  | ❌ Don't Mock       |
+| ------------------------ | ------------------- |
+| External APIs            | Code under test     |
+| Database (in unit tests) | Simple dependencies |
+| Time/Date                | Pure functions      |
+| Network calls            | In-memory stores    |
+| Third-party services     | Internal modules    |
+
+### Mock Types
+
+| Type     | Purpose                      | Example                      |
+| -------- | ---------------------------- | ---------------------------- |
+| **Stub** | Return fixed values          | `mockFn.mockReturnValue(42)` |
+| **Spy**  | Track calls without changing | `jest.spyOn(obj, 'method')`  |
+| **Mock** | Replace with expectations    | `jest.fn()`                  |
+| **Fake** | Simplified implementation    | In-memory database           |
+
+### Mocking Decision Tree
+
+```
+Need to isolate from dependency?
+├─ Yes → Is it external (API, DB)?
+│  ├─ Yes → Mock it
+│  └─ No → Prefer real implementation
+│
+└─ No → Use real dependency
+```
+
+---
+
+## Test Data Strategies
+
+| Strategy    | Use Case              | Example                                   |
+| ----------- | --------------------- | ----------------------------------------- |
+| **Factory** | Generate varied data  | `createUser({ name: 'John' })`            |
+| **Fixture** | Predefined datasets   | JSON files                                |
+| **Builder** | Fluent construction   | `UserBuilder.default().withRole('admin')` |
+| **Faker**   | Random realistic data | `faker.person.fullName()`                 |
+
+### Factory Pattern Example
+
+```typescript
+// factories/user.factory.ts
+export const createUser = (overrides = {}) => ({
+  id: faker.string.uuid(),
+  name: faker.person.fullName(),
+  email: faker.internet.email(),
+  createdAt: new Date(),
+  ...overrides,
+});
+
+// Usage
+const user = createUser({ role: "admin" });
+```
+
+---
+
+## TDD Workflow (Red-Green-Refactor)
+
+```
+┌─────────┐      ┌─────────┐      ┌──────────┐
+│   RED   │ ──→  │  GREEN  │ ──→  │ REFACTOR │
+│  Write  │      │  Write  │      │ Improve  │
+│ failing │      │ minimal │      │   code   │
+│  test   │      │  code   │      │  quality │
+└─────────┘      └─────────┘      └──────────┘
+     ↑                                  │
+     └──────────────────────────────────┘
+```
+
+---
+
+## Test Naming Conventions
+
+| Pattern                           | Example                                  |
+| --------------------------------- | ---------------------------------------- |
+| **should_behavior**               | `should returnErrorWhenUserNotFound`     |
+| **when_condition**                | `whenUserIsNull_throwsError`             |
+| **given_when_then**               | `givenValidInput_whenSubmit_thenSuccess` |
+| **methodName_condition_expected** | `getUser_withInvalidId_returnsNull`      |
+
+**Rule:** Test names should describe behavior, not implementation.
+
+---
+
+## Coverage Guidelines
+
+| Level    | Meaning                             |
+| -------- | ----------------------------------- |
+| **80%+** | Good coverage for most projects     |
+| **90%+** | High coverage, critical systems     |
+| **100%** | Often impractical, may waste effort |
+
+### What to Cover
+
+| Priority   | Area                         |
+| ---------- | ---------------------------- |
+| **High**   | Business logic, calculations |
+| **Medium** | Error paths, edge cases      |
+| **Low**    | Simple getters, boilerplate  |
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't                    | ✅ Do                      |
+| --------------------------- | -------------------------- |
+| Test implementation details | Test behavior/outcomes     |
+| Duplicate test code         | Use factories/helpers      |
+| Complex test setup          | Simplify or split tests    |
+| Ignore flaky tests          | Fix root cause immediately |
+| Skip cleanup                | Reset state every test     |
+| Test multiple things        | One assertion per test     |
+| Hard-code test data         | Use factories              |
+| Rely on test order          | Make tests independent     |
+
+---
+
+## Testing Checklist
+
+Before pushing code:
+
+- [ ] All tests pass?
+- [ ] Coverage meets threshold?
+- [ ] Edge cases covered?
+- [ ] Error paths tested?
+- [ ] Tests are isolated?
+- [ ] No flaky tests?
+- [ ] Test names are descriptive?
+
+---
+
+## Related Skills
+
+| Need                | Skill                   |
+| ------------------- | ----------------------- |
+| Clean code          | `clean-code`            |
+| API testing         | `api-patterns`          |
+| E2E testing         | `webapp-testing`        |
+| Performance testing | `performance-profiling` |
+
+---
+
+> **Remember:** If you can't understand what code does from its tests, rewrite the tests.

package/kits/coder/skills/testing-patterns/assets/.gitkeep

@@ -0,0 +1 @@
+# Assets directory - add templates, images, etc.

package/kits/coder/skills/testing-patterns/references/deep-dive.md

@@ -0,0 +1,21 @@
+# Reference Documentation for Testing Patterns
+
+[TODO: Add detailed reference content here]
+
+## Overview
+
+[Detailed explanation of concepts]
+
+## Deep Dive Topics
+
+### Topic 1
+
+[Content]
+
+### Topic 2
+
+[Content]
+
+## Examples
+
+[Real-world examples]

package/kits/coder/skills/testing-patterns/scripts/test_runner.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Test Runner - Unified test execution and coverage
+==================================================
+
+Auto-detects project type and runs appropriate test framework.
+
+Usage:
+    python .agent/skills/testing-patterns/scripts/test_runner.py <project_path>
+    python .agent/skills/testing-patterns/scripts/test_runner.py . --coverage
+
+Supports:
+    - Node.js: npm test, jest, vitest
+    - Python: pytest, unittest
+"""
+
+import subprocess
+import sys
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+# Fix 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", {})}
+            
+            if "test" in scripts:
+                result["framework"] = "npm test"
+                result["cmd"] = ["npm", "test"]
+                
+                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
+        )
+        
+        result["output"] = proc.stdout[:3000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+        # Parse test counts
+        output = proc.stdout or ""
+        
+        # Jest/Vitest pattern
+        if "passed" in output.lower() and "failed" in output.lower():
+            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
+        if "pytest" in str(cmd):
+            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"[AGT-KIT TEST RUNNER] 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 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.")
+        output = {
+            "script": "test_runner",
+            "skill": "testing-patterns",
+            "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)
+    
+    # Run tests
+    cmd = test_info["coverage_cmd"] if with_coverage and test_info["coverage_cmd"] else test_info["cmd"]
+    print(f"Running: {' '.join(cmd)}")
+    print("-"*60)
+    
+    result = run_tests(cmd, project_path)
+    
+    # Print output
+    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("✅ All tests passed")
+    else:
+        print("❌ 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",
+        "skill": "testing-patterns",
+        "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()

package/kits/coder/skills/testing-patterns/scripts/validate.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Example validator for testing-patterns
+
+Usage:
+    python validate.py <project_path>
+"""
+
+import sys
+from pathlib import Path
+
+
+def validate(project_path: str) -> dict:
+    """Main validation logic"""
+    results = {
+        'errors': [],
+        'warnings': [],
+        'passed': []
+    }
+    
+    # TODO: Add validation logic
+    results['passed'].append('Placeholder validation passed')
+    
+    return results
+
+
+def print_results(results: dict):
+    """Pretty print results"""
+    print("\n🔍 Validation Results\n")
+    
+    if results['errors']:
+        print(f"❌ Errors ({len(results['errors'])})")
+        for error in results['errors']:
+            print(f"  - {error}")
+    
+    if results['warnings']:
+        print(f"\n⚠️  Warnings ({len(results['warnings'])})")
+        for warning in results['warnings']:
+            print(f"  - {warning}")
+    
+    if results['passed']:
+        print(f"\n✅ Passed ({len(results['passed'])})")
+        for passed in results['passed']:
+            print(f"  - {passed}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python validate.py <project_path>")
+        sys.exit(1)
+    
+    project_path = sys.argv[1]
+    results = validate(project_path)
+    print_results(results)
+    
+    sys.exit(1 if results['errors'] else 0)