playwright-cucumber-ts-steps 1.0.0 → 1.0.2

package/src/assertions/visualSteps.ts

@@ -1,275 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Then } from "@cucumber/cucumber";
-import { expect } from "@playwright/test";
-import pixelmatch from "pixelmatch"; // Ensure pixelmatch is installed: npm install pixelmatch
-import { PNG } from "pngjs"; // Ensure pngjs is installed: npm install pngjs
-import type { CustomWorld } from "../helpers/world"; // Assuming this path is correct
-
-// --- Configuration for Snapshot Directories ---
-// It's good practice to make these configurable (e.g., via world.config or env variables)
-// For now, keeping them as resolved constants as per your original code.
-const SNAPSHOTS_BASE_DIR = path.resolve("e2e/snapshots"); // Base directory for all snapshots
-const BASELINE_DIR = path.join(SNAPSHOTS_BASE_DIR, "baseline");
-const CURRENT_DIR = path.join(SNAPSHOTS_BASE_DIR, "current");
-const DIFF_DIR = path.join(SNAPSHOTS_BASE_DIR, "diff");
-
-// Helper function to generate standardized snapshot paths
-function getSnapshotPaths(name: string) {
-  // Sanitize the name for use in filenames
-  const safeName = name.replace(/[^a-z0-9]/gi, "_").toLowerCase();
-  return {
-    baseline: path.join(BASELINE_DIR, `${safeName}.png`),
-    current: path.join(CURRENT_DIR, `${safeName}.png`),
-    diff: path.join(DIFF_DIR, `${safeName}.diff.png`),
-  };
-}
-
-// Helper to ensure all necessary directories exist
-function ensureSnapshotDirs() {
-  fs.mkdirSync(BASELINE_DIR, { recursive: true });
-  fs.mkdirSync(CURRENT_DIR, { recursive: true });
-  fs.mkdirSync(DIFF_DIR, { recursive: true });
-}
-
-// ===================================================================================
-// VISUAL REGRESSION ASSERTIONS: PAGE SNAPSHOTS
-// ===================================================================================
-
-/**
- * Asserts that the current page's visual appearance matches a named baseline snapshot.
- * If no baseline exists for the given name, a new one is created from the current page.
- * Differences between current and baseline snapshots are highlighted in a 'diff' image.
- *
- * ```gherkin
- * Then I should see the page matches the snapshot {string}
- * ```
- *
- * @param name - A unique name for the snapshot (e.g., "homepage", "product-details-page").
- *
- * @example
- * Then I should see the page matches the snapshot "homepage"
- *
- * @remarks
- * This is a core step for visual regression testing.
- * 1. Takes a screenshot of the current page and saves it to the `current` directory.
- * 2. If a `baseline` snapshot does not exist, the `current` snapshot is copied to `baseline`,
- * and the test passes (a new baseline is established).
- * 3. If a `baseline` exists, it compares the `current` and `baseline` snapshots pixel by pixel
- * using `pixelmatch`.
- * 4. If a mismatch is detected (more than 0 differing pixels based on `threshold`), a `diff`
- * image is generated, and the test fails.
- *
- * All snapshots (baseline, current, diff) are stored in `e2e/snapshots/`.
- * Adjust `threshold` for sensitivity (0.1 means 10% difference in pixel color is allowed).
- * @category Visual Regression Steps
- */
-export async function Then_I_should_see_page_matches_snapshot(this: CustomWorld, name: string) {
-  const { page } = this;
-  const paths = getSnapshotPaths(name);
-
-  ensureSnapshotDirs(); // Ensure directories exist before taking screenshot
-
-  // Take current screenshot
-  await page.screenshot({ path: paths.current, fullPage: true });
-  this.log?.(`📸 Captured current snapshot: "${paths.current}".`);
-
-  if (!fs.existsSync(paths.baseline)) {
-    // If no baseline exists, create one from the current screenshot
-    fs.copyFileSync(paths.current, paths.baseline);
-    this.log?.(`✨ Created new baseline snapshot: "${paths.baseline}".`);
-    return; // Pass the test if a new baseline was created
-  }
-
-  // Load baseline and current images for comparison
-  const baselineImg = PNG.sync.read(fs.readFileSync(paths.baseline));
-  const currentImg = PNG.sync.read(fs.readFileSync(paths.current));
-
-  // Ensure images have the same dimensions for comparison
-  if (baselineImg.width !== currentImg.width || baselineImg.height !== currentImg.height) {
-    fs.writeFileSync(
-      paths.diff,
-      PNG.sync.write(
-        new PNG({
-          width: Math.max(baselineImg.width, currentImg.width),
-          height: Math.max(baselineImg.height, currentImg.height),
-        })
-      )
-    );
-    throw new Error(
-      `Visual snapshot mismatch for "${name}": Dimensions differ! ` +
-        `Baseline: ${baselineImg.width}x${baselineImg.height}, Current: ${currentImg.width}x${currentImg.height}. ` +
-        `Diff image generated at "${paths.diff}".`
-    );
-  }
-
-  const { width, height } = baselineImg;
-  const diffImg = new PNG({ width, height });
-
-  // Compare images pixel by pixel
-  const pixelDiff = pixelmatch(
-    baselineImg.data,
-    currentImg.data,
-    diffImg.data,
-    width,
-    height,
-    { threshold: 0.1 } // Adjust threshold for sensitivity (0.1 means 10% difference in pixel color is allowed)
-  );
-
-  if (pixelDiff > 0) {
-    // If differences found, write the diff image
-    fs.writeFileSync(paths.diff, PNG.sync.write(diffImg));
-    this.log?.(
-      `❌ Visual mismatch detected for "${name}". ${pixelDiff} pixels differ. Diff image: "${paths.diff}".`
-    );
-  }
-
-  // Assert that no pixels differ
-  expect(pixelDiff, `Visual snapshot "${name}" mismatch: ${pixelDiff} pixels differ.`).toBe(0);
-  this.log?.(`✅ Visual snapshot "${name}" matches baseline (0 pixels differ).`);
-}
-Then(
-  "I should see the page matches the snapshot {string}",
-  Then_I_should_see_page_matches_snapshot
-);
-
-// ===================================================================================
-// VISUAL REGRESSION: ELEMENT SNAPSHOT CAPTURE & MATCH
-// ===================================================================================
-
-/**
- * Captures a visual snapshot of a specific element identified by its selector and saves it under a given alias.
- * This snapshot is saved to the `current` directory and can later be compared against a baseline.
- *
- * ```gherkin
- * Then I capture a snapshot of the element {string} as {string}
- * ```
- *
- * @param selector - The CSS selector of the element to capture.
- * @param alias - A unique alias name for this element snapshot (e.g., "logo-image", "product-card").
- *
- * @example
- * Then I capture a snapshot of the element ".header .logo" as "logo-snapshot"
- * Then I capture a snapshot of the element "#user-profile" as "user-profile-widget"
- *
- * @remarks
- * This step is typically followed by {@link Then_the_snapshot_should_match_baseline | "Then the snapshot {string} should match baseline"}
- * to perform the actual visual comparison.
- * @category Visual Regression Steps
- */
-export async function Then_I_capture_element_snapshot_as_alias(
-  this: CustomWorld,
-  selector: string,
-  alias: string
-) {
-  const elementLocator = this.getScope().locator(selector);
-  ensureSnapshotDirs(); // Ensure directories exist
-  const pathCurrent = path.join(CURRENT_DIR, `${alias}.png`);
-
-  await elementLocator.screenshot({ path: pathCurrent });
-  this.log?.(`📸 Captured snapshot of element "${selector}" saved as "${alias}".`);
-}
-Then(
-  "I capture a snapshot of the element {string} as {string}",
-  Then_I_capture_element_snapshot_as_alias
-);
-
-/**
- * Asserts that a previously captured named snapshot (of an element) matches its baseline.
- * If no baseline exists, a new one is created from the current snapshot.
- *
- * ```gherkin
- * Then The snapshot {string} should match baseline
- * ```
- *
- * @param alias - The unique alias name of the snapshot (as used in "Then I capture a snapshot...").
- *
- * @example
- * Then I capture a snapshot of the element ".logo" as "logo-snapshot"
- * Then The snapshot "logo-snapshot" should match baseline
- *
- * @remarks
- * This step is designed to be used after a step like
- * {@link Then_I_capture_element_snapshot_as_alias | "Then I capture a snapshot of the element {string} as {string}"}.
- * It performs the same comparison logic as `Then I should see the page matches the snapshot`,
- * but specifically for an element snapshot.
- * All snapshots (baseline, current, diff) are stored in `e2e/snapshots/`.
- * @category Visual Regression Steps
- */
-export async function Then_the_snapshot_should_match_baseline(this: CustomWorld, alias: string) {
-  const paths = getSnapshotPaths(alias); // Get paths for baseline, current, diff based on alias
-
-  ensureSnapshotDirs(); // Ensure directories exist
-
-  // Check if the current snapshot file actually exists.
-  // This is crucial because `Then I capture a snapshot` must have been run first.
-  if (!fs.existsSync(paths.current)) {
-    throw new Error(
-      `Current snapshot file for alias "${alias}" not found at "${paths.current}".` +
-        `Ensure "Then I capture a snapshot of the element {string} as {string}" was run successfully before this step.`
-    );
-  }
-
-  // Load current image
-  const currentImg = PNG.sync.read(fs.readFileSync(paths.current));
-
-  let baselineImg: PNG | null = null;
-  if (fs.existsSync(paths.baseline)) {
-    // Load baseline image if it exists
-    baselineImg = PNG.sync.read(fs.readFileSync(paths.baseline));
-  }
-
-  if (!baselineImg) {
-    // If no baseline exists, create one from the current snapshot
-    fs.copyFileSync(paths.current, paths.baseline);
-    this.log?.(`✨ Created new baseline for snapshot "${alias}": "${paths.baseline}".`);
-    return; // Pass the test if a new baseline was created
-  }
-
-  // Ensure images have the same dimensions for comparison
-  if (baselineImg.width !== currentImg.width || baselineImg.height !== currentImg.height) {
-    fs.writeFileSync(
-      paths.diff,
-      PNG.sync.write(
-        new PNG({
-          width: Math.max(baselineImg.width, currentImg.width),
-          height: Math.max(baselineImg.height, currentImg.height),
-        })
-      )
-    );
-    throw new Error(
-      `Visual element snapshot mismatch for "${alias}": Dimensions differ! ` +
-        `Baseline: ${baselineImg.width}x${baselineImg.height}, Current: ${currentImg.width}x${currentImg.height}. ` +
-        `Diff image generated at "${paths.diff}".`
-    );
-  }
-
-  const { width, height } = baselineImg;
-  const diffImg = new PNG({ width, height });
-
-  // Compare images pixel by pixel
-  const pixelDiff = pixelmatch(
-    baselineImg.data,
-    currentImg.data,
-    diffImg.data,
-    width,
-    height,
-    { threshold: 0.1 } // Consistent threshold
-  );
-
-  if (pixelDiff > 0) {
-    // If differences found, write the diff image
-    fs.writeFileSync(paths.diff, PNG.sync.write(diffImg));
-    this.log?.(
-      `❌ Visual mismatch detected for snapshot "${alias}". ${pixelDiff} pixels differ. Diff image: "${paths.diff}".`
-    );
-  }
-
-  // Assert that no pixels differ
-  expect(
-    pixelDiff,
-    `Visual element snapshot "${alias}" mismatch: ${pixelDiff} pixels differ.`
-  ).toBe(0);
-  this.log?.(`✅ Visual element snapshot "${alias}" matches baseline (0 pixels differ).`);
-}
-Then("The snapshot {string} should match baseline", Then_the_snapshot_should_match_baseline);

package/src/custom_setups/loginHooks.ts

@@ -1,154 +0,0 @@
-import fs from "fs";
-import { When } from "@cucumber/cucumber";
-import { resolveSessionPath } from "../helpers/utils/resolveUtils";
-import { CustomWorld } from "../helpers/world";
-
-// Step 1: Check and load existing session if valid
-When(
-  "I login with a session data {string}",
-  async function (this: CustomWorld, sessionName: string) {
-    const sessionPath = resolveSessionPath(this, sessionName);
-    this.data.sessionFile = sessionPath;
-
-    if (fs.existsSync(sessionPath)) {
-      try {
-        await this.context?.addCookies(
-          JSON.parse(fs.readFileSync(sessionPath, "utf-8")).cookies || []
-        );
-        this.log?.(`✅ Loaded session from ${sessionPath}`);
-      } catch (err) {
-        this.log?.(`⚠️ Failed to apply session: ${(err as Error).message}`);
-      }
-    } else {
-      this.log?.(`⚠️ Session file not found: ${sessionPath}`);
-    }
-  }
-);
-
-/**
- * @step
- * @description Saves the current browser context (cookies, localStorage, sessionStorage) as a session file.
- * @example
- * When I save session as "my-session"
- */
-When(/^I save session as "([^"]+)"$/, async function (this: CustomWorld, sessionName: string) {
-  const sessionPath = resolveSessionPath(this, sessionName);
-
-  const cookies = await this.context.cookies();
-
-  const [localStorageData, sessionStorageData]: [
-    { origin: string; values: [string, string][] }[],
-    { origin: string; values: [string, string][] }[],
-  ] = await this.page.evaluate(() => {
-    const toPairs = (store: Storage): [string, string][] => Object.entries(store);
-
-    return [
-      [{ origin: location.origin, values: toPairs(localStorage) }],
-      [{ origin: location.origin, values: toPairs(sessionStorage) }],
-    ];
-  });
-
-  const sessionData = {
-    cookies,
-    localStorage: localStorageData,
-    sessionStorage: sessionStorageData,
-  };
-
-  try {
-    fs.writeFileSync(sessionPath, JSON.stringify(sessionData, null, 2));
-    this.log?.(`💾 Saved session as "${sessionName}"`);
-  } catch (err) {
-    this.log?.(`❌ Failed to save session "${sessionName}": ${(err as Error).message}`);
-  }
-});
-
-/**
- * @step
- * @description Removes a session file with the given name.
- * @example
- * When I clear session "my-session"
- */
-When("I clear session {string}", function (this: CustomWorld, sessionName: string) {
-  const sessionPath = resolveSessionPath(this, sessionName);
-  if (fs.existsSync(sessionPath)) {
-    fs.unlinkSync(sessionPath);
-    this.log?.(`🧹 Cleared session: ${sessionPath}`);
-  } else {
-    this.log?.(`⚠️ Session not found: ${sessionPath}`);
-  }
-});
-
-/**
- * @step
- * @description Restores cookies, localStorage, and sessionStorage from a session file. Optionally reloads the page.
- * @example
- * When I restore session cookies "my-session"
- * When I restore session cookies "my-session" with reload "false"
- */
-When(
-  /^I restore session cookies "([^"]+)"(?: with reload "(true|false)")?$/,
-  async function (this: CustomWorld, sessionName: string, reload = "true") {
-    const sessionPath = resolveSessionPath(this, sessionName);
-
-    if (!fs.existsSync(sessionPath)) {
-      this.log?.(`❌ Session file not found: ${sessionPath}`);
-      return;
-    }
-
-    const sessionData = JSON.parse(fs.readFileSync(sessionPath, "utf-8"));
-    const { cookies = [], localStorage = [], sessionStorage = [] } = sessionData;
-
-    try {
-      // Clear & set cookies
-      if (cookies.length) {
-        const existing = await this.context.cookies();
-        if (existing.length) await this.context.clearCookies();
-        await this.context.addCookies(cookies);
-        this.log?.(`🍪 Cookies restored from "${sessionName}"`);
-      }
-
-      // Apply storage into page context
-      await this.page.goto("about:blank");
-
-      if (localStorage.length > 0) {
-        for (const entry of localStorage) {
-          await this.page.addInitScript(
-            ([origin, values]) => {
-              if (window.origin === origin) {
-                for (const [key, val] of values) {
-                  localStorage.setItem(key, val);
-                }
-              }
-            },
-            [entry.origin, entry.values]
-          );
-        }
-        this.log?.("📦 localStorage restored");
-      }
-
-      if (sessionStorage.length > 0) {
-        for (const entry of sessionStorage) {
-          await this.page.addInitScript(
-            ([origin, values]) => {
-              if (window.origin === origin) {
-                for (const [key, val] of values) {
-                  sessionStorage.setItem(key, val);
-                }
-              }
-            },
-            [entry.origin, entry.values]
-          );
-        }
-        this.log?.("🗄️ sessionStorage restored");
-      }
-
-      // Final reload to apply context if requested
-      if (reload !== "false") {
-        await this.page.reload();
-        this.log?.("🔄 Page reloaded to apply restored session");
-      }
-    } catch (err) {
-      this.log?.(`❌ Error restoring session: ${(err as Error).message}`);
-    }
-  }
-);

package/src/helpers/checkPeerDeps.ts

@@ -1,19 +0,0 @@
-export function checkPeerDependencies(dependencies: string[]) {
-  const missing: string[] = [];
-
-  for (const dep of dependencies) {
-    try {
-      require.resolve(dep);
-    } catch {
-      missing.push(dep);
-    }
-  }
-
-  if (missing.length) {
-    console.warn(
-      `\n❌ Missing peer dependencies: ${missing.join(", ")}` +
-        `\nPlease install them in your project:\n\n` +
-        `npm install --save-dev ${missing.join(" ")}\n`
-    );
-  }
-}

package/src/helpers/compareSnapshots.ts

@@ -1,35 +0,0 @@
-import fs from "fs";
-import pixelmatch from "pixelmatch";
-import { PNG } from "pngjs";
-
-export function compareSnapshots({
-  actualPath,
-  baselinePath,
-  diffPath,
-  threshold = 0.1,
-}: {
-  actualPath: string;
-  baselinePath: string;
-  diffPath: string;
-  threshold?: number;
-}): number {
-  const actual = PNG.sync.read(fs.readFileSync(actualPath));
-  const baseline = PNG.sync.read(fs.readFileSync(baselinePath));
-
-  if (actual.width !== baseline.width || actual.height !== baseline.height) {
-    throw new Error("Snapshot size mismatch");
-  }
-
-  const diff = new PNG({ width: actual.width, height: actual.height });
-  const numDiffPixels = pixelmatch(
-    actual.data,
-    baseline.data,
-    diff.data,
-    actual.width,
-    actual.height,
-    { threshold }
-  );
-
-  fs.writeFileSync(diffPath, PNG.sync.write(diff));
-  return numDiffPixels;
-}

package/src/helpers/hooks.ts

@@ -1,212 +0,0 @@
-import fs from "fs";
-import path from "path";
-import {
-  Before,
-  After,
-  BeforeAll,
-  AfterAll,
-  ITestCaseHookParameter,
-  setDefaultTimeout,
-} from "@cucumber/cucumber";
-import * as dotenv from "dotenv";
-import { chromium, devices, Browser, BrowserContextOptions } from "playwright";
-import { compareSnapshots } from "./compareSnapshots";
-import { CustomWorld } from "./world";
-
-// Set to 30 seconds
-setDefaultTimeout(30 * 1000);
-dotenv.config();
-
-let sharedBrowser: Browser;
-
-BeforeAll(async () => {
-  sharedBrowser = await chromium.launch({
-    headless: process.env.HEADLESS !== "false",
-  });
-  console.log("🚀 Launched shared browser for all scenarios");
-});
-
-AfterAll(async () => {
-  await sharedBrowser?.close();
-  console.log("🧹 Closed shared browser after all scenarios");
-});
-
-Before(async function (this: CustomWorld, scenario: ITestCaseHookParameter) {
-  const params = this.parameters || {};
-  const ARTIFACT_DIR = params.artifactDir || process.env.TEST_ARTIFACT_DIR || "test-artifacts";
-  const SCREENSHOT_DIR = path.resolve(ARTIFACT_DIR, "screenshots");
-  const VIDEO_DIR = path.resolve(ARTIFACT_DIR, "videos");
-  const TRACE_DIR = path.resolve(ARTIFACT_DIR, "traces");
-  const SESSION_FILE = path.resolve(ARTIFACT_DIR, "auth-cookies", "session.json");
-
-  this.data.artifactDir = ARTIFACT_DIR;
-  this.data.screenshotDir = SCREENSHOT_DIR;
-  this.data.videoDir = VIDEO_DIR;
-  this.data.traceDir = TRACE_DIR;
-  this.data.sessionFile = SESSION_FILE;
-
-  // Modes: "false" | "fail" | "all"
-  const traceMode = (params.enableTrace || process.env.ENABLE_TRACE || "false").toLowerCase();
-  const screenshotMode = (
-    params.enableScreenshots ||
-    process.env.ENABLE_SCREENSHOTS ||
-    "false"
-  ).toLowerCase();
-  const videoMode = (params.enableVideos || process.env.ENABLE_VIDEOS || "false").toLowerCase();
-
-  this.data.traceMode = traceMode;
-  this.data.screenshotMode = screenshotMode;
-  this.data.videoMode = videoMode;
-
-  const isMobileTag = scenario.pickle.tags.some((t) => t.name === "@mobile");
-  const deviceName =
-    params.device || process.env.MOBILE_DEVICE || (isMobileTag ? "iPhone 13 Pro" : null);
-  const deviceSettings = deviceName ? devices[deviceName] : undefined;
-
-  if (deviceName && !deviceSettings) {
-    throw new Error(`🚫 Invalid MOBILE_DEVICE: "${deviceName}" is not recognized by Playwright.`);
-  }
-
-  const isVisualTest =
-    params.enableVisualTest ??
-    (process.env.ENABLE_VISUAL_TEST === "true" ||
-      scenario.pickle.tags.some((t) => t.name === "@visual"));
-
-  this.data.enableVisualTest = isVisualTest;
-  if (isVisualTest) process.env.VISUAL_TEST = "true";
-
-  const contextOptions: BrowserContextOptions = {
-    ...(videoMode !== "false" ? { recordVideo: { dir: VIDEO_DIR } } : {}),
-    ...(deviceSettings || {}),
-  };
-
-  if (fs.existsSync(SESSION_FILE)) {
-    contextOptions.storageState = SESSION_FILE;
-    this.log?.("✅ Reusing session from saved file.");
-  }
-
-  const context = await sharedBrowser.newContext(contextOptions);
-  const page = await context.newPage();
-
-  this.browser = sharedBrowser;
-  this.context = context;
-  this.page = page;
-
-  if (traceMode !== "false") {
-    await context.tracing.start({
-      screenshots: true,
-      snapshots: true,
-      sources: true,
-    });
-    this.data.tracingStarted = true;
-    this.log?.(`🧪 Tracing started (${traceMode})`);
-  }
-
-  if (deviceName) this.log?.(`📱 Mobile emulation enabled (${deviceName})`);
-});
-
-After(async function (this: CustomWorld, scenario: ITestCaseHookParameter) {
-  const name = scenario.pickle.name.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
-  const failed = scenario.result?.status === "FAILED";
-  const mode = (value: string | undefined) => value?.toLowerCase();
-
-  const screenshotMode = mode(this.parameters?.enableScreenshots || process.env.ENABLE_SCREENSHOTS);
-  const videoMode = mode(this.parameters?.enableVideos || process.env.ENABLE_VIDEOS);
-  const traceMode = mode(this.parameters?.enableTrace || process.env.ENABLE_TRACE);
-
-  const shouldSaveScreenshot = screenshotMode === "all" || (screenshotMode === "fail" && failed);
-  const shouldSaveVideo = videoMode === "all" || (videoMode === "fail" && failed);
-  const shouldSaveTrace = traceMode === "all" || (traceMode === "fail" && failed);
-
-  // 📸 Screenshot
-  if (shouldSaveScreenshot && this.page) {
-    const screenshotPath = path.join(
-      this.data.screenshotDir,
-      `${failed ? "failed-" : ""}${name}.png`
-    );
-    try {
-      fs.mkdirSync(this.data.screenshotDir, { recursive: true });
-      await this.page.screenshot({ path: screenshotPath, fullPage: true });
-      console.log(`🖼️ Screenshot saved: ${screenshotPath}`);
-    } catch (err) {
-      console.warn("❌ Failed to save screenshot:", err);
-    }
-  }
-
-  // 🎥 Video
-  if (this.page && videoMode !== "false") {
-    try {
-      const video = this.page.video();
-      if (video) {
-        const rawPath = await video.path();
-        if (fs.existsSync(rawPath)) {
-          const finalPath = path.join(this.data.videoDir, `${failed ? "failed-" : ""}${name}.webm`);
-          fs.mkdirSync(this.data.videoDir, { recursive: true });
-          shouldSaveVideo ? fs.renameSync(rawPath, finalPath) : fs.unlinkSync(rawPath);
-          console.log(`${shouldSaveVideo ? "🎥 Video saved" : "🧹 Deleted video"}: ${finalPath}`);
-        }
-      }
-    } catch (err) {
-      console.warn(`⚠️ Video error: ${(err as Error).message}`);
-    }
-  }
-
-  // 🧪 Tracing
-  if (this.context && this.data.tracingStarted) {
-    const tracePath = path.join(this.data.artifactDir, "traces", `${name}.zip`);
-    try {
-      fs.mkdirSync(path.dirname(tracePath), { recursive: true });
-      await this.context.tracing.stop({ path: tracePath });
-      shouldSaveTrace
-        ? console.log(`📦 Trace saved: ${tracePath}`)
-        : (fs.existsSync(tracePath) && fs.unlinkSync(tracePath),
-          console.log(`🧹 Trace discarded: ${tracePath}`));
-    } catch (err) {
-      console.warn("❌ Trace handling error:", err);
-    }
-  }
-
-  // 🧪 Visual regression
-  if (this.page && this.data.enableVisualTest) {
-    const BASELINE_DIR = path.resolve(this.data.artifactDir, "snapshots/baseline");
-    const DIFF_DIR = path.resolve(this.data.artifactDir, "snapshots/diff");
-
-    fs.mkdirSync(BASELINE_DIR, { recursive: true });
-    fs.mkdirSync(DIFF_DIR, { recursive: true });
-
-    const baselinePath = path.join(BASELINE_DIR, `${name}.png`);
-    const actualPath = path.join(DIFF_DIR, `${name}.actual.png`);
-    const diffPath = path.join(DIFF_DIR, `${name}.diff.png`);
-
-    await this.page.screenshot({ path: actualPath, fullPage: true });
-
-    if (!fs.existsSync(baselinePath)) {
-      fs.copyFileSync(actualPath, baselinePath);
-      console.log(`📸 Created baseline image: ${baselinePath}`);
-    } else {
-      try {
-        const diffPixels = compareSnapshots({
-          actualPath,
-          baselinePath,
-          diffPath,
-          threshold: 0.1,
-        });
-
-        console.log(
-          diffPixels > 0
-            ? `⚠️ Visual diff found (${diffPixels} pixels): ${diffPath}`
-            : "✅ No visual changes detected"
-        );
-      } catch (err) {
-        console.warn("❌ Snapshot comparison failed:", err);
-      }
-    }
-  }
-
-  // Cleanup
-  try {
-    await this.cleanup(scenario);
-  } catch (err) {
-    this.log?.("❌ Error during cleanup: " + (err as Error).message);
-  }
-});