qa360 2.1.2 → 2.1.4

package/core/src/runner/__tests__/phase3-runner.test.ts

@@ -0,0 +1,1118 @@
+/**
+ * Phase3Runner Integration Tests
+ *
+ * Tests the complete test execution workflow including:
+ * - Key initialization
+ * - Evidence vault setup
+ * - Hook execution (beforeAll/afterAll)
+ * - Gate execution (api_smoke, ui, perf, sast, etc.)
+ * - Proof generation
+ * - Vault storage
+ */
+
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdirSync, rmSync, existsSync, writeFileSync } from 'fs';
+import { Phase3Runner, type Phase3RunResult } from '../phase3-runner.js';
+import type { PackConfigV1 } from '../../types/pack-v1.js';
+import type { PackConfigV2 } from '../../types/pack-v2.js';
+import { vi } from 'vitest';
+
+describe('Phase3Runner - Initialization', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should initialize with valid pack configuration', () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: ['api_smoke'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: ['GET /get -> 200']
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    expect(runner).toBeDefined();
+  });
+
+  it('should use custom output directory when provided', () => {
+    const customOutputDir = join(testDir, 'custom-output');
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+      outputDir: customOutputDir,
+    });
+
+    expect(runner).toBeDefined();
+  });
+
+  it('should initialize with empty gates array', () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'empty-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    expect(runner).toBeDefined();
+  });
+});
+
+describe('Phase3Runner - Summary Calculation', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should calculate 100% trust score for all passing gates', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    // Access private method via type casting
+    const calculateSummary = (runner as any).calculateSummary.bind(runner);
+
+    const gateResults = [
+      { gate: 'api_smoke', success: true, duration: 100, adapter: 'playwright-api', results: {} },
+      { gate: 'ui', success: true, duration: 200, adapter: 'playwright-ui', results: {} },
+    ];
+
+    const summary = calculateSummary(gateResults);
+
+    expect(summary.total).toBe(2);
+    expect(summary.passed).toBe(2);
+    expect(summary.failed).toBe(0);
+    expect(summary.trustScore).toBe(100);
+  });
+
+  it('should calculate weighted trust score based on gate importance', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const calculateSummary = (runner as any).calculateSummary.bind(runner);
+
+    const gateResults = [
+      { gate: 'api_smoke', success: true, duration: 100, adapter: 'playwright-api', results: {} }, // weight: 20
+      { gate: 'ui', success: false, duration: 200, adapter: 'playwright-ui', results: {}, error: 'Failed' }, // weight: 15
+    ];
+
+    const summary = calculateSummary(gateResults);
+
+    expect(summary.total).toBe(2);
+    expect(summary.passed).toBe(1);
+    expect(summary.failed).toBe(1);
+    // Trust score = (20 passed) / (20 + 15 total) * 100 = 57%
+    expect(summary.trustScore).toBe(57);
+  });
+
+  it('should calculate 0% trust score for all failing gates', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const calculateSummary = (runner as any).calculateSummary.bind(runner);
+
+    const gateResults = [
+      { gate: 'api_smoke', success: false, duration: 100, adapter: 'playwright-api', results: {}, error: 'Failed 1' },
+      { gate: 'ui', success: false, duration: 200, adapter: 'playwright-ui', results: {}, error: 'Failed 2' },
+    ];
+
+    const summary = calculateSummary(gateResults);
+
+    expect(summary.total).toBe(2);
+    expect(summary.passed).toBe(0);
+    expect(summary.failed).toBe(2);
+    expect(summary.trustScore).toBe(0);
+  });
+
+  it('should handle empty gate results', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const calculateSummary = (runner as any).calculateSummary.bind(runner);
+
+    const summary = calculateSummary([]);
+
+    expect(summary.total).toBe(0);
+    expect(summary.passed).toBe(0);
+    expect(summary.failed).toBe(0);
+    expect(summary.trustScore).toBe(0);
+  });
+});
+
+describe('Phase3Runner - Output Directory', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should create output directory if it does not exist', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    // Access private method
+    const ensureOutputDir = (runner as any).ensureOutputDir.bind(runner);
+    ensureOutputDir();
+
+    const expectedOutputDir = join(testDir, '.qa360', 'runs');
+    expect(existsSync(expectedOutputDir)).toBe(true);
+  });
+
+  it('should not fail if output directory already exists', async () => {
+    const outputDir = join(testDir, '.qa360', 'runs');
+    mkdirSync(outputDir, { recursive: true });
+
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const ensureOutputDir = (runner as any).ensureOutputDir.bind(runner);
+
+    // Should not throw
+    expect(() => ensureOutputDir()).not.toThrow();
+  });
+});
+
+describe('Phase3Runner - Error Handling', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should handle invalid working directory gracefully', () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack',
+      gates: [],
+    };
+
+    // Should not throw during construction
+    expect(() => {
+      new Phase3Runner({
+        workingDir: '/nonexistent/directory',
+        pack,
+      });
+    }).not.toThrow();
+  });
+
+  it('should handle pack with no gates', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'empty-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    expect(runner).toBeDefined();
+  });
+});
+
+describe('Phase3Runner - End-to-End Execution', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-e2e-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should execute pack with no gates successfully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'empty-pack',
+      gates: [],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    expect(result.success).toBe(true);
+    expect(result.summary.total).toBe(0);
+    expect(result.summary.passed).toBe(0);
+    expect(result.summary.failed).toBe(0);
+    expect(result.summary.trustScore).toBe(0);
+    expect(result.gates).toEqual([]);
+    expect(result.proofPath).toBeDefined();
+  }, 30000); // 30s timeout for initialization
+
+  it('should handle pack file creation and output directory', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'output-test',
+      gates: [],
+    };
+
+    // Create pack file
+    const packPath = join(testDir, 'qa360.yml');
+    writeFileSync(packPath, JSON.stringify(pack));
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    expect(result.success).toBe(true);
+    expect(existsSync(join(testDir, '.qa360', 'runs'))).toBe(true);
+    expect(result.proofPath).toBeDefined();
+  }, 30000);
+});
+
+describe('Phase3Runner - Real Gate Execution', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-gates-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  // TODO: Flaky test on Node 20 CI - passes on Node 18/22 and locally
+  // Skip until network issue is investigated
+  it.skip('should execute api_smoke gate with real HTTP calls', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'api-smoke-test',
+      gates: ['api_smoke'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: [
+            'GET /get -> 200',
+            'GET /status/200 -> 200',
+          ]
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    // Verify execution
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('api_smoke');
+    expect(result.gates[0].adapter).toBe('playwright-native-api');
+    expect(result.gates[0].success).toBe(true);
+    expect(result.gates[0].duration).toBeGreaterThan(0);
+
+    // Verify summary
+    expect(result.summary.total).toBe(1);
+    expect(result.summary.passed).toBe(1);
+    expect(result.summary.failed).toBe(0);
+    expect(result.summary.trustScore).toBeGreaterThan(0);
+
+    // Verify proof generation
+    expect(result.success).toBe(true);
+    expect(result.proofPath).toBeDefined();
+    expect(existsSync(result.proofPath!)).toBe(true);
+  }, 60000); // 60s timeout for network calls
+
+  it('should handle api_smoke gate failure gracefully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'api-smoke-fail-test',
+      gates: ['api_smoke'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: [
+            'GET /status/404 -> 200', // Expected 200 but will get 404
+          ]
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    // Gate should fail but execution should complete
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('api_smoke');
+    expect(result.gates[0].success).toBe(false);
+    expect(result.gates[0].error).toBeDefined();
+
+    // Overall result should be failure
+    expect(result.success).toBe(false);
+    expect(result.summary.failed).toBe(1);
+
+    // Proof should still be generated
+    expect(result.proofPath).toBeDefined();
+  }, 60000);
+
+  it('should execute multiple gates in sequence', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'multi-gate-test',
+      gates: ['api_smoke'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: ['GET /get -> 200']
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates.length).toBeGreaterThan(0);
+    expect(result.duration).toBeGreaterThan(0);
+    expect(result.proofPath).toBeDefined();
+  }, 60000);
+
+  it('should handle unknown gate type', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'unknown-gate-test',
+      gates: ['unknown_gate' as any],
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    // Should complete but with error
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].success).toBe(false);
+    expect(result.gates[0].error).toContain('Unknown gate');
+  }, 30000);
+
+  it('should respect on_failure=stop setting', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'stop-on-failure-test',
+      gates: ['api_smoke', 'ui'], // Second gate won't run if first fails
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: ['GET /status/500 -> 200'] // Will fail
+        }
+      },
+      execution: {
+        on_failure: 'stop'
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    // Only first gate should have executed
+    expect(result.gates.length).toBeLessThanOrEqual(1);
+    expect(result.success).toBe(false);
+  }, 60000);
+
+  it('should continue with on_failure=continue setting', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'continue-on-failure-test',
+      gates: ['api_smoke'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: ['GET /status/500 -> 200'] // Will fail
+        }
+      },
+      execution: {
+        on_failure: 'continue'
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    // All gates should execute despite failures
+    expect(result.gates).toHaveLength(1);
+    expect(result.success).toBe(false);
+    expect(result.proofPath).toBeDefined(); // Proof still generated
+  }, 60000);
+});
+
+describe('Phase3Runner - Mocked Gate Execution', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-mocked-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+    vi.clearAllMocks();
+  });
+
+  it('should execute ui gate successfully', async () => {
+    // Mock PlaywrightUiAdapter
+    const mockUiAdapter = {
+      runSmokeTests: vi.fn().mockResolvedValue({
+        success: true,
+        summary: { total: 2, passed: 2, failed: 0 },
+        junit: '<testsuites><testsuite tests="2" failures="0"></testsuite></testsuites>'
+      })
+    };
+
+    // Inject mock by accessing private method
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'ui-test',
+      gates: ['ui'],
+      targets: {
+        web: {
+          baseUrl: 'https://example.com',
+          pages: ['https://example.com']
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock the runUiGate method
+    const originalRunUiGate = (runner as any).runUiGate;
+    (runner as any).runUiGate = vi.fn().mockResolvedValue(mockUiAdapter.runSmokeTests());
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('ui');
+    expect(result.gates[0].success).toBe(true);
+    expect(result.success).toBe(true);
+
+    // Restore original method
+    (runner as any).runUiGate = originalRunUiGate;
+  }, 30000);
+
+  it('should execute perf gate successfully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'perf-test',
+      gates: ['perf'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org'
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock the runPerfGate method
+    (runner as any).runPerfGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 },
+      metrics: { p95: 150, p99: 200 }
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('perf');
+    expect(result.gates[0].success).toBe(true);
+  }, 30000);
+
+  it('should execute sast gate successfully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'sast-test',
+      gates: ['sast'],
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock the runSastGate method
+    (runner as any).runSastGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 100, passed: 98, failed: 2 },
+      findings: []
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('sast');
+    expect(result.gates[0].success).toBe(true);
+  }, 30000);
+
+  it('should execute dast gate successfully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'dast-test',
+      gates: ['dast'],
+      targets: {
+        web: {
+          baseUrl: 'https://example.com'
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock the runDastGate method
+    (runner as any).runDastGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 50, passed: 50, failed: 0 },
+      findings: []
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('dast');
+    expect(result.gates[0].success).toBe(true);
+  }, 30000);
+
+  it('should execute a11y gate successfully', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'a11y-test',
+      gates: ['a11y'],
+      targets: {
+        web: {
+          baseUrl: 'https://example.com',
+          pages: ['https://example.com']
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock the runA11yGate method (which calls runUiGate)
+    (runner as any).runA11yGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 },
+      a11y: { violations: 0 }
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(1);
+    expect(result.gates[0].gate).toBe('a11y');
+    expect(result.gates[0].success).toBe(true);
+  }, 30000);
+
+  it('should execute all gates in order', async () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'all-gates-test',
+      gates: ['api_smoke', 'ui', 'perf', 'sast', 'dast', 'a11y'],
+      targets: {
+        api: {
+          baseUrl: 'https://httpbin.org',
+          smoke: ['GET /get -> 200']
+        },
+        web: {
+          baseUrl: 'https://example.com',
+          pages: ['https://example.com']
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // Mock all gate methods except api_smoke (real)
+    (runner as any).runUiGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 }
+    });
+    (runner as any).runPerfGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 }
+    });
+    (runner as any).runSastGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 }
+    });
+    (runner as any).runDastGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 }
+    });
+    (runner as any).runA11yGate = vi.fn().mockResolvedValue({
+      success: true,
+      summary: { total: 1, passed: 1, failed: 0 }
+    });
+
+    const result = await runner.run();
+
+    expect(result.gates).toHaveLength(6);
+    expect(result.gates.map(g => g.gate)).toEqual([
+      'api_smoke', 'ui', 'perf', 'sast', 'dast', 'a11y'
+    ]);
+    expect(result.summary.total).toBe(6);
+    expect(result.summary.passed).toBeGreaterThan(0);
+  }, 90000); // 90s for real api_smoke + mocked gates
+});
+
+describe('Phase3Runner - Pack v2 Support', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-v2-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should initialize with PackConfigV2', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      gates: {
+        api_smoke: {
+          adapter: 'playwright-api',
+          enabled: true
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    expect(runner).toBeDefined();
+  });
+
+  it('should detect pack v2 correctly', () => {
+    const packV2: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      gates: {
+        api_smoke: { adapter: 'playwright-api' }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack: packV2 });
+    const isPackV2 = (runner as any).isPackV2(packV2);
+
+    expect(isPackV2).toBe(true);
+  });
+
+  it('should detect pack v1 correctly', () => {
+    const packV1: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack-v1',
+      gates: ['api_smoke']
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack: packV1 });
+    const isPackV2 = (runner as any).isPackV2(packV1);
+
+    expect(isPackV2).toBe(false);
+  });
+
+  it('should get gates array from v2 pack', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      gates: {
+        api_smoke: { adapter: 'playwright-api', enabled: true },
+        ui: { adapter: 'playwright-ui', enabled: true },
+        sast: { adapter: 'semgrep', enabled: false } // disabled
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const gates = (runner as any).getGatesArray();
+
+    expect(gates).toEqual(['api_smoke', 'ui']); // sast is disabled
+  });
+
+  it('should convert v2 hooks to v1 format', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      hooks: {
+        beforeAll: [
+          { type: 'run', command: 'echo "setup"', timeout: 5000 }
+        ]
+      },
+      gates: {}
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const converted = (runner as any).convertV2HooksToV1(pack.hooks);
+
+    expect(converted.beforeAll).toHaveLength(1);
+    expect(converted.beforeAll[0].run).toBe('echo "setup"');
+    expect(converted.beforeAll[0].timeout).toBe(5000);
+  });
+
+  it('should convert v2 execution to v1 format', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      execution: {
+        default_timeout: 15000,
+        default_retries: 3,
+        on_failure: 'stop'
+      },
+      gates: {}
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const converted = (runner as any).convertV2ExecutionToV1(pack.execution);
+
+    expect(converted.timeout).toBe(15000);
+    expect(converted.max_retries).toBe(3);
+    expect(converted.on_failure).toBe('stop');
+  });
+
+  it('should execute v2 pack with no gates successfully', async () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'empty-pack-v2',
+      gates: {}
+    };
+
+    const runner = new Phase3Runner({
+      workingDir: testDir,
+      pack,
+    });
+
+    const result = await runner.run();
+
+    expect(result.success).toBe(true);
+    expect(result.summary.total).toBe(0);
+    expect(result.proofPath).toBeDefined();
+  }, 30000);
+});
+
+describe('Phase3Runner - Auth Integration', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    testDir = join(tmpdir(), `qa360-phase3-auth-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should register auth profiles from pack v2', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-auth-pack',
+      auth: {
+        api: 'default-api',
+        profiles: {
+          'default-api': {
+            type: 'bearer',
+            config: { token: 'test-token-123' }
+          },
+          'basic-auth': {
+            type: 'basic',
+            config: { username: 'user', password: 'pass' }
+          }
+        }
+      },
+      gates: {}
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const authManager = (runner as any).authManager;
+
+    expect(authManager.listProfiles()).toContain('default-api');
+    expect(authManager.listProfiles()).toContain('basic-auth');
+  });
+
+  it('should get auth profile for api_smoke gate', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-auth-pack',
+      auth: {
+        api: 'default-api',
+        profiles: {
+          'default-api': {
+            type: 'api_key',
+            config: { key: 'secret-key' }
+          }
+        }
+      },
+      gates: {
+        api_smoke: { adapter: 'playwright-api' }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const profileName = (runner as any).getAuthProfileForGate('api_smoke');
+
+    expect(profileName).toBe('default-api');
+  });
+
+  it('should get auth profile for ui gate', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-auth-pack',
+      auth: {
+        ui: 'ui-session',
+        profiles: {
+          'ui-session': {
+            type: 'none',
+            config: {}
+          }
+        }
+      },
+      gates: {
+        ui: { adapter: 'playwright-ui' }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const profileName = (runner as any).getAuthProfileForGate('ui');
+
+    expect(profileName).toBe('ui-session');
+  });
+
+  it('should use gate-specific auth override', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-auth-pack',
+      auth: {
+        api: 'default-api',
+        profiles: {
+          'default-api': {
+            type: 'api_key',
+            config: { key: 'default-key' }
+          },
+          'override-auth': {
+            type: 'bearer',
+            config: { token: 'override-token' }
+          }
+        }
+      },
+      gates: {
+        api_smoke: {
+          adapter: 'playwright-api',
+          auth: 'override-auth' // Override default
+        }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const profileName = (runner as any).getAuthProfileForGate('api_smoke');
+
+    expect(profileName).toBe('override-auth');
+  });
+
+  it('should return undefined for gate without auth in v1 pack', () => {
+    const pack: PackConfigV1 = {
+      version: 1,
+      name: 'test-pack-v1',
+      gates: ['api_smoke']
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const profileName = (runner as any).getAuthProfileForGate('api_smoke');
+
+    expect(profileName).toBeUndefined();
+  });
+
+  it('should return undefined for gate without auth in v2 pack', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-pack-v2',
+      gates: {
+        api_smoke: { adapter: 'playwright-api' }
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const profileName = (runner as any).getAuthProfileForGate('api_smoke');
+
+    expect(profileName).toBeUndefined();
+  });
+
+  it('should cache credentials after authentication', async () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-auth-cache',
+      auth: {
+        api: 'test-profile',
+        profiles: {
+          'test-profile': {
+            type: 'bearer',
+            config: { token: 'cached-token' }
+          }
+        }
+      },
+      gates: {}
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+
+    // First call - authenticate
+    const credentials1 = await (runner as any).getCredentialsForGate('api_smoke');
+    expect(credentials1).toBeDefined();
+    expect(credentials1.headers?.Authorization).toContain('cached-token');
+
+    // Second call - should use cache
+    const credentials2 = await (runner as any).getCredentialsForGate('api_smoke');
+    expect(credentials2).toBeDefined();
+    expect(credentials2.headers?.Authorization).toContain('cached-token');
+  });
+
+  it('should handle v2 pack with disabled gate', () => {
+    const pack: PackConfigV2 = {
+      version: 2,
+      name: 'test-disabled-gate',
+      gates: {
+        api_smoke: { adapter: 'playwright-api', enabled: true },
+        ui: { adapter: 'playwright-ui', enabled: false },
+        sast: { adapter: 'semgrep' } // enabled by default
+      }
+    };
+
+    const runner = new Phase3Runner({ workingDir: testDir, pack });
+    const gates = (runner as any).getGatesArray();
+
+    expect(gates).toContain('api_smoke');
+    expect(gates).toContain('sast');
+    expect(gates).not.toContain('ui');
+  });
+});