qa360 2.1.2 → 2.1.4

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

@@ -0,0 +1,346 @@
+/**
+ * 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

@@ -0,0 +1,301 @@
+/**
+ * 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');
+    });
+  });
+});