@playq/core 0.2.77

package/src/helper/fixtures/logFixture.ts

@@ -0,0 +1,57 @@
+import { Logger, createLogger } from 'winston';
+import { options } from '../util/logger';
+import fs from 'fs';
+import path from 'path';
+
+let logger: Logger;
+
+export const logFixture = {
+  init(scenarioName: string): void {
+    logger = createLogger(options(scenarioName));
+  },
+  get(): Logger {
+    if (!logger) throw new Error("Logger not initialized!");
+    return logger;
+  },
+  setLogger(log: Logger) {
+    logger = log;
+  },
+  getLogger(): Logger {
+    return logger;
+  },
+  async attach(name: string, data: Buffer, type: string = 'application/octet-stream') {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const ext = type.includes('png') ? 'png' : type.includes('jpg') ? 'jpg' : 'txt';
+    const filename = `${timestamp}-${name.replace(/\s+/g, '_')}.${ext}`;
+    const attachmentDir = path.resolve('logs', 'attachments');
+    const filePath = path.join(attachmentDir, filename);
+
+    fs.mkdirSync(attachmentDir, { recursive: true });
+    fs.writeFileSync(filePath, data);
+
+    logger.info(`📎 Attached file: ${filePath}`);
+  }
+};
+
+
+// // src/hooks/logFixture.ts
+// import { Logger, createLogger, format, transports } from 'winston';
+
+// let logger: Logger;
+
+// export const logFixture = {
+//   init(scenarioName: string): void {
+//     logger = createLogger({
+//       level: 'info',
+//       format: format.combine(
+//         format.timestamp(),
+//         format.printf(({ timestamp, level, message }) => `[${timestamp}] ${level}: ${message}`)
+//       ),
+//       transports: [new transports.Console()]
+//     });
+//   },
+//   get(): Logger {
+//     if (!logger) throw new Error("Logger not initialized!");
+//     return logger;
+//   }
+// };

package/src/helper/fixtures/webFixture.ts

@@ -0,0 +1,206 @@
+import type { Browser, BrowserContext, Page, Frame } from "playwright";
+import { Logger } from "winston";
+import { invokeBrowser } from "../browsers/browserManager";
+// Inline runner detection to avoid external alias dependency
+function isPlaywrightRunner() { return process.env.TEST_RUNNER === 'playwright'; }
+
+
+const pages = new Map<string, Page>();
+const frames = new Map<string, Frame>();
+let currentPage: Page | undefined;
+let currentFrame: Frame | undefined;
+let logger: Logger;
+let currentPageName = "main";
+let browser: Browser;
+let context: BrowserContext;
+let _world: any = null;
+let smartIQData: any[] = [];
+
+
+export const webFixture = {
+  pages,
+  frames,
+  async launchBrowser() {
+    browser = await invokeBrowser();
+  },
+  async newContext(options?: Parameters<Browser["newContext"]>[0]) {
+    if (!options) {
+        options = {
+            recordVideo: {
+            dir: "test-results/videos",
+            },
+        };
+    }   
+    context = await browser.newContext(options);
+    return context;
+  },
+  async newPage(name = "main") {
+    const page = await context.newPage();
+    pages.set(name, page);
+    currentPage = page;
+    currentPageName = name;
+    return page;
+  },
+  getBrowser() {
+    return browser;
+  },
+  getContext() {
+    return context;
+  },
+  getCurrentPage(): Page | undefined {
+    return currentPage;
+  },
+  setCurrentPage(name: string) {
+    currentPage = pages.get(name);
+    currentPageName = name;
+  },
+  async closeContext() {
+    if (context) {
+      await context.close();
+    }
+  },
+  async closeAll() {
+    try {
+      if (context) {
+        // Close all pages explicitly
+        const allPages = context.pages();
+        for (const page of allPages) {
+          try {
+            // If tracing is on, stop and save
+            if (context.tracing && context.tracing.stop) {
+              await context.tracing.stop({ path: `test-results/trace/trace.zip` });
+            }
+            await page.close();
+          } catch (err) {
+            // Swallow errors silently
+          }
+        }
+        await context.close();
+      }
+      if (browser) {
+        await browser.close();
+      }
+    } catch (err) {
+      // Swallow errors silently
+    }
+  },
+  setWorld(world: any) {
+    _world = world;
+  },
+  getWorld(): any {
+    if (isPlaywrightRunner()) {
+      console.warn('⚠️ Skipping getWorld() in Playwright Runner');
+      return null;
+    }
+    if (!_world) {
+      throw new Error("❌ Cucumber World context not set. Did you forget to call webFixture.setWorld(this) in your step?");
+    }
+    return _world;
+  },
+  // other frame helpers remain the same
+   setPlaywrightPage(page: Page) {  // ✅ Added this method!
+    console.log('✅ Playwright page set in webFixture');
+    currentPage = page;
+  },
+  // SmartIQ Imeplementation
+  getSmartIQData(): any[] {
+    return smartIQData;
+  },
+  
+  setSmartIQData(data: any[]) {
+    smartIQData = data;
+  }
+};
+
+
+async function createContextWithDefaults(scenarioName: string): Promise<BrowserContext> {
+    const ctx = await browser.newContext({
+      recordVideo: {
+        dir: "test-results/videos",
+      },
+    });
+  
+    await ctx.tracing.start({
+      name: scenarioName,
+      title: scenarioName,
+      sources: true,
+      screenshots: true,
+      snapshots: true,
+    });
+  
+    return ctx;
+  }
+
+// import { Page, Frame } from "@playwright/test";
+// import { Logger } from "winston";
+// import { invokeBrowser } from "@helper/browsers/browserManager";
+
+
+// const pages = new Map<string, Page>();
+// const frames = new Map<string, Frame>();
+// let currentPage: Page | undefined;
+// let currentFrame: Frame | undefined;
+// let logger: Logger;
+// let currentPageName: string = "main";
+
+// export const uiFixture = {
+//     pages,
+//     frames,
+//     setPage(page: Page) {
+//         pages.set(currentPageName, page);
+//     },
+//     setPageWithName(name: string, page: Page) {
+//         pages.set(name, page);
+//         currentPage = page;
+//         currentPageName = name;
+//     },
+//     getPage(name: string): Page | undefined {
+//         return pages.get(name);
+//     },
+//     setCurrentPage(name: string) {
+//         currentPage = pages.get(name);
+//         currentPageName = name;
+//     },
+//     getCurrentPage(): Page | undefined {
+//         return currentPage;
+//     },
+//     getCurrentPageName(): string {
+//         return currentPageName;
+//     },
+//     setFrame(name: string, frame: Frame) {
+//         frames.set(name, frame);
+//         currentFrame = frame;
+//     },
+//     getFrame(name: string): Frame | undefined {
+//         return frames.get(name);
+//     },
+//     setCurrentFrame(name: string) {
+//         currentFrame = frames.get(name);
+//     },
+//     getCurrentFrame(): Frame | undefined {
+//         return currentFrame;
+//     },
+//     setLogger(log: Logger) {
+//         logger = log;
+//     },
+//     getLogger(): Logger {
+//         return logger;
+//     }
+// };
+
+
+
+
+
+
+
+
+
+// import { Page } from "@playwright/test";
+// import { Logger } from "winston";
+
+// export const fixture = {
+//     // @ts-ignore
+//     page: undefined as Page,
+//     logger: undefined as Logger
+// }

package/src/helper/fixtures/webLocFixture.ts

@@ -0,0 +1,143 @@
+// src/helper/loc/locatorResolver.ts
+import type { Page, Locator } from "playwright";
+import * as vars from "../bundle/vars";
+// Access project-provided engines dynamically at call time to avoid module init ordering issues
+function getEngines(): any { return (globalThis as any).engines || {}; }
+// import { smartAI} from "@project/engines/smartAi/smartAiEngine";
+
+
+
+
+export async function webLocResolver(
+    type: string,
+    selector: string,
+    pageArg: Page,
+    overridePattern?: string,
+    timeout?: number,
+    smartAiRefresh: 'before' | 'after' | '' = ''
+  ): Promise<Locator> {
+    console.log(`🔍 Resolving locator: ${selector}`);
+    const page = pageArg
+    const isPlaywrightPrefixed = selector.startsWith("xpath=") || selector.startsWith("xpath =") || selector.startsWith("css=") || selector.startsWith("css =");
+    if (isPlaywrightPrefixed) {
+      // const rawSelector = selector.replace(/^xpath=|^css=|^xpath =|^xpath=\\|^xpath =\\|^css =/, "");
+      // Normalize escaped forward slashes first, then remove prefix
+      const rawSelector = selector
+        .replace(/^xpath=\\|^xpath =\\/, "xpath=") // normalize `xpath=\` to `xpath=`
+        .replace(/^xpath=|^xpath =|^css=|^css =/, "") // remove the actual prefix
+        .replace(/\\\//g, "/"); // replace escaped slashes with normal ones
+      console.log("📍 Detected Playwright-prefixed selector. Returning raw locator.");
+      return page.locator(rawSelector);
+    }
+
+    const isPlaywrightChainedPrefixed = selector.startsWith("chain=") || selector.startsWith("chain =");
+    if (isPlaywrightChainedPrefixed) {
+      const rawSelector = selector.replace(/^chain=|^chain =/, "");
+      console.log("📍 Detected Playwright-prefixed chained selector. Returning raw locator.");
+      return page.locator(rawSelector);
+    }
+
+    const isXPath =
+      selector.trim().startsWith("//") || selector.trim().startsWith("(");
+    const isCSS =
+      selector.includes(">") ||
+      selector.startsWith(".") ||
+      selector.includes("#");
+    const isChained = selector.includes(">>");
+    const isResourceLocator = selector.startsWith("loc.");
+
+    if ((isXPath || isCSS || isChained) && !isResourceLocator) {
+      console.log("📍 Detected XPath/CSS/Chained. Returning locator directly.");
+      return page.locator(selector);
+    }
+
+    if (isResourceLocator) {
+      const parts = selector.split(".");
+      if (parts.length < 3) {
+        throw new Error(
+          `❌ Invalid locator format: "${selector}". Expected format: loc.(ts|json).<page>.<field>`
+        );
+      }
+
+      const [, locType, pageName, fieldName] = parts;
+        if (selector.startsWith("loc.json.")) {
+        const [, , fileName, pageName, fieldName] = selector.split(".");
+        const jsonLocatorMap = await import(
+          `@resources/locators/json/${fileName}.json`
+        );
+        const pageObj = jsonLocatorMap?.[pageName];
+        if (!pageObj)
+          throw new Error(
+            `❌ Page "${pageName}" not found in ${fileName}.json`
+          );
+        const locatorString = pageObj[fieldName];
+        if (!locatorString)
+          throw new Error(
+            `❌ Field "${fieldName}" not found in ${fileName}.json[${pageName}]`
+          );
+        console.log(
+          `🧩 Resolved locator string from loc.json.${fileName}.${pageName}.${fieldName} -> ${locatorString}`
+        );
+        return page.locator(await vars.replaceVariables(locatorString));
+      }
+
+      if (selector.startsWith("loc.ts.")) {
+        const [, , fileName, pageName, fieldName] = selector.split(".");
+        // First try globalThis.loc if available
+        const globalLoc = (globalThis as any).loc;
+        if (globalLoc?.[fileName]?.[pageName]?.[fieldName]) {
+          // console.log(`✅ Found locator in globalThis.loc for loc.ts.${fileName}.${pageName}.${fieldName}`);
+          return globalLoc[fileName][pageName][fieldName](page);
+        }
+      }
+
+      if (selector.startsWith("loc.")) {
+        const [, fileName, pageName, fieldName] = selector.split(".");
+        
+        // First try globalThis.loc if available
+        const globalLoc = (globalThis as any).loc;
+        if (globalLoc?.[fileName]?.[pageName]?.[fieldName]) {
+          // console.log(`✅ Found locator in globalThis.loc for loc.ts.${fileName}.${pageName}.${fieldName}`);
+          return globalLoc[fileName][pageName][fieldName](page);
+        }
+      }
+
+
+      throw new Error(
+        `❌ Unknown locator source type "${locType}". Use loc. or locator.`
+      );
+    }
+   if (overridePattern && overridePattern.toLowerCase() === '-no-check-') {
+      console.log("📍 '-no-check-' detected. Skipping locator resolution.");
+      return undefined as any; // or even better, throw a custom signal or null to trigger fallback
+    }
+    
+    // SmartAI (guard if engine missing)
+    const isSmartAiEnabled = String(vars.getConfigValue('smartAi.enable')).toLowerCase().trim() === 'true';
+    if (isSmartAiEnabled) {
+      const smartAiEngine = getEngines()?.smartAi;
+      if (typeof smartAiEngine === 'function') {
+        return await smartAiEngine(page, type, selector, smartAiRefresh);
+      } else {
+        console.warn('⚠️ SmartAI enabled but engines.smartAi not available/function. Falling back.');
+      }
+    }
+   
+    // Fallback to locatorPattern (locPattern)
+    const isPatternEnabled = String(vars.getConfigValue('patternIq.enable')).toLowerCase().trim() === 'true';
+    console.log('PatternIQ enabled?', isPatternEnabled);
+    if (isPatternEnabled) {
+      const eng = getEngines();
+      try { console.log('PatternIQ engines keys:', Object.keys(eng || {})); } catch {}
+      const patternEngine = eng?.patternIq || (eng && (eng as any).engines && (eng as any).engines.patternIq);
+      if (typeof patternEngine === 'function') {
+        return await patternEngine(page, type, selector, overridePattern, timeout);
+      } else {
+        console.warn('⚠️ PatternIQ enabled but engines.patternIq not available/function. Falling back to default locator.');
+      }
+    }
+
+    // Fallback to default locator
+    return page.locator(selector);
+  }
+

package/src/helper/report/allureStepLogger.ts

@@ -0,0 +1,26 @@
+// src/helper/report/allureStepLogger.ts
+// import { step, attachment, owner, issue } from 'allure-js-commons';
+// import { isCucumberRunner } from '@config/runner';
+// import { webFixture } from '@helper/fixtures/webFixture';
+
+// /**
+//  * Logs a step to Allure or attaches it in Cucumber world.
+//  * 
+//  * @param stepName Description of the step
+//  * @param stepFn Function to execute within the step
+//  */
+// export async function logStep(stepName: string, stepFn: () => Promise<void>) {
+//   if (isCucumberRunner()) {
+//     const world = webFixture.getWorld();
+//     try {
+//       await world.attach(`🟡 Step: ${stepName}`, 'text/plain');
+//       await stepFn();
+//       await world.attach(`✅ Passed: ${stepName}`, 'text/plain');
+//     } catch (err: any) {
+//       await world.attach(`❌ Failed: ${stepName} - ${err.message}`, 'text/plain');
+//       throw err;
+//     }
+//   } else {
+//     await allure.step(stepName, stepFn);
+//   }
+// }

package/src/helper/report/customiseReport.ts

@@ -0,0 +1,61 @@
+import fs from 'fs';
+
+const inputPath = 'test-results/cucumber-report.json';
+const outputPath = 'test-results/cucumber-report-custom.json';
+
+function extractReplacements(embeddings: any[]): Record<string, string> {
+  const replacements: Record<string, string> = {};
+  embeddings?.forEach(embed => {
+    const data = embed?.data;
+    const match = data?.match(/Replaced: \|\\?"(.*?)\\?"\|-with-\|(.*?)\|/);
+    if (match) {
+      const original = match[1];
+      const replaced = match[2];
+      replacements[original] = replaced;
+    }
+  });
+  return replacements;
+}
+
+function updateStepName(step: any) {
+  const replacements = extractReplacements(step.embeddings || []);
+  for (const [original, replaced] of Object.entries(replacements)) {
+    const quotedOriginal = `"${original}"`;
+    const quotedReplaced = `"${replaced}"`;
+    step.name = step.name.replace(quotedOriginal, quotedReplaced);
+  }
+}
+
+function processReport() {
+  const raw = fs.readFileSync(inputPath, 'utf-8');
+  if (!raw || !raw.trim()) {
+    console.warn("⚠️ customiseReport: Empty or invalid JSON input. Skipping processing.");
+    return;
+  }
+  const report = JSON.parse(raw);
+
+  for (const feature of report) {
+    for (const scenario of feature.elements || []) {
+      for (const step of scenario.steps || []) {
+        updateStepName(step);
+        // Check for soft assertion failures in embeddings
+        if (
+          Array.isArray(step.embeddings) &&
+          step.embeddings.some(
+            (embed) =>
+              typeof embed.data === "string" &&
+              embed.data.includes("Soft Assertion: [Failed]")
+          )
+        ) {
+          if (!step.result) step.result = {};
+          step.result.status = "failed";
+        }
+      }
+    }
+  }
+
+  fs.writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf-8');
+  console.log(`✅ Updated report written to ${outputPath}`);
+}
+
+processReport();

package/src/helper/report/init.ts

@@ -0,0 +1,18 @@
+
+const fs = require("fs-extra");
+
+try {
+    fs.ensureDirSync("test-results/screenshots");
+    fs.emptyDirSync("test-results/screenshots");
+
+    fs.ensureDirSync("test-results/videos");
+    fs.emptyDirSync("test-results/videos");
+
+    fs.ensureDirSync("test-results/trace");
+    fs.emptyDirSync("test-results/trace");
+
+    // Do NOT clean the whole test-results folder!
+    // fs.emptyDirSync("test-results");
+} catch (error) {
+    console.log("⚠️ Folder setup failed! " + error);
+}

package/src/helper/report/report.ts

@@ -0,0 +1,72 @@
+const report = require("multiple-cucumber-html-reporter");
+import * as fs from "fs";
+import * as os from "os";
+
+
+const jsonPath = "test-results/cucumber-report.json";
+if (!fs.existsSync(jsonPath)) {
+  console.warn("⚠️ cucumber-report.json not found.");
+  const files = fs.readdirSync("test-results");
+  console.warn("📁 test-results folder contains:", files);
+} else {
+  // 💡 Load JSON, patch paths, save back
+  const raw = fs.readFileSync(jsonPath, "utf-8");
+  const data = JSON.parse(raw);
+  data.forEach((feature: any) => {
+    if (feature.uri?.startsWith("_TEMP/execution/")) {
+      feature.uri = feature.uri.replace("_TEMP/execution/", "");
+    }
+  });
+  fs.writeFileSync(jsonPath, JSON.stringify(data, null, 2)); // Save the cleaned version
+}
+
+// Removing "_TEMP/execution/" from cucumber-report.html
+const htmlReportPath = "test-results/cucumber-report.html";
+if (fs.existsSync(htmlReportPath)) {
+  let html = fs.readFileSync(htmlReportPath, "utf-8");
+  // Use split/join for wide Node compatibility (avoid String.replaceAll requirement)
+  const updatedHtml = html.split("_TEMP/execution/").join("");
+
+  fs.writeFileSync(htmlReportPath, updatedHtml, "utf-8");
+  console.log("🧼 Cleaned cucumber-report.html by removing '_TEMP/execution/'");
+} else {
+  console.warn("⚠️ cucumber-report.html not found.");
+}
+
+if (fs.existsSync(jsonPath)) {
+  fs.unlinkSync(jsonPath);
+  console.log(`🗑️ Removed existing ${jsonPath}`);
+}
+
+
+// Fetching the system details
+const platformName = os.platform(); 
+const platformVersion = os.release();
+const deviceName = os.hostname(); 
+
+report.generate({
+  jsonDir: "test-results",
+  reportPath: "test-results/reports/",
+  reportName: "Playwright Automation Report",
+  pageTitle: "BookCart App test report",
+  displayDuration: false,
+  metadata: {
+    browser: {
+      name: "chrome",
+      version: "112",
+    },
+    device: deviceName,
+    platform: {
+      name: platformName,
+      version: platformVersion,
+    },
+  },
+  customData: {
+    title: "Test Info",
+    data: [
+      { label: "Project", value: "Book Cart Application" },
+      { label: "Release", value: "1.2.3" },
+      { label: "Cycle", value: "Smoke-1" },
+    ],
+  },
+});

package/src/helper/util/dataLoader.ts

@@ -0,0 +1,42 @@
+
+import fs from 'fs';
+import path from 'path';
+import * as XLSX from '@e965/xlsx';
+
+type DataFormat = 'json' | 'excel' | 'csv';
+
+/**
+ * Reads test data from .json, .xlsx, or .csv
+ *
+ * @param file - Filename (without extension), e.g., "login"
+ * @param format - File format: "json" | "excel" | "csv"
+ * @param sheetName - (optional) Sheet name for Excel files
+ */
+export function getTestData(file: string, format: DataFormat = 'json', sheetName?: string): any[] {
+  const basePath = path.resolve(`resources/test-data`);
+
+  switch (format) {
+    case 'json': {
+      const jsonPath = path.join(basePath, `${file}.json`);
+      const raw = fs.readFileSync(jsonPath, 'utf-8');
+      return JSON.parse(raw);
+    }
+
+    case 'excel': {
+      const xlsxPath = path.join(basePath, `${file}.xlsx`);
+      const workbook = XLSX.readFile(xlsxPath);
+      const sheet = workbook.Sheets[sheetName || workbook.SheetNames[0]];
+      return XLSX.utils.sheet_to_json(sheet);
+    }
+
+    case 'csv': {
+      const csvPath = path.join(basePath, `${file}.csv`);
+      const fileData = fs.readFileSync(csvPath, 'utf-8');
+      const worksheet = XLSX.read(fileData, { type: 'string' }).Sheets['Sheet1'];
+      return XLSX.utils.sheet_to_json(worksheet);
+    }
+
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}

package/src/helper/util/logger.ts

@@ -0,0 +1,32 @@
+import { transports, format } from "winston";
+import * as fs from "fs";
+import * as path from "path";
+
+// ✅ Replace invalid characters for Windows file/folder names
+function sanitiseFileName(name: string): string {
+    return name.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').slice(0, 100);
+}
+
+export function options(scenarioName: string) {
+    const sanitised = sanitiseFileName(scenarioName);
+    const logDir = path.join("test-results", "logs", sanitised);
+
+    // ✅ Ensure directory exists
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    return {
+        transports: [
+            new transports.File({
+                filename: path.join(logDir, "log.log"),
+                level: 'info',
+                format: format.combine(
+                    format.timestamp({ format: 'MMM-DD-YYYY HH:mm:ss' }),
+                    format.align(),
+                    format.printf(info => `${info.level}: ${[info.timestamp]}: ${info.message}`)
+                )
+            }),
+        ]
+    }
+};