qa360 2.2.1 → 2.2.7

package/cli/dist/core/generation/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * QA360 AI Test Generation Module
+ *
+ * Generates test code from various sources using LLM.
+ * Phase 4 of AI Integration Roadmap.
+ *
+ * Components:
+ * - PromptBuilder: Build effective prompts for LLM
+ * - CodeGenerator: Generate test code from prompts
+ * - CodeFormatter: Format and validate generated code
+ * - TestOptimizer: Optimize generated tests
+ * - PackGenerator: Convert specs to QA360 pack YAML
+ * - SourceAnalyzer: Analyze source code for test requirements
+ *
+ * Supported Generators:
+ * - Playwright API tests (TypeScript)
+ * - Playwright UI tests (TypeScript)
+ * - K6 performance tests (JavaScript)
+ * - Vitest unit tests (TypeScript)
+ */
+export { PromptBuilder, PromptBuilderOptions, type BuiltPrompt } from './prompt-builder.js';
+export { CodeGenerator, CodeGeneratorOptions, type GeneratedTestInternal, type GenerationResult } from './code-generator.js';
+export { CodeFormatter, FormatterConfig, type FormatResult } from './code-formatter.js';
+export { TestOptimizer, OptimizationOptions, type OptimizationResult } from './test-optimizer.js';
+export { PackGenerator, generatePackFromApiSpec, generatePackFromUiSpec, generatePackFromPerfSpec } from './pack-generator.js';
+export { SourceAnalyzer, analyzeSourceFile, analyzeSourceDirectory, generateTestSpec } from './source-analyzer.js';
+export type { PackGeneratorOptions, PackGenerationResult } from './pack-generator.js';
+export type { SourceAnalysis, SourceAnalyzerOptions, TestSuggestion } from './source-analyzer.js';
+export type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec, UnitTestSpec, GenerationContext, GeneratedTest, GenerationSource, GenerationOptions, } from './types.js';
+export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';
+export { generatePackFromCrawl, quickCrawl, } from './crawler-pack-generator.js';
+export type { CrawlerPackGeneratorOptions } from './crawler-pack-generator.js';

package/cli/dist/core/generation/index.js

@@ -0,0 +1,30 @@
+/**
+ * QA360 AI Test Generation Module
+ *
+ * Generates test code from various sources using LLM.
+ * Phase 4 of AI Integration Roadmap.
+ *
+ * Components:
+ * - PromptBuilder: Build effective prompts for LLM
+ * - CodeGenerator: Generate test code from prompts
+ * - CodeFormatter: Format and validate generated code
+ * - TestOptimizer: Optimize generated tests
+ * - PackGenerator: Convert specs to QA360 pack YAML
+ * - SourceAnalyzer: Analyze source code for test requirements
+ *
+ * Supported Generators:
+ * - Playwright API tests (TypeScript)
+ * - Playwright UI tests (TypeScript)
+ * - K6 performance tests (JavaScript)
+ * - Vitest unit tests (TypeScript)
+ */
+export { PromptBuilder } from './prompt-builder.js';
+export { CodeGenerator } from './code-generator.js';
+export { CodeFormatter } from './code-formatter.js';
+export { TestOptimizer } from './test-optimizer.js';
+export { PackGenerator, generatePackFromApiSpec, generatePackFromUiSpec, generatePackFromPerfSpec } from './pack-generator.js';
+export { SourceAnalyzer, analyzeSourceFile, analyzeSourceDirectory, generateTestSpec } from './source-analyzer.js';
+// Convenience functions
+export { generateTests, generateApiTestsFromOpenAPI, generateUiTestsFromUrl, generatePerfTests, generateUnitTests, checkGenerationAvailability, } from './generator.js';
+// Crawler Pack Generator (UI Testing 100%)
+export { generatePackFromCrawl, quickCrawl, } from './crawler-pack-generator.js';

package/cli/dist/core/generation/pack-generator.d.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 } from '../types/pack-v2.js';
+export type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec, UnitTestSpec, } from './types.js';
+import type { TestSpec, ApiTestSpec, UiTestSpec, PerfTestSpec } 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 declare class PackGenerator {
+    private readonly defaults;
+    constructor(options?: PackGeneratorOptions);
+    /**
+     * Generate pack from API test specification
+     */
+    generateFromApiSpec(spec: ApiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from UI test specification
+     */
+    generateFromUiSpec(spec: UiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from performance test specification
+     */
+    generateFromPerfSpec(spec: PerfTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Generate pack from generic test specification
+     */
+    generateFromSpec(spec: TestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+    /**
+     * Format endpoint as smoke test spec
+     */
+    private formatEndpointSpec;
+    /**
+     * Format page action
+     */
+    private formatPageAction;
+    /**
+     * Extract threshold value from thresholds array
+     */
+    private extractThreshold;
+    /**
+     * Convert config to YAML string
+     * Note: This is a simple YAML generator. For production, use a proper YAML library.
+     */
+    private toYaml;
+    /**
+     * Helper to indent object properties
+     */
+    private indentObject;
+}
+/**
+ * Convenience function to generate pack from API spec
+ */
+export declare function generatePackFromApiSpec(spec: ApiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+/**
+ * Convenience function to generate pack from UI spec
+ */
+export declare function generatePackFromUiSpec(spec: UiTestSpec, options?: PackGeneratorOptions): PackGenerationResult;
+/**
+ * Convenience function to generate pack from performance spec
+ */
+export declare function generatePackFromPerfSpec(spec: PerfTestSpec, options?: PackGeneratorOptions): PackGenerationResult;

package/cli/dist/core/generation/pack-generator.js

@@ -0,0 +1,416 @@
+/**
+ * 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
+ * });
+ * ```
+ */
+/**
+ * Pack Generator
+ *
+ * Converts test specifications into QA360 pack YAML format.
+ */
+export class PackGenerator {
+    defaults;
+    constructor(options = {}) {
+        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, options) {
+        const opts = { ...this.defaults, ...options };
+        const warnings = [];
+        // Build gates from API endpoints
+        const gates = {};
+        // Group endpoints by type (smoke, full, etc.)
+        const smokeEndpoints = spec.endpoints.filter((e) => e.method === 'GET' && (e.path.includes('/health') || e.path.includes('/status') || e.path === '/'));
+        const apiEndpoints = spec.endpoints.filter((e) => !smokeEndpoints.includes(e));
+        // 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) => this.formatEndpointSpec(e))
+                    },
+                    timeout: opts.timeout,
+                    retries: opts.retries
+                },
+                options: {
+                    timeout: opts.timeout,
+                    retries: opts.retries
+                },
+                budgets: {
+                    p95_ms: 2000,
+                    p99_ms: 5000
+                }
+            };
+        }
+        // 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) => this.formatEndpointSpec(e))
+                    },
+                    timeout: opts.timeout,
+                    retries: opts.retries
+                },
+                options: {
+                    timeout: opts.timeout,
+                    retries: opts.retries
+                }
+            };
+        }
+        // Build pack config
+        const config = {
+            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,
+                        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, options) {
+        const opts = { ...this.defaults, ...options };
+        const warnings = [];
+        const gates = {};
+        // 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) => ({
+                        url: p.url,
+                        name: p.name,
+                        actions: p.actions.slice(0, 5).map((a) => this.formatPageAction(a))
+                    }))
+                },
+                viewport: spec.viewport || { width: 1280, height: 720 }
+            },
+            options: {
+                timeout: opts.timeout,
+                retries: opts.retries
+            },
+            budgets: {
+                a11y_min: 80
+            }
+        };
+        // 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) => ({
+                            url: p.url,
+                            name: p.name,
+                            actions: p.actions.map((a) => this.formatPageAction(a))
+                        }))
+                    },
+                    viewport: spec.viewport || { width: 1280, height: 720 }
+                },
+                options: {
+                    timeout: opts.timeout * 2,
+                    retries: opts.retries
+                },
+                budgets: {
+                    a11y_min: 90
+                }
+            };
+        }
+        const config = {
+            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, options) {
+        const opts = { ...this.defaults, ...options };
+        const warnings = [];
+        const gates = {};
+        // Build budgets from thresholds
+        const budgets = {
+            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) => ({
+                        name: s.name,
+                        weight: s.weight,
+                        requests: s.requests.map((r) => ({
+                            method: r.method,
+                            path: r.path,
+                            headers: r.headers,
+                            body: r.body
+                        }))
+                    }))
+                },
+                options: spec.options || {
+                    duration: '30s',
+                    vus: 10,
+                    maxVus: 50
+                }
+            },
+            budgets
+        };
+        const config = {
+            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, options) {
+        switch (spec.type) {
+            case 'api':
+                return this.generateFromApiSpec(spec, options);
+            case 'ui':
+                return this.generateFromUiSpec(spec, options);
+            case 'perf':
+                return this.generateFromPerfSpec(spec, options);
+            case 'unit':
+                return {
+                    success: false,
+                    yaml: '',
+                    config: {},
+                    errors: ['Unit tests are not supported in pack YAML format. Use direct test file generation instead.']
+                };
+            default:
+                return {
+                    success: false,
+                    yaml: '',
+                    config: {},
+                    errors: [`Unknown test type: ${spec.type}`]
+                };
+        }
+    }
+    /**
+     * Format endpoint as smoke test spec
+     */
+    formatEndpointSpec(endpoint) {
+        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
+     */
+    formatPageAction(action) {
+        const formatted = {
+            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
+     */
+    extractThreshold(thresholds, metric) {
+        const threshold = thresholds.find((t) => 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.
+     */
+    toYaml(config) {
+        const lines = [];
+        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, 6);
+                }
+                if (gateConfig.options) {
+                    lines.push(`    options:`);
+                    this.indentObject(lines, gateConfig.options, 6);
+                }
+                if (gateConfig.budgets) {
+                    lines.push(`    budgets:`);
+                    this.indentObject(lines, gateConfig.budgets, 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, 6);
+            }
+        }
+        // Execution
+        if (config.execution) {
+            lines.push(`\nexecution:`);
+            this.indentObject(lines, config.execution, 2);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Helper to indent object properties
+     */
+    indentObject(lines, obj, indent) {
+        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, 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, 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, options) {
+    const generator = new PackGenerator(options);
+    return generator.generateFromApiSpec(spec, options);
+}
+/**
+ * Convenience function to generate pack from UI spec
+ */
+export function generatePackFromUiSpec(spec, options) {
+    const generator = new PackGenerator(options);
+    return generator.generateFromUiSpec(spec, options);
+}
+/**
+ * Convenience function to generate pack from performance spec
+ */
+export function generatePackFromPerfSpec(spec, options) {
+    const generator = new PackGenerator(options);
+    return generator.generateFromPerfSpec(spec, options);
+}