qa360 2.1.7 → 2.2.0

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

@@ -0,0 +1,533 @@
+/**
+ * Pack v2 Loader - Unit Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import * as yaml from 'js-yaml';
+import { PackLoaderV2 } from '../loader.js';
+import { PackConfigV2 } from '../../types/pack-v2.js';
+
+describe('PackLoaderV2', () => {
+  let loader: PackLoaderV2;
+  let tempDir: string;
+  let packPath: string;
+
+  beforeEach(() => {
+    loader = new PackLoaderV2();
+    tempDir = join(process.cwd(), '.tmp-test-' + Date.now());
+    if (!existsSync(tempDir)) {
+      mkdirSync(tempDir, { recursive: true });
+    }
+    packPath = join(tempDir, 'pack.yml');
+  });
+
+  afterEach(() => {
+    if (existsSync(packPath)) {
+      unlinkSync(packPath);
+    }
+  });
+
+  describe('basic loading', () => {
+    it('should load a valid v2 pack', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api', test_files: ['tests/*.spec.ts'] }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(true);
+      expect(result.pack?.version).toBe(2);
+      expect(result.pack?.name).toBe('test-pack');
+      expect(result.format).toBe('v2');
+    });
+
+    it('should detect v1 pack format', async () => {
+      const v1Pack = {
+        version: 1,
+        name: 'v1-pack',
+        gates: ['api_smoke', 'ui']
+      };
+
+      writeFileSync(packPath, yaml.dump(v1Pack), 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(true);
+      expect(result.format).toBe('v2'); // Auto-migrated to v2
+      expect(result.migrated).toBe(true);
+    });
+
+    it('should load v1 pack without migration when migrate=false', async () => {
+      const v1Pack = {
+        version: 1,
+        name: 'v1-pack',
+        gates: ['api_smoke', 'ui']
+      };
+
+      writeFileSync(packPath, yaml.dump(v1Pack), 'utf8');
+
+      const result = await loader.load(packPath, { migrate: false });
+
+      expect(result.success).toBe(true);
+      expect(result.format).toBe('v1');
+      expect(result.migrated).toBe(false);
+      expect(result.pack?.version).toBe(1);
+    });
+
+    it('should handle missing file gracefully', async () => {
+      const missingPath = join(tempDir, 'missing.yml');
+
+      const result = await loader.load(missingPath);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error?.message).toContain('not found');
+    });
+
+    it('should handle invalid YAML gracefully', async () => {
+      writeFileSync(packPath, 'invalid: yaml: content:', 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('validation option', () => {
+    it('should validate pack when validate option is true', async () => {
+      const invalidPack = {
+        version: 2,
+        name: '',  // Empty name should fail validation
+        gates: {}
+      };
+
+      writeFileSync(packPath, yaml.dump(invalidPack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: true });
+
+      expect(result.success).toBe(false);
+      expect(result.valid).toBe(false);
+      expect(result.validationErrors).toBeDefined();
+      expect(result.validationErrors?.length).toBeGreaterThan(0);
+    });
+
+    it('should skip validation when validate option is false', async () => {
+      const invalidPack = {
+        version: 2,
+        name: '',
+        gates: {}
+      };
+
+      writeFileSync(packPath, yaml.dump(invalidPack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.success).toBe(true);
+      expect(result.pack?.name).toBe('');
+    });
+
+    it('should validate by default', async () => {
+      const validPack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(validPack), 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(true);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('checkFilesExist option', () => {
+    it('should verify test files exist when checkFilesExist is true', async () => {
+      // Create test file
+      const testDir = join(tempDir, 'tests');
+      if (!existsSync(testDir)) {
+        mkdirSync(testDir, { recursive: true });
+      }
+      const testFile = join(testDir, 'smoke.spec.ts');
+      writeFileSync(testFile, '// test', 'utf8');
+
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api', test_files: ['tests/*.spec.ts'] }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { checkFilesExist: true });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should report missing test files in validation', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api', test_files: ['tests/missing.spec.ts'] }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { checkFilesExist: true });
+
+      expect(result.success).toBe(true);
+      // Missing files should be in warnings, not errors
+    });
+  });
+
+  describe('migration option', () => {
+    it('should auto-migrate v1 to v2 when migrate is true', async () => {
+      const v1Pack = {
+        version: 1,
+        name: 'v1-pack',
+        gates: ['api_smoke'],
+        environment: {
+          API_URL: 'http://localhost:3000'
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(v1Pack), 'utf8');
+
+      const result = await loader.load(packPath, { migrate: true });
+
+      expect(result.success).toBe(true);
+      expect(result.migrated).toBe(true);
+      expect(result.format).toBe('v2');
+      expect(result.pack?.version).toBe(2);
+      expect(result.changes?.length).toBeGreaterThan(0);
+    });
+
+    it('should not migrate v2 pack', async () => {
+      const v2Pack: PackConfigV2 = {
+        version: 2,
+        name: 'v2-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(v2Pack), 'utf8');
+
+      const result = await loader.load(packPath, { migrate: true });
+
+      expect(result.success).toBe(true);
+      expect(result.migrated).toBe(false);
+      expect(result.format).toBe('v2');
+    });
+  });
+
+  describe('caching', () => {
+    it('should cache pack when useCache is true', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      // First load without validation to cache
+      const result1 = await loader.load(packPath, { useCache: true, validate: false });
+      expect(loader.getCacheSize()).toBe(1);
+
+      // Second load should use cache
+      const result2 = await loader.load(packPath, { useCache: true, validate: false });
+
+      expect(result1.success).toBe(true);
+      expect(result2.success).toBe(true);
+      expect(result1.pack).toEqual(result2.pack);
+    });
+
+    it('should not cache when useCache is false', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result1 = await loader.load(packPath, { useCache: false, validate: false });
+      const result2 = await loader.load(packPath, { useCache: false, validate: false });
+
+      expect(result1.success).toBe(true);
+      expect(result2.success).toBe(true);
+      // Different object reference indicates no cache
+      expect(result1.pack).not.toBe(result2.pack);
+    });
+  });
+
+  describe('version detection', () => {
+    it('should detect v2 by version field', async () => {
+      const pack = { version: 2, name: 'test', gates: { smoke: { adapter: 'playwright-api' } } };
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.format).toBe('v2');
+    });
+
+    it('should detect v1 by version field', async () => {
+      const pack = { version: 1, name: 'test', gates: ['api_smoke'] };
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.format).toBe('v2'); // Auto-migrated
+    });
+
+    it('should detect v2 by gates structure', async () => {
+      const pack = {
+        version: 2,
+        name: 'test',
+        gates: { smoke: { test_files: ['tests/*.ts'] } }
+      };
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.format).toBe('v2');
+    });
+
+    it('should detect v1 by gates array', async () => {
+      const pack = {
+        version: 1,
+        name: 'test',
+        gates: ['ui', 'perf']
+      };
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.format).toBe('v2'); // Auto-migrated
+    });
+
+    it('should return unknown for unrecognizable format', async () => {
+      const pack = { name: 'test', foo: 'bar' };
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath, { validate: false });
+
+      expect(result.format).toBe('unknown');
+    });
+  });
+
+  describe('loadAndValidate', () => {
+    it('should load and validate in one step', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.loadAndValidate(packPath);
+
+      expect(result.success).toBe(true);
+      expect(result.valid).toBe(true);
+      expect(result.pack).toBeDefined();
+    });
+
+    it('should return validation errors for invalid pack', async () => {
+      const pack = {
+        version: 2,
+        name: '',  // Invalid: empty name
+        gates: {}
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.loadAndValidate(packPath);
+
+      expect(result.success).toBe(false);
+      expect(result.valid).toBe(false);
+      expect(result.validationErrors?.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should clear the cache', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      await loader.load(packPath, { useCache: true, validate: false });
+      loader.clearCache();
+
+      const result = await loader.load(packPath, { useCache: true, validate: false });
+
+      expect(result.success).toBe(true);
+      expect(result.pack).toBeDefined();
+    });
+
+    it('should report cache size', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'test-pack',
+        gates: {
+          smoke: { adapter: 'playwright-api' }
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      expect(loader.getCacheSize()).toBe(0);
+
+      await loader.load(packPath, { useCache: true, validate: false });
+
+      expect(loader.getCacheSize()).toBe(1);
+
+      loader.clearCache();
+
+      expect(loader.getCacheSize()).toBe(0);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle malformed YAML with clear error', async () => {
+      writeFileSync(packPath, ':\n  bad: yaml: :', 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('should handle empty file', async () => {
+      writeFileSync(packPath, '', 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should load complete v2 pack with all features', async () => {
+      const pack: PackConfigV2 = {
+        version: 2,
+        name: 'complete-pack',
+        description: 'Complete test pack',
+        auth: {
+          api: 'bearer',
+          profiles: {
+            bearer: {
+              type: 'bearer',
+              config: { token: '${{ secrets.API_TOKEN }}' }
+            }
+          }
+        },
+        gates: {
+          smoke: {
+            adapter: 'playwright-api',
+            test_files: ['tests/smoke/*.spec.ts'],
+            budgets: { p95_ms: 1000 }
+          },
+          integration: {
+            adapter: 'playwright-api',
+            test_files: ['tests/integration/*.spec.ts'],
+            depends_on: ['smoke']
+          }
+        },
+        hooks: {
+          beforeAll: [
+            { type: 'run', command: 'docker-compose up -d' }
+          ],
+          afterAll: [
+            { type: 'run', command: 'docker-compose down' }
+          ]
+        },
+        execution: {
+          on_failure: 'continue',
+          default_timeout: 30000,
+          default_retries: 2
+        },
+        variables: {
+          API_URL: 'http://localhost:3000'
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(pack), 'utf8');
+
+      const result = await loader.load(packPath);
+
+      expect(result.success).toBe(true);
+      expect(result.pack?.name).toBe('complete-pack');
+      expect(Object.keys(result.pack!.gates).length).toBe(2);
+      expect(result.pack?.auth?.profiles).toBeDefined();
+      expect(result.pack?.hooks).toBeDefined();
+      expect(result.pack?.execution).toBeDefined();
+      expect(result.pack?.variables).toBeDefined();
+    });
+
+    it('should migrate and validate v1 pack in one operation', async () => {
+      const v1Pack = {
+        version: 1,
+        name: 'legacy-pack',
+        description: 'Legacy v1 pack',
+        gates: ['api_smoke', 'ui'],
+        targets: {
+          api: { baseUrl: 'https://api.example.com' },
+          web: { baseUrl: 'https://example.com' }
+        },
+        environment: {
+          API_KEY: 'sk_test_key'
+        },
+        execution: {
+          timeout: 60000,
+          max_retries: 3,
+          on_failure: 'continue'
+        }
+      };
+
+      writeFileSync(packPath, yaml.dump(v1Pack), 'utf8');
+
+      const result = await loader.load(packPath, {
+        migrate: true,
+        validate: true
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.migrated).toBe(true);
+      expect(result.valid).toBe(true);
+      expect(result.format).toBe('v2');
+      expect(result.pack?.version).toBe(2);
+      expect(result.changes).toBeDefined();
+    });
+  });
+});