qa360 2.0.13 → 2.1.1

package/dist/core/core/coverage/vault.js

@@ -0,0 +1,405 @@
+/**
+ * Coverage Vault Integration
+ *
+ * Integrates coverage data storage and retrieval with the Evidence Vault.
+ */
+import { promisify } from 'util';
+/**
+ * Coverage Vault class
+ */
+export class CoverageVault {
+    db;
+    dbRun;
+    dbAll;
+    dbGet;
+    constructor(db) {
+        this.db = db;
+        this.dbRun = promisify(db.run.bind(db));
+        this.dbAll = promisify(db.all.bind(db));
+        this.dbGet = promisify(db.get.bind(db));
+    }
+    /**
+     * Initialize coverage tables
+     */
+    async initialize() {
+        const schema = `
+      -- Coverage metrics table
+      CREATE TABLE IF NOT EXISTS coverage_metrics (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          gate TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          total_lines INTEGER DEFAULT 0,
+          covered_lines INTEGER DEFAULT 0,
+          branch_coverage REAL DEFAULT 0,
+          function_coverage REAL DEFAULT 0,
+          line_coverage REAL DEFAULT 0,
+          statement_coverage REAL DEFAULT 0,
+          total_branches INTEGER DEFAULT 0,
+          covered_branches INTEGER DEFAULT 0,
+          total_functions INTEGER DEFAULT 0,
+          covered_functions INTEGER DEFAULT 0,
+          total_statements INTEGER DEFAULT 0,
+          covered_statements INTEGER DEFAULT 0,
+          uncovered_lines TEXT,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_run_id ON coverage_metrics(run_id);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_gate ON coverage_metrics(gate);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_file_path ON coverage_metrics(file_path);
+      CREATE INDEX IF NOT EXISTS idx_coverage_metrics_run_gate ON coverage_metrics(run_id, gate);
+
+      -- Coverage trends table
+      CREATE TABLE IF NOT EXISTS coverage_trends (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          test_id TEXT NOT NULL,
+          file_path TEXT NOT NULL,
+          run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+          coverage_type TEXT NOT NULL,
+          coverage_value REAL NOT NULL,
+          date INTEGER NOT NULL,
+          commit TEXT,
+          branch TEXT,
+          UNIQUE(test_id, file_path, coverage_type, date)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_test_id ON coverage_trends(test_id);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_file_path ON coverage_trends(file_path);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_date ON coverage_trends(date);
+      CREATE INDEX IF NOT EXISTS idx_coverage_trends_type ON coverage_trends(coverage_type);
+
+      -- Coverage summary table (aggregate metrics per run)
+      CREATE TABLE IF NOT EXISTS coverage_summary (
+          run_id TEXT PRIMARY KEY REFERENCES runs(id) ON DELETE CASCADE,
+          line_coverage REAL NOT NULL DEFAULT 0,
+          branch_coverage REAL NOT NULL DEFAULT 0,
+          function_coverage REAL NOT NULL DEFAULT 0,
+          statement_coverage REAL NOT NULL DEFAULT 0,
+          total_files INTEGER DEFAULT 0,
+          files_meeting_threshold INTEGER DEFAULT 0,
+          total_lines INTEGER DEFAULT 0,
+          covered_lines INTEGER DEFAULT 0,
+          thresholds_met INTEGER DEFAULT 1,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_coverage_summary_created_at ON coverage_summary(created_at);
+    `;
+        const statements = schema
+            .split(';')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+        for (const statement of statements) {
+            await this.dbRun(statement, []);
+        }
+    }
+    /**
+     * Store coverage result for a run
+     */
+    async storeCoverage(runId, result) {
+        // Store per-file metrics
+        for (const [filePath, fileCoverage] of Object.entries(result.files)) {
+            const record = {
+                run_id: runId,
+                gate: result.gate,
+                file_path: filePath,
+                total_lines: fileCoverage.totalLines,
+                covered_lines: fileCoverage.coveredLines,
+                branch_coverage: fileCoverage.branchCoverage,
+                function_coverage: fileCoverage.functionCoverage,
+                line_coverage: fileCoverage.lineCoverage,
+                statement_coverage: fileCoverage.statementCoverage,
+                total_branches: fileCoverage.totalBranches,
+                covered_branches: fileCoverage.coveredBranches,
+                total_functions: fileCoverage.totalFunctions,
+                covered_functions: fileCoverage.coveredFunctions,
+                total_statements: fileCoverage.totalStatements,
+                covered_statements: fileCoverage.coveredStatements,
+                uncovered_lines: JSON.stringify(fileCoverage.uncoveredLines),
+                created_at: Date.now()
+            };
+            await this.dbRun(`INSERT INTO coverage_metrics (
+          run_id, gate, file_path, total_lines, covered_lines,
+          branch_coverage, function_coverage, line_coverage, statement_coverage,
+          total_branches, covered_branches, total_functions, covered_functions,
+          total_statements, covered_statements, uncovered_lines, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                record.run_id, record.gate, record.file_path, record.total_lines, record.covered_lines,
+                record.branch_coverage, record.function_coverage, record.line_coverage, record.statement_coverage,
+                record.total_branches, record.covered_branches, record.total_functions, record.covered_functions,
+                record.total_statements, record.covered_statements, record.uncovered_lines, record.created_at
+            ]);
+        }
+        // Store aggregate summary
+        await this.storeSummary(runId, result.metrics);
+    }
+    /**
+     * Store coverage summary for a run
+     */
+    async storeSummary(runId, metrics) {
+        await this.dbRun(`INSERT OR REPLACE INTO coverage_summary (
+        run_id, line_coverage, branch_coverage, function_coverage, statement_coverage,
+        total_files, files_meeting_threshold, total_lines, covered_lines, thresholds_met, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+            runId,
+            metrics.lineCoverage,
+            metrics.branchCoverage,
+            metrics.functionCoverage,
+            metrics.statementCoverage,
+            metrics.totalFiles,
+            metrics.filesMeetingThreshold,
+            metrics.totalLines,
+            metrics.coveredLines,
+            1, // thresholds_met placeholder
+            Date.now()
+        ]);
+    }
+    /**
+     * Retrieve coverage for a run
+     */
+    async getCoverage(runId) {
+        const rows = await this.dbAll(`SELECT * FROM coverage_metrics WHERE run_id = ?`, [runId]);
+        if (rows.length === 0) {
+            return null;
+        }
+        const files = {};
+        let gate = 'unknown';
+        for (const row of rows) {
+            gate = row.gate;
+            files[row.file_path] = {
+                path: row.file_path,
+                totalLines: row.total_lines,
+                coveredLines: row.covered_lines,
+                lineCoverage: row.line_coverage,
+                totalBranches: row.total_branches,
+                coveredBranches: row.covered_branches,
+                branchCoverage: row.branch_coverage,
+                totalFunctions: row.total_functions,
+                coveredFunctions: row.covered_functions,
+                functionCoverage: row.function_coverage,
+                totalStatements: row.total_statements,
+                coveredStatements: row.covered_statements,
+                statementCoverage: row.statement_coverage,
+                uncoveredLines: JSON.parse(row.uncovered_lines || '[]'),
+                partiallyCoveredLines: [],
+                branchesByLine: {}
+            };
+        }
+        // Get summary
+        const summary = await this.getSummary(runId);
+        const metrics = summary || {
+            lineCoverage: 0,
+            branchCoverage: 0,
+            functionCoverage: 0,
+            statementCoverage: 0,
+            totalFiles: Object.keys(files).length,
+            filesWithCoverage: Object.keys(files).length,
+            filesMeetingThreshold: 0,
+            totalLines: 0,
+            coveredLines: 0,
+            timestamp: Date.now()
+        };
+        return {
+            source: 'custom',
+            gate,
+            files,
+            metrics,
+            format: 'json',
+            timestamp: Date.now()
+        };
+    }
+    /**
+     * Get coverage summary for a run
+     */
+    async getSummary(runId) {
+        const row = await this.dbGet(`SELECT * FROM coverage_summary WHERE run_id = ?`, [runId]);
+        if (!row) {
+            return null;
+        }
+        return {
+            lineCoverage: row.line_coverage,
+            branchCoverage: row.branch_coverage,
+            functionCoverage: row.function_coverage,
+            statementCoverage: row.statement_coverage,
+            totalFiles: row.total_files,
+            filesWithCoverage: row.total_files,
+            filesMeetingThreshold: row.files_meeting_threshold,
+            totalLines: row.total_lines,
+            coveredLines: row.covered_lines,
+            timestamp: row.created_at
+        };
+    }
+    /**
+     * Get coverage trends for a file
+     */
+    async getTrends(filePath, coverageType = 'line', limit = 30) {
+        const rows = await this.dbAll(`SELECT * FROM coverage_trends
+       WHERE file_path = ? AND coverage_type = ?
+       ORDER BY date DESC
+       LIMIT ?`, [filePath, coverageType, limit]);
+        const trends = [];
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const row = rows[i];
+            const prev = i > 0 ? rows[i - 1] : null;
+            trends.push({
+                runId: row.run_id,
+                timestamp: row.date,
+                coverage: row.coverage_value,
+                type: coverageType,
+                change: prev ? row.coverage_value - prev.coverage_value : 0,
+                commit: row.commit,
+                branch: row.branch
+            });
+        }
+        return trends;
+    }
+    /**
+     * Get overall coverage trends
+     */
+    async getOverallTrends(coverageType = 'line', limit = 30) {
+        const rows = await this.dbAll(`SELECT
+        run_id,
+        ${coverageType}_coverage as coverage_value,
+        created_at as date
+       FROM coverage_summary
+       ORDER BY date DESC
+       LIMIT ?`, [limit]);
+        const trends = [];
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const row = rows[i];
+            const prev = i > 0 ? rows[i - 1] : null;
+            trends.push({
+                runId: row.run_id,
+                timestamp: row.date,
+                coverage: row.coverage_value,
+                type: coverageType,
+                change: prev ? row.coverage_value - prev.coverage_value : 0
+            });
+        }
+        return trends;
+    }
+    /**
+     * Get coverage by gate
+     */
+    async getCoverageByGate(gate, limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        cs.line_coverage,
+        cs.branch_coverage,
+        cs.function_coverage,
+        cs.statement_coverage,
+        cs.total_files,
+        cs.files_meeting_threshold,
+        cs.total_lines,
+        cs.covered_lines,
+        cs.created_at as timestamp
+       FROM coverage_summary cs
+       JOIN runs r ON cs.run_id = r.id
+       JOIN gates g ON g.run_id = r.id
+       WHERE g.name = ?
+       ORDER BY cs.created_at DESC
+       LIMIT ?`, [gate, limit]);
+        return rows.map(row => ({
+            lineCoverage: row.line_coverage,
+            branchCoverage: row.branch_coverage,
+            functionCoverage: row.function_coverage,
+            statementCoverage: row.statement_coverage,
+            totalFiles: row.total_files,
+            filesWithCoverage: row.total_files,
+            filesMeetingThreshold: row.files_meeting_threshold,
+            totalLines: row.total_lines,
+            coveredLines: row.covered_lines,
+            timestamp: row.timestamp
+        }));
+    }
+    /**
+     * Get files with lowest coverage
+     */
+    async getLowestCoverageFiles(limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        file_path,
+        AVG(line_coverage) as avg_coverage,
+        gate
+       FROM coverage_metrics
+       GROUP BY file_path
+       ORDER BY avg_coverage ASC
+       LIMIT ?`, [limit]);
+        return rows.map(row => ({
+            filePath: row.file_path,
+            coverage: row.avg_coverage,
+            gate: row.gate
+        }));
+    }
+    /**
+     * Get files with highest coverage
+     */
+    async getHighestCoverageFiles(limit = 10) {
+        const rows = await this.dbAll(`SELECT
+        file_path,
+        AVG(line_coverage) as avg_coverage,
+        gate
+       FROM coverage_metrics
+       GROUP BY file_path
+       ORDER BY avg_coverage DESC
+       LIMIT ?`, [limit]);
+        return rows.map(row => ({
+            filePath: row.file_path,
+            coverage: row.avg_coverage,
+            gate: row.gate
+        }));
+    }
+    /**
+     * Get coverage statistics across all runs
+     */
+    async getStatistics() {
+        const totalRuns = await this.dbGet(`SELECT COUNT(DISTINCT run_id) as count FROM coverage_summary`, []);
+        const averages = await this.dbGet(`SELECT
+        AVG(line_coverage) as line,
+        AVG(branch_coverage) as branch,
+        AVG(function_coverage) as function
+       FROM coverage_summary`, []);
+        const best = await this.dbGet(`SELECT run_id, line_coverage FROM coverage_summary ORDER BY line_coverage DESC LIMIT 1`, []);
+        const worst = await this.dbGet(`SELECT run_id, line_coverage FROM coverage_summary ORDER BY line_coverage ASC LIMIT 1`, []);
+        return {
+            totalRuns: totalRuns?.count || 0,
+            averageLineCoverage: averages?.line || 0,
+            averageBranchCoverage: averages?.branch || 0,
+            averageFunctionCoverage: averages?.function || 0,
+            bestCoverage: { runId: best?.run_id || '', coverage: best?.line_coverage || 0 },
+            worstCoverage: { runId: worst?.run_id || '', coverage: worst?.line_coverage || 0 }
+        };
+    }
+    /**
+     * Delete coverage data for a run
+     */
+    async deleteCoverage(runId) {
+        await this.dbRun(`DELETE FROM coverage_metrics WHERE run_id = ?`, [runId]);
+        await this.dbRun(`DELETE FROM coverage_summary WHERE run_id = ?`, [runId]);
+        await this.dbRun(`DELETE FROM coverage_trends WHERE run_id = ?`, [runId]);
+    }
+    /**
+     * Get recent coverage changes (comparison with previous run)
+     */
+    async getRecentChanges(limit = 5) {
+        const rows = await this.dbAll(`SELECT
+        run_id,
+        created_at as timestamp,
+        line_coverage
+       FROM coverage_summary
+       ORDER BY created_at DESC
+       LIMIT ?`, [limit * 2] // Get extra to calculate changes
+        );
+        const result = [];
+        for (let i = 0; i < Math.min(rows.length - 1, limit); i++) {
+            const current = rows[i];
+            const previous = rows[i + 1];
+            result.push({
+                runId: current.run_id,
+                timestamp: current.timestamp,
+                lineCoverage: current.line_coverage,
+                change: previous ? current.line_coverage - previous.line_coverage : 0
+            });
+        }
+        return result;
+    }
+}

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>;