qa360 2.1.7 → 2.2.0

package/core/src/artifacts/ui-artifacts.ts

@@ -0,0 +1,412 @@
+/**
+ * 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, dirname } from 'path';
+import { ContentAddressableStorage } from '../vault/cas.js';
+
+export type ScreenshotFormat = 'png' | 'jpeg' | 'webp';
+
+export interface ScreenshotOptions {
+  fullPage?: boolean;
+  quality?: number; // for jpeg/webp
+  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; // Path in CAS (content-addressable)
+  localPath: string; // Path for immediate access
+  hash: string; // SHA-256 hash
+  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 class UIArtifactsManager {
+  private artifactDir: string;
+  private casDir: string;
+  private currentRunId: string;
+  private currentTestId?: string;
+  private artifacts: Map<string, StoredArtifact> = new Map();
+  private cas: ContentAddressableStorage;
+
+  constructor(artifactDir: string = '.qa360/artifacts/ui', casDir: string = '.qa360/runs/cas') {
+    this.artifactDir = artifactDir;
+    this.casDir = casDir;
+    this.currentRunId = `run-${Date.now()}`;
+    this.cas = new ContentAddressableStorage(casDir);
+    this.ensureDirectories();
+  }
+
+  private ensureDirectories(): void {
+    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: string): void {
+    this.currentTestId = testId;
+  }
+
+  /**
+   * End current test session
+   */
+  endTest(): void {
+    this.currentTestId = undefined;
+  }
+
+  /**
+   * Take a screenshot and store it
+   */
+  async takeScreenshot(
+    page: any, // Playwright Page
+    options: ScreenshotOptions = {},
+    metadata?: Partial<ArtifactMetadata>
+  ): Promise<ScreenshotArtifact> {
+    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: ScreenshotArtifact = {
+      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: any, stepName: string, stepIndex: number): Promise<ScreenshotArtifact> {
+    return this.takeScreenshot(page, {}, {
+      stepIndex,
+      stepName: `${stepName}-before`,
+      tags: ['before-step'],
+    });
+  }
+
+  /**
+   * Take screenshot after a step
+   */
+  async takeAfterScreenshot(page: any, stepName: string, stepIndex: number, success: boolean): Promise<ScreenshotArtifact> {
+    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: any, error: Error, stepName?: string): Promise<ScreenshotArtifact> {
+    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: ScreenshotArtifact = {
+      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: string, metadata?: Partial<ArtifactMetadata>): Promise<VideoArtifact> {
+    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: VideoArtifact = {
+      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: string, metadata?: Partial<ArtifactMetadata>): Promise<TraceArtifact> {
+    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: TraceArtifact = {
+      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: string): StoredArtifact | undefined {
+    return this.artifacts.get(id);
+  }
+
+  /**
+   * Get all artifacts for current test
+   */
+  getTestArtifacts(): StoredArtifact[] {
+    const testId = this.currentTestId || 'unknown';
+    return Array.from(this.artifacts.values()).filter(
+      a => a.metadata.testId === testId
+    );
+  }
+
+  /**
+   * Get all artifacts by type
+   */
+  getArtifactsByType(type: StoredArtifact['type']): StoredArtifact[] {
+    return Array.from(this.artifacts.values()).filter(a => a.type === type);
+  }
+
+  /**
+   * Clean up old artifacts
+   */
+  cleanup(maxAge: number = 24 * 60 * 60 * 1000): void {
+    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
+   */
+  private getCasPath(hash: string): string {
+    // 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(): {
+    screenshots: number;
+    videos: number;
+    traces: number;
+    totalSize: number;
+    casDedupSavings: number; // Bytes saved by CAS deduplication
+  } {
+    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?: string,
+  casDir?: string
+): UIArtifactsManager {
+  return new UIArtifactsManager(artifactDir, casDir);
+}