qa360 2.0.13 → 2.1.0

package/dist/core/artifacts/ui-artifacts.js

@@ -0,0 +1,304 @@
+/**
+ * QA360 UI Artifacts Manager
+ *
+ * Manages screenshots, videos, traces, and other test artifacts
+ * with content-addressable storage (CAS) integration
+ */
+import { mkdirSync, existsSync, writeFileSync, readFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { ContentAddressableStorage } from '../vault/cas.js';
+/**
+ * UI Artifacts Manager
+ *
+ * Handles:
+ * - Automatic screenshots (before/after steps, on error)
+ * - Video recording
+ * - Trace files
+ * - Network captures
+ * - Console logs
+ * - Storage in CAS for deduplication
+ */
+export class UIArtifactsManager {
+    artifactDir;
+    casDir;
+    currentRunId;
+    currentTestId;
+    artifacts = new Map();
+    cas;
+    constructor(artifactDir = '.qa360/artifacts/ui', casDir = '.qa360/runs/cas') {
+        this.artifactDir = artifactDir;
+        this.casDir = casDir;
+        this.currentRunId = `run-${Date.now()}`;
+        this.cas = new ContentAddressableStorage(casDir);
+        this.ensureDirectories();
+    }
+    ensureDirectories() {
+        const dirs = [
+            this.artifactDir,
+            `${this.artifactDir}/screenshots`,
+            `${this.artifactDir}/videos`,
+            `${this.artifactDir}/traces`,
+            `${this.artifactDir}/network`,
+            `${this.artifactDir}/console`,
+            `${this.artifactDir}/coverage`,
+            this.casDir,
+            `${this.casDir}/art`,
+        ];
+        for (const dir of dirs) {
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    /**
+     * Start a new test session
+     */
+    startTest(testId) {
+        this.currentTestId = testId;
+    }
+    /**
+     * End current test session
+     */
+    endTest() {
+        this.currentTestId = undefined;
+    }
+    /**
+     * Take a screenshot and store it
+     */
+    async takeScreenshot(page, // Playwright Page
+    options = {}, metadata) {
+        const testId = this.currentTestId || 'unknown';
+        const timestamp = new Date().toISOString();
+        const filename = `${testId}-${Date.now()}.png`;
+        const localPath = join(this.artifactDir, 'screenshots', filename);
+        // Take screenshot
+        const screenshot = await page.screenshot({
+            path: localPath,
+            type: options.type || 'png',
+            fullPage: options.fullPage || false,
+            animations: options.animations || 'disabled',
+        });
+        // Get image dimensions
+        const viewportSize = page.viewportSize();
+        const dimensions = await page.evaluate(() => ({
+            width: document.documentElement.scrollWidth,
+            height: document.documentElement.scrollHeight,
+        }));
+        // Calculate hash and store in CAS
+        const hash = ContentAddressableStorage.hashContent(screenshot);
+        const casPath = this.getCasPath(hash);
+        // Store in CAS if not exists
+        if (!existsSync(casPath)) {
+            writeFileSync(casPath, screenshot);
+        }
+        const artifact = {
+            type: 'screenshot',
+            format: options.type || 'png',
+            casPath,
+            localPath,
+            hash,
+            width: options.fullPage ? dimensions.width : (viewportSize?.width || 1280),
+            height: options.fullPage ? dimensions.height : (viewportSize?.height || 720),
+            size: screenshot.length,
+            metadata: {
+                testId,
+                timestamp,
+                type: 'screenshot',
+                ...metadata,
+            },
+        };
+        this.artifacts.set(`${testId}-screenshot-${Date.now()}`, artifact);
+        return artifact;
+    }
+    /**
+     * Take screenshot before a step
+     */
+    async takeBeforeScreenshot(page, stepName, stepIndex) {
+        return this.takeScreenshot(page, {}, {
+            stepIndex,
+            stepName: `${stepName}-before`,
+            tags: ['before-step'],
+        });
+    }
+    /**
+     * Take screenshot after a step
+     */
+    async takeAfterScreenshot(page, stepName, stepIndex, success) {
+        return this.takeScreenshot(page, {}, {
+            stepIndex,
+            stepName: `${stepName}-after`,
+            status: success ? 'passed' : 'failed',
+            tags: ['after-step', success ? 'success' : 'failure'],
+        });
+    }
+    /**
+     * Take screenshot on error
+     */
+    async takeErrorScreenshot(page, error, stepName) {
+        const filename = `error-${Date.now()}.png`;
+        const localPath = join(this.artifactDir, 'screenshots', filename);
+        await page.screenshot({
+            path: localPath,
+            fullPage: true,
+        });
+        const screenshot = readFileSync(localPath);
+        const hash = ContentAddressableStorage.hashContent(screenshot);
+        const casPath = this.getCasPath(hash);
+        if (!existsSync(casPath)) {
+            writeFileSync(casPath, screenshot);
+        }
+        const artifact = {
+            type: 'screenshot',
+            format: 'png',
+            casPath,
+            localPath,
+            hash,
+            width: 0,
+            height: 0,
+            size: screenshot.length,
+            metadata: {
+                testId: this.currentTestId || 'unknown',
+                timestamp: new Date().toISOString(),
+                type: 'screenshot',
+                status: 'failed',
+                stepName: stepName || 'error',
+                tags: ['error', 'failure-screenshot'],
+            },
+        };
+        this.artifacts.set(`error-${Date.now()}`, artifact);
+        return artifact;
+    }
+    /**
+     * Save video artifact
+     */
+    async saveVideo(videoPath, metadata) {
+        const testId = this.currentTestId || 'unknown';
+        const filename = `${testId}-${Date.now()}.webm`;
+        const localPath = join(this.artifactDir, 'videos', filename);
+        // Read video file
+        const video = readFileSync(videoPath);
+        const hash = ContentAddressableStorage.hashContent(video);
+        const casPath = this.getCasPath(hash);
+        // Store in CAS
+        if (!existsSync(casPath)) {
+            writeFileSync(casPath, video);
+        }
+        // Get video duration (basic estimate)
+        const size = video.length;
+        const duration = Math.round(size / 100000); // Rough estimate: 100KB per second
+        const artifact = {
+            type: 'video',
+            format: 'webm',
+            casPath,
+            localPath,
+            hash,
+            duration,
+            size,
+            metadata: {
+                testId,
+                timestamp: new Date().toISOString(),
+                type: 'video',
+                ...metadata,
+            },
+        };
+        this.artifacts.set(`${testId}-video-${Date.now()}`, artifact);
+        return artifact;
+    }
+    /**
+     * Save trace artifact
+     */
+    async saveTrace(tracePath, metadata) {
+        const testId = this.currentTestId || 'unknown';
+        const filename = `${testId}-${Date.now()}.zip`;
+        const localPath = join(this.artifactDir, 'traces', filename);
+        const trace = readFileSync(tracePath);
+        const hash = ContentAddressableStorage.hashContent(trace);
+        const casPath = this.getCasPath(hash);
+        if (!existsSync(casPath)) {
+            writeFileSync(casPath, trace);
+        }
+        const artifact = {
+            type: 'trace',
+            format: 'zip',
+            casPath,
+            localPath,
+            hash,
+            size: trace.length,
+            metadata: {
+                testId,
+                timestamp: new Date().toISOString(),
+                type: 'trace',
+                ...metadata,
+            },
+        };
+        this.artifacts.set(`${testId}-trace-${Date.now()}`, artifact);
+        return artifact;
+    }
+    /**
+     * Get artifact by ID
+     */
+    getArtifact(id) {
+        return this.artifacts.get(id);
+    }
+    /**
+     * Get all artifacts for current test
+     */
+    getTestArtifacts() {
+        const testId = this.currentTestId || 'unknown';
+        return Array.from(this.artifacts.values()).filter(a => a.metadata.testId === testId);
+    }
+    /**
+     * Get all artifacts by type
+     */
+    getArtifactsByType(type) {
+        return Array.from(this.artifacts.values()).filter(a => a.type === type);
+    }
+    /**
+     * Clean up old artifacts
+     */
+    cleanup(maxAge = 24 * 60 * 60 * 1000) {
+        const now = Date.now();
+        for (const [id, artifact] of this.artifacts.entries()) {
+            const artifactTime = new Date(artifact.metadata.timestamp).getTime();
+            if (now - artifactTime > maxAge) {
+                // Remove local file (keep in CAS)
+                if (existsSync(artifact.localPath)) {
+                    unlinkSync(artifact.localPath);
+                }
+                this.artifacts.delete(id);
+            }
+        }
+    }
+    /**
+     * Generate CAS path from hash
+     */
+    getCasPath(hash) {
+        // hash is already a hex string from SHA256
+        return join(this.casDir, 'art', hash.substring(0, 2), hash.substring(2, 4), hash.substring(4));
+    }
+    /**
+     * Generate artifacts summary for reporting
+     */
+    generateSummary() {
+        const screenshots = this.getArtifactsByType('screenshot').length;
+        const videos = this.getArtifactsByType('video').length;
+        const traces = this.getArtifactsByType('trace').length;
+        const totalSize = Array.from(this.artifacts.values()).reduce((sum, a) => sum + a.size, 0);
+        // Calculate CAS savings (unique hashes)
+        const uniqueHashes = new Set(Array.from(this.artifacts.values()).map(a => a.hash));
+        const casDedupSavings = totalSize - (uniqueHashes.size * 1000); // Rough estimate
+        return {
+            screenshots,
+            videos,
+            traces,
+            totalSize,
+            casDedupSavings,
+        };
+    }
+}
+/**
+ * Create a UI artifacts manager
+ */
+export function createUIArtifactsManager(artifactDir, casDir) {
+    return new UIArtifactsManager(artifactDir, casDir);
+}

package/dist/core/index.d.ts

@@ -96,3 +96,9 @@ 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

@@ -80,3 +80,12 @@ export * from './regression/index.js';
 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();
+    }
+}