qa360 2.0.12 → 2.1.0

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

@@ -0,0 +1,231 @@
+/**
+ * QA360 Crawler Pack Generator
+ *
+ * Crawls a website and generates a complete pack.yml with E2E tests
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { crawlWebsite } from '../crawler/index.js';
+/**
+ * Generate pack.yml from crawled website
+ */
+export async function generatePackFromCrawl(options) {
+    try {
+        console.log(`🕷️  Crawling ${options.baseUrl}...`);
+        // Crawl the website
+        const crawlResult = await crawlWebsite({
+            baseUrl: options.baseUrl,
+            maxDepth: options.crawl?.maxDepth || 2,
+            maxPages: options.crawl?.maxPages || 20,
+            headless: options.crawl?.headless ?? true,
+            screenshots: false,
+            timeout: 30000,
+            excludePatterns: options.crawl?.excludePatterns,
+        });
+        if (!crawlResult.success) {
+            return {
+                success: false,
+                result: crawlResult,
+                error: 'Crawling failed',
+            };
+        }
+        console.log(`  ✅ Discovered ${crawlResult.siteMap.metadata.pagesCrawled} pages`);
+        console.log(`  ✅ Found ${crawlResult.forms.length} forms`);
+        console.log(`  ✅ Generated ${crawlResult.userJourneys.length} user journeys`);
+        // Generate pack.yml
+        const pack = generatePackFromCrawlResult(crawlResult, options);
+        // Write pack file
+        const packPath = options.output || resolve(process.cwd(), 'pack.yml');
+        const packDir = dirname(packPath);
+        if (!existsSync(packDir)) {
+            mkdirSync(packDir, { recursive: true });
+        }
+        writeFileSync(packPath, pack, 'utf-8');
+        console.log(`\n📦 Generated pack: ${packPath}`);
+        return {
+            success: true,
+            packPath,
+            result: crawlResult,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Generate pack.yml YAML from crawl result
+ */
+function generatePackFromCrawlResult(crawlResult, options) {
+    const { siteMap, userJourneys, forms } = crawlResult;
+    const packName = options.packName || `${new URL(options.baseUrl).hostname.replace(/\./g, '-')}-tests`;
+    // Build gates array
+    const gates = ['ui'];
+    if (options.includeA11y)
+        gates.push('a11y');
+    // Build UI tests from user journeys
+    const uiTests = userJourneys.map((journey, index) => ({
+        name: options.journeyNames?.[journey.name] || journey.name,
+        description: journey.description,
+        path: new URL(journey.entryPoint).pathname,
+        steps: journey.steps.map((step, stepIndex) => journeyStepToUiTestStep(step, stepIndex)),
+    }));
+    // Also add form-based tests
+    for (const form of forms) {
+        if (form.purpose !== 'login' && form.purpose !== 'signup') {
+            uiTests.push({
+                name: `${form.purpose.charAt(0).toUpperCase() + form.purpose.slice(1)} Form Test`,
+                description: `Test the ${form.purpose} form`,
+                path: siteMap.pages.find(p => p.elements.forms.includes(form))?.path || '/',
+                steps: generateFormTestSteps(form),
+            });
+        }
+    }
+    // Generate YAML
+    let yaml = `# QA360 Pack - Generated by crawler
+# Source: ${options.baseUrl}
+# Generated: ${new Date().toISOString()}
+
+version: 1
+name: "${packName}"
+description: "Auto-generated E2E tests for ${new URL(options.baseUrl).hostname}"
+
+gates:
+${gates.map(g => `  - ${g}`).join('\n')}
+
+targets:
+  web:
+    baseUrl: "${options.baseUrl}"
+    headless: true
+    screenshot: "only-on-fail"
+    video: "retain-on-fail"
+
+    # Pages discovered by crawler
+    pages:
+${siteMap.pages.map(p => `      - "${p.path}"`).join('\n')}
+
+    # E2E UI tests generated from discovered user journeys
+    uiTests:
+${uiTests.map(test => generateUiTestYaml(test)).join('\n')}
+`;
+    if (siteMap.metadata.pagesCrawled > 0) {
+        yaml += `
+budgets:
+  a11y_min: 80
+  perf_p95_ms: ${Math.round(siteMap.metadata.avgLoadTime * 1.5)}
+`;
+    }
+    return yaml;
+}
+/**
+ * Convert journey step to UI test step
+ */
+function journeyStepToUiTestStep(step, index) {
+    const uiStep = {
+        order: index + 1,
+        action: step.action,
+        description: step.description,
+        selector: step.selector,
+        value: step.value,
+        wait: 500,
+    };
+    if (step.expected) {
+        uiStep.expected = {};
+        if (step.expected.url)
+            uiStep.expected.url = step.expected.url;
+        if (step.expected.visible)
+            uiStep.expected.visible = step.expected.visible;
+    }
+    return uiStep;
+}
+/**
+ * Generate test steps for a form
+ */
+function generateFormTestSteps(form) {
+    const steps = [];
+    // Navigate to form
+    steps.push({
+        order: 1,
+        action: 'navigate',
+        description: 'Navigate to form',
+        value: form.selector,
+    });
+    // Fill form fields
+    for (const field of form.fields) {
+        if (field.required) {
+            const step = {
+                order: steps.length + 1,
+                action: field.inputType === 'select-one' ? 'select' : 'fill',
+                description: `Fill ${field.name || field.inputType}`,
+                selector: field.selector,
+            };
+            if (field.inputType === 'select-one' && field.options && field.options.length > 0) {
+                step.value = field.options[0];
+            }
+            else if (field.inputType === 'email') {
+                step.value = 'test@example.com';
+            }
+            else if (field.inputType === 'tel') {
+                step.value = '+1234567890';
+            }
+            else if (field.inputType === 'checkbox') {
+                step.action = 'check';
+            }
+            else {
+                step.value = 'Test value';
+            }
+            steps.push(step);
+        }
+    }
+    // Submit form
+    if (form.submitButton) {
+        steps.push({
+            order: steps.length + 1,
+            action: 'click',
+            description: 'Submit form',
+            selector: form.submitButton.selector,
+            wait: 1000,
+        });
+    }
+    return steps;
+}
+/**
+ * Generate YAML for a UI test definition
+ */
+function generateUiTestYaml(test) {
+    const steps = test.steps.map(step => {
+        let yaml = `      - action: ${step.action}`;
+        if (step.description)
+            yaml += `\n        description: "${step.description}"`;
+        if (step.selector)
+            yaml += `\n        selector: "${step.selector}"`;
+        if (step.value)
+            yaml += `\n        value: "${step.value}"`;
+        if (step.expected)
+            yaml += `\n        expected: ${JSON.stringify(step.expected)}`;
+        if (step.wait)
+            yaml += `\n        wait: ${step.wait}`;
+        return yaml;
+    }).join('\n');
+    return `    - name: "${test.name}"
+      description: "${test.description || ''}"
+      path: "${test.path || '/'}"
+      steps:
+${steps}`;
+}
+/**
+ * Quick crawl - generates pack without detailed analysis
+ */
+export async function quickCrawl(baseUrl, outputPath) {
+    return generatePackFromCrawl({
+        baseUrl,
+        output: outputPath,
+        crawl: {
+            maxDepth: 1,
+            maxPages: 10,
+        },
+        includeA11y: true,
+    });
+}

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

@@ -28,3 +28,5 @@ export type { PackGeneratorOptions, PackGenerationResult } from './pack-generato
 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/dist/core/generation/index.js

@@ -26,3 +26,5 @@ export { PackGenerator, generatePackFromApiSpec, generatePackFromUiSpec, generat
 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/dist/core/index.d.ts

@@ -93,3 +93,12 @@ export * from './self-healing/index.js';
 export * from './coverage/index.js';
 export * from './slo/index.js';
 export * from './regression/index.js';
+export * from './crawler/index.js';
+export { AssertionsEngine, createAssertionsEngine, AssertionResult, AssertionGroupResult, AssertionRunOptions, AssertionError, SoftAssertionError, Assertion, AssertionOperator, AssertionSuite, } from './assertions/index.js';
+export type { AssertionType as UiAssertionType } from './assertions/types.js';
+export * from './artifacts/index.js';
+export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
+export type { ReportData, TestReport, StepReport, } from './reporting/index.js';
+export type { ScreenshotArtifact as ReportScreenshotArtifact, VideoArtifact as ReportVideoArtifact, TraceArtifact as ReportTraceArtifact, } from './reporting/index.js';
+export * from './parallel/index.js';
+export * from './visual/index.js';

package/dist/core/index.js

@@ -76,3 +76,16 @@ export * from './coverage/index.js';
 export * from './slo/index.js';
 // Regression Detection Module (Vision 2.0 - Phase 2 - F12)
 export * from './regression/index.js';
+// Crawler Module (Vision 2.0 - UI Testing 100%)
+export * from './crawler/index.js';
+// Assertions Engine (Vision 2.0 - UI Testing 100%)
+export { AssertionsEngine, createAssertionsEngine, AssertionError, SoftAssertionError, } from './assertions/index.js';
+// Artifacts Module (Vision 2.0 - UI Testing Artifacts)
+export * from './artifacts/index.js';
+// Reporting Module (Vision 2.0 - HTML Reports)
+// Note: Using selective exports to avoid naming conflicts with artifacts module
+export { HTMLReporter, generateHTMLReport } from './reporting/index.js';
+// Parallel Module (Vision 2.0 - Parallel Test Execution)
+export * from './parallel/index.js';
+// Visual Regression Module (Vision 2.0 - Visual Testing)
+export * from './visual/index.js';

package/dist/core/parallel/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QA360 Parallel Module
+ *
+ * Parallel test execution for faster feedback
+ */
+export { ParallelTestRunner, createParallelRunner, runParallelTests, type ParallelTestConfig, type ParallelTestResult, type ParallelRunResult, type WorkerMessage, type WorkerJob, } from './parallel-runner.js';

package/dist/core/parallel/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Parallel Module
+ *
+ * Parallel test execution for faster feedback
+ */
+export { ParallelTestRunner, createParallelRunner, runParallelTests, } from './parallel-runner.js';

package/dist/core/parallel/parallel-runner.d.ts

@@ -0,0 +1,107 @@
+/**
+ * QA360 Parallel Test Runner
+ *
+ * Runs multiple UI tests concurrently for faster execution.
+ * Supports worker pools, load balancing, and resource limits.
+ */
+export interface ParallelTestConfig {
+    /** Test definition to run */
+    test: any;
+    /** Target configuration */
+    target: any;
+    /** Worker timeout in ms */
+    timeout?: number;
+    /** Maximum concurrent workers (default: CPU count) */
+    maxWorkers?: number;
+    /** Number of retries for failed tests */
+    retries?: number;
+}
+export interface ParallelTestResult {
+    test: any;
+    success: boolean;
+    duration: number;
+    error?: string;
+    artifacts?: any;
+    workerId?: number;
+}
+export interface ParallelRunResult {
+    success: boolean;
+    totalTests: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+    results: ParallelTestResult[];
+    workerStats: {
+        totalWorkers: number;
+        totalJobs: number;
+        avgJobDuration: number;
+    };
+}
+export interface WorkerMessage {
+    type: 'run' | 'result' | 'error' | 'timeout';
+    testId: string;
+    data?: any;
+    error?: string;
+}
+export interface WorkerJob {
+    id: string;
+    test: any;
+    target: any;
+    retries: number;
+    workerId?: number;
+}
+/**
+ * Parallel Test Runner
+ *
+ * Executes multiple tests concurrently using worker threads.
+ * Each test runs in isolation with its own browser instance.
+ */
+export declare class ParallelTestRunner {
+    private maxWorkers;
+    private timeout;
+    private retries;
+    private workerPool;
+    private activeJobs;
+    constructor(config?: {
+        maxWorkers?: number;
+        timeout?: number;
+        retries?: number;
+    });
+    /**
+     * Run tests in parallel
+     */
+    runParallel(tests: any[], target: any): Promise<ParallelRunResult>;
+    /**
+     * Run a single worker job
+     */
+    private runWorker;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    /**
+     * Clean up all workers
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get optimal worker count based on resources
+     */
+    static getOptimalWorkerCount(): number;
+}
+/**
+ * Create a parallel test runner
+ */
+export declare function createParallelRunner(config?: {
+    maxWorkers?: number;
+    timeout?: number;
+    retries?: number;
+}): ParallelTestRunner;
+/**
+ * Run tests in parallel (convenience function)
+ */
+export declare function runParallelTests(tests: any[], target: any, config?: {
+    maxWorkers?: number;
+    timeout?: number;
+    retries?: number;
+}): Promise<ParallelRunResult>;

package/dist/core/parallel/parallel-runner.js

@@ -0,0 +1,192 @@
+/**
+ * QA360 Parallel Test Runner
+ *
+ * Runs multiple UI tests concurrently for faster execution.
+ * Supports worker pools, load balancing, and resource limits.
+ */
+import { cpus } from 'os';
+/**
+ * Parallel Test Runner
+ *
+ * Executes multiple tests concurrently using worker threads.
+ * Each test runs in isolation with its own browser instance.
+ */
+export class ParallelTestRunner {
+    maxWorkers;
+    timeout;
+    retries;
+    workerPool;
+    activeJobs;
+    constructor(config) {
+        this.maxWorkers = config?.maxWorkers || Math.max(2, cpus().length - 1);
+        this.timeout = config?.timeout || 60000; // 60s default per test
+        this.retries = config?.retries || 1;
+        this.workerPool = new Map();
+        this.activeJobs = new Map();
+    }
+    /**
+     * Run tests in parallel
+     */
+    async runParallel(tests, target) {
+        const startTime = Date.now();
+        console.log(`\n🚀 Parallel Test Runner`);
+        console.log(`   Workers: ${this.maxWorkers}`);
+        console.log(`   Tests: ${tests.length}`);
+        const results = [];
+        const jobs = tests.map((test, i) => ({
+            id: `test-${i}`,
+            test,
+            target,
+            retries: this.retries,
+        }));
+        // Process jobs in batches
+        let completed = 0;
+        let workerId = 0;
+        while (jobs.length > 0 || this.activeJobs.size > 0) {
+            // Start new jobs up to max workers
+            while (this.activeJobs.size < this.maxWorkers && jobs.length > 0) {
+                const job = jobs.shift();
+                job.workerId = workerId;
+                this.activeJobs.set(job.id, job);
+                this.runWorker(workerId, job)
+                    .then((result) => {
+                    results.push(result);
+                    completed++;
+                    const progress = Math.round((completed / tests.length) * 100);
+                    console.log(`   [${completed}/${tests.length}] ${progress}% - ${result.test.name || job.id}: ${result.success ? 'PASS' : 'FAIL'}`);
+                })
+                    .catch((error) => {
+                    results.push({
+                        test: job.test,
+                        success: false,
+                        duration: 0,
+                        error: error.message,
+                        workerId,
+                    });
+                    completed++;
+                })
+                    .finally(() => {
+                    this.activeJobs.delete(job.id);
+                });
+                workerId = (workerId + 1) % this.maxWorkers;
+            }
+            // Wait a bit before checking again
+            await this.sleep(100);
+        }
+        const duration = Date.now() - startTime;
+        const passed = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+        const workerStats = {
+            totalWorkers: this.maxWorkers,
+            totalJobs: results.length,
+            avgJobDuration: results.length > 0 ? duration / results.length : 0,
+        };
+        console.log(`\n✅ Parallel execution complete`);
+        console.log(`   Duration: ${duration}ms`);
+        console.log(`   Throughput: ${Math.round(results.length / (duration / 1000))} tests/sec`);
+        return {
+            success: failed === 0,
+            totalTests: results.length,
+            passed,
+            failed,
+            skipped: 0,
+            duration,
+            results,
+            workerStats,
+        };
+    }
+    /**
+     * Run a single worker job
+     */
+    async runWorker(workerId, job) {
+        // For now, run in-process (worker threads setup is complex)
+        // In production, this would spawn a worker thread
+        const startTime = Date.now();
+        try {
+            // Import adapter dynamically to run test
+            const { PlaywrightNativeAdapter } = await import('../adapters/playwright-native-adapter.js');
+            const adapter = new PlaywrightNativeAdapter({
+                target: job.target,
+                timeout: this.timeout,
+                screenshots: 'only-on-failure',
+                video: 'never',
+                trace: 'never',
+            });
+            const result = await adapter.runTest(job.test);
+            // Retry on failure
+            if (!result.success && job.retries > 0) {
+                console.log(`   🔄 Retrying ${job.test.name || job.id} (${job.retries} retries left)`);
+                job.retries--;
+                return this.runWorker(workerId, job);
+            }
+            return {
+                test: job.test,
+                success: result.success,
+                duration: Date.now() - startTime,
+                error: result.error,
+                artifacts: result.artifacts,
+                workerId,
+            };
+        }
+        catch (error) {
+            // Retry on error
+            if (job.retries > 0) {
+                console.log(`   🔄 Retrying ${job.test.name || job.id} after error (${job.retries} retries left)`);
+                job.retries--;
+                return this.runWorker(workerId, job);
+            }
+            return {
+                test: job.test,
+                success: false,
+                duration: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+                workerId,
+            };
+        }
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Clean up all workers
+     */
+    async cleanup() {
+        for (const [id, worker] of this.workerPool) {
+            await worker.terminate();
+            this.workerPool.delete(id);
+        }
+        this.activeJobs.clear();
+    }
+    /**
+     * Get optimal worker count based on resources
+     */
+    static getOptimalWorkerCount() {
+        const cpuCount = cpus().length;
+        const memGB = require('os').totalmem() / (1024 ** 3);
+        // Each worker uses ~500MB RAM
+        const memBasedWorkers = Math.floor(memGB / 0.5);
+        const cpuBasedWorkers = Math.max(2, cpuCount - 1);
+        return Math.min(cpuBasedWorkers, memBasedWorkers);
+    }
+}
+/**
+ * Create a parallel test runner
+ */
+export function createParallelRunner(config) {
+    return new ParallelTestRunner(config);
+}
+/**
+ * Run tests in parallel (convenience function)
+ */
+export async function runParallelTests(tests, target, config) {
+    const runner = new ParallelTestRunner(config);
+    try {
+        return await runner.runParallel(tests, target);
+    }
+    finally {
+        await runner.cleanup();
+    }
+}