qa360 2.1.7 → 2.2.0

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

@@ -0,0 +1,358 @@
+/**
+ * History Command Integration Tests
+ */
+
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { mkdirSync, rmSync } from 'fs';
+
+// Mock chalk
+vi.mock('chalk', () => ({
+  default: {
+    blue: (s: string) => s,
+    green: (s: string) => s,
+    red: (s: string) => s,
+    yellow: (s: string) => s,
+    cyan: (s: string) => s,
+    gray: (s: string) => s,
+    bold: (s: string) => s,
+  },
+  blue: (s: string) => s,
+  green: (s: string) => s,
+  red: (s: string) => s,
+  yellow: (s: string) => s,
+  cyan: (s: string) => s,
+  gray: (s: string) => s,
+  bold: (s: string) => s,
+}));
+
+// Mock EvidenceVault
+const mockVault = {
+  listRuns: vi.fn().mockResolvedValue([
+    {
+      id: 'run-123',
+      started_at: Date.now() - 3600000,
+      ended_at: Date.now() - 3500000,
+      status: 'passed',
+      trust_score: 95,
+      pack_path: 'test-pack.yaml',
+      pinned: 0
+    }
+  ]),
+  getRun: vi.fn().mockResolvedValue({
+    id: 'run-123',
+    started_at: Date.now() - 3600000,
+    ended_at: Date.now() - 3500000,
+    status: 'passed',
+    trust_score: 95,
+    pack_path: 'test-pack.yaml',
+    pack_hash: 'abc123def456',
+    pinned: 0
+  }),
+  getGates: vi.fn().mockResolvedValue([
+    { name: 'api_smoke', status: 'passed', duration_ms: 500 }
+  ]),
+  getFindings: vi.fn().mockResolvedValue([]),
+  getRunArtifacts: vi.fn().mockResolvedValue([]),
+  pinRun: vi.fn().mockResolvedValue(undefined),
+  close: vi.fn().mockResolvedValue(undefined)
+};
+
+vi.mock('../../../../core/dist/index.js', () => ({
+  EvidenceVault: {
+    open: vi.fn().mockResolvedValue(mockVault)
+  }
+}));
+
+describe('History Command Integration', () => {
+  let testDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-history-int-test-${Date.now()}`);
+    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) {}
+    vi.clearAllMocks();
+  });
+
+  describe('QA360History class', () => {
+    it('should initialize with vault connection', async () => {
+      const { EvidenceVault } = await import('../../../../core/dist/index.js');
+      const vault = await EvidenceVault.open(join(testDir, '.qa360'));
+      expect(vault).toBeDefined();
+    });
+  });
+
+  describe('list()', () => {
+    it('should list runs with default options', async () => {
+      const runs = await mockVault.listRuns({ limit: 20 });
+      expect(runs.length).toBeGreaterThan(0);
+      expect(runs[0].status).toBe('passed');
+    });
+
+    it('should filter by status', async () => {
+      await mockVault.listRuns({ status: ['passed'] });
+      expect(mockVault.listRuns).toHaveBeenCalledWith(
+        expect.objectContaining({ status: ['passed'] })
+      );
+    });
+
+    it('should limit results', async () => {
+      await mockVault.listRuns({ limit: 5 });
+      expect(mockVault.listRuns).toHaveBeenCalledWith(
+        expect.objectContaining({ limit: 5 })
+      );
+    });
+
+    it('should output JSON when option set', async () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation();
+      
+      const runs = await mockVault.listRuns({ limit: 10 });
+      console.log(JSON.stringify(runs, null, 2));
+      
+      expect(consoleSpy).toHaveBeenCalled();
+      const output = consoleSpy.mock.calls[0][0];
+      expect(() => JSON.parse(output)).not.toThrow();
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('get()', () => {
+    it('should get run details', async () => {
+      const run = await mockVault.getRun('run-123');
+      expect(run).toBeDefined();
+      expect(run.id).toBe('run-123');
+      expect(run.trust_score).toBe(95);
+    });
+
+    it('should get gates for run', async () => {
+      const gates = await mockVault.getGates('run-123');
+      expect(gates.length).toBeGreaterThan(0);
+      expect(gates[0].name).toBe('api_smoke');
+    });
+
+    it('should get findings for run', async () => {
+      const findings = await mockVault.getFindings('run-123');
+      expect(findings).toBeDefined();
+      expect(Array.isArray(findings)).toBe(true);
+    });
+  });
+
+  describe('pin()', () => {
+    it('should pin a run', async () => {
+      await mockVault.pinRun('run-123', true);
+      expect(mockVault.pinRun).toHaveBeenCalledWith('run-123', true);
+    });
+
+    it('should unpin a run', async () => {
+      await mockVault.pinRun('run-123', false);
+      expect(mockVault.pinRun).toHaveBeenCalledWith('run-123', false);
+    });
+  });
+
+  describe('formatStatus()', () => {
+    it('should format passed status', () => {
+      const formatStatus = (status: string) => {
+        const map: Record<string, string> = {
+          passed: '✅ PASSED',
+          failed: '❌ FAILED',
+          cancelled: '⏹️ CANCELLED',
+          error: '💥 ERROR'
+        };
+        return map[status] || status;
+      };
+      
+      expect(formatStatus('passed')).toContain('PASSED');
+      expect(formatStatus('failed')).toContain('FAILED');
+    });
+  });
+
+  describe('formatSeverity()', () => {
+    it('should format severity levels', () => {
+      const formatSeverity = (severity: string) => {
+        const map: Record<string, string> = {
+          critical: '🔴 CRITICAL',
+          high: '🟠 HIGH',
+          medium: '🟡 MEDIUM',
+          low: '🔵 LOW'
+        };
+        return map[severity] || severity;
+      };
+
+      expect(formatSeverity('critical')).toContain('CRITICAL');
+      expect(formatSeverity('high')).toContain('HIGH');
+    });
+  });
+
+  describe('export()', () => {
+    it('should require bundle path option', () => {
+      const validateExportOptions = (options: any) => {
+        return !!options.bundle;
+      };
+
+      expect(validateExportOptions({ bundle: 'export.zip' })).toBe(true);
+      expect(validateExportOptions({})).toBe(false);
+    });
+
+    it('should validate bundle path is .zip', () => {
+      const validateBundlePath = (path: string) => {
+        return path.endsWith('.zip');
+      };
+
+      expect(validateBundlePath('export.zip')).toBe(true);
+      expect(validateBundlePath('export.tar.gz')).toBe(false);
+    });
+
+    it('should get run, gates, findings, and artifacts', async () => {
+      await mockVault.getRun('run-123');
+      await mockVault.getGates('run-123');
+      await mockVault.getFindings('run-123');
+      await mockVault.getRunArtifacts('run-123');
+
+      expect(mockVault.getRun).toHaveBeenCalledWith('run-123');
+      expect(mockVault.getGates).toHaveBeenCalledWith('run-123');
+      expect(mockVault.getFindings).toHaveBeenCalledWith('run-123');
+      expect(mockVault.getRunArtifacts).toHaveBeenCalledWith('run-123');
+    });
+
+    it('should create ZIP structure with required files', () => {
+      const expectedFiles = [
+        'proof.json',
+        'report.pdf',
+        'run.json',
+        'artifacts/',
+        'VERIFICATION.json'
+      ];
+
+      const validateZipStructure = (files: string[]) => {
+        return expectedFiles.every(f =>
+          files.some(file => file.includes(f.replace('/', '')))
+        );
+      };
+
+      expect(validateZipStructure(expectedFiles)).toBe(true);
+    });
+
+    it('should include verification instructions', () => {
+      const verificationData = {
+        verificationInstructions: [
+          '1. Extract public key from ~/.qa360/keys/ed25519.pub',
+          '2. Verify signature in proof.json using Ed25519',
+          '3. Check SHA-256 hash of all artifacts match',
+          '4. Ensure trust score meets requirements'
+        ]
+      };
+
+      expect(verificationData.verificationInstructions).toHaveLength(4);
+      expect(verificationData.verificationInstructions[0]).toContain('public key');
+    });
+  });
+
+  describe('gc()', () => {
+    const createMockRuns = (count: number, pinnedCount: number = 0) => {
+      const runs = [];
+      for (let i = 0; i < count; i++) {
+        runs.push({
+          id: `run-${i}`,
+          started_at: Date.now() - (i * 3600000),
+          ended_at: Date.now() - (i * 3600000) + 100000,
+          status: 'passed',
+          trust_score: 90,
+          pack_path: 'test.yaml',
+          pinned: i < pinnedCount ? 1 : 0
+        });
+      }
+      return runs;
+    };
+
+    it('should keep last N runs by default', () => {
+      const allRuns = createMockRuns(50);
+      const keepLast = 10;
+      const runsToDelete = allRuns.slice(keepLast);
+
+      expect(runsToDelete.length).toBe(40);
+      expect(allRuns.length - runsToDelete.length).toBe(keepLast);
+    });
+
+    it('should never delete pinned runs', () => {
+      const allRuns = createMockRuns(20, 5);
+      const pinnedRuns = allRuns.filter(r => r.pinned === 1);
+      const unpinnedRuns = allRuns.filter(r => r.pinned === 0);
+      const keepLast = 10;
+      const runsToDelete = unpinnedRuns.slice(keepLast);
+
+      expect(pinnedRuns.length).toBe(5);
+      expect(runsToDelete.every(r => r.pinned === 0)).toBe(true);
+    });
+
+    it('should track artifact references', () => {
+      const artifacts = [
+        { sha256: 'hash1' },
+        { sha256: 'hash2' },
+        { sha256: 'hash3' }
+      ];
+
+      const referencedHashes = new Set(artifacts.map(a => a.sha256));
+
+      expect(referencedHashes.size).toBe(3);
+      expect(referencedHashes.has('hash1')).toBe(true);
+      expect(referencedHashes.has('hash4')).toBe(false);
+    });
+
+    it('should identify orphaned artifacts', () => {
+      const referencedHashes = new Set(['hash1', 'hash2', 'hash3']);
+      const allArtifacts = ['hash1', 'hash2', 'hash3', 'hash4', 'hash5'];
+
+      const orphaned = allArtifacts.filter(h => !referencedHashes.has(h));
+
+      expect(orphaned).toEqual(['hash4', 'hash5']);
+      expect(orphaned.length).toBe(2);
+    });
+
+    it('should support dry-run mode', () => {
+      const options = { dryRun: true, keepLast: 10 };
+
+      expect(options.dryRun).toBe(true);
+
+      // In dry-run, no deletion should occur
+      const simulatedDeletion = (dryRun: boolean) => {
+        return dryRun ? 'simulated' : 'executed';
+      };
+
+      expect(simulatedDeletion(options.dryRun)).toBe('simulated');
+    });
+
+    it('should calculate space freed', () => {
+      const orphanedArtifacts = [
+        { size: 1024 * 1024 },      // 1 MB
+        { size: 2 * 1024 * 1024 },  // 2 MB
+        { size: 500 * 1024 }        // 500 KB
+      ];
+
+      const totalSize = orphanedArtifacts.reduce((sum, a) => sum + a.size, 0);
+      const sizeMB = totalSize / (1024 * 1024);
+
+      expect(sizeMB).toBeCloseTo(3.49, 1);
+    });
+
+    it('should validate keepLast option', () => {
+      const validateKeepLast = (keepLast: number) => {
+        return keepLast > 0 && Number.isInteger(keepLast);
+      };
+
+      expect(validateKeepLast(10)).toBe(true);
+      expect(validateKeepLast(0)).toBe(false);
+      expect(validateKeepLast(-1)).toBe(false);
+      expect(validateKeepLast(5.5)).toBe(false);
+    });
+  });
+});