qa360 2.0.12 → 2.1.0

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

@@ -0,0 +1,6 @@
+/**
+ * QA360 Artifacts Module
+ *
+ * Manages screenshots, videos, traces, and other test artifacts
+ */
+export { UIArtifactsManager, createUIArtifactsManager, type ScreenshotOptions, type ArtifactMetadata, type StoredArtifact, type VideoArtifact, type ScreenshotArtifact, type TraceArtifact, } from './ui-artifacts.js';

package/dist/core/artifacts/index.js

@@ -0,0 +1,6 @@
+/**
+ * QA360 Artifacts Module
+ *
+ * Manages screenshots, videos, traces, and other test artifacts
+ */
+export { UIArtifactsManager, createUIArtifactsManager, } from './ui-artifacts.js';

package/dist/core/artifacts/ui-artifacts.d.ts

@@ -0,0 +1,133 @@
+/**
+ * QA360 UI Artifacts Manager
+ *
+ * Manages screenshots, videos, traces, and other test artifacts
+ * with content-addressable storage (CAS) integration
+ */
+export type ScreenshotFormat = 'png' | 'jpeg' | 'webp';
+export interface ScreenshotOptions {
+    fullPage?: boolean;
+    quality?: number;
+    type?: ScreenshotFormat;
+    animations?: 'disabled' | 'allow';
+}
+export interface ArtifactMetadata {
+    testId: string;
+    stepIndex?: number;
+    stepName?: string;
+    type: 'screenshot' | 'video' | 'trace' | 'network' | 'console' | 'coverage';
+    timestamp: string;
+    status?: 'passed' | 'failed' | 'flaky';
+    tags?: string[];
+}
+export interface StoredArtifact {
+    casPath: string;
+    localPath: string;
+    hash: string;
+    metadata: ArtifactMetadata;
+    size: number;
+    type: 'screenshot' | 'video' | 'trace' | 'network' | 'console' | 'coverage';
+}
+export interface VideoArtifact extends StoredArtifact {
+    type: 'video';
+    format: 'webm';
+    duration: number;
+}
+export interface ScreenshotArtifact extends StoredArtifact {
+    type: 'screenshot';
+    format: ScreenshotFormat;
+    width: number;
+    height: number;
+}
+export interface TraceArtifact extends StoredArtifact {
+    type: 'trace';
+    format: 'zip';
+}
+/**
+ * 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 declare class UIArtifactsManager {
+    private artifactDir;
+    private casDir;
+    private currentRunId;
+    private currentTestId?;
+    private artifacts;
+    private cas;
+    constructor(artifactDir?: string, casDir?: string);
+    private ensureDirectories;
+    /**
+     * Start a new test session
+     */
+    startTest(testId: string): void;
+    /**
+     * End current test session
+     */
+    endTest(): void;
+    /**
+     * Take a screenshot and store it
+     */
+    takeScreenshot(page: any, // Playwright Page
+    options?: ScreenshotOptions, metadata?: Partial<ArtifactMetadata>): Promise<ScreenshotArtifact>;
+    /**
+     * Take screenshot before a step
+     */
+    takeBeforeScreenshot(page: any, stepName: string, stepIndex: number): Promise<ScreenshotArtifact>;
+    /**
+     * Take screenshot after a step
+     */
+    takeAfterScreenshot(page: any, stepName: string, stepIndex: number, success: boolean): Promise<ScreenshotArtifact>;
+    /**
+     * Take screenshot on error
+     */
+    takeErrorScreenshot(page: any, error: Error, stepName?: string): Promise<ScreenshotArtifact>;
+    /**
+     * Save video artifact
+     */
+    saveVideo(videoPath: string, metadata?: Partial<ArtifactMetadata>): Promise<VideoArtifact>;
+    /**
+     * Save trace artifact
+     */
+    saveTrace(tracePath: string, metadata?: Partial<ArtifactMetadata>): Promise<TraceArtifact>;
+    /**
+     * Get artifact by ID
+     */
+    getArtifact(id: string): StoredArtifact | undefined;
+    /**
+     * Get all artifacts for current test
+     */
+    getTestArtifacts(): StoredArtifact[];
+    /**
+     * Get all artifacts by type
+     */
+    getArtifactsByType(type: StoredArtifact['type']): StoredArtifact[];
+    /**
+     * Clean up old artifacts
+     */
+    cleanup(maxAge?: number): void;
+    /**
+     * Generate CAS path from hash
+     */
+    private getCasPath;
+    /**
+     * Generate artifacts summary for reporting
+     */
+    generateSummary(): {
+        screenshots: number;
+        videos: number;
+        traces: number;
+        totalSize: number;
+        casDedupSavings: number;
+    };
+}
+/**
+ * Create a UI artifacts manager
+ */
+export declare function createUIArtifactsManager(artifactDir?: string, casDir?: string): UIArtifactsManager;

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/assertions/engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * QA360 Assertions Engine
+ *
+ * Executes assertions against Playwright Page objects
+ */
+import type { Assertion, AssertionResult, AssertionRunOptions, AssertionGroupResult } from './types.js';
+/**
+ * Assertions Engine class
+ */
+export declare class AssertionsEngine {
+    private page;
+    private defaultTimeout;
+    constructor(page: any, defaultTimeout?: number);
+    /**
+     * Run a single assertion
+     */
+    runAssertion(assertion: Assertion): Promise<AssertionResult>;
+    /**
+     * Run multiple assertions
+     */
+    runAssertions(assertions: Assertion[], options?: Partial<AssertionRunOptions>): Promise<AssertionGroupResult>;
+    private isVisible;
+    private waitForVisible;
+    private isHidden;
+    private waitForHidden;
+    private isAttached;
+    private getTextContent;
+    private getInputValue;
+    private getAttribute;
+    private hasAttribute;
+    private getClasses;
+    private getTagName;
+    private count;
+    private isEnabled;
+    private isChecked;
+    private isFocused;
+    private isReadOnly;
+    private isSelected;
+    private getCssProperty;
+    private isInViewport;
+    private getBoundingBox;
+    private compare;
+    private contains;
+    private matches;
+    private formatError;
+}
+/**
+ * Create an assertions engine
+ */
+export declare function createAssertionsEngine(page: any, timeout?: number): AssertionsEngine;
+export * from './types.js';