qa360 2.2.1 → 2.2.13

package/cli/dist/core/pack-v2/migrator.js

@@ -0,0 +1,505 @@
+/**
+ * QA360 Pack v1 to v2 Migrator
+ *
+ * Migrates Pack v1 configurations to Pack v2 format.
+ */
+/**
+ * Map v1 quality gates to v2 adapters
+ */
+const GATE_TO_ADAPTER = {
+    'api_smoke': 'playwright-api',
+    'ui': 'playwright-ui',
+    'a11y': 'playwright-ui',
+    'perf': 'k6-perf',
+    'sast': 'semgrep-sast',
+    'dast': 'zap-dast',
+    'secrets': 'gitleaks-secrets',
+    'deps': 'osv-deps'
+};
+/**
+ * Migrate Pack v1 to v2
+ */
+export class PackMigrator {
+    /**
+     * Migrate a v1 pack to v2 format
+     */
+    migrate(v1Pack) {
+        const changes = [];
+        const warnings = [];
+        // Create base v2 structure
+        const v2Pack = {
+            version: 2,
+            name: v1Pack.name,
+            description: v1Pack.description,
+            gates: {}
+        };
+        // Migrate environment variables to v2 variables
+        if (v1Pack.environment) {
+            v2Pack.variables = { ...v1Pack.environment };
+            changes.push('Renamed environment to variables');
+        }
+        // Migrate metadata
+        if (v1Pack.observability) {
+            v2Pack.metadata = {
+                observability: v1Pack.observability
+            };
+            changes.push('Moved observability to metadata.observability');
+        }
+        // Migrate gates
+        const gatesResult = this.migrateGates(v1Pack);
+        v2Pack.gates = gatesResult.gates;
+        changes.push(...gatesResult.changes);
+        warnings.push(...gatesResult.warnings);
+        // Migrate auth (from environment secrets)
+        const authResult = this.migrateAuth(v1Pack);
+        if (authResult.auth) {
+            v2Pack.auth = authResult.auth;
+            changes.push(...authResult.changes);
+            warnings.push(...authResult.warnings);
+        }
+        // Migrate hooks
+        if (v1Pack.hooks) {
+            const hooksResult = this.migrateHooks(v1Pack.hooks);
+            v2Pack.hooks = hooksResult.hooks;
+            changes.push(...hooksResult.changes);
+            warnings.push(...hooksResult.warnings);
+        }
+        // Migrate execution config
+        const execResult = this.migrateExecution(v1Pack);
+        if (execResult.execution) {
+            v2Pack.execution = execResult.execution;
+            changes.push(...execResult.changes);
+        }
+        // Migrate budgets to individual gates
+        if (v1Pack.budgets) {
+            this.migrateBudgetsToGates(v1Pack, v2Pack);
+            changes.push('Migrated budgets to individual gate configurations');
+        }
+        // Migrate security config to individual gates
+        if (v1Pack.security) {
+            this.migrateSecurityToGates(v1Pack, v2Pack);
+            changes.push('Migrated security to individual gate configurations');
+        }
+        // Migrate targets to gate configs
+        if (v1Pack.targets) {
+            this.migrateTargetsToGates(v1Pack, v2Pack);
+            changes.push('Migrated targets to individual gate configurations');
+        }
+        // Add data profile to metadata
+        if (v1Pack.data) {
+            v2Pack.metadata = v2Pack.metadata || {};
+            v2Pack.metadata.data = v1Pack.data;
+            changes.push('Moved data to metadata.data');
+        }
+        return {
+            success: true,
+            migrated: v2Pack,
+            changes,
+            warnings
+        };
+    }
+    /**
+     * Migrate gates from v1 to v2
+     */
+    migrateGates(v1Pack) {
+        const gates = {};
+        const changes = [];
+        const warnings = [];
+        for (const gate of v1Pack.gates) {
+            const adapter = GATE_TO_ADAPTER[gate] || gate;
+            const gateName = this.sanitizeGateName(gate);
+            gates[gateName] = {
+                adapter,
+                enabled: true
+            };
+            changes.push(`Migrated gate "${gate}" to "${gateName}" with adapter "${adapter}"`);
+        }
+        // Handle a11y as separate gate from ui
+        if (v1Pack.gates.includes('ui') && v1Pack.gates.includes('a11y')) {
+            // Both exist, keep separate
+            if (gates['ui'] && gates['a11y']) {
+                gates['a11y'].adapter = 'playwright-ui';
+            }
+        }
+        else if (v1Pack.gates.includes('a11y') && !v1Pack.gates.includes('ui')) {
+            // Only a11y, rename to a11y
+            if (gates['ui']) {
+                gates['a11y'] = gates['ui'];
+                delete gates['ui'];
+            }
+        }
+        return { gates, changes, warnings };
+    }
+    /**
+     * Migrate authentication from v1 to v2
+     */
+    migrateAuth(v1Pack) {
+        const changes = [];
+        const warnings = [];
+        // Check for auth-related environment variables
+        const authProfiles = {};
+        let apiAuth;
+        let uiAuth;
+        // Detect JWT/Bearer token
+        const jwtToken = this.findSecretInEnv(v1Pack, ['JWT_TOKEN', 'JWT', 'TOKEN', 'BEARER', 'AUTH_TOKEN']);
+        if (jwtToken) {
+            const profileName = 'jwt-default';
+            authProfiles[profileName] = {
+                type: 'bearer',
+                config: {
+                    token: jwtToken
+                },
+                cache: {
+                    enabled: true,
+                    ttl: 3600
+                }
+            };
+            apiAuth = profileName;
+            changes.push('Created JWT bearer auth profile from environment variables');
+        }
+        // Detect Basic auth
+        const username = this.findSecretInEnv(v1Pack, ['USERNAME', 'USER', 'API_USER']);
+        const password = this.findSecretInEnv(v1Pack, ['PASSWORD', 'PASS', 'API_PASSWORD', 'SECRET']);
+        if (username && password) {
+            const profileName = 'basic-default';
+            authProfiles[profileName] = {
+                type: 'basic',
+                config: {
+                    username,
+                    password
+                },
+                cache: {
+                    enabled: true
+                }
+            };
+            apiAuth = profileName;
+            changes.push('Created Basic auth profile from environment variables');
+        }
+        // Detect API key
+        const apiKey = this.findSecretInEnv(v1Pack, ['API_KEY', 'APIKEY', 'X_API_KEY']);
+        if (apiKey) {
+            const profileName = 'api-key-default';
+            authProfiles[profileName] = {
+                type: 'api_key',
+                config: {
+                    key: apiKey
+                },
+                cache: {
+                    enabled: true
+                }
+            };
+            apiAuth = profileName;
+            changes.push('Created API key auth profile from environment variables');
+        }
+        if (Object.keys(authProfiles).length === 0) {
+            return { changes, warnings };
+        }
+        warnings.push('Review auth profiles and replace secret references with actual secret management');
+        return {
+            auth: {
+                api: apiAuth,
+                ui: uiAuth,
+                profiles: authProfiles
+            },
+            changes,
+            warnings
+        };
+    }
+    /**
+     * Migrate hooks from v1 to v2
+     */
+    migrateHooks(v1Hooks) {
+        const hooks = {};
+        const changes = [];
+        const warnings = [];
+        const hookTypes = ['beforeAll', 'beforeEach', 'afterEach', 'afterAll'];
+        for (const hookType of hookTypes) {
+            const hooksForType = v1Hooks[hookType];
+            if (!hooksForType || hooksForType.length === 0)
+                continue;
+            hooks[hookType] = hooksForType.map((h) => {
+                // Convert string hooks to run type
+                if (typeof h === 'string') {
+                    // Detect special hook patterns
+                    if (h.startsWith('docker-compose') || h.startsWith('compose')) {
+                        const action = h.includes('up') ? 'up' : 'down';
+                        changes.push(`Converted hook "${h}" to docker compose type`);
+                        return {
+                            type: 'docker',
+                            compose: {
+                                command: action
+                            },
+                            timeout: 60000
+                        };
+                    }
+                    else if (h.startsWith('wait-on') || h.startsWith('wait_on')) {
+                        const resource = h.split(/\s+/).slice(1).join(' ');
+                        changes.push(`Converted hook "${h}" to wait_on type`);
+                        return {
+                            type: 'wait_on',
+                            wait_for: {
+                                resource,
+                                timeout: 30000
+                            }
+                        };
+                    }
+                    else {
+                        return {
+                            type: 'run',
+                            command: h,
+                            timeout: 30000
+                        };
+                    }
+                }
+                // Convert object hooks
+                if (typeof h === 'object') {
+                    if (h.run) {
+                        return {
+                            type: 'run',
+                            command: h.run,
+                            timeout: h.timeout || 30000,
+                            cwd: h.cwd,
+                            env: h.env
+                        };
+                    }
+                    else if (h.compose) {
+                        return {
+                            type: 'docker',
+                            compose: {
+                                command: h.compose,
+                                file: h.file,
+                                services: h.services
+                            },
+                            timeout: h.timeout || 60000
+                        };
+                    }
+                    else if (h.wait_on) {
+                        return {
+                            type: 'wait_on',
+                            wait_for: {
+                                resource: h.wait_on,
+                                timeout: h.timeout || 30000,
+                                method: h.method
+                            }
+                        };
+                    }
+                }
+                return h;
+            });
+            changes.push(`Migrated hooks.${hookType} with ${hooks[hookType].length} hook(s)`);
+        }
+        return { hooks, changes, warnings };
+    }
+    /**
+     * Migrate execution config from v1 to v2
+     */
+    migrateExecution(v1Pack) {
+        const changes = [];
+        if (!v1Pack.execution) {
+            return { changes };
+        }
+        const v1Exec = v1Pack.execution;
+        const execution = {
+            on_failure: v1Exec.on_failure || 'stop',
+            hook_timeout_ms: v1Exec.hook_timeout_ms,
+            compose_file: v1Exec.compose_file,
+            default_timeout: v1Exec.timeout,
+            default_retries: v1Exec.max_retries,
+            limits: v1Exec.limits,
+            parallel: false
+        };
+        changes.push('Migrated execution configuration');
+        return { execution, changes };
+    }
+    /**
+     * Migrate budgets to individual gates
+     */
+    migrateBudgetsToGates(v1Pack, v2Pack) {
+        if (!v1Pack.budgets)
+            return;
+        for (const [gateName, gate] of Object.entries(v2Pack.gates)) {
+            const budgets = {};
+            // Map v1 budget names to v2 gate budgets
+            if (v1Pack.budgets.perf_p95_ms) {
+                budgets.p95_ms = v1Pack.budgets.perf_p95_ms;
+            }
+            if (v1Pack.budgets.a11y_min) {
+                budgets.a11y_min = v1Pack.budgets.a11y_min;
+            }
+            if (Object.keys(budgets).length > 0) {
+                gate.budgets = budgets;
+            }
+        }
+    }
+    /**
+     * Migrate security config to individual gates
+     */
+    migrateSecurityToGates(v1Pack, v2Pack) {
+        if (!v1Pack.security)
+            return;
+        const security = v1Pack.security;
+        // SAST budget - create gate if not exists
+        if (security.sast) {
+            if (!v2Pack.gates['sast']) {
+                v2Pack.gates['sast'] = { adapter: 'semgrep-sast' };
+            }
+            v2Pack.gates['sast'].budgets = {
+                max_critical: security.sast.max_critical,
+                max_high: security.sast.max_high,
+                max_medium: security.sast.max_medium
+            };
+        }
+        // DAST budget - create gate if not exists
+        if (security.dast) {
+            if (!v2Pack.gates['dast']) {
+                v2Pack.gates['dast'] = { adapter: 'zap-dast' };
+            }
+            v2Pack.gates['dast'].budgets = {
+                max_critical: security.dast.max_critical,
+                max_high: security.dast.max_high,
+                max_medium: security.dast.max_medium
+            };
+        }
+        // Secrets budget - create gate if not exists
+        if (security.secrets) {
+            if (!v2Pack.gates['secrets']) {
+                v2Pack.gates['secrets'] = { adapter: 'gitleaks-secrets' };
+            }
+            v2Pack.gates['secrets'].budgets = {
+                max_critical: security.secrets.max_findings,
+                max_high: security.secrets.max_findings
+            };
+        }
+        // Dependencies budget - create gate if not exists
+        if (security.deps) {
+            if (!v2Pack.gates['deps']) {
+                v2Pack.gates['deps'] = { adapter: 'osv-deps' };
+            }
+            v2Pack.gates['deps'].budgets = {
+                max_critical: security.deps.max_critical,
+                max_high: security.deps.max_high,
+                max_medium: security.deps.max_medium
+            };
+        }
+    }
+    /**
+     * Migrate targets to gate configs
+     */
+    migrateTargetsToGates(v1Pack, v2Pack) {
+        if (!v1Pack.targets)
+            return;
+        // API target - api_smoke gets renamed to smoke in v2
+        if (v1Pack.targets.api && v2Pack.gates['smoke']) {
+            const gate = v2Pack.gates['smoke'];
+            gate.config = gate.config || {};
+            gate.config.baseUrl = v1Pack.targets.api.baseUrl;
+            gate.config.smoke = v1Pack.targets.api.smoke;
+        }
+        // Web target
+        if (v1Pack.targets.web && v2Pack.gates['ui']) {
+            const gate = v2Pack.gates['ui'];
+            gate.config = gate.config || {};
+            gate.config.baseUrl = v1Pack.targets.web.baseUrl;
+            gate.config.pages = v1Pack.targets.web.pages;
+        }
+    }
+    /**
+     * Find a secret in environment variables by trying common names
+     */
+    findSecretInEnv(pack, names) {
+        if (!pack.environment)
+            return undefined;
+        for (const name of names) {
+            // Try exact match
+            if (pack.environment[name]) {
+                return `\${{ secrets.${name} }}`;
+            }
+            // Try lowercase
+            const lowerName = name.toLowerCase();
+            if (pack.environment[lowerName]) {
+                return `\${{ secrets.${lowerName} }}`;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Sanitize gate name for v2 format
+     * Handles both strings and objects (from YAML parsing edge cases)
+     */
+    sanitizeGateName(gate) {
+        // Handle edge case where gate might be an object from YAML parsing
+        if (typeof gate !== 'string') {
+            // If gate is an object, try to extract a name
+            if (gate && typeof gate === 'object') {
+                // Try common property names
+                const possibleName = gate.name || gate.id || gate.gate;
+                if (typeof possibleName === 'string') {
+                    gate = possibleName;
+                }
+                else {
+                    // Fallback: stringify the object keys
+                    const keys = Object.keys(gate);
+                    if (keys.length === 1) {
+                        gate = keys[0];
+                    }
+                    else {
+                        throw new Error(`Invalid gate format: expected string, got object with keys: ${keys.join(', ')}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Invalid gate format: expected string, got ${typeof gate}`);
+            }
+        }
+        // Map v1 gate names to v2 conventions
+        const nameMap = {
+            'api_smoke': 'smoke',
+            'a11y': 'accessibility'
+        };
+        return nameMap[gate] || gate.replace(/-/g, '_');
+    }
+    /**
+     * Detect pack version
+     * Handles both integer versions (1, 2) and semver strings (1.0.0, 2.0.0)
+     */
+    detectVersion(pack) {
+        // Handle semver format (e.g., "1.0.0", "2.0.0")
+        if (pack.version) {
+            if (typeof pack.version === 'number') {
+                if (pack.version === 2)
+                    return 2;
+                if (pack.version === 1)
+                    return 1;
+            }
+            else if (typeof pack.version === 'string') {
+                // Extract major version from semver string
+                const majorVersion = parseInt(pack.version.split('.')[0], 10);
+                if (majorVersion === 2)
+                    return 2;
+                if (majorVersion === 1)
+                    return 1;
+            }
+        }
+        // Heuristic detection
+        if (pack.gates && Array.isArray(pack.gates))
+            return 1;
+        if (pack.gates && typeof pack.gates === 'object' && !Array.isArray(pack.gates)) {
+            // Check for v2 structure
+            const firstGate = Object.values(pack.gates)[0];
+            if (firstGate?.test_files || firstGate?.adapter)
+                return 2;
+        }
+        // Check for legacy format (v0.9.x) with adapters/tests
+        if (pack.adapters || pack.tests) {
+            // Legacy format detected - treat as unknown to trigger helpful error
+            return 'unknown';
+        }
+        return 'unknown';
+    }
+    /**
+     * Check if pack is in legacy format (v0.9.x or earlier)
+     */
+    isLegacyFormat(pack) {
+        return !!(pack.adapters || (pack.tests && Array.isArray(pack.tests)));
+    }
+}

package/cli/dist/core/pack-v2/validator.d.ts

@@ -0,0 +1,65 @@
+/**
+ * QA360 Pack v2 Validator
+ *
+ * Validates pack.yml v2 files with test_files patterns and auth profiles.
+ */
+import { PackValidationResultV2 } from '../types/pack-v2.js';
+export declare class PackValidatorV2 {
+    private packPath;
+    private baseDir;
+    constructor(packPath: string);
+    /**
+     * Validate a Pack v2 configuration
+     */
+    validate(pack: any, options?: {
+        checkFilesExist?: boolean;
+    }): Promise<PackValidationResultV2>;
+    /**
+     * Validate basic structure
+     */
+    private validateStructure;
+    /**
+     * Validate required fields
+     */
+    private validateRequiredFields;
+    /**
+     * Validate fixtures configuration
+     */
+    private validateFixtures;
+    /**
+     * Validate auth configuration
+     */
+    private validateAuthConfig;
+    /**
+     * Validate a single auth profile
+     */
+    private validateAuthProfile;
+    /**
+     * Validate gates configuration
+     */
+    private validateGates;
+    /**
+     * Validate a test file pattern
+     */
+    private validateTestPattern;
+    /**
+     * Validate gate budgets
+     */
+    private validateGateBudgets;
+    /**
+     * Validate hooks configuration
+     */
+    private validateHooks;
+    /**
+     * Validate a single hook
+     */
+    private validateHook;
+    /**
+     * Validate execution configuration
+     */
+    private validateExecutionConfig;
+    /**
+     * Validate business rules
+     */
+    private validateBusinessRules;
+}