qa360 2.1.7 → 2.2.0

package/core/src/__tests__/vault/cas.test.ts

@@ -0,0 +1,178 @@
+/**
+ * QA360 Content-Addressable Storage Tests
+ */
+
+import { ContentAddressableStorage } from '../../vault/cas';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { rmSync, mkdirSync } from 'fs';
+
+describe('ContentAddressableStorage', () => {
+  let cas: ContentAddressableStorage;
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-cas-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    cas = new ContentAddressableStorage(testDir);
+  });
+
+  afterEach(() => {
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('saveArtifact()', () => {
+    it('should save content and return artifact metadata', async () => {
+      const content = Buffer.from('Hello, QA360!');
+      const mimeType = 'text/plain';
+
+      const artifact = await cas.saveArtifact(content, mimeType);
+
+      expect(artifact.sha256).toHaveLength(64);
+      expect(artifact.size).toBe(content.length);
+      expect(artifact.path).toContain(artifact.sha256);
+      expect(artifact.exists).toBe(false); // First time saving
+    });
+
+    it('should deduplicate identical content', async () => {
+      const content = Buffer.from('Duplicate content');
+      const mimeType = 'text/plain';
+
+      const artifact1 = await cas.saveArtifact(content, mimeType);
+      const artifact2 = await cas.saveArtifact(content, mimeType);
+
+      expect(artifact1.sha256).toBe(artifact2.sha256);
+      expect(artifact1.path).toBe(artifact2.path);
+      expect(artifact1.exists).toBe(false); // First save
+      expect(artifact2.exists).toBe(true);  // Deduplicated
+    });
+
+    it('should handle different content with different hashes', async () => {
+      const content1 = Buffer.from('Content 1');
+      const content2 = Buffer.from('Content 2');
+
+      const artifact1 = await cas.saveArtifact(content1, 'text/plain');
+      const artifact2 = await cas.saveArtifact(content2, 'text/plain');
+
+      expect(artifact1.sha256).not.toBe(artifact2.sha256);
+      expect(artifact1.path).not.toBe(artifact2.path);
+    });
+  });
+
+  describe('getArtifact()', () => {
+    it('should retrieve saved content', async () => {
+      const originalContent = Buffer.from('Test content for retrieval');
+      const artifact = await cas.saveArtifact(originalContent, 'text/plain');
+
+      const retrievedContent = await cas.getArtifact(artifact.sha256);
+
+      expect(retrievedContent).toEqual(originalContent);
+    });
+
+    it('should return null for non-existent artifact', async () => {
+      const fakeHash = 'a'.repeat(64);
+      const content = await cas.getArtifact(fakeHash);
+
+      expect(content).toBeNull();
+    });
+  });
+
+  describe('exists()', () => {
+    it('should return true for existing artifacts', async () => {
+      const content = Buffer.from('Exists test');
+      const artifact = await cas.saveArtifact(content, 'text/plain');
+
+      expect(cas.exists(artifact.sha256)).toBe(true);
+    });
+
+    it('should return false for non-existent artifacts', async () => {
+      const fakeHash = 'b'.repeat(64);
+      expect(cas.exists(fakeHash)).toBe(false);
+    });
+  });
+
+  describe('listArtifacts()', () => {
+    it('should list all stored artifacts', async () => {
+      const content1 = Buffer.from('Artifact 1');
+      const content2 = Buffer.from('Artifact 2');
+
+      const artifact1 = await cas.saveArtifact(content1, 'text/plain');
+      const artifact2 = await cas.saveArtifact(content2, 'text/plain');
+
+      const artifacts = await cas.listArtifacts();
+
+      expect(artifacts).toContain(artifact1.sha256);
+      expect(artifacts).toContain(artifact2.sha256);
+      expect(artifacts).toHaveLength(2);
+    });
+
+    it('should return empty array when no artifacts exist', async () => {
+      const artifacts = await cas.listArtifacts();
+      expect(artifacts).toEqual([]);
+    });
+  });
+
+  describe('getStats()', () => {
+    it('should return correct statistics', async () => {
+      const content1 = Buffer.from('Stats test 1');
+      const content2 = Buffer.from('Stats test 2 - longer content');
+
+      await cas.saveArtifact(content1, 'text/plain');
+      await cas.saveArtifact(content2, 'text/plain');
+
+      const stats = await cas.getStats();
+
+      expect(stats.totalFiles).toBe(2);
+      expect(stats.totalBytes).toBe(content1.length + content2.length);
+      // When no referenced hashes provided, orphan counts are 0
+      expect(stats.orphanedFiles).toBe(0);
+      expect(stats.orphanedBytes).toBe(0);
+    });
+
+    it('should identify orphaned artifacts', async () => {
+      const content1 = Buffer.from('Referenced content');
+      const content2 = Buffer.from('Orphaned content');
+
+      const artifact1 = await cas.saveArtifact(content1, 'text/plain');
+      const artifact2 = await cas.saveArtifact(content2, 'text/plain');
+
+      const referencedHashes = new Set([artifact1.sha256]);
+      const stats = await cas.getStats(referencedHashes);
+
+      expect(stats.totalFiles).toBe(2);
+      expect(stats.orphanedFiles).toBe(1);
+      expect(stats.orphanedBytes).toBe(content2.length);
+    });
+  });
+
+  describe('verifyArtifact()', () => {
+    it('should verify artifact integrity', async () => {
+      const content = Buffer.from('Integrity test content');
+      const artifact = await cas.saveArtifact(content, 'text/plain');
+
+      const isValid = await cas.verifyArtifact(artifact.sha256);
+
+      expect(isValid).toBe(true);
+    });
+
+    it('should return false for non-existent artifact', async () => {
+      const fakeHash = 'c'.repeat(64);
+      const isValid = await cas.verifyArtifact(fakeHash);
+
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('formatBytes()', () => {
+    it('should format bytes correctly', () => {
+      expect(ContentAddressableStorage.formatBytes(0)).toBe('0.0 B');
+      expect(ContentAddressableStorage.formatBytes(1024)).toBe('1.0 KB');
+      expect(ContentAddressableStorage.formatBytes(1024 * 1024)).toBe('1.0 MB');
+      expect(ContentAddressableStorage.formatBytes(1024 * 1024 * 1024)).toBe('1.0 GB');
+    });
+  });
+});

package/core/src/__tests__/vault/vault.test.ts

@@ -0,0 +1,296 @@
+/**
+ * QA360 Evidence Vault Tests
+ */
+
+import { EvidenceVault } from '../../vault';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { rmSync, mkdirSync } from 'fs';
+
+describe('EvidenceVault', () => {
+  let vault: EvidenceVault;
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `qa360-vault-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    vault = await EvidenceVault.open(testDir);
+  });
+
+  afterEach(async () => {
+    await vault.close();
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('beginRun()', () => {
+    it('should create a new run', async () => {
+      const options = {
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123',
+        weights: { ui: 0.4, api: 0.6 }
+      };
+
+      const result = await vault.beginRun(options);
+
+      expect(result.runId).toMatch(/^[0-9a-f-]{36}$/); // UUID format
+      expect(result.isReused).toBe(false);
+
+      const run = await vault.getRun(result.runId);
+      expect(run).not.toBeNull();
+      expect(run!.pack_path).toBe(options.pack_path);
+      expect(run!.pack_hash).toBe(options.pack_hash);
+      expect(run!.status).toBe('running');
+    });
+
+    it('should implement idempotence with run_key', async () => {
+      const options = {
+        run_key: 'test-idempotent-key',
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      };
+
+      const result1 = await vault.beginRun(options);
+      const result2 = await vault.beginRun(options);
+
+      expect(result1.runId).toBe(result2.runId);
+      expect(result1.isReused).toBe(false);
+      expect(result2.isReused).toBe(true);
+    });
+
+    it('should allow different runs with different run_keys', async () => {
+      const options1 = {
+        run_key: 'key-1',
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      };
+
+      const options2 = {
+        run_key: 'key-2',
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      };
+
+      const result1 = await vault.beginRun(options1);
+      const result2 = await vault.beginRun(options2);
+
+      expect(result1.runId).not.toBe(result2.runId);
+      expect(result1.isReused).toBe(false);
+      expect(result2.isReused).toBe(false);
+    });
+  });
+
+  describe('finishRun()', () => {
+    it('should update run with final status', async () => {
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      await vault.finishRun(runId, {
+        status: 'passed',
+        trust_score: 85,
+        signature: 'signature-hex'
+      });
+
+      const run = await vault.getRun(runId);
+      expect(run!.status).toBe('passed');
+      expect(run!.trust_score).toBe(85);
+      expect(run!.signature_hex).toBe('signature-hex');
+      expect(run!.ended_at).toBeDefined();
+    });
+  });
+
+  describe('recordGate()', () => {
+    it('should record gate execution', async () => {
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      const gateId = await vault.recordGate(runId, {
+        name: 'ui',
+        status: 'passed',
+        duration_ms: 1500,
+        metrics_json: JSON.stringify({ interactions: 5 })
+      });
+
+      expect(typeof gateId).toBe('number');
+
+      const gates = await vault.getGates(runId);
+      expect(gates).toHaveLength(1);
+      expect(gates[0].name).toBe('ui');
+      expect(gates[0].status).toBe('passed');
+      expect(gates[0].duration_ms).toBe(1500);
+    });
+  });
+
+  describe('recordFinding()', () => {
+    it('should record and redact findings', async () => {
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      const findingId = await vault.recordFinding(runId, {
+        gate: 'sast',
+        severity: 'high',
+        rule: 'semgrep:hardcoded-password',
+        location: '/src/auth.js:42',
+        message: 'Hardcoded password found: password123',
+        raw_output: 'Raw tool output with password123'
+      });
+
+      expect(typeof findingId).toBe('number');
+
+      const findings = await vault.getFindings(runId);
+      expect(findings).toHaveLength(1);
+      expect(findings[0].gate).toBe('sast');
+      expect(findings[0].severity).toBe('high');
+      expect(findings[0].fingerprint).toBeDefined();
+      // Message should be redacted (note: actual redaction depends on SecurityRedactor rules)
+      expect(findings[0].message).toBeDefined();
+    });
+  });
+
+  describe('storeArtifact()', () => {
+    it('should store artifact in CAS and link to run', async () => {
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      const content = Buffer.from('Test artifact content');
+      const artifact = await vault.storeArtifact(
+        runId,
+        content,
+        'text/plain',
+        'test-report',
+        'report.txt'
+      );
+
+      expect(artifact.sha256).toHaveLength(64);
+      expect(artifact.size).toBe(content.length);
+
+      const runArtifacts = await vault.getRunArtifacts(runId);
+      expect(runArtifacts).toHaveLength(1);
+      expect(runArtifacts[0].label).toBe('test-report');
+      expect(runArtifacts[0].original_name).toBe('report.txt');
+    });
+  });
+
+  describe('listRuns()', () => {
+    it('should list runs with filters', async () => {
+      // Create multiple runs
+      const { runId: runId1 } = await vault.beginRun({
+        pack_path: '/test/pack1.yml',
+        pack_hash: 'hash1'
+      });
+
+      const { runId: runId2 } = await vault.beginRun({
+        pack_path: '/test/pack2.yml',
+        pack_hash: 'hash2'
+      });
+
+      await vault.finishRun(runId1, { status: 'passed', trust_score: 90 });
+      await vault.finishRun(runId2, { status: 'failed', trust_score: 45 });
+
+      // List all runs
+      const allRuns = await vault.listRuns();
+      expect(allRuns).toHaveLength(2);
+
+      // Filter by status
+      const passedRuns = await vault.listRuns({ status: ['passed'] });
+      expect(passedRuns).toHaveLength(1);
+      expect(passedRuns[0].id).toBe(runId1);
+
+      // Limit results
+      const limitedRuns = await vault.listRuns({ limit: 1 });
+      expect(limitedRuns).toHaveLength(1);
+    });
+  });
+
+  describe('pinRun()', () => {
+    it('should pin and unpin runs', async () => {
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      // Pin the run
+      await vault.pinRun(runId, true);
+      let run = await vault.getRun(runId);
+      expect(run!.pinned).toBe(1);
+
+      // Unpin the run
+      await vault.pinRun(runId, false);
+      run = await vault.getRun(runId);
+      expect(run!.pinned).toBe(0);
+    });
+  });
+
+  describe('calculatePackHash()', () => {
+    it('should generate consistent hashes for normalized content', () => {
+      const pack1 = `
+name: test
+version: 1.0.0
+# This is a comment
+description: Test pack
+`;
+
+      const pack2 = `
+name: test
+version: 1.0.0
+description: Test pack
+# Different comment
+`;
+
+      const hash1 = EvidenceVault.calculatePackHash(pack1);
+      const hash2 = EvidenceVault.calculatePackHash(pack2);
+
+      expect(hash1).toBe(hash2); // Should be same after normalization
+      expect(hash1).toHaveLength(64); // SHA256 length
+    });
+  });
+
+  describe('getStats()', () => {
+    it('should return vault statistics', async () => {
+      // Create some test data
+      const { runId } = await vault.beginRun({
+        pack_path: '/test/pack.yml',
+        pack_hash: 'abc123'
+      });
+
+      await vault.recordGate(runId, {
+        name: 'ui',
+        status: 'passed',
+        duration_ms: 1000
+      });
+
+      await vault.recordFinding(runId, {
+        gate: 'sast',
+        severity: 'medium',
+        rule: 'test-rule',
+        message: 'Test finding'
+      });
+
+      await vault.storeArtifact(
+        runId,
+        Buffer.from('test'),
+        'text/plain',
+        'test-artifact'
+      );
+
+      const stats = await vault.getStats();
+
+      expect(stats.totalRuns).toBe(1);
+      expect(stats.totalGates).toBe(1);
+      expect(stats.totalFindings).toBe(1);
+      expect(stats.totalArtifacts).toBe(1);
+      expect(stats.vaultSizeBytes).toBeGreaterThan(0);
+    });
+  });
+});

package/core/src/adapters/__tests__/fixtures/jest-coverage.json

@@ -0,0 +1,8 @@
+{
+  "total": {
+    "lines": { "total": 150, "covered": 135, "pct": 90 },
+    "branches": { "total": 40, "covered": 30, "pct": 75 },
+    "functions": { "total": 20, "covered": 18, "pct": 90 },
+    "statements": { "total": 160, "covered": 145, "pct": 90.62 }
+  }
+}

package/core/src/adapters/__tests__/fixtures/jest-results.json

@@ -0,0 +1,41 @@
+{
+  "numFailedTests": 1,
+  "numFailedTestSuites": 1,
+  "numPassedTests": 3,
+  "numPassedTestSuites": 2,
+  "numPendingTests": 1,
+  "numTodoTests": 0,
+  "numTotalTests": 5,
+  "startTime": 1705087200000,
+  "success": false,
+  "testResults": [
+    {
+      "name": "math.test.ts add",
+      "status": "passed",
+      "duration": 45
+    },
+    {
+      "name": "math.test.ts subtract",
+      "status": "passed",
+      "duration": 32
+    },
+    {
+      "name": "math.test.ts multiply",
+      "status": "passed",
+      "duration": 28
+    },
+    {
+      "name": "math.test.ts divide",
+      "status": "failed",
+      "duration": 15,
+      "message": "Expected 2 but got 0",
+      "failureMessages": [
+        "Error: Expected 2 but got 0\n    at math.test.ts:15:12"
+      ]
+    },
+    {
+      "name": "math.test.ts skipped",
+      "status": "pending"
+    }
+  ]
+}

package/core/src/adapters/__tests__/fixtures/pytest-junit.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<testsuites>
+  <testsuite name="test_math.py" tests="5" failures="1" errors="0" skipped="1" time="2.5">
+    <testcase name="test_add" classname="test_math.py" time="0.045"></testcase>
+    <testcase name="test_subtract" classname="test_math.py" time="0.032"></testcase>
+    <testcase name="test_multiply" classname="test_math.py" time="0.028"></testcase>
+    <testcase name="test_divide" classname="test_math.py" time="0.015">
+      <failure message="AssertionError: assert 2 == 0">def test_divide():
+        assert 2 == 0
+       AssertionError: assert 2 == 0</failure>
+    </testcase>
+    <testcase name="test_skipped" classname="test_math.py" time="0">
+      <skipped message="Test skipped"/>
+    </testcase>
+  </testsuite>
+</testsuites>

package/core/src/adapters/__tests__/fixtures/vitest-coverage.json

@@ -0,0 +1,8 @@
+{
+  "total": {
+    "lines": { "total": 150, "covered": 135, "pct": 90 },
+    "branches": { "total": 40, "covered": 30, "pct": 75 },
+    "functions": { "total": 20, "covered": 18, "pct": 90 },
+    "statements": { "total": 160, "covered": 145, "pct": 90.62 }
+  }
+}

package/core/src/adapters/__tests__/fixtures/vitest-results.json

@@ -0,0 +1,50 @@
+{
+  "startTime": 1705087200000,
+  "endTime": 1705087275000,
+  "testResults": [
+    {
+      "name": "add()",
+      "filePath": "/src/math.test.ts",
+      "result": {
+        "state": "pass",
+        "duration": 45
+      }
+    },
+    {
+      "name": "subtract()",
+      "filePath": "/src/math.test.ts",
+      "result": {
+        "state": "pass",
+        "duration": 32
+      }
+    },
+    {
+      "name": "multiply()",
+      "filePath": "/src/math.test.ts",
+      "result": {
+        "state": "pass",
+        "duration": 28
+      }
+    },
+    {
+      "name": "divide()",
+      "filePath": "/src/math.test.ts",
+      "result": {
+        "state": "fail",
+        "duration": 15,
+        "error": {
+          "name": "AssertionError",
+          "message": "Expected 2 but got 0",
+          "stack": "Error: Expected 2 but got 0\n    at /src/math.test.ts:15:12"
+        }
+      }
+    },
+    {
+      "name": "skipped test",
+      "filePath": "/src/math.test.ts",
+      "result": {
+        "state": "skip"
+      }
+    }
+  ]
+}