qa360 2.1.7 → 2.2.0

package/core/src/pack-v2/__tests__/validator.test.ts

@@ -0,0 +1,609 @@
+/**
+ * Pack v2 Validator - Unit Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PackValidatorV2 } from '../validator.js';
+import { PackConfigV2 } from '../../types/pack-v2.js';
+
+describe('PackValidatorV2', () => {
+  let validator: PackValidatorV2;
+
+  beforeEach(() => {
+    validator = new PackValidatorV2('/test/pack.yml');
+  });
+
+  describe('structure validation', () => {
+    it('should reject null pack', async () => {
+      const result = await validator.validate(null);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].code).toBe('QP2V002');
+    });
+
+    it('should reject non-object pack', async () => {
+      const result = await validator.validate('string');
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].code).toBe('QP2V002');
+    });
+  });
+
+  describe('version validation', () => {
+    it('should reject wrong version', async () => {
+      const pack = { version: 1, name: 'test', gates: {} } as any;
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].code).toBe('QP2V001');
+    });
+
+    it('should accept version 2', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('required fields validation', () => {
+    it('should reject missing name', async () => {
+      const pack = { version: 2, gates: {} } as any;
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V003')).toBe(true);
+    });
+
+    it('should reject empty name', async () => {
+      const pack = { version: 2, name: '', gates: {} } as any;
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+    });
+
+    it('should reject missing gates', async () => {
+      const pack = { version: 2, name: 'test' } as any;
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V004')).toBe(true);
+    });
+
+    it('should reject empty gates', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {}
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V005')).toBe(true);
+    });
+  });
+
+  describe('auth configuration validation', () => {
+    it('should reject auth.api referencing non-existent profile', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          api: 'missing-profile',
+          profiles: {
+            'other-profile': { type: 'bearer', config: { token: 'test' } }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V006')).toBe(true);
+    });
+
+    it('should reject auth.ui referencing non-existent profile', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { ui: { adapter: 'playwright-ui' } },
+        auth: {
+          ui: 'missing-profile',
+          profiles: {}
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V007')).toBe(true);
+    });
+
+    it('should validate OAuth2 profile requirements', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          profiles: {
+            'oauth': {
+              type: 'oauth2',
+              config: {}
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V010')).toBe(true); // token_url required
+    });
+
+    it('should validate API key profile requirements', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          profiles: {
+            'apikey': {
+              type: 'api_key',
+              config: {}
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V012')).toBe(true); // key required
+    });
+
+    it('should validate Bearer token profile requirements', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          profiles: {
+            'bearer': {
+              type: 'bearer',
+              config: {}
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V013')).toBe(true); // token required
+    });
+
+    it('should validate UI login profile requirements', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { ui: { adapter: 'playwright-ui' } },
+        auth: {
+          profiles: {
+            'uilogin': {
+              type: 'ui_login',
+              config: {}
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V015')).toBe(true); // url required
+    });
+
+    it('should validate TOTP profile requirements', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          profiles: {
+            'totp': {
+              type: 'totp',
+              config: {}
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V016')).toBe(true); // secret required
+    });
+
+    it('should accept valid auth profile', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        auth: {
+          api: 'bearer',
+          profiles: {
+            'bearer': {
+              type: 'bearer',
+              config: { token: '${{ secrets.API_TOKEN }}' }
+            }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('gates validation', () => {
+    it('should warn about unknown adapter', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'unknown-adapter' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V017')).toBe(true);
+    });
+
+    it('should warn about gate without test_files or config', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: {} }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V018')).toBe(true);
+    });
+
+    it('should validate gate dependencies', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: { adapter: 'playwright-api' },
+          e2e: { adapter: 'playwright-ui', depends_on: ['missing-gate'] }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V020')).toBe(true);
+    });
+
+    it('should accept valid gates configuration', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: {
+            adapter: 'playwright-api',
+            test_files: ['tests/**/*.spec.ts'],
+            budgets: { p95_ms: 2000 }
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.info?.gatesCount).toBe(1);
+    });
+
+    it('should detect invalid test pattern with ..', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: {
+            adapter: 'playwright-api',
+            test_files: ['../tests/**/*.spec.ts']
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V021')).toBe(true);
+    });
+
+    it('should warn about absolute paths', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: {
+            adapter: 'playwright-api',
+            test_files: ['/absolute/path/tests.ts']
+          }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V022')).toBe(true);
+    });
+  });
+
+  describe('hooks validation', () => {
+    it('should validate hook type', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        hooks: {
+          beforeAll: [{ type: 'invalid-type' as any }]
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V026')).toBe(true);
+    });
+
+    it('should validate run hook has command', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        hooks: {
+          beforeAll: [{ type: 'run' }]
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V027')).toBe(true);
+    });
+
+    it('should validate wait_on hook has resource', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        hooks: {
+          beforeAll: [{ type: 'wait_on' }]
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V028')).toBe(true);
+    });
+
+    it('should warn about dangerous commands', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        hooks: {
+          beforeAll: [{ type: 'run', command: 'rm -rf /tmp/data' }]
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V030')).toBe(true);
+    });
+
+    it('should accept valid hooks', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        hooks: {
+          beforeAll: [
+            { type: 'run', command: 'docker-compose up -d', timeout: 30000 },
+            { type: 'wait_on', wait_for: { resource: 'http://localhost:3000', timeout: 10000 } }
+          ],
+          afterAll: [
+            { type: 'docker', compose: { command: 'down' } }
+          ]
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('execution config validation', () => {
+    it('should validate on_failure values', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        execution: { on_failure: 'invalid' as any }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V031')).toBe(true);
+    });
+
+    it('should validate default_timeout is positive', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        execution: { on_failure: 'stop', default_timeout: -100 }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V032')).toBe(true);
+    });
+
+    it('should validate max_concurrency is positive', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        execution: { on_failure: 'stop', max_concurrency: 0 }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V033')).toBe(true);
+    });
+
+    it('should accept valid execution config', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { adapter: 'playwright-api' } },
+        execution: {
+          on_failure: 'continue',
+          default_timeout: 30000,
+          default_retries: 2,
+          parallel: true,
+          max_concurrency: 4
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('business rules validation', () => {
+    it('should warn when API gates without auth profile', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: { adapter: 'playwright-api', test_files: ['tests/*.ts'] },
+          api: { adapter: 'playwright-api', test_files: ['tests/*.ts'] }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V034')).toBe(true);
+    });
+
+    it('should warn when UI gates without auth profile', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          ui: { adapter: 'playwright-ui', test_files: ['tests/*.ts'] }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V035')).toBe(true);
+    });
+
+    it('should warn about gates without adapter', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test',
+        gates: {
+          smoke: { test_files: ['tests/*.ts'] }
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(w => w.code === 'QP2V036')).toBe(true);
+    });
+  });
+
+  describe('complete valid pack', () => {
+    it('should accept complete valid pack v2', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'my-api-tests',
+        description: 'API smoke tests',
+        auth: {
+          api: 'default',
+          profiles: {
+            'default': {
+              type: 'bearer',
+              config: { token: '${{ secrets.API_TOKEN }}' },
+              cache: { enabled: true, ttl: 3600 }
+            }
+          }
+        },
+        gates: {
+          smoke: {
+            adapter: 'playwright-api',
+            test_files: ['tests/smoke/**/*.spec.ts'],
+            budgets: { p95_ms: 1000, p99_ms: 2000 },
+            options: { timeout: 30000, retries: 2 }
+          },
+          integration: {
+            adapter: 'playwright-api',
+            test_files: ['tests/integration/**/*.spec.ts'],
+            depends_on: ['smoke']
+          }
+        },
+        hooks: {
+          beforeAll: [
+            { type: 'run', command: 'docker-compose up -d', timeout: 60000 },
+            { type: 'wait_on', wait_for: { resource: 'http://localhost:3000/health', timeout: 30000 } }
+          ],
+          afterAll: [
+            { type: 'docker', compose: { command: 'down' } }
+          ]
+        },
+        execution: {
+          on_failure: 'continue',
+          default_timeout: 30000,
+          default_retries: 2,
+          parallel: true,
+          max_concurrency: 4,
+          hook_timeout_ms: 60000
+        },
+        variables: {
+          API_URL: 'http://localhost:3000',
+          TEST_USER: 'test@example.com'
+        }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+      expect(result.info?.gatesCount).toBe(2);
+    });
+  });
+
+  describe('fixtures configuration validation', () => {
+    it('should accept valid fixtures configuration', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        fixtures: ['./fixtures/users.yml', './fixtures/products.yml'],
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should accept pack without fixtures', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should reject fixture path with parent directory reference', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        fixtures: ['../fixtures/users.yml'],
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === 'QP2V038')).toBe(true);
+    });
+
+    it('should warn about unknown file extension', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        fixtures: ['./fixtures/users.txt'],
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      expect(result.warnings.some(e => e.code === 'QP2V039')).toBe(true);
+    });
+
+    it('should accept all valid file extensions', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        fixtures: ['./data.yml', './data.yaml', './data.json'],
+        gates: { smoke: { adapter: 'playwright-api' } }
+      };
+      const result = await validator.validate(pack);
+      expect(result.valid).toBe(true);
+      // Check no fixture-related warnings
+      expect(result.warnings.some(w => w.code === 'QP2V039')).toBe(false);
+    });
+  });
+});

package/core/src/pack-v2/index.ts

@@ -0,0 +1,41 @@
+/**
+ * QA360 Pack v2 Module
+ *
+ * Provides validation, migration, and loading for Pack v2 configurations.
+ */
+
+export { PackValidatorV2 } from './validator.js';
+export { PackMigrator } from './migrator.js';
+export { PackLoaderV2, PackLoadResult } from './loader.js';
+
+// Re-export types
+export type {
+  PackConfigV2,
+  AuthConfigV2,
+  AuthProfile,
+  AuthTypeV2,
+  AuthCacheConfig,
+  GateConfigV2,
+  GateBudgets,
+  GateOptions,
+  HooksConfig,
+  Hook,
+  ExecutionConfigV2,
+  ResourceLimits,
+  SecurityBudgets,
+  PerformanceTargets,
+  JWTAuthProfileV2,
+  OAuth2AuthProfileV2,
+  UILoginAuthProfileV2,
+  GCPADCProfileV2,
+  AWSIamProfileV2,
+  TargetConfig,
+  ApiTarget,
+  WebTarget,
+  ApiRequest,
+  WebPage,
+  PageAction,
+  PackValidationResultV2,
+  ValidationError,
+  PackMigrationResultV2
+} from '../types/pack-v2.js';