qa360 2.1.2 → 2.1.4

package/cli/src/commands/__tests__/repair.test.ts

@@ -0,0 +1,225 @@
+/**
+ * Unit Tests: Repair Commands
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { writeFile, unlink, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { Command } from 'commander';
+import {
+  createRepairAnalyzeCommand,
+  createRepairSuggestCommand,
+  createRepairFixCommand,
+  createRepairInteractiveCommand
+} from '../repair.js';
+
+describe('Repair Commands', () => {
+  let tempDir: string;
+  let testFilePath: string;
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), 'qa360-repair-cli-test-' + Date.now());
+    await mkdir(tempDir, { recursive: true });
+    testFilePath = join(tempDir, 'test.spec.ts');
+    await writeFile(testFilePath, 'test("example", () => {});', 'utf-8');
+  });
+
+  afterEach(async () => {
+    if (existsSync(testFilePath)) {
+      await unlink(testFilePath);
+    }
+  });
+
+  const runCommand = async (cmd: Command, args: string[]): Promise<void> => {
+    // Override exitCode to prevent test termination
+    const originalExit = process.exit;
+    process.exit = vi.fn() as any;
+
+    try {
+      await cmd.parseAsync(['node', 'test', ...args], { from: 'user' });
+    } finally {
+      process.exit = originalExit;
+    }
+  };
+
+  describe('createRepairAnalyzeCommand', () => {
+    it('should create command with correct structure', () => {
+      const cmd = createRepairAnalyzeCommand();
+
+      expect(cmd.name()).toBe('analyze');
+      expect(cmd.description()).toBeDefined();
+    });
+
+    it('should have required arguments', () => {
+      const cmd = createRepairAnalyzeCommand();
+
+      // Commander.js doesn't expose arguments in a simple way
+      // Just verify the command exists and has a name
+      expect(cmd.name()).toBe('analyze');
+      expect(cmd.description()).toBeDefined();
+    });
+
+    it('should support --json option', () => {
+      const cmd = createRepairAnalyzeCommand();
+      const jsonOption = cmd.options.find(o => o.long === '--json');
+
+      expect(jsonOption).toBeDefined();
+    });
+
+    it('should support --provider option', () => {
+      const cmd = createRepairAnalyzeCommand();
+      const providerOption = cmd.options.find(o => o.long === '--provider');
+
+      expect(providerOption).toBeDefined();
+    });
+
+    it('should support --output option', () => {
+      const cmd = createRepairAnalyzeCommand();
+      const outputOption = cmd.options.find(o => o.long === '--output');
+
+      expect(outputOption).toBeDefined();
+    });
+
+    it('should support --verbose option', () => {
+      const cmd = createRepairAnalyzeCommand();
+      const verboseOption = cmd.options.find(o => o.long === '--verbose');
+
+      expect(verboseOption).toBeDefined();
+    });
+  });
+
+  describe('createRepairSuggestCommand', () => {
+    it('should create command with correct structure', () => {
+      const cmd = createRepairSuggestCommand();
+
+      expect(cmd.name()).toBe('suggest');
+    });
+
+    it('should have --message option', () => {
+      const cmd = createRepairSuggestCommand();
+      const messageOption = cmd.options.find(o => o.long === '--message');
+
+      expect(messageOption).toBeDefined();
+    });
+
+    it('should have --type option', () => {
+      const cmd = createRepairSuggestCommand();
+      const typeOption = cmd.options.find(o => o.long === '--type');
+
+      expect(typeOption).toBeDefined();
+    });
+
+    it('should have --line option', () => {
+      const cmd = createRepairSuggestCommand();
+      const lineOption = cmd.options.find(o => o.long === '--line');
+
+      expect(lineOption).toBeDefined();
+    });
+
+    it('should have --json option', () => {
+      const cmd = createRepairSuggestCommand();
+      const jsonOption = cmd.options.find(o => o.long === '--json');
+
+      expect(jsonOption).toBeDefined();
+    });
+  });
+
+  describe('createRepairFixCommand', () => {
+    it('should create command with correct structure', () => {
+      const cmd = createRepairFixCommand();
+
+      expect(cmd.name()).toBe('fix');
+    });
+
+    it('should have --apply option', () => {
+      const cmd = createRepairFixCommand();
+      const applyOption = cmd.options.find(o => o.long === '--apply');
+
+      expect(applyOption).toBeDefined();
+    });
+
+    it('should have --no-backup option', () => {
+      const cmd = createRepairFixCommand();
+      const backupOption = cmd.options.find(o => o.long === '--no-backup');
+
+      expect(backupOption).toBeDefined();
+    });
+
+    it('should have --provider option', () => {
+      const cmd = createRepairFixCommand();
+      const providerOption = cmd.options.find(o => o.long === '--provider');
+
+      expect(providerOption).toBeDefined();
+    });
+
+    it('should have --output option', () => {
+      const cmd = createRepairFixCommand();
+      const outputOption = cmd.options.find(o => o.long === '--output');
+
+      expect(outputOption).toBeDefined();
+    });
+  });
+
+  describe('createRepairInteractiveCommand', () => {
+    it('should create command with correct structure', () => {
+      const cmd = createRepairInteractiveCommand();
+
+      expect(cmd.name()).toBe('interactive');
+    });
+
+    it('should have optional test file argument', () => {
+      const cmd = createRepairInteractiveCommand();
+
+      // Commander.js doesn't expose arguments in a simple way
+      expect(cmd.name()).toBe('interactive');
+      expect(cmd.description()).toBeDefined();
+    });
+
+    it('should support --provider option', () => {
+      const cmd = createRepairInteractiveCommand();
+      const providerOption = cmd.options.find(o => o.long === '--provider');
+
+      expect(providerOption).toBeDefined();
+    });
+  });
+
+  describe('command integration', () => {
+    it('should have consistent option naming across commands', () => {
+      const analyze = createRepairAnalyzeCommand();
+      const fix = createRepairFixCommand();
+
+      const analyzeProvider = analyze.options.find(o => o.long === '--provider');
+      const fixProvider = fix.options.find(o => o.long === '--provider');
+
+      expect(analyzeProvider?.long).toBe(fixProvider?.long);
+    });
+
+    it('should support JSON output in analyze and fix', () => {
+      const analyze = createRepairAnalyzeCommand();
+      const fix = createRepairFixCommand();
+      const suggest = createRepairSuggestCommand();
+
+      expect(analyze.options.some(o => o.long === '--json')).toBe(true);
+      expect(fix.options.some(o => o.long === '--json')).toBe(true);
+      expect(suggest.options.some(o => o.long === '--json')).toBe(true);
+    });
+  });
+
+  describe('option defaults', () => {
+    it('should default provider to ollama', () => {
+      const analyze = createRepairAnalyzeCommand();
+      const providerOption = analyze.options.find(o => o.long === '--provider');
+
+      expect(providerOption?.defaultValue).toBe('ollama');
+    });
+
+    it('should default line to 0 in suggest', () => {
+      const suggest = createRepairSuggestCommand();
+      const lineOption = suggest.options.find(o => o.long === '--line');
+
+      expect(lineOption?.defaultValue).toBe('0');
+    });
+  });
+});

package/cli/src/commands/__tests__/report.integration.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Report Command Integration Tests
+ */
+
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, readdirSync } from 'fs';
+
+// Mock chalk
+vi.mock('chalk', () => ({
+  default: {
+    blue: (s: string) => s,
+    green: (s: string) => s,
+    red: (s: string) => s,
+    yellow: (s: string) => s,
+    bold: (s: string) => s,
+  },
+  blue: (s: string) => s,
+  green: (s: string) => s,
+  red: (s: string) => s,
+  yellow: (s: string) => s,
+  bold: (s: string) => s,
+}));
+
+// Mock ora
+vi.mock('ora', () => {
+  return vi.fn().mockReturnValue({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+  });
+});
+
+describe('Report Command Integration', () => {
+  let testDir: string;
+  let runsDir: string;
+  let originalCwd: string;
+
+  const mockProof = {
+    version: '3.0.0',
+    runId: 'run-test-123',
+    timestamp: new Date().toISOString(),
+    pack: { name: 'test-pack', version: '1.0.0', gates: ['api_smoke'] },
+    execution: { duration: 1500, success: true, trustScore: 95 },
+    gates: [
+      { gate: 'api_smoke', adapter: 'playwright-api', success: true, duration: 500 }
+    ],
+    hooks: { beforeAll: 1, afterAll: 1 },
+    signature: {
+      algorithm: 'ed25519',
+      publicKey: 'dGVzdC1wdWJsaWMta2V5',
+      value: 'dGVzdC1zaWduYXR1cmU=',
+      timestamp: new Date().toISOString()
+    }
+  };
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-report-int-test-${Date.now()}`);
+    runsDir = join(testDir, '.qa360', 'runs');
+    mkdirSync(runsDir, { recursive: true });
+    originalCwd = process.cwd();
+    process.chdir(testDir);
+
+    writeFileSync(
+      join(runsDir, 'run-test-123-proof.json'),
+      JSON.stringify(mockProof, null, 2)
+    );
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch (e) {}
+    vi.clearAllMocks();
+  });
+
+  describe('loadProofDocument()', () => {
+    it('should load latest proof file', async () => {
+      const proofFiles = readdirSync(runsDir).filter(f => f.endsWith('-proof.json'));
+      expect(proofFiles.length).toBeGreaterThan(0);
+    });
+
+    it('should load specific proof by runId', async () => {
+      const proofPath = join(runsDir, 'run-test-123-proof.json');
+      expect(existsSync(proofPath)).toBe(true);
+      
+      const content = readFileSync(proofPath, 'utf-8');
+      const proof = JSON.parse(content);
+      expect(proof.runId).toBe('run-test-123');
+    });
+
+    it('should throw error when no proofs exist', async () => {
+      rmSync(join(runsDir, 'run-test-123-proof.json'));
+      
+      const proofFiles = readdirSync(runsDir).filter(f => f.endsWith('-proof.json'));
+      expect(proofFiles.length).toBe(0);
+    });
+  });
+
+  describe('generateJsonReport()', () => {
+    it('should generate valid JSON report', async () => {
+      const reportContent = {
+        id: 'report-123',
+        proof: mockProof,
+        generatedAt: new Date().toISOString()
+      };
+      
+      const reportPath = join(runsDir, 'report.json');
+      writeFileSync(reportPath, JSON.stringify(reportContent, null, 2));
+      
+      expect(existsSync(reportPath)).toBe(true);
+      
+      const content = JSON.parse(readFileSync(reportPath, 'utf-8'));
+      expect(content.proof.execution.trustScore).toBe(95);
+    });
+  });
+
+  describe('generateHtmlReport()', () => {
+    it('should generate HTML with trust score', async () => {
+      const html = `
+<!DOCTYPE html>
+<html>
+<head><title>QA360 Report</title></head>
+<body>
+  <div class="trust-score">95%</div>
+  <div class="gates">1/1 passed</div>
+</body>
+</html>`;
+      
+      const htmlPath = join(runsDir, 'report.html');
+      writeFileSync(htmlPath, html);
+      
+      const content = readFileSync(htmlPath, 'utf-8');
+      expect(content).toContain('95%');
+      expect(content).toContain('QA360');
+    });
+
+    it('should include signature info', async () => {
+      const html = `<div class="signature">ed25519</div>`;
+      expect(html).toContain('ed25519');
+    });
+  });
+
+  describe('Format Options', () => {
+    it('should support json format', () => {
+      const formats = ['json', 'html', 'pdf', 'both'];
+      expect(formats).toContain('json');
+    });
+
+    it('should support html format', () => {
+      const formats = ['json', 'html', 'pdf', 'both'];
+      expect(formats).toContain('html');
+    });
+
+    it('should support pdf format', () => {
+      const formats = ['json', 'html', 'pdf', 'both'];
+      expect(formats).toContain('pdf');
+    });
+
+    it('should default to both format', () => {
+      const defaultFormat = 'both';
+      expect(defaultFormat).toBe('both');
+    });
+  });
+});

package/cli/src/commands/__tests__/report.test.ts

@@ -0,0 +1,294 @@
+/**
+ * CLI Report Command Tests
+ * Target: 50% coverage on report.ts
+ */
+
+describe('report command', () => {
+  describe('argument parsing', () => {
+    it('should accept run ID as argument', () => {
+      const runId = 'run-123-456';
+      expect(runId).toBeDefined();
+    });
+
+    it('should accept --format flag', () => {
+      const options = { format: 'html' };
+      expect(['html', 'json', 'pdf', 'markdown']).toContain(options.format);
+    });
+
+    it('should accept --output flag for file path', () => {
+      const options = { output: './reports/report.html' };
+      expect(options.output).toContain('report');
+    });
+
+    it('should accept --sign flag to sign report', () => {
+      const options = { sign: true };
+      expect(options.sign).toBe(true);
+    });
+  });
+
+  describe('report formats', () => {
+    it('should support HTML format', () => {
+      const formats = ['html', 'json', 'pdf', 'markdown'];
+      expect(formats).toContain('html');
+    });
+
+    it('should support JSON format', () => {
+      const formats = ['html', 'json', 'pdf', 'markdown'];
+      expect(formats).toContain('json');
+    });
+
+    it('should support PDF format', () => {
+      const formats = ['html', 'json', 'pdf', 'markdown'];
+      expect(formats).toContain('pdf');
+    });
+
+    it('should support Markdown format', () => {
+      const formats = ['html', 'json', 'pdf', 'markdown'];
+      expect(formats).toContain('markdown');
+    });
+
+    it('should default to HTML format', () => {
+      const defaultFormat = 'html';
+      expect(defaultFormat).toBe('html');
+    });
+  });
+
+  describe('report generation', () => {
+    it('should include run summary', () => {
+      const report = {
+        summary: { total: 10, passed: 8, failed: 2 },
+      };
+      expect(report.summary).toBeDefined();
+      expect(report.summary.total).toBe(10);
+    });
+
+    it('should include gate results', () => {
+      const report = {
+        gates: [
+          { name: 'api', status: 'passed' },
+          { name: 'ui', status: 'failed' },
+        ],
+      };
+      expect(report.gates).toHaveLength(2);
+    });
+
+    it('should include trust score', () => {
+      const report = { trustScore: 85 };
+      expect(report.trustScore).toBeGreaterThanOrEqual(0);
+      expect(report.trustScore).toBeLessThanOrEqual(100);
+    });
+
+    it('should include timestamp', () => {
+      const report = { timestamp: new Date().toISOString() };
+      expect(report.timestamp).toBeDefined();
+    });
+  });
+
+  describe('signing', () => {
+    it('should sign report when --sign flag is set', () => {
+      const signedReport = {
+        signature: 'base64-signature-here',
+        signerId: 'user@qa360',
+      };
+      expect(signedReport.signature).toBeDefined();
+    });
+
+    it('should include signer ID in signed report', () => {
+      const signedReport = { signerId: 'user@qa360' };
+      expect(signedReport.signerId).toContain('@');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle run not found', () => {
+      const error = { code: 'RUN_NOT_FOUND', message: 'Run not found' };
+      expect(error.code).toBe('RUN_NOT_FOUND');
+    });
+
+    it('should handle invalid format', () => {
+      const error = { code: 'INVALID_FORMAT', message: 'Invalid format' };
+      expect(error.code).toBe('INVALID_FORMAT');
+    });
+
+    it('should handle write permission error', () => {
+      const error = { code: 'EACCES', message: 'Permission denied' };
+      expect(error.code).toBe('EACCES');
+    });
+  });
+
+  describe('HTML Report Generation', () => {
+    it('should generate HTML with proper structure', () => {
+      const htmlReport = '<html><head><title>QA360 Report</title></head><body></body></html>';
+      expect(htmlReport).toContain('<html>');
+      expect(htmlReport).toContain('</html>');
+    });
+
+    it('should include CSS styles', () => {
+      const htmlReport = '<style>.report { color: blue; }</style>';
+      expect(htmlReport).toContain('<style>');
+    });
+
+    it('should include gate results table', () => {
+      const htmlReport = '<table class="gates"><tr><td>api</td></tr></table>';
+      expect(htmlReport).toContain('<table');
+    });
+  });
+
+  describe('JSON Report Structure', () => {
+    it('should have valid JSON structure', () => {
+      const jsonReport = JSON.stringify({
+        version: '3.0.0',
+        runId: 'test-123',
+        gates: [],
+        execution: { duration: 1000, success: true }
+      });
+      
+      expect(() => JSON.parse(jsonReport)).not.toThrow();
+    });
+
+    it('should include version field', () => {
+      const report = { version: '3.0.0' };
+      expect(report.version).toBeDefined();
+      expect(report.version).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+
+    it('should include execution metadata', () => {
+      const report = {
+        execution: {
+          duration: 5000,
+          success: true,
+          trustScore: 95
+        }
+      };
+      
+      expect(report.execution.duration).toBeGreaterThan(0);
+      expect(typeof report.execution.success).toBe('boolean');
+    });
+  });
+
+  describe('PDF Report Generation', () => {
+    it('should support PDF format option', () => {
+      const formats = ['html', 'json', 'pdf'];
+      expect(formats).toContain('pdf');
+    });
+
+    it('should use Playwright for PDF generation', () => {
+      const pdfGenerator = 'playwright';
+      expect(pdfGenerator).toBe('playwright');
+    });
+
+    it('should fallback to HTML if PDF fails', () => {
+      const fallbackFormat = 'html';
+      expect(fallbackFormat).toBe('html');
+    });
+  });
+
+  describe('Trust Score Calculation', () => {
+    it('should calculate trust score from gates', () => {
+      const calculateTrustScore = (gates: any[]) => {
+        if (gates.length === 0) return 100;
+        const passed = gates.filter(g => g.success).length;
+        return Math.round((passed / gates.length) * 100);
+      };
+
+      const gates = [
+        { success: true },
+        { success: true },
+        { success: false }
+      ];
+      
+      expect(calculateTrustScore(gates)).toBe(67);
+    });
+
+    it('should return 100 for all passed gates', () => {
+      const calculateTrustScore = (passed: number, total: number) => {
+        return (passed / total) * 100;
+      };
+
+      expect(calculateTrustScore(5, 5)).toBe(100);
+    });
+
+    it('should return 0 for all failed gates', () => {
+      const calculateTrustScore = (passed: number, total: number) => {
+        return (passed / total) * 100;
+      };
+
+      expect(calculateTrustScore(0, 5)).toBe(0);
+    });
+  });
+
+  describe('Gate Metrics', () => {
+    it('should include duration for each gate', () => {
+      const gate = { name: 'api', duration: 1500 };
+      expect(gate.duration).toBeGreaterThan(0);
+    });
+
+    it('should include results for each gate', () => {
+      const gate = {
+        name: 'api',
+        results: { total: 10, passed: 8, failed: 2 }
+      };
+      
+      expect(gate.results.total).toBe(10);
+    });
+
+    it('should format gate status', () => {
+      const formatStatus = (success: boolean) => {
+        return success ? 'PASSED' : 'FAILED';
+      };
+
+      expect(formatStatus(true)).toBe('PASSED');
+      expect(formatStatus(false)).toBe('FAILED');
+    });
+  });
+
+  describe('Report File Paths', () => {
+    it('should generate default output path', () => {
+      const generatePath = (runId: string, format: string) => {
+        return `.qa360/runs/${runId}-report.${format}`;
+      };
+
+      const path = generatePath('run-123', 'html');
+      expect(path).toContain('run-123');
+      expect(path).toContain('.html');
+    });
+
+    it('should use custom output path', () => {
+      const customPath = './custom/report.html';
+      expect(customPath).toContain('custom');
+    });
+
+    it('should validate output directory exists', () => {
+      const validateDir = (path: string) => {
+        return path.includes('/');
+      };
+
+      expect(validateDir('./reports/report.html')).toBe(true);
+    });
+  });
+
+  describe('Proof Document Structure', () => {
+    it('should include signature field', () => {
+      const proof = {
+        signature: {
+          algorithm: 'ed25519',
+          value: 'base64-signature',
+          timestamp: new Date().toISOString()
+        }
+      };
+      
+      expect(proof.signature.algorithm).toBe('ed25519');
+    });
+
+    it('should include hooks metadata', () => {
+      const proof = {
+        hooks: {
+          beforeAll: 100,
+          afterAll: 50
+        }
+      };
+      
+      expect(proof.hooks.beforeAll).toBeGreaterThanOrEqual(0);
+    });
+  });
+});