@oalacea/demon 1.0.0

package/agents/test-generator.js

@@ -0,0 +1,387 @@
+/**
+ * Demon - Test Generator Agent
+ *
+ * Generates test files based on source code analysis.
+ * Supports unit, integration, and E2E test generation.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generate a unit test for a component
+ */
+function generateComponentTest(componentPath, componentName, content) {
+  const hasProps = /interface Props|type Props|Props:/.test(content);
+  const hasOnClick = /onClick|handleClick/.test(content);
+  const hasDisabled = /disabled|isDisabled/.test(content);
+  const hasLoading = /loading|isLoading/.test(content);
+  const hasChildren = /children|{props\.children}/.test(content);
+  const hasError = /error|isError/.test(content);
+  const hasVariants = /variant=|variants/.test(content);
+
+  let imports = [
+    `import { render, screen } from '@testing-library/react';`,
+    `import { describe, it, expect, vi } from 'vitest';`,
+    `import { ${componentName} } from '@/components/${componentName}';`,
+  ];
+
+  let tests = [];
+
+  // Basic render test
+  tests.push(`
+  it('should render', () => {
+    render(<${componentName} />);
+    expect(screen.getByRole('button')).toBeInTheDocument();
+  });`);
+
+  // Children test
+  if (hasChildren) {
+    tests.push(`
+  it('should render children', () => {
+    render(<${componentName}>Test content</${componentName}>);
+    expect(screen.getByText('Test content')).toBeInTheDocument();
+  });`);
+  }
+
+  // Disabled test
+  if (hasDisabled) {
+    tests.push(`
+  it('should be disabled when disabled prop is true', () => {
+    render(<${componentName} disabled />);
+    expect(screen.getByRole('button')).toBeDisabled();
+  });`);
+  }
+
+  // Loading test
+  if (hasLoading) {
+    tests.push(`
+  it('should show loading state', () => {
+    render(<${componentName} loading />);
+    expect(screen.getByTestId(/spinner|loading/i)).toBeInTheDocument();
+  });`);
+  }
+
+  // Error test
+  if (hasError) {
+    tests.push(`
+  it('should show error message', () => {
+    render(<${componentName} error="Something went wrong" />);
+    expect(screen.getByText('Something went wrong')).toBeInTheDocument();
+  });`);
+  }
+
+  // onClick test
+  if (hasOnClick) {
+    tests.push(`
+  it('should call onClick when clicked', async () => {
+    const handleClick = vi.fn();
+    render(<${componentName} onClick={handleClick} />);
+    await screen.getByRole('button').click();
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });`);
+  }
+
+  // Variant test
+  if (hasVariants) {
+    tests.push(`
+  it('should apply variant class', () => {
+    render(<${componentName} variant="danger" />);
+    expect(screen.getByRole('button')).toHaveClass('btn-danger');
+  });`);
+  }
+
+  return `${imports.join('\n')}
+
+describe('${componentName}', () => {${tests.join('\n')}
+});
+`;
+}
+
+/**
+ * Generate a unit test for a hook
+ */
+function generateHookTest(hookPath, hookName, content) {
+  const hasReturn = /return\s*{/.test(content);
+  const hasState = /useState|useReducer/.test(content);
+  const hasEffect = /useEffect/.test(content);
+  const hasCallback = /useCallback/.test(content);
+  const hasMemo = /useMemo/.test(content);
+
+  let imports = [
+    `import { renderHook, act, waitFor } from '@testing-library/react';`,
+    `import { describe, it, expect, vi } from 'vitest';`,
+    `import { ${hookName} } from '@/hooks/${hookName}';`,
+  ];
+
+  let tests = [];
+
+  // Basic return test
+  tests.push(`
+  it('should return initial state', () => {
+    const { result } = renderHook(() => ${hookName}());
+    expect(result.current).toBeDefined();
+  });`);
+
+  // State update test
+  if (hasState) {
+    tests.push(`
+  it('should update state', async () => {
+    const { result } = renderHook(() => ${hookName}());
+
+    act(() => {
+      result.current.setValue('test');
+    });
+
+    await waitFor(() => {
+      expect(result.current.value).toBe('test');
+    });
+  });`);
+  }
+
+  // Cleanup test
+  if (hasEffect) {
+    tests.push(`
+  it('should cleanup on unmount', () => {
+    const cleanup = vi.fn();
+    const { unmount } = renderHook(() => ${hookName}({ cleanup }));
+    unmount();
+    expect(cleanup).toHaveBeenCalled();
+  });`);
+  }
+
+  return `${imports.join('\n')}
+
+describe('${hookName}', () => {${tests.join('\n')}
+});
+`;
+}
+
+/**
+ * Generate a unit test for a utility function
+ */
+function generateUtilTest(utilPath, utilName, content) {
+  const hasParams = /function\s+\w+\s*\(([^)]+)\)|export\s+const\s+\w+\s*=\s*\(([^)]+)\)/.test(content);
+  const isAsync = /async\s+function|=>\s*async/.test(content);
+
+  let imports = [
+    `import { describe, it, expect } from 'vitest';`,
+    `import { ${utilName} } from '@/utils/${utilName}';`,
+  ];
+
+  let tests = [];
+
+  if (isAsync) {
+    tests.push(`
+  it('should return result', async () => {
+    const result = await ${utilName}('test');
+    expect(result).toBeDefined();
+  });`);
+  } else {
+    tests.push(`
+  it('should return result', () => {
+    const result = ${utilName}('test');
+    expect(result).toBeDefined();
+  });`);
+  }
+
+  return `${imports.join('\n')}
+
+describe('${utilName}', () => {${tests.join('\n')}
+});
+`;
+}
+
+/**
+ * Generate an integration test for an API route
+ */
+function generateApiTest(routePath, routeMethod, content) {
+  const hasValidation = /zod|validate|schema/.test(content);
+  const hasAuth = /auth|requireAuth|getSession/.test(content);
+  const hasDb = /prisma|db\./.test(content);
+
+  let imports = [
+    `import { describe, it, expect, beforeEach, afterEach } from 'vitest';`,
+    `import { POST, GET } from '@/app${routePath}/route';`,
+  ];
+
+  if (hasDb) {
+    imports.push(`import { db } from '@test/db';`);
+  }
+
+  let tests = [];
+
+  // Success test
+  tests.push(`
+  it('should return 200 on success', async () => {
+    const request = new Request('http://localhost:3000${routePath}', {
+      method: '${routeMethod}',
+      body: JSON.stringify({ test: 'data' }),
+    });
+
+    const response = await ${routeMethod}(request);
+    expect(response.status).toBe(200);
+  });`);
+
+  // Validation test
+  if (hasValidation) {
+    tests.push(`
+  it('should return 400 for invalid data', async () => {
+    const request = new Request('http://localhost:3000${routePath}', {
+      method: '${routeMethod}',
+      body: JSON.stringify({ invalid: 'data' }),
+    });
+
+    const response = await ${routeMethod}(request);
+    expect(response.status).toBe(400);
+  });`);
+  }
+
+  // Auth test
+  if (hasAuth) {
+    tests.push(`
+  it('should return 401 without auth', async () => {
+    const request = new Request('http://localhost:3000${routePath}', {
+      method: '${routeMethod}',
+    });
+
+    const response = await ${routeMethod}(request);
+    expect(response.status).toBe(401);
+  });`);
+  }
+
+  // DB transaction test
+  if (hasDb) {
+    tests = [
+      `
+  beforeEach(async () => {
+    await db.begin();
+  });`,
+      `
+  afterEach(async () => {
+    await db.rollback();
+  });`,
+      ...tests,
+    ];
+  }
+
+  return `${imports.join('\n')}
+
+describe('${routeMethod} ${routePath}', () => {${tests.join('\n')}
+});
+`;
+}
+
+/**
+ * Generate an E2E test with Playwright
+ */
+function generateE2ETest(pageName, actions) {
+  let imports = [
+    `import { test, expect } from '@playwright/test';`,
+  ];
+
+  let testContent = '';
+
+  if (actions.includes('login')) {
+    testContent += `
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/login');
+  });`;
+  }
+
+  testContent += `
+
+  test('should complete flow', async ({ page }) => {
+    await page.goto('/${pageName}');`;
+
+  if (actions.includes('fill')) {
+    testContent += `
+    await page.fill('input[name="email"]', 'test@example.com');`;
+  }
+
+  if (actions.includes('click')) {
+    testContent += `
+    await page.click('button[type="submit"]');`;
+  }
+
+  if (actions.includes('navigate')) {
+    testContent += `
+    await expect(page).toHaveURL('/dashboard');`;
+  }
+
+  testContent += `
+  });`;
+
+  return `${imports.join('\n')}
+
+test.describe('${pageName}', () => {${testContent}
+});
+`;
+}
+
+/**
+ * Main generator function
+ */
+function generateTest(type, filePath, options = {}) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const filename = path.basename(filePath, path.extname(filePath));
+
+  switch (type) {
+    case 'component':
+      return generateComponentTest(filePath, filename, content);
+    case 'hook':
+      return generateHookTest(filePath, filename, content);
+    case 'util':
+      return generateUtilTest(filePath, filename, content);
+    case 'api':
+      return generateApiTest(options.route, options.method, content);
+    case 'e2e':
+      return generateE2ETest(filename, options.actions || []);
+    default:
+      throw new Error(`Unknown test type: ${type}`);
+  }
+}
+
+/**
+ * Find files without tests
+ */
+function findFilesWithoutTests(projectDir, pattern) {
+  const files = [];
+
+  function findInDir(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (['node_modules', '.next', 'dist', 'build', '.git', 'coverage'].includes(entry.name)) {
+          continue;
+        }
+        findInDir(fullPath);
+      } else if (entry.isFile() && fullPath.match(pattern)) {
+        const testPath = fullPath.replace(/\.(tsx?)$/, '.test$1');
+        if (!fs.existsSync(testPath)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+
+  findInDir(projectDir);
+  return files;
+}
+
+module.exports = {
+  generateTest,
+  generateComponentTest,
+  generateHookTest,
+  generateUtilTest,
+  generateApiTest,
+  generateE2ETest,
+  findFilesWithoutTests,
+};

package/agents/test-runner.js

@@ -0,0 +1,318 @@
+/**
+ * Demon - Test Runner Agent
+ *
+ * Executes tests and parses results.
+ * Supports Vitest, Jest, and Playwright.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const CONFIG = {
+  container: 'demon-tools',
+  docker: 'docker exec',
+};
+
+/**
+ * Run tests inside the Docker container
+ */
+function runTests(command, options = {}) {
+  const dockerCmd = `${CONFIG.docker} ${CONFIG.container} ${command}`;
+
+  try {
+    const output = execSync(dockerCmd, {
+      encoding: 'utf-8',
+      stdio: options.silent ? 'pipe' : 'inherit',
+      timeout: options.timeout || 120000,
+      cwd: options.cwd || process.cwd(),
+    });
+
+    return {
+      success: true,
+      output,
+      exitCode: 0,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      output: error.stdout || '',
+      error: error.stderr || error.message,
+      exitCode: error.status || 1,
+    };
+  }
+}
+
+/**
+ * Run unit tests
+ */
+function runUnitTests(testFile = null) {
+  const cmd = testFile
+    ? `npm test -- ${testFile}`
+    : `npm test`;
+
+  return runTests(cmd);
+}
+
+/**
+ * Run integration tests
+ */
+function runIntegrationTests(testFile = null) {
+  const cmd = testFile
+    ? `npm test -- ${testFile}`
+    : `npm test -- tests/integration`;
+
+  return runTests(cmd);
+}
+
+/**
+ * Run E2E tests
+ */
+function runE2ETests(testFile = null) {
+  const cmd = testFile
+    ? `npx playwright test ${testFile}`
+    : `npx playwright test`;
+
+  return runTests(cmd);
+}
+
+/**
+ * Run performance tests
+ */
+function runPerformanceTests(testFile = null) {
+  const cmd = testFile
+    ? `k6 run ${testFile}`
+    : `k6 run tests/performance`;
+
+  return runTests(cmd);
+}
+
+/**
+ * Parse Vitest/Jest output
+ */
+function parseTestOutput(output) {
+  const results = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    failures: [],
+  };
+
+  // Parse Vitest output
+  const testFiles = output.match(/Test Files\s+\d+ passed/g);
+  if (testFiles) {
+    results.total += parseInt(testFiles[0].match(/\d+/)[0]);
+  }
+
+  const passed = output.match(/(\d+) passed/);
+  if (passed) {
+    results.passed += parseInt(passed[1]);
+  }
+
+  const failed = output.match(/(\d+) failed/);
+  if (failed) {
+    results.failed += parseInt(failed[1]);
+    // Parse failure details
+    const failOutput = output.match(/FAIL\s+(.+)/g);
+    if (failOutput) {
+      results.failures = failOutput.map((f) => {
+        const match = f.match(/FAIL\s+(.+?)\s+/);
+        return match ? match[1] : f;
+      });
+    }
+  }
+
+  const skipped = output.match(/(\d+) skipped/);
+  if (skipped) {
+    results.skipped += parseInt(skipped[1]);
+  }
+
+  return results;
+}
+
+/**
+ * Parse Playwright output
+ */
+function parseE2EOutput(output) {
+  const results = {
+    total: 0,
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    failures: [],
+  };
+
+  const passed = output.match(/passed\s+(\d+)/);
+  if (passed) results.passed += parseInt(passed[1]);
+
+  const failed = output.match(/failed\s+(\d+)/);
+  if (failed) {
+    results.failed += parseInt(failed[1]);
+    // Parse failure details
+    const failLines = output.match(/^.*?\[ERROR\].*$/gm);
+    if (failLines) {
+      results.failures = failLines;
+    }
+  }
+
+  const skipped = output.match(/skipped\s+(\d+)/);
+  if (skipped) results.skipped += parseInt(skipped[1]);
+
+  results.total = results.passed + results.failed + results.skipped;
+
+  return results;
+}
+
+/**
+ * Parse k6 output
+ */
+function parsePerfOutput(output) {
+  const results = {
+    requests: 0,
+    duration: 0,
+    avgResponseTime: 0,
+    p95: 0,
+    p99: 0,
+    rps: 0,
+    failureRate: 0,
+  };
+
+  // Parse k6 summary output
+  const checks = output.match(/checks.*?:\s+([\d.]+)%/);
+  if (checks) results.failureRate = 100 - parseFloat(checks[1]);
+
+  const dataReceived = output.match(/data_received\s+([\d.]+\s+\w+)/);
+  if (dataReceived) results.dataReceived = dataReceived[1];
+
+  const httpReqDuration = output.match(/http_req_duration.*?avg=\s*([\d.]+)ms.*?p\(95\)=\s*([\d.]+)ms/);
+  if (httpReqDuration) {
+    results.avgResponseTime = parseFloat(httpReqDuration[1]);
+    results.p95 = parseFloat(httpReqDuration[2]);
+  }
+
+  const httpReqs = output.match(/http_reqs\s+([\d.]+)/);
+  if (httpReqs) results.requests = parseInt(httpReqs[1]);
+
+  const iterationDuration = output.match(/iteration_duration.*?avg=\s*([\d.]+)/);
+  if (iterationDuration) results.duration = parseFloat(iterationDuration[1]);
+
+  return results;
+}
+
+/**
+ * Get test coverage
+ */
+function getCoverage() {
+  const result = runTests('npm test -- --coverage');
+
+  if (!result.success) {
+    return null;
+  }
+
+  const coverage = {
+    lines: 0,
+    functions: 0,
+    branches: 0,
+    statements: 0,
+  };
+
+  // Parse coverage output
+  const lines = result.output.match(/All files[^]*?(\d+)%/);
+  if (lines) coverage.lines = parseInt(lines[1]);
+
+  const functions = result.output.match(/functions[^]*?(\d+)%/);
+  if (functions) coverage.functions = parseInt(functions[1]);
+
+  const branches = result.output.match(/branches[^]*?(\d+)%/);
+  if (branches) coverage.branches = parseInt(branches[1]);
+
+  const statements = result.output.match(/statements[^]*?(\d+)%/);
+  if (statements) coverage.statements = parseInt(statements[1]);
+
+  return coverage;
+}
+
+/**
+ * Run all tests and return summary
+ */
+async function runAllTests() {
+  const summary = {
+    unit: null,
+    integration: null,
+    e2e: null,
+    performance: null,
+    coverage: null,
+  };
+
+  // Unit tests
+  const unitResult = runUnitTests();
+  summary.unit = {
+    ...parseTestOutput(unitResult.output),
+    success: unitResult.success,
+  };
+
+  // Integration tests
+  const integrationResult = runIntegrationTests();
+  summary.integration = {
+    ...parseTestOutput(integrationResult.output),
+    success: integrationResult.success,
+  };
+
+  // E2E tests
+  const e2eResult = runE2ETests();
+  summary.e2e = {
+    ...parseE2EOutput(e2eResult.output),
+    success: e2eResult.success,
+  };
+
+  // Performance tests
+  const perfResult = runPerformanceTests();
+  summary.performance = {
+    ...parsePerfOutput(perfResult.output),
+    success: perfResult.success,
+  };
+
+  // Coverage
+  summary.coverage = getCoverage();
+
+  return summary;
+}
+
+/**
+ * Run a single test file
+ */
+function runSingleTest(testPath) {
+  return runTests(`npm test -- ${testPath}`);
+}
+
+/**
+ * Watch tests
+ */
+function watchTests() {
+  return runTests('npm test -- --watch');
+}
+
+/**
+ * Debug a failing test
+ */
+function debugTest(testPath) {
+  return runTests(`npm test -- ${testPath} --reporter=verbose --no-coverage`);
+}
+
+module.exports = {
+  runTests,
+  runUnitTests,
+  runIntegrationTests,
+  runE2ETests,
+  runPerformanceTests,
+  parseTestOutput,
+  parseE2EOutput,
+  parsePerfOutput,
+  getCoverage,
+  runAllTests,
+  runSingleTest,
+  watchTests,
+  debugTest,
+};