qa360 2.0.13 → 2.1.1

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/core/coverage/analyzer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Coverage Analyzer
+ *
+ * Analyzes coverage data to provide insights, trends, and recommendations.
+ */
+import type { FileCoverage, CoverageMetrics, CoverageResult, CoverageTrend, CoverageGap, CoverageComparison, CoverageThreshold, CoverageType, CoverageReport } from './types.js';
+/**
+ * Historical coverage data point
+ */
+interface HistoricalCoverage {
+    runId: string;
+    timestamp: number;
+    metrics: CoverageMetrics;
+}
+/**
+ * Coverage Analyzer class
+ */
+export declare class CoverageAnalyzer {
+    private history;
+    /**
+     * Analyze coverage and generate insights
+     */
+    analyze(result: CoverageResult, threshold?: CoverageThreshold): CoverageReport;
+    /**
+     * Check if coverage meets thresholds
+     */
+    checkThresholds(metrics: CoverageMetrics, threshold?: CoverageThreshold): boolean;
+    /**
+     * Check if a single file meets thresholds
+     */
+    checkFileThresholds(file: FileCoverage, threshold?: CoverageThreshold): boolean;
+    /**
+     * Find coverage gaps
+     */
+    findGaps(files: Record<string, FileCoverage>, threshold?: CoverageThreshold): CoverageGap[];
+    /**
+     * Calculate priority for covering a file
+     */
+    private calculatePriority;
+    /**
+     * Estimate effort to cover a file
+     */
+    private estimateEffort;
+    /**
+     * Generate test suggestions for a file
+     */
+    private generateSuggestions;
+    /**
+     * Group consecutive numbers into ranges
+     */
+    private groupConsecutiveNumbers;
+    /**
+     * Get top and bottom files by coverage
+     */
+    getTopFiles(files: Record<string, FileCoverage>, limit?: number): Array<{
+        path: string;
+        coverage: number;
+        type: 'best' | 'worst';
+    }>;
+    /**
+     * Compare two coverage results
+     */
+    compare(baseResult: CoverageResult, compareResult: CoverageResult): CoverageComparison;
+    /**
+     * Add historical coverage data
+     */
+    addHistory(key: string, data: HistoricalCoverage): void;
+    /**
+     * Get coverage trends
+     */
+    getTrends(key: string, type?: CoverageType, limit?: number): CoverageTrend[];
+    /**
+     * Calculate trend direction
+     */
+    getTrendDirection(trends: CoverageTrend[]): 'improving' | 'stable' | 'declining';
+    /**
+     * Predict future coverage based on trends
+     */
+    predictCoverage(key: string, type: CoverageType | undefined, targetCoverage: number): {
+        predictedReach: number | null;
+        projectedCoverage: number;
+        confidence: 'high' | 'medium' | 'low';
+    };
+    /**
+     * Generate coverage summary text
+     */
+    generateSummary(metrics: CoverageMetrics): string;
+    /**
+     * Format coverage percentage with color indicator
+     */
+    formatCoverage(percentage: number, threshold?: number): string;
+    /**
+     * Clear history
+     */
+    clearHistory(key?: string): void;
+}
+/**
+ * Create a coverage analyzer
+ */
+export declare function createCoverageAnalyzer(): CoverageAnalyzer;
+export {};