qa360 2.1.7 → 2.2.0

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

@@ -1,304 +0,0 @@
-/**
- * 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

@@ -1,51 +0,0 @@
-/**
- * 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';