qa360 2.2.1 → 2.2.13

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

@@ -1,433 +0,0 @@
-/**
- * CLI History Command Tests
- * Target: 30-40% coverage on history.ts
- */
-
-import { Command } from 'commander';
-
-describe('history command', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-  });
-
-  describe('Command Structure', () => {
-    it('should create history command', () => {
-      const historyCmd = program.command('history');
-      expect(historyCmd).toBeDefined();
-      expect(historyCmd.name()).toBe('history');
-    });
-
-    it('should have description', () => {
-      const historyCmd = program
-        .command('history')
-        .description('Evidence vault history and analysis');
-      
-      expect(historyCmd.description()).toContain('history');
-    });
-  });
-
-  describe('Subcommands', () => {
-    it('should support list subcommand', () => {
-      const historyCmd = program.command('history');
-      const listCmd = historyCmd.command('list');
-      
-      expect(listCmd).toBeDefined();
-      expect(listCmd.name()).toBe('list');
-    });
-
-    it('should support get subcommand', () => {
-      const historyCmd = program.command('history');
-      const getCmd = historyCmd.command('get <runId>');
-      
-      expect(getCmd).toBeDefined();
-      expect(getCmd.name()).toBe('get');
-    });
-
-    it('should support diff subcommand', () => {
-      const historyCmd = program.command('history');
-      const diffCmd = historyCmd.command('diff <runIdA> <runIdB>');
-      
-      expect(diffCmd).toBeDefined();
-      expect(diffCmd.name()).toBe('diff');
-    });
-
-    it('should support trend subcommand', () => {
-      const historyCmd = program.command('history');
-      const trendCmd = historyCmd.command('trend');
-      
-      expect(trendCmd).toBeDefined();
-      expect(trendCmd.name()).toBe('trend');
-    });
-
-    it('should support export subcommand', () => {
-      const historyCmd = program.command('history');
-      const exportCmd = historyCmd.command('export <runId>');
-      
-      expect(exportCmd).toBeDefined();
-      expect(exportCmd.name()).toBe('export');
-    });
-
-    it('should support gc subcommand', () => {
-      const historyCmd = program.command('history');
-      const gcCmd = historyCmd.command('gc');
-      
-      expect(gcCmd).toBeDefined();
-      expect(gcCmd.name()).toBe('gc');
-    });
-
-    it('should support pin subcommand', () => {
-      const historyCmd = program.command('history');
-      const pinCmd = historyCmd.command('pin <runId>');
-      
-      expect(pinCmd).toBeDefined();
-      expect(pinCmd.name()).toBe('pin');
-    });
-
-    it('should support unpin subcommand', () => {
-      const historyCmd = program.command('history');
-      const unpinCmd = historyCmd.command('unpin <runId>');
-      
-      expect(unpinCmd).toBeDefined();
-      expect(unpinCmd.name()).toBe('unpin');
-    });
-  });
-
-  describe('List Command Options', () => {
-    it('should support --limit option', () => {
-      const listCmd = program
-        .command('list')
-        .option('-l, --limit <number>', 'Number of runs', '10');
-      
-      const limitOption = listCmd.options.find(opt => opt.long === '--limit');
-      expect(limitOption).toBeDefined();
-    });
-
-    it('should support --status filter', () => {
-      const listCmd = program
-        .command('list')
-        .option('--status <status>', 'Filter by status');
-      
-      const statusOption = listCmd.options.find(opt => opt.long === '--status');
-      expect(statusOption).toBeDefined();
-    });
-
-    it('should support --since date filter', () => {
-      const listCmd = program
-        .command('list')
-        .option('--since <date>', 'Filter runs since date');
-      
-      const sinceOption = listCmd.options.find(opt => opt.long === '--since');
-      expect(sinceOption).toBeDefined();
-    });
-
-    it('should support --json output', () => {
-      const listCmd = program
-        .command('list')
-        .option('--json', 'Output as JSON');
-      
-      const jsonOption = listCmd.options.find(opt => opt.long === '--json');
-      expect(jsonOption).toBeDefined();
-    });
-
-    it('should default limit to 10', () => {
-      const defaultLimit = 10;
-      expect(defaultLimit).toBe(10);
-    });
-  });
-
-  describe('Get Command', () => {
-    it('should require runId argument', () => {
-      const getCmd = program.command('get <runId>');
-      expect(getCmd.name()).toBe('get');
-    });
-
-    it('should support --json output', () => {
-      const getCmd = program
-        .command('get <runId>')
-        .option('--json', 'Output as JSON');
-      
-      const jsonOption = getCmd.options.find(opt => opt.long === '--json');
-      expect(jsonOption).toBeDefined();
-    });
-
-    it('should validate runId format', () => {
-      const validateRunId = (runId: string) => {
-        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-        return uuidRegex.test(runId);
-      };
-
-      expect(validateRunId('8eaeeb61-ee3f-4ba2-a0af-106b60176a32')).toBe(true);
-      expect(validateRunId('invalid-id')).toBe(false);
-    });
-  });
-
-  describe('Diff Command', () => {
-    it('should require two runId arguments', () => {
-      const diffCmd = program.command('diff <runIdA> <runIdB>');
-      expect(diffCmd.name()).toBe('diff');
-    });
-
-    it('should support --json output', () => {
-      const diffCmd = program
-        .command('diff <runIdA> <runIdB>')
-        .option('--json', 'Output as JSON');
-      
-      const jsonOption = diffCmd.options.find(opt => opt.long === '--json');
-      expect(jsonOption).toBeDefined();
-    });
-
-    it('should calculate trust score delta', () => {
-      const calculateDelta = (scoreA: number, scoreB: number) => {
-        return scoreB - scoreA;
-      };
-
-      expect(calculateDelta(80, 90)).toBe(10);
-      expect(calculateDelta(90, 80)).toBe(-10);
-    });
-  });
-
-  describe('Trend Command', () => {
-    it('should support --window option', () => {
-      const trendCmd = program
-        .command('trend')
-        .option('--window <number>', 'Window size', '20');
-      
-      const windowOption = trendCmd.options.find(opt => opt.long === '--window');
-      expect(windowOption).toBeDefined();
-    });
-
-    it('should support --gate filter', () => {
-      const trendCmd = program
-        .command('trend')
-        .option('--gate <name>', 'Filter by gate');
-      
-      const gateOption = trendCmd.options.find(opt => opt.long === '--gate');
-      expect(gateOption).toBeDefined();
-    });
-
-    it('should support --json output', () => {
-      const trendCmd = program
-        .command('trend')
-        .option('--json', 'Output as JSON');
-      
-      const jsonOption = trendCmd.options.find(opt => opt.long === '--json');
-      expect(jsonOption).toBeDefined();
-    });
-
-    it('should support --csv export', () => {
-      const trendCmd = program
-        .command('trend')
-        .option('--csv <file>', 'Export to CSV');
-      
-      const csvOption = trendCmd.options.find(opt => opt.long === '--csv');
-      expect(csvOption).toBeDefined();
-    });
-
-    it('should calculate average trust score', () => {
-      const calculateAverage = (scores: number[]) => {
-        if (scores.length === 0) return 0;
-        return scores.reduce((sum, score) => sum + score, 0) / scores.length;
-      };
-
-      expect(calculateAverage([80, 90, 100])).toBe(90);
-      expect(calculateAverage([])).toBe(0);
-    });
-  });
-
-  describe('Export Command', () => {
-    it('should require runId argument', () => {
-      const exportCmd = program.command('export <runId>');
-      expect(exportCmd.name()).toBe('export');
-    });
-
-    it('should require --bundle option', () => {
-      const exportCmd = program
-        .command('export <runId>')
-        .requiredOption('-b, --bundle <path>', 'Output bundle path');
-      
-      const bundleOption = exportCmd.options.find(opt => opt.long === '--bundle');
-      expect(bundleOption).toBeDefined();
-      expect(bundleOption?.required).toBe(true);
-    });
-
-    it('should validate bundle path extension', () => {
-      const validateBundlePath = (path: string) => {
-        return path.endsWith('.zip');
-      };
-
-      expect(validateBundlePath('export.zip')).toBe(true);
-      expect(validateBundlePath('export.tar.gz')).toBe(false);
-    });
-  });
-
-  describe('GC Command', () => {
-    it('should support --keep-last option', () => {
-      const gcCmd = program
-        .command('gc')
-        .option('--keep-last <number>', 'Keep last N runs', '50');
-      
-      const keepOption = gcCmd.options.find(opt => opt.long === '--keep-last');
-      expect(keepOption).toBeDefined();
-    });
-
-    it('should support --max-bytes option', () => {
-      const gcCmd = program
-        .command('gc')
-        .option('--max-bytes <size>', 'Maximum vault size');
-      
-      const maxBytesOption = gcCmd.options.find(opt => opt.long === '--max-bytes');
-      expect(maxBytesOption).toBeDefined();
-    });
-
-    it('should support --dry-run option', () => {
-      const gcCmd = program
-        .command('gc')
-        .option('--dry-run', 'Show what would be deleted');
-      
-      const dryRunOption = gcCmd.options.find(opt => opt.long === '--dry-run');
-      expect(dryRunOption).toBeDefined();
-    });
-
-    it('should parse size strings', () => {
-      const parseSize = (size: string): number => {
-        const units: Record<string, number> = {
-          'KB': 1024,
-          'MB': 1024 * 1024,
-          'GB': 1024 * 1024 * 1024
-        };
-        
-        const match = size.match(/^(\d+)(KB|MB|GB)$/i);
-        if (!match) return 0;
-        
-        const [, value, unit] = match;
-        return parseInt(value) * (units[unit.toUpperCase()] || 1);
-      };
-
-      expect(parseSize('5GB')).toBe(5 * 1024 * 1024 * 1024);
-      expect(parseSize('100MB')).toBe(100 * 1024 * 1024);
-    });
-  });
-
-  describe('Pin/Unpin Commands', () => {
-    it('should pin run by ID', () => {
-      const pinCmd = program.command('pin <runId>');
-      expect(pinCmd.name()).toBe('pin');
-    });
-
-    it('should unpin run by ID', () => {
-      const unpinCmd = program.command('unpin <runId>');
-      expect(unpinCmd.name()).toBe('unpin');
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle vault not found', () => {
-      const error = { code: 'VAULT_NOT_FOUND', message: 'No QA360 vault found' };
-      expect(error.code).toBe('VAULT_NOT_FOUND');
-    });
-
-    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 date format', () => {
-      const validateDate = (dateStr: string) => {
-        const date = new Date(dateStr);
-        return !isNaN(date.getTime());
-      };
-
-      expect(validateDate('2025-01-01')).toBe(true);
-      expect(validateDate('invalid-date')).toBe(false);
-    });
-
-    it('should handle empty result set', () => {
-      const formatEmptyResult = () => {
-        return 'No runs found matching criteria.';
-      };
-
-      expect(formatEmptyResult()).toContain('No runs');
-    });
-  });
-
-  describe('Output Formatting', () => {
-    it('should format run status', () => {
-      const formatStatus = (status: string) => {
-        const statusMap: Record<string, string> = {
-          'passed': '✅ PASSED',
-          'failed': '❌ FAILED',
-          'running': '⏳ RUNNING'
-        };
-        return statusMap[status] || status;
-      };
-
-      expect(formatStatus('passed')).toContain('✅');
-      expect(formatStatus('failed')).toContain('❌');
-    });
-
-    it('should format trust score percentage', () => {
-      const formatTrustScore = (score: number) => {
-        return `${score}%`;
-      };
-
-      expect(formatTrustScore(95)).toBe('95%');
-      expect(formatTrustScore(100)).toBe('100%');
-    });
-
-    it('should format duration', () => {
-      const formatDuration = (ms: number) => {
-        if (ms < 1000) return `${ms}ms`;
-        const seconds = Math.floor(ms / 1000);
-        return `${seconds}s`;
-      };
-
-      expect(formatDuration(500)).toBe('500ms');
-      expect(formatDuration(5000)).toBe('5s');
-    });
-
-    it('should format date timestamp', () => {
-      const formatDate = (timestamp: number) => {
-        const date = new Date(timestamp);
-        return date.toLocaleString();
-      };
-
-      const now = Date.now();
-      expect(formatDate(now)).toBeDefined();
-      expect(typeof formatDate(now)).toBe('string');
-    });
-  });
-
-  describe('Data Validation', () => {
-    it('should validate limit is positive', () => {
-      const validateLimit = (limit: number) => {
-        return limit > 0;
-      };
-
-      expect(validateLimit(10)).toBe(true);
-      expect(validateLimit(0)).toBe(false);
-      expect(validateLimit(-1)).toBe(false);
-    });
-
-    it('should validate window size range', () => {
-      const validateWindow = (window: number) => {
-        return window >= 1 && window <= 1000;
-      };
-
-      expect(validateWindow(20)).toBe(true);
-      expect(validateWindow(0)).toBe(false);
-      expect(validateWindow(1001)).toBe(false);
-    });
-
-    it('should validate status values', () => {
-      const validateStatus = (status: string) => {
-        const validStatuses = ['passed', 'failed', 'running', 'cancelled', 'error'];
-        return validStatuses.includes(status);
-      };
-
-      expect(validateStatus('passed')).toBe(true);
-      expect(validateStatus('invalid')).toBe(false);
-    });
-  });
-});

package/cli/src/commands/__tests__/monitor-realworld.test.ts

@@ -1,199 +0,0 @@
-/**
- * Real-world CLI Monitor Commands Tests
- * Tests CLI commands with actual file system operations
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdir, writeFile, rm } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { createMonitorCommands, createDashboardCommand } from '../monitor.js';
-import { Command } from 'commander';
-
-describe('CLI Monitor Commands Real-world Tests', () => {
-  let tempDir: string;
-  let packPath: string;
-
-  beforeEach(async () => {
-    tempDir = join(tmpdir(), 'qa360-cli-monitor-test-' + Date.now());
-    await mkdir(tempDir, { recursive: true });
-
-    // Create a realistic pack.yml
-    packPath = join(tempDir, 'qa360.yml');
-    await writeFile(packPath, `
-name: e-commerce-api-tests
-version: 2
-
-description: Test suite for e-commerce API
-
-gates:
-  api_health:
-    type: api
-    config:
-      baseUrl: https://api.example.com
-      requests:
-        - method: GET
-          path: /health
-          expect:
-            status: 200
-        - method: GET
-          path: /version
-          expect:
-            status: 200
-
-  ui_smoke:
-    type: ui
-    config:
-      baseUrl: https://example.com
-      pages:
-        - https://example.com/
-        - https://example.com/products
-
-  performance:
-    type: perf
-    config:
-      baseUrl: https://api.example.com
-      scenarios:
-        - name: load_test
-          target: https://api.example.com/api/products
-          vus: 10
-          duration: 30s
-`, 'utf8');
-  });
-
-  afterEach(async () => {
-    try {
-      await rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore
-    }
-  });
-
-  describe('Monitor command validation', () => {
-    it('should have all required options', () => {
-      const cmd = createMonitorCommands();
-
-      expect(cmd.name()).toBe('monitor');
-
-      // Check options exist
-      const optionNames = cmd.options.map(o => o.long.replace('--', ''));
-      expect(optionNames).toContain('mode');
-      expect(optionNames).toContain('retries');
-      expect(optionNames).toContain('timeout');
-      expect(optionNames).toContain('docker');
-    });
-
-    it('should have proper defaults', () => {
-      const cmd = createMonitorCommands();
-
-      const modeOption = cmd.options.find(o => o.long === '--mode');
-      expect(modeOption?.defaultValue).toBe('soft');
-
-      const retriesOption = cmd.options.find(o => o.long === '--retries');
-      expect(retriesOption?.defaultValue).toBe('2');
-
-      const timeoutOption = cmd.options.find(o => o.long === '--timeout');
-      expect(timeoutOption?.defaultValue).toBe('30000');
-    });
-  });
-
-  describe('Dashboard command validation', () => {
-    it('should have all required options', () => {
-      const cmd = createDashboardCommand();
-
-      expect(cmd.name()).toBe('dashboard');
-
-      const optionNames = cmd.options.map(o => o.long.replace('--', ''));
-      expect(optionNames).toContain('port');
-      expect(optionNames).toContain('host');
-      expect(optionNames).toContain('no-auto-open');
-    });
-
-    it('should have proper defaults', () => {
-      const cmd = createDashboardCommand();
-
-      const portOption = cmd.options.find(o => o.long === '--port');
-      expect(portOption?.defaultValue).toBe('8080');
-
-      const hostOption = cmd.options.find(o => o.long === '--host');
-      expect(hostOption?.defaultValue).toBe('127.0.0.1');
-    });
-
-    it('should accept port number', () => {
-      const cmd = createDashboardCommand();
-
-      // Verify port option accepts numeric values
-      const portOption = cmd.options.find(o => o.long === '--port');
-      expect(portOption).toBeDefined();
-      // Port has a default value so it's always provided
-      expect(portOption?.required).toBe(true);
-    });
-  });
-
-  describe('Pack file discovery', () => {
-    it('should use default pack files', async () => {
-      // Test with pack.yml in current directory
-      const files = ['qa360.yml', 'qa360.yaml', 'pack.yml', 'pack.yaml'];
-
-      for (const file of files) {
-        await writeFile(join(tempDir, file), 'name: test\nversion: 2', 'utf8');
-        // File should exist
-        const { existsSync } = await import('fs');
-        expect(existsSync(join(tempDir, file))).toBe(true);
-        await rm(join(tempDir, file));
-      }
-    });
-
-    it('should accept custom pack path', async () => {
-      // Create pack in subdirectory
-      const subdir = join(tempDir, 'tests');
-      await mkdir(subdir, { recursive: true });
-      const customPack = join(subdir, 'custom-pack.yml');
-      await writeFile(customPack, 'name: custom\nversion: 2', 'utf8');
-
-      const { existsSync } = await import('fs');
-      expect(existsSync(customPack)).toBe(true);
-    });
-  });
-
-  describe('Option combinations', () => {
-    it('should handle soft mode option', () => {
-      const cmd = createMonitorCommands();
-      const modeOption = cmd.options.find(o => o.long === '--mode');
-
-      // Should accept 'soft' or 'strict'
-      expect(modeOption).toBeDefined();
-    });
-
-    it('should handle timeout in milliseconds', () => {
-      const cmd = createMonitorCommands();
-      const timeoutOption = cmd.options.find(o => o.long === '--timeout');
-
-      // Should accept numeric string
-      expect(timeoutOption).toBeDefined();
-    });
-
-    it('should handle docker fallback flag', () => {
-      const cmd = createMonitorCommands();
-      const dockerOption = cmd.options.find(o => o.long === '--docker');
-
-      // Should be a boolean flag
-      expect(dockerOption).toBeDefined();
-      expect(dockerOption?.required).toBe(false);
-    });
-  });
-
-  describe('Command help output', () => {
-    it('should show helpful description for monitor', () => {
-      const cmd = createMonitorCommands();
-      expect(cmd.description()).toBeDefined();
-      expect(cmd.description()).toContain('terminal');
-    });
-
-    it('should show helpful description for dashboard', () => {
-      const cmd = createDashboardCommand();
-      expect(cmd.description()).toBeDefined();
-      expect(cmd.description()).toContain('web');
-    });
-  });
-});