qa360 2.1.7 → 2.2.0

package/core/src/generation/pack-generator.ts

@@ -0,0 +1,527 @@
+/**
+ * QA360 Pack Generator
+ *
+ * Converts generated test specifications into QA360 pack YAML format.
+ * This bridges the gap between AI-generated tests and runnable QA360 packs.
+ *
+ * @example
+ * ```typescript
+ * const generator = new PackGenerator();
+ * const packYaml = generator.generateFromApiSpec(apiSpec, {
+ *   name: 'my-api-tests',
+ *   version: 2
+ * });
+ * ```
+ */
+
+import { PackConfigV2, GateConfigV2, GateBudgets, GateOptions, AuthConfigV2, AuthProfile, AuthTypeV2, ExecutionConfigV2 } from '../types/pack-v2.js';
+
+// Re-export types from generation/types.ts for convenience
+export type {
+  TestSpec,
+  ApiTestSpec,
+  UiTestSpec,
+  PerfTestSpec,
+  UnitTestSpec,
+} from './types.js';
+
+// Import types for use within this file
+import type {
+  TestSpec,
+  ApiTestSpec,
+  UiTestSpec,
+  PerfTestSpec,
+  ApiEndpoint,
+  ApiExpectation,
+  PageSpec,
+  PageAction,
+  PerfScenario,
+  PerfRequest,
+  PerfThreshold,
+} from './types.js';
+
+/**
+ * Pack generator options
+ */
+export interface PackGeneratorOptions {
+  /** Pack name */
+  name?: string;
+  /** Pack version (1 or 2) */
+  version?: 1 | 2;
+  /** Pack description */
+  description?: string;
+  /** Default timeout for tests */
+  timeout?: number;
+  /** Default retries */
+  retries?: number;
+  /** On failure behavior */
+  onFailure?: 'stop' | 'continue';
+  /** Include cache configuration */
+  enableCache?: boolean;
+  /** Cache TTL in milliseconds */
+  cacheTtl?: number;
+}
+
+/**
+ * Generated pack result
+ */
+export interface PackGenerationResult {
+  success: boolean;
+  yaml: string;
+  config: PackConfigV2;
+  warnings?: string[];
+  errors?: string[];
+}
+
+/**
+ * Pack Generator
+ *
+ * Converts test specifications into QA360 pack YAML format.
+ */
+export class PackGenerator {
+  private readonly defaults: Required<Omit<PackGeneratorOptions, 'version' | 'enableCache'>>;
+
+  constructor(options: PackGeneratorOptions = {}) {
+    this.defaults = {
+      name: options.name ?? 'generated-tests',
+      description: options.description ?? 'Auto-generated test pack',
+      timeout: options.timeout ?? 30000,
+      retries: options.retries ?? 2,
+      onFailure: options.onFailure ?? 'continue',
+      cacheTtl: options.cacheTtl ?? 300000
+    };
+  }
+
+  /**
+   * Generate pack from API test specification
+   */
+  generateFromApiSpec(spec: ApiTestSpec, options?: PackGeneratorOptions): PackGenerationResult {
+    const opts = { ...this.defaults, ...options };
+    const warnings: string[] = [];
+
+    // Build gates from API endpoints
+    const gates: Record<string, GateConfigV2> = {};
+
+    // Group endpoints by type (smoke, full, etc.)
+    const smokeEndpoints = spec.endpoints.filter((e: ApiEndpoint) =>
+      e.method === 'GET' && (e.path.includes('/health') || e.path.includes('/status') || e.path === '/')
+    );
+
+    const apiEndpoints = spec.endpoints.filter((e: ApiEndpoint) =>
+      !smokeEndpoints.includes(e as any)
+    );
+
+    // Add api_smoke gate if we have smoke endpoints
+    if (smokeEndpoints.length > 0) {
+      gates['api_smoke'] = {
+        adapter: 'playwright-native-api',
+        config: {
+          target: {
+            baseUrl: spec.baseUrl,
+            smoke: smokeEndpoints.map((e: ApiEndpoint) => this.formatEndpointSpec(e))
+          },
+          timeout: opts.timeout,
+          retries: opts.retries
+        },
+        options: {
+          timeout: opts.timeout,
+          retries: opts.retries
+        },
+        budgets: {
+          p95_ms: 2000,
+          p99_ms: 5000
+        } as GateBudgets
+      };
+    }
+
+    // Add api_full gate if we have other endpoints
+    if (apiEndpoints.length > 0) {
+      gates['api_full'] = {
+        adapter: 'playwright-native-api',
+        config: {
+          target: {
+            baseUrl: spec.baseUrl,
+            smoke: apiEndpoints.map((e: ApiEndpoint) => this.formatEndpointSpec(e))
+          },
+          timeout: opts.timeout,
+          retries: opts.retries
+        },
+        options: {
+          timeout: opts.timeout,
+          retries: opts.retries
+        }
+      };
+    }
+
+    // Build pack config
+    const config: PackConfigV2 = {
+      version: 2,
+      name: opts.name,
+      description: opts.description,
+      gates,
+      execution: {
+        parallel: false,
+        on_failure: opts.onFailure === 'stop' ? 'stop' : 'continue'
+      }
+    };
+
+    // Add auth if specified
+    if (spec.auth && spec.auth.type !== 'none') {
+      const authType = spec.auth.type === 'bearer' ? 'bearer' :
+                       spec.auth.type === 'basic' ? 'basic' :
+                       spec.auth.type === 'api_key' ? 'api_key' :
+                       spec.auth.type === 'jwt' ? 'jwt' :
+                       spec.auth.type === 'oauth2' ? 'oauth2' :
+                       'bearer';
+
+      config.auth = {
+        profiles: {
+          default: {
+            type: authType as AuthTypeV2,
+            config: spec.auth.config || {}
+          }
+        }
+      };
+    }
+
+    return {
+      success: true,
+      yaml: this.toYaml(config),
+      config,
+      warnings: warnings.length > 0 ? warnings : undefined
+    };
+  }
+
+  /**
+   * Generate pack from UI test specification
+   */
+  generateFromUiSpec(spec: UiTestSpec, options?: PackGeneratorOptions): PackGenerationResult {
+    const opts = { ...this.defaults, ...options };
+    const warnings: string[] = [];
+
+    const gates: Record<string, GateConfigV2> = {};
+
+    // Add ui_smoke gate for basic page checks
+    gates['ui_smoke'] = {
+      adapter: 'playwright-ui',
+      config: {
+        target: {
+          baseUrl: spec.baseUrl,
+          pages: spec.pages.slice(0, 3).map((p: PageSpec) => ({
+            url: p.url,
+            name: p.name,
+            actions: p.actions.slice(0, 5).map((a: PageAction) => this.formatPageAction(a))
+          }))
+        },
+        viewport: spec.viewport || { width: 1280, height: 720 }
+      },
+      options: {
+        timeout: opts.timeout,
+        retries: opts.retries
+      },
+      budgets: {
+        a11y_min: 80
+      } as GateBudgets
+    };
+
+    // Add ui_full gate if we have more pages
+    if (spec.pages.length > 3) {
+      gates['ui_full'] = {
+        adapter: 'playwright-ui',
+        config: {
+          target: {
+            baseUrl: spec.baseUrl,
+            pages: spec.pages.map((p: PageSpec) => ({
+              url: p.url,
+              name: p.name,
+              actions: p.actions.map((a: PageAction) => this.formatPageAction(a))
+            }))
+          },
+          viewport: spec.viewport || { width: 1280, height: 720 }
+        },
+        options: {
+          timeout: opts.timeout * 2,
+          retries: opts.retries
+        },
+        budgets: {
+          a11y_min: 90
+        } as GateBudgets
+      };
+    }
+
+    const config: PackConfigV2 = {
+      version: 2,
+      name: opts.name,
+      description: opts.description,
+      gates,
+      execution: {
+        parallel: false,
+        on_failure: opts.onFailure === 'stop' ? 'stop' : 'continue'
+      }
+    };
+
+    return {
+      success: true,
+      yaml: this.toYaml(config),
+      config,
+      warnings: warnings.length > 0 ? warnings : undefined
+    };
+  }
+
+  /**
+   * Generate pack from performance test specification
+   */
+  generateFromPerfSpec(spec: PerfTestSpec, options?: PackGeneratorOptions): PackGenerationResult {
+    const opts = { ...this.defaults, ...options };
+    const warnings: string[] = [];
+
+    const gates: Record<string, GateConfigV2> = {};
+
+    // Build budgets from thresholds
+    const budgets: GateBudgets = {
+      p95_ms: this.extractThreshold(spec.options?.thresholds || [], 'p(95)'),
+      p99_ms: this.extractThreshold(spec.options?.thresholds || [], 'p(99)')
+    };
+
+    // Add perf gate
+    gates['perf'] = {
+      adapter: 'k6-perf',
+      config: {
+        target: {
+          baseUrl: spec.baseUrl,
+          scenarios: spec.scenarios.map((s: PerfScenario) => ({
+            name: s.name,
+            weight: s.weight,
+            requests: s.requests.map((r: PerfRequest) => ({
+              method: r.method,
+              path: r.path,
+              headers: r.headers,
+              body: r.body
+            }))
+          }))
+        },
+        options: spec.options || {
+          duration: '30s',
+          vus: 10,
+          maxVus: 50
+        }
+      },
+      budgets
+    };
+
+    const config: PackConfigV2 = {
+      version: 2,
+      name: opts.name,
+      description: opts.description,
+      gates,
+      execution: {
+        parallel: false,
+        on_failure: opts.onFailure === 'stop' ? 'stop' : 'continue'
+      }
+    };
+
+    return {
+      success: true,
+      yaml: this.toYaml(config),
+      config,
+      warnings: warnings.length > 0 ? warnings : undefined
+    };
+  }
+
+  /**
+   * Generate pack from generic test specification
+   */
+  generateFromSpec(spec: TestSpec, options?: PackGeneratorOptions): PackGenerationResult {
+    switch (spec.type) {
+      case 'api':
+        return this.generateFromApiSpec(spec as ApiTestSpec, options);
+      case 'ui':
+        return this.generateFromUiSpec(spec as UiTestSpec, options);
+      case 'perf':
+        return this.generateFromPerfSpec(spec as PerfTestSpec, options);
+      case 'unit':
+        return {
+          success: false,
+          yaml: '',
+          config: {} as PackConfigV2,
+          errors: ['Unit tests are not supported in pack YAML format. Use direct test file generation instead.']
+        };
+      default:
+        return {
+          success: false,
+          yaml: '',
+          config: {} as PackConfigV2,
+          errors: [`Unknown test type: ${(spec as TestSpec).type}`]
+        };
+    }
+  }
+
+  /**
+   * Format endpoint as smoke test spec
+   */
+  private formatEndpointSpec(endpoint: ApiEndpoint): string {
+    const firstExpectation = endpoint.expectations?.[0];
+    const status = firstExpectation?.status ?? 200;
+    const statusStr = Array.isArray(status) ? status[0] : status;
+    return `${endpoint.method} ${endpoint.path} -> ${statusStr}`;
+  }
+
+  /**
+   * Format page action
+   */
+  private formatPageAction(action: PageAction): Record<string, unknown> {
+    const formatted: Record<string, unknown> = {
+      action: action.type
+    };
+
+    if (action.selector) {
+      formatted.selector = action.selector;
+    }
+    if (action.value) {
+      formatted.value = action.value;
+    }
+    if (action.timeout) {
+      formatted.timeout = action.timeout;
+    }
+
+    return formatted;
+  }
+
+  /**
+   * Extract threshold value from thresholds array
+   */
+  private extractThreshold(
+    thresholds: PerfThreshold[],
+    metric: string
+  ): number {
+    const threshold = thresholds.find((t: PerfThreshold) => t.condition.includes(metric));
+    if (threshold) {
+      const match = threshold.condition.match(/<(\d+)/);
+      return match ? parseInt(match[1], 10) : 1000;
+    }
+    return 1000;
+  }
+
+  /**
+   * Convert config to YAML string
+   * Note: This is a simple YAML generator. For production, use a proper YAML library.
+   */
+  private toYaml(config: PackConfigV2): string {
+    const lines: string[] = [];
+
+    lines.push(`version: ${config.version}`);
+    lines.push(`name: ${config.name}`);
+
+    if (config.description) {
+      lines.push(`description: ${config.description}`);
+    }
+
+    // Gates
+    if (config.gates && Object.keys(config.gates).length > 0) {
+      lines.push(`\ngates:`);
+      for (const [gateName, gateConfig] of Object.entries(config.gates)) {
+        lines.push(`  ${gateName}:`);
+        if (gateConfig.adapter) {
+          lines.push(`    adapter: ${gateConfig.adapter}`);
+        }
+        if (gateConfig.config) {
+          lines.push(`    config:`);
+          this.indentObject(lines, gateConfig.config as Record<string, unknown>, 6);
+        }
+        if (gateConfig.options) {
+          lines.push(`    options:`);
+          this.indentObject(lines, gateConfig.options as Record<string, unknown>, 6);
+        }
+        if (gateConfig.budgets) {
+          lines.push(`    budgets:`);
+          this.indentObject(lines, gateConfig.budgets as Record<string, unknown>, 6);
+        }
+      }
+    }
+
+    // Auth
+    if (config.auth && config.auth.profiles) {
+      lines.push(`\nauth:`);
+      lines.push(`  profiles:`);
+      for (const [profileName, profile] of Object.entries(config.auth.profiles)) {
+        lines.push(`    ${profileName}:`);
+        this.indentObject(lines, profile as unknown as Record<string, unknown>, 6);
+      }
+    }
+
+    // Execution
+    if (config.execution) {
+      lines.push(`\nexecution:`);
+      this.indentObject(lines, config.execution as unknown as Record<string, unknown>, 2);
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Helper to indent object properties
+   */
+  private indentObject(lines: string[], obj: Record<string, unknown>, indent: number): void {
+    const spaces = ' '.repeat(indent);
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        lines.push(`${spaces}${key}:`);
+        this.indentObject(lines, value as Record<string, unknown>, indent + 2);
+      } else if (Array.isArray(value)) {
+        if (value.length === 0) {
+          lines.push(`${spaces}${key}: []`);
+        } else {
+          lines.push(`${spaces}${key}:`);
+          for (const item of value) {
+            if (typeof item === 'object' && !Array.isArray(item)) {
+              lines.push(`${spaces}  -`);
+              this.indentObject(lines, item as Record<string, unknown>, indent + 4);
+            } else {
+              lines.push(`${spaces}  - ${JSON.stringify(item)}`);
+            }
+          }
+        }
+      } else if (typeof value === 'string') {
+        lines.push(`${spaces}${key}: ${value}`);
+      } else {
+        lines.push(`${spaces}${key}: ${JSON.stringify(value)}`);
+      }
+    }
+  }
+}
+
+/**
+ * Convenience function to generate pack from API spec
+ */
+export function generatePackFromApiSpec(
+  spec: ApiTestSpec,
+  options?: PackGeneratorOptions
+): PackGenerationResult {
+  const generator = new PackGenerator(options);
+  return generator.generateFromApiSpec(spec, options);
+}
+
+/**
+ * Convenience function to generate pack from UI spec
+ */
+export function generatePackFromUiSpec(
+  spec: UiTestSpec,
+  options?: PackGeneratorOptions
+): PackGenerationResult {
+  const generator = new PackGenerator(options);
+  return generator.generateFromUiSpec(spec, options);
+}
+
+/**
+ * Convenience function to generate pack from performance spec
+ */
+export function generatePackFromPerfSpec(
+  spec: PerfTestSpec,
+  options?: PackGeneratorOptions
+): PackGenerationResult {
+  const generator = new PackGenerator(options);
+  return generator.generateFromPerfSpec(spec, options);
+}