qa360 2.2.1 → 2.2.13

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

@@ -1,346 +0,0 @@
-/**
- * CLI Run Command Tests
- * Target: 40-50% coverage on run.ts
- */
-
-import { Command } from 'commander';
-
-describe('run command', () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-  });
-
-  describe('Basic Functionality', () => {
-    it('should create run command', () => {
-      const runCommand = program.command('run');
-      expect(runCommand).toBeDefined();
-      expect(runCommand.name()).toBe('run');
-    });
-
-    it('should accept pack file argument', () => {
-      const runCommand = program
-        .command('run [packFile]')
-        .description('Run test pack');
-      
-      expect(runCommand.description()).toContain('pack');
-    });
-
-    it('should support verbose flag', () => {
-      const runCommand = program
-        .command('run')
-        .option('-v, --verbose', 'Verbose output');
-      
-      expect(runCommand.options).toHaveLength(1);
-      expect(runCommand.options[0].short).toBe('-v');
-    });
-
-    it('should support help flag', () => {
-      const runCommand = program
-        .command('run')
-        .option('-h, --help', 'Display help');
-      
-      const helpOption = runCommand.options.find(opt => opt.long === '--help');
-      expect(helpOption).toBeDefined();
-    });
-
-    it('should have description', () => {
-      const runCommand = program
-        .command('run')
-        .description('Execute QA360 test pack');
-      
-      expect(runCommand.description()).toBe('Execute QA360 test pack');
-    });
-  });
-
-  describe('Arguments and Options', () => {
-    it('should accept pack file path', () => {
-      const runCommand = program.command('run <packFile>');
-      runCommand.parse(['node', 'cli', 'run', 'test-pack.yml']);
-      
-      expect(runCommand.args).toContain('test-pack.yml');
-    });
-
-    it('should support dry-run option', () => {
-      const runCommand = program
-        .command('run')
-        .option('--dry-run', 'Dry run without execution');
-      
-      const dryRunOption = runCommand.options.find(opt => opt.long === '--dry-run');
-      expect(dryRunOption).toBeDefined();
-    });
-
-    it('should support output directory option', () => {
-      const runCommand = program
-        .command('run')
-        .option('-o, --output <dir>', 'Output directory');
-      
-      const outputOption = runCommand.options.find(opt => opt.long === '--output');
-      expect(outputOption).toBeDefined();
-    });
-  });
-
-  describe('Exit Codes', () => {
-    it('should define exit code 0 for success', () => {
-      const EXIT_SUCCESS = 0;
-      expect(EXIT_SUCCESS).toBe(0);
-    });
-
-    it('should define exit code 1 for error', () => {
-      const EXIT_ERROR = 1;
-      expect(EXIT_ERROR).toBe(1);
-    });
-
-    it('should define exit code for validation failure', () => {
-      const EXIT_VALIDATION_ERROR = 1;
-      expect(EXIT_VALIDATION_ERROR).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle missing pack file gracefully', () => {
-      const errorHandler = (message: string) => {
-        expect(message).toContain('not found');
-        return 1;
-      };
-
-      const result = errorHandler('Pack file not found');
-      expect(result).toBe(1);
-    });
-
-    it('should handle invalid YAML format', () => {
-      const errorHandler = (message: string) => {
-        expect(message.toLowerCase()).toContain('invalid');
-        return 1;
-      };
-
-      const result = errorHandler('Invalid YAML format');
-      expect(result).toBe(1);
-    });
-
-    it('should handle schema validation errors', () => {
-      const validatePack = (pack: any) => {
-        if (!pack.gates) {
-          throw new Error('Missing gates');
-        }
-        return true;
-      };
-
-      expect(() => validatePack({})).toThrow('Missing gates');
-    });
-
-    it('should handle missing adapter error', () => {
-      const checkAdapter = (adapter: string) => {
-        const available = ['playwright', 'k6', 'zap'];
-        if (!available.includes(adapter)) {
-          throw new Error(`Adapter ${adapter} not found`);
-        }
-        return true;
-      };
-
-      expect(() => checkAdapter('unknown')).toThrow('not found');
-    });
-  });
-
-  describe('Output Formatting', () => {
-    it('should format success message', () => {
-      const formatSuccess = (packName: string) => {
-        return `✓ Pack ${packName} completed successfully`;
-      };
-
-      const message = formatSuccess('test-pack');
-      expect(message).toContain('✓');
-      expect(message).toContain('successfully');
-    });
-
-    it('should format error message', () => {
-      const formatError = (error: string) => {
-        return `✗ Error: ${error}`;
-      };
-
-      const message = formatError('Pack validation failed');
-      expect(message).toContain('✗');
-      expect(message).toContain('Error');
-    });
-
-    it('should format progress indicator', () => {
-      const formatProgress = (current: number, total: number) => {
-        return `[${current}/${total}] Running gates...`;
-      };
-
-      const progress = formatProgress(2, 5);
-      expect(progress).toContain('[2/5]');
-      expect(progress).toContain('Running');
-    });
-  });
-
-  describe('Pack Validation', () => {
-    it('should validate pack structure', () => {
-      const validateStructure = (pack: any) => {
-        return pack && pack.gates && Array.isArray(pack.gates);
-      };
-
-      const validPack = { gates: [{ name: 'api' }] };
-      const invalidPack = { gates: 'invalid' };
-
-      expect(validateStructure(validPack)).toBe(true);
-      expect(validateStructure(invalidPack)).toBe(false);
-    });
-
-    it('should validate gate definitions', () => {
-      const validateGate = (gate: any) => {
-        return !!(gate && gate.name && gate.type);
-      };
-      
-      const validGate = { name: 'api_smoke', type: 'quality' };
-      const invalidGate = { name: '' };
-      
-      expect(validateGate(validGate)).toBe(true);
-      expect(validateGate(invalidGate)).toBe(false);
-    });
-
-    it('should validate adapter configuration', () => {
-      const validateAdapter = (adapter: any) => {
-        return !!(adapter && adapter.type && adapter.config);
-      };
-      
-      const validAdapter = { type: 'playwright', config: {} };
-      const invalidAdapter = { type: 'playwright' };
-      
-      expect(validateAdapter(validAdapter)).toBe(true);
-      expect(validateAdapter(invalidAdapter)).toBe(false);
-    });
-  });
-
-  describe('Timeout Handling', () => {
-    it('should support global timeout option', () => {
-      const runCommand = program
-        .command('run')
-        .option('--timeout <ms>', 'Global timeout', '30000');
-      
-      const timeoutOption = runCommand.options.find(opt => opt.long === '--timeout');
-      expect(timeoutOption).toBeDefined();
-    });
-
-    it('should validate timeout value is positive', () => {
-      const validateTimeout = (timeout: number) => {
-        return timeout > 0;
-      };
-
-      expect(validateTimeout(30000)).toBe(true);
-      expect(validateTimeout(0)).toBe(false);
-      expect(validateTimeout(-1000)).toBe(false);
-    });
-
-    it('should handle timeout exceeded error', () => {
-      const error = { code: 'TIMEOUT_EXCEEDED', message: 'Timeout exceeded' };
-      expect(error.code).toBe('TIMEOUT_EXCEEDED');
-    });
-  });
-
-  describe('Retry Logic', () => {
-    it('should support retries option', () => {
-      const runCommand = program
-        .command('run')
-        .option('--retries <number>', 'Number of retries', '2');
-      
-      const retriesOption = runCommand.options.find(opt => opt.long === '--retries');
-      expect(retriesOption).toBeDefined();
-    });
-
-    it('should validate retry count is non-negative', () => {
-      const validateRetries = (retries: number) => {
-        return retries >= 0;
-      };
-
-      expect(validateRetries(2)).toBe(true);
-      expect(validateRetries(0)).toBe(true);
-      expect(validateRetries(-1)).toBe(false);
-    });
-
-    it('should calculate max attempts', () => {
-      const calculateMaxAttempts = (retries: number) => {
-        return 1 + retries;
-      };
-
-      expect(calculateMaxAttempts(0)).toBe(1);
-      expect(calculateMaxAttempts(2)).toBe(3);
-    });
-  });
-
-  describe('Execution Modes', () => {
-    it('should support soft mode (continue on error)', () => {
-      const runCommand = program
-        .command('run')
-        .option('--mode <mode>', 'Execution mode', 'soft');
-      
-      const modeOption = runCommand.options.find(opt => opt.long === '--mode');
-      expect(modeOption).toBeDefined();
-    });
-
-    it('should support strict mode (stop on first error)', () => {
-      const modes = ['soft', 'strict'];
-      expect(modes).toContain('strict');
-    });
-
-    it('should validate mode value', () => {
-      const validateMode = (mode: string) => {
-        return ['soft', 'strict'].includes(mode);
-      };
-
-      expect(validateMode('soft')).toBe(true);
-      expect(validateMode('strict')).toBe(true);
-      expect(validateMode('invalid')).toBe(false);
-    });
-  });
-
-  describe('Docker Fallback', () => {
-    it('should support docker fallback option', () => {
-      const runCommand = program
-        .command('run')
-        .option('--docker', 'Use Docker fallback');
-      
-      const dockerOption = runCommand.options.find(opt => opt.long === '--docker');
-      expect(dockerOption).toBeDefined();
-    });
-
-    it('should check docker availability', () => {
-      const isDockerAvailable = () => {
-        return process.env.DOCKER_HOST !== undefined || true;
-      };
-
-      expect(typeof isDockerAvailable()).toBe('boolean');
-    });
-  });
-
-  describe('Pack File Paths', () => {
-    it('should handle absolute paths', () => {
-      const isAbsolutePath = (path: string) => {
-        return path.startsWith('/');
-      };
-
-      expect(isAbsolutePath('/absolute/path/pack.yaml')).toBe(true);
-      expect(isAbsolutePath('relative/pack.yaml')).toBe(false);
-    });
-
-    it('should handle relative paths', () => {
-      const isRelativePath = (path: string) => {
-        return !path.startsWith('/');
-      };
-
-      expect(isRelativePath('./pack.yaml')).toBe(true);
-      expect(isRelativePath('../pack.yaml')).toBe(true);
-    });
-
-    it('should validate yaml extension', () => {
-      const hasYamlExtension = (path: string) => {
-        return path.endsWith('.yaml') || path.endsWith('.yml');
-      };
-
-      expect(hasYamlExtension('pack.yaml')).toBe(true);
-      expect(hasYamlExtension('pack.yml')).toBe(true);
-      expect(hasYamlExtension('pack.json')).toBe(false);
-    });
-  });
-});

package/cli/src/commands/__tests__/run.vitest.ts

@@ -1,301 +0,0 @@
-/**
- * Run Command Integration Tests - Vitest
- * Tests actual run.ts code with direct imports
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { mkdirSync, writeFileSync, rmSync, readFileSync } from 'fs';
-import { load } from 'js-yaml';
-
-// Import actual functions from run.ts
-import { loadPack, findPackFile, displayResults } from '../run.js';
-
-// Mock chalk to avoid ANSI codes
-vi.mock('chalk', () => ({
-  default: {
-    blue: (s: any) => s,
-    green: { bold: (s: any) => s },
-    red: Object.assign((s: any) => s, { bold: (s: any) => s }),  // red() and red.bold()
-    yellow: (s: any) => s,
-    gray: (s: any) => s,
-    bold: (s: any) => s,
-  },
-}));
-
-// Simple YAML parser for the mock
-function parseYamlMock(content: string): any {
-  return load(content);
-}
-
-// Mock qa360-core
-vi.mock('qa360-core', () => ({
-  PackValidator: vi.fn().mockImplementation(() => ({
-    validate: vi.fn().mockResolvedValue({ valid: true, errors: [], warnings: [] })
-  })),
-  PackLoaderV2: vi.fn().mockImplementation(() => ({
-    load: vi.fn().mockImplementation((packPath: string) => {
-      // Read and parse the actual YAML file
-      const content = readFileSync(packPath, 'utf8');
-      const pack = parseYamlMock(content);
-      return Promise.resolve({
-        success: true,
-        pack,
-        validationErrors: [],
-        warnings: [],
-        migrated: false
-      });
-    })
-  })),
-  Phase3Runner: vi.fn()
-}));
-
-describe('Run Command - Vitest Integration', () => {
-  let testDir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    testDir = join(tmpdir(), `qa360-run-vitest-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-    mkdirSync(join(testDir, '.qa360'), { recursive: true });
-    originalCwd = process.cwd();
-    process.chdir(testDir);
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch (e) {
-      // Ignore cleanup errors
-    }
-    vi.clearAllMocks();
-  });
-
-  describe('loadPack()', () => {
-    it('should load valid pack file successfully', async () => {
-      const packContent = `
-version: 1
-name: test-pack
-gates:
-  - api_smoke
-targets:
-  api:
-    baseUrl: https://httpbin.org
-    smoke:
-      - GET /get -> 200
-`;
-      const packPath = join(testDir, 'pack.yaml');
-      writeFileSync(packPath, packContent);
-
-      const pack = await loadPack(packPath);
-
-      expect(pack).toBeDefined();
-      expect(pack.name).toBe('test-pack');
-      expect(pack.version).toBe(1);
-      expect(pack.gates).toEqual(['api_smoke']);
-    });
-
-    it('should throw error for missing pack file', async () => {
-      const nonExistentPath = join(testDir, 'nonexistent.yaml');
-
-      await expect(loadPack(nonExistentPath)).rejects.toThrow('Pack file not found');
-    });
-
-    it('should validate pack schema', async () => {
-      const validPack = `
-version: 1
-name: validation-test
-gates:
-  - api_smoke
-targets:
-  api:
-    baseUrl: https://api.example.com
-`;
-      const packPath = join(testDir, 'valid.yaml');
-      writeFileSync(packPath, validPack);
-
-      const pack = await loadPack(packPath);
-
-      expect(pack).toBeDefined();
-      expect(pack.name).toBe('validation-test');
-    });
-  });
-
-  describe('findPackFile()', () => {
-    it('should return explicit path when provided', () => {
-      const explicitPath = join(testDir, 'custom', 'my-pack.yaml');
-      mkdirSync(join(testDir, 'custom'), { recursive: true });
-      writeFileSync(explicitPath, 'version: 1\nname: test\ngates: []');
-
-      const result = findPackFile(explicitPath);
-
-      expect(result).toBe(explicitPath);
-    });
-
-    it('should find pack.yaml in current directory', () => {
-      const packPath = join(testDir, 'pack.yaml');
-      writeFileSync(packPath, 'version: 1\nname: test\ngates: []');
-
-      const result = findPackFile();
-
-      // Handle /private/var vs /var symlinks on macOS
-      expect(result).toContain('pack.yaml');
-      expect(result.endsWith('pack.yaml')).toBe(true);
-    });
-
-    it('should find pack.yml in current directory', () => {
-      const packPath = join(testDir, 'pack.yml');
-      writeFileSync(packPath, 'version: 1\nname: test\ngates: []');
-
-      const result = findPackFile();
-
-      // Handle /private/var vs /var symlinks on macOS
-      expect(result).toContain('pack.yml');
-      expect(result.endsWith('pack.yml')).toBe(true);
-    });
-
-    it('should find pack in .qa360 directory (priority order)', () => {
-      const qa360PackPath = join(testDir, '.qa360', 'pack.yml');
-      writeFileSync(qa360PackPath, 'version: 1\nname: qa360\ngates: []');
-
-      // Also create pack.yaml in root (should be lower priority)
-      const rootPackPath = join(testDir, 'pack.yaml');
-      writeFileSync(rootPackPath, 'version: 1\nname: root\ngates: []');
-
-      const result = findPackFile();
-
-      // .qa360/pack.yml has higher priority - handle symlinks
-      expect(result).toContain('.qa360');
-      expect(result).toContain('pack.yml');
-    });
-
-    it('should find qa360.yaml if pack.yaml not found', () => {
-      const qa360Path = join(testDir, 'qa360.yaml');
-      writeFileSync(qa360Path, 'version: 1\nname: qa360\ngates: []');
-
-      const result = findPackFile();
-
-      // Handle /private/var vs /var symlinks on macOS
-      expect(result).toContain('qa360.yaml');
-      expect(result.endsWith('qa360.yaml')).toBe(true);
-    });
-
-    it('should throw error when no pack file found', () => {
-      // No pack files in testDir
-      expect(() => findPackFile()).toThrow('No pack file found');
-    });
-  });
-
-  describe('displayResults()', () => {
-    it('should display success summary', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      const mockResult: any = {
-        success: true,
-        duration: 2000,
-        summary: { total: 3, passed: 3, failed: 0, trustScore: 100 },
-        gates: [],
-        proofPath: '/path/to/proof.json'
-      };
-
-      displayResults(mockResult);
-
-      const output = consoleSpy.mock.calls.map(call => call.join(' ')).join('\n');
-      expect(output).toContain('2000ms');
-      expect(output).toContain('100%');
-      expect(output).toContain('3/3');
-      expect(output).toContain('All quality gates passed');
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should display failure summary with failed gates', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      const mockResult: any = {
-        success: false,
-        duration: 1500,
-        summary: { total: 3, passed: 1, failed: 2, trustScore: 33 },
-        gates: [
-          { gate: 'api_smoke', success: false, error: 'Connection timeout' },
-          { gate: 'security_scan', success: false, error: 'Vulnerabilities found' }
-        ],
-        proofPath: null
-      };
-
-      displayResults(mockResult);
-
-      const output = consoleSpy.mock.calls.map(call => call.join(' ')).join('\n');
-      expect(output).toContain('1500ms');
-      expect(output).toContain('33%');
-      expect(output).toContain('2 gate(s) failed');
-      expect(output).toContain('api_smoke');
-      expect(output).toContain('Connection timeout');
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should display proof path when available', () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      const mockResult: any = {
-        success: true,
-        duration: 1000,
-        summary: { total: 1, passed: 1, failed: 0, trustScore: 100 },
-        gates: [],
-        proofPath: '/tmp/.qa360/runs/test-proof.json'
-      };
-
-      displayResults(mockResult);
-
-      const output = consoleSpy.mock.calls.map(call => call.join(' ')).join('\n');
-      expect(output).toContain('test-proof.json');
-      expect(output).toContain('qa360 verify');
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Integration Scenarios', () => {
-    it('should handle complete flow: find -> load -> validate', async () => {
-      const packContent = `
-version: 1
-name: complete-flow-test
-gates:
-  - api_smoke
-  - security_scan
-targets:
-  api:
-    baseUrl: https://api.example.com
-    smoke:
-      - GET /health -> 200
-`;
-      const packPath = join(testDir, 'pack.yaml');
-      writeFileSync(packPath, packContent);
-
-      // Step 1: Find pack file
-      const foundPath = findPackFile();
-      expect(foundPath).toContain('pack.yaml');
-
-      // Step 2: Load pack
-      const pack = await loadPack(foundPath);
-      expect(pack.name).toBe('complete-flow-test');
-      expect(pack.gates).toHaveLength(2);
-    });
-
-    it('should handle multiple pack files with priority', async () => {
-      // Create multiple pack files
-      writeFileSync(join(testDir, '.qa360', 'pack.yml'), 'version: 1\nname: qa360-pack\ngates: []');
-      writeFileSync(join(testDir, 'pack.yaml'), 'version: 1\nname: root-pack\ngates: []');
-      writeFileSync(join(testDir, 'qa360.yaml'), 'version: 1\nname: qa360-yaml\ngates: []');
-
-      const foundPath = findPackFile();
-      const pack = await loadPack(foundPath);
-
-      // Should load .qa360/pack.yml (highest priority)
-      expect(pack.name).toBe('qa360-pack');
-    });
-  });
-});