qa360 1.4.5 → 2.0.1

package/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);
+}

package/dist/core/generation/prompt-builder.d.ts

@@ -0,0 +1,132 @@
+/**
+ * QA360 Prompt Builder
+ *
+ * Constructs effective prompts for LLM test generation.
+ * Uses system prompts, few-shot examples, and structured templates.
+ */
+import type { TestSpec, GenerationSource } from './types.js';
+/**
+ * Prompt builder options
+ */
+export interface PromptBuilderOptions {
+    /**
+     * Include code comments in generated tests
+     */
+    includeComments?: boolean;
+    /**
+     * Include detailed assertions
+     */
+    includeDetailedAssertions?: boolean;
+    /**
+     * Include retry logic for flaky tests
+     */
+    includeRetryLogic?: boolean;
+    /**
+     * Target code style
+     */
+    codeStyle?: 'clean' | 'verbose' | 'concise';
+    /**
+     * Few-shot examples to include
+     */
+    examples?: string[];
+    /**
+     * Custom system prompt
+     */
+    systemPrompt?: string;
+}
+/**
+ * Built prompt result
+ */
+export interface BuiltPrompt {
+    system: string;
+    user: string;
+    estimatedTokens: number;
+}
+/**
+ * Prompt Builder class
+ */
+export declare class PromptBuilder {
+    private readonly options;
+    private readonly defaultOptions;
+    constructor(options?: PromptBuilderOptions);
+    /**
+     * Build prompt from generation source
+     */
+    buildFromSource(source: GenerationSource): Promise<BuiltPrompt>;
+    /**
+     * Build prompt from OpenAPI/Swagger spec
+     */
+    buildFromOpenAPI(specPath: string): BuiltPrompt;
+    /**
+     * Build prompt from HAR file
+     */
+    buildFromHAR(filePath: string): BuiltPrompt;
+    /**
+     * Build prompt from URL
+     */
+    buildFromUrl(url: string): BuiltPrompt;
+    /**
+     * Build prompt from test spec
+     */
+    buildFromSpec(spec: TestSpec): BuiltPrompt;
+    /**
+     * Build prompt from description
+     */
+    buildFromDescription(description: string): BuiltPrompt;
+    /**
+     * Build prompt from existing code
+     */
+    buildFromCode(code: string, language: string): BuiltPrompt;
+    /**
+     * Build API spec prompt
+     */
+    private buildApiSpecPrompt;
+    /**
+     * Build UI spec prompt
+     */
+    private buildUiSpecPrompt;
+    /**
+     * Build performance spec prompt
+     */
+    private buildPerfSpecPrompt;
+    /**
+     * Build unit test spec prompt
+     */
+    private buildUnitSpecPrompt;
+    /**
+     * Get default system prompt
+     */
+    private getDefaultSystemPrompt;
+    /**
+     * Get code style instructions
+     */
+    private getCodeStyleInstructions;
+    /**
+     * Get few-shot example
+     */
+    private getFewShotExample;
+    /**
+     * Get API test example
+     */
+    private getApiExample;
+    /**
+     * Get UI test example
+     */
+    private getUiExample;
+    /**
+     * Get performance test example
+     */
+    private getPerfExample;
+    /**
+     * Get unit test example
+     */
+    private getUnitExample;
+    /**
+     * Count approximate tokens
+     */
+    private countTokens;
+}
+/**
+ * Create a prompt builder with default options
+ */
+export declare function createPromptBuilder(options?: PromptBuilderOptions): PromptBuilder;