pw-automation-framework 2.0.1

package/src/core/PlaywrightEngine.ts

@@ -0,0 +1,371 @@
+// import { ActionResponse, ParsedStep, TestCaseConfig } from "../types/types";
+// import { ActionRegistry } from "./registry/ActionRegistry";
+// import { BrowserManager } from "./BrowserManager";
+// import { InputHandler } from "./handlers/InputHandler";
+// import { ClickHandler } from "./handlers/ClickHandler";
+// import { DropdownHandler } from "./handlers/DropdownHandler";
+// import { CustomCodeHandler } from "./handlers/CustomCodeHandler";
+// import { AssertionHandler, WaitHandler, KeyboardHandler, CheckboxHandler, TableHandler } from "./handlers/AllHandlers";
+// import { Logger } from "../utils/logger";
+
+// export class PlaywrightEngine {
+//   private browserManager: BrowserManager;
+//   private registry:       ActionRegistry;
+//   private tConfig:        TestCaseConfig;
+//   private log:            Logger;
+
+//   constructor(tConfig: TestCaseConfig) {
+//     this.tConfig        = tConfig;
+//     this.browserManager = new BrowserManager(tConfig);
+//     this.registry       = new ActionRegistry();
+//     this.log            = Logger.create("PlaywrightEngine", tConfig.executionId);
+//     this.registerBrowserActions();
+//   }
+
+//   // ─── Script Parser ─────────────────────────────────────────────────────────
+//   parsedStepScript(script: string | undefined | null): ParsedStep | null {
+//     // ✅ Guard: must be a non-empty string — no crash on undefined
+//     if (!script || typeof script !== "string" || !script.trim()) return null;
+
+//     const match = script.match(/tSetup\.(\w+)\(([\s\S]*)\)/i);
+//     if (!match) return null;
+
+//     const action = match[1];
+//     const args: string[] = [];
+//     const rx    = /'((?:[^'\\]|\\.)*)'/g;
+//     let   m: RegExpExecArray | null;
+//     while ((m = rx.exec(match[2])) !== null) {
+//       args.push(m[1].replace(/\\'/g, "'"));
+//     }
+//     return { action, args };
+//   }
+
+//   async execute(script: string | undefined | null,label:string | undefined | null): Promise<ActionResponse | undefined> {
+//     // ✅ Guard: missing step_script — actionable error instead of crash
+//     if (!script || typeof script !== "string" || !script.trim()) {
+//       const msg =
+//         "step_script is missing or empty. " +
+//         "Your steps contain only step_name and value — they are RAW database objects. " +
+//         "You must call prepareSteps(scriptUid) in your main app BEFORE sending to the framework. " +
+//         "prepareSteps() resolves obj_uid → locator → step_script for each step.";
+//       this.log.error(msg);
+//       return { status: "Fail", comments: msg };
+//     }
+
+//     const parsed = this.parsedStepScript(script);
+//     if (!parsed) {
+//       this.log.error(`Cannot parse: "${script}"`);
+//       return {
+//         status:   "Fail",
+//         comments: `Invalid script format: "${script}". Expected: tSetup.actionName('arg1', ...)`,
+//       };
+//     }
+
+//     this.log.info(`→ ${parsed.action}(${parsed.args.join(", ")})`);
+    
+//     const result = await this.registry.execute(parsed.action, parsed.args, label ?? undefined);
+
+//     if (!result) {
+//       return {
+//         status:   "Fail",
+//         comments: `Unknown action: "${parsed.action}". Call GET /api/actions to list all available actions.`,
+//       };
+//     }
+//     return result;
+//   }
+
+//   private registerBrowserActions(): void {
+//     const bm = this.browserManager;
+//     this.registry.register({
+//       getActions: () => ({
+//         openbrowser:            async (a) => {
+//           const result = await bm.openBrowser(a[0] || "chromium");
+//           if (result.status === "Pass") this.registerPageHandlers();
+//           return result;
+//         },
+//         closebrowser:           ()  => bm.closeBrowser(),
+//         navigatetourl:          (a) => bm.navigateToURL(a[0]),
+//         navigateback:           ()  => bm.navigateBack(),
+//         navigateforward:        ()  => bm.navigateForward(),
+//         refreshpage:            ()  => bm.refreshPage(),
+//         gettitle:               (a) => bm.getTitle(a[0]),
+//         verifytitle:            (a) => bm.verifyTitle(a[0]),
+//         verifypartialtitle:     (a) => bm.verifyPartialTitle(a[0]),
+//         getcurrenturl:          ()  => bm.getCurrentURL(),
+//         maximizewindow:         ()  => bm.maximizeWindow(),
+//         setwindowsize:          (a) => bm.setWindowSize(a[0], a[1]),
+//         switchtotab:            (a) => bm.switchToTab(a[0]),
+//         opennewtab:             (a) => bm.openNewTab(a[0]),
+//         closecurrenttab:        ()  => bm.closeCurrentTab(),
+//         acceptalert:            (a) => bm.acceptAlert(a[0]),
+//         dismissalert:           ()  => bm.dismissAlert(),
+//         getalerttext:           (a) => bm.getAlertText(a[0]),
+//         switchtoframe:          (a) => bm.switchToFrame(a[0]),
+//         executescript:          (a) => bm.executeScript(a[0]),
+//         scrolltobottom:         ()  => bm.scrollToBottom(),
+//         scrolltotop:            ()  => bm.scrollToTop(),
+//         deleteallcookies:       ()  => bm.deleteAllCookies(),
+//         clearlocalstorage:      ()  => bm.clearLocalStorage(),
+//         clearsessionstorage:    ()  => bm.clearSessionStorage(),
+//         takescreenshot:         ()  => bm.takeScreenshot(),
+//       }),
+//     });
+//   }
+
+//   private registerPageHandlers(): void {
+//     const page = this.browserManager.getPage();
+//     const cfg  = this.tConfig;
+//     this.registry.register(new InputHandler(cfg, page));
+//     this.registry.register(new ClickHandler(cfg, page));
+//     this.registry.register(new DropdownHandler(cfg, page));
+//     this.registry.register(new AssertionHandler(cfg, page));
+//     this.registry.register(new WaitHandler(cfg, page));
+//     this.registry.register(new KeyboardHandler(cfg, page));
+//     this.registry.register(new CheckboxHandler(cfg, page));
+//     this.registry.register(new TableHandler(cfg, page));
+
+//     this.registry.register(new CustomCodeHandler(cfg, page));
+//     this.log.info(`Registered ${this.registry.listActions().length} actions`);
+//   }
+
+//   async forceClose(): Promise<void> {
+//     try { await this.browserManager.closeBrowser(); } catch { /* ignore */ }
+//   }
+
+//   getRegisteredActions(): string[] { return this.registry.listActions(); }
+// }
+import { ActionResponse, ParsedStep, TestCaseConfig } from "../types/types";
+import { ActionRegistry } from "./registry/ActionRegistry";
+import { BrowserManager } from "./BrowserManager";
+import { InputHandler } from "./handlers/InputHandler";
+import { ClickHandler } from "./handlers/ClickHandler";
+import { DropdownHandler } from "./handlers/DropdownHandler";
+import { CustomCodeHandler } from "./handlers/CustomCodeHandler";
+import { AssertionHandler, WaitHandler, KeyboardHandler, CheckboxHandler, TableHandler } from "./handlers/AllHandlers";
+import { Logger } from "../utils/logger";
+
+export class PlaywrightEngine {
+  private browserManager: BrowserManager;
+  private registry:       ActionRegistry;
+  private tConfig:        TestCaseConfig;
+  private log:            Logger;
+
+  constructor(tConfig: TestCaseConfig) {
+    this.tConfig        = tConfig;
+    this.browserManager = new BrowserManager(tConfig);
+    this.registry       = new ActionRegistry();
+    this.log            = Logger.create("PlaywrightEngine", tConfig.executionId);
+    this.registerBrowserActions();
+  }
+
+  // ─── Script Parser ─────────────────────────────────────────────────────────
+  parsedStepScript(script: string | undefined | null): ParsedStep | null {
+    // ✅ Guard: must be a non-empty string — no crash on undefined
+    if (!script || typeof script !== "string" || !script.trim()) return null;
+
+    const match = script.match(/tSetup\.(\w+)\(([\s\S]*)\)/i);
+    if (!match) return null;
+
+    const action  = match[1];
+    const rawArgs = match[2];
+    const args: string[] = [];
+
+    // ── Robust tokenizer ────────────────────────────────────────────────────
+    // Handles: triple-double-quoted strings """..."""  (e.g. runCustomCode blocks)
+    //          double-quoted strings        "..."
+    //          single-quoted strings        '...'
+    //          tSetup.testData['KEY']       → stored as __testData__:KEY marker
+    //                                         and resolved in execute() at runtime
+    let i = 0;
+    while (i < rawArgs.length) {
+      const ch = rawArgs[i];
+
+      // Skip whitespace and commas between arguments
+      if (ch === " " || ch === "," || ch === "\n" || ch === "\r" || ch === "\t") {
+        i++;
+        continue;
+      }
+
+      // tSetup.testData['KEY'] or tSetup.testData["KEY"]
+      // Captures the variable key and defers resolution to execute()
+      if (rawArgs.startsWith("tSetup.testData[", i)) {
+        const closeIdx = rawArgs.indexOf("]", i);
+        if (closeIdx !== -1) {
+          const inner = rawArgs.slice(i + "tSetup.testData[".length, closeIdx).trim();
+          const key   = inner.replace(/^['"]|['"]$/g, ""); // strip surrounding quotes
+          args.push(`__testData__:${key}`);
+          i = closeIdx + 1;
+          continue;
+        }
+      }
+
+      // Triple double-quote string: """..."""  (used in runCustomCode JS blocks)
+      if (ch === '"' && rawArgs[i + 1] === '"' && rawArgs[i + 2] === '"') {
+        i += 3;
+        let str = "";
+        while (i < rawArgs.length) {
+          if (rawArgs[i] === '"' && rawArgs[i + 1] === '"' && rawArgs[i + 2] === '"') {
+            i += 3;
+            break;
+          }
+          // Unescape \n and \t written as two-character literals inside JSON strings
+          if (rawArgs[i] === "\\" && rawArgs[i + 1] === "n")       { str += "\n"; i += 2; }
+          else if (rawArgs[i] === "\\" && rawArgs[i + 1] === "t")  { str += "\t"; i += 2; }
+          else if (rawArgs[i] === "\\" && rawArgs[i + 1] === "\\") { str += "\\"; i += 2; }
+          else { str += rawArgs[i++]; }
+        }
+        args.push(str);
+        continue;
+      }
+
+      // Double-quoted string: "..."
+      if (ch === '"') {
+        i++;
+        let str = "";
+        while (i < rawArgs.length && rawArgs[i] !== '"') {
+          if (rawArgs[i] === "\\") { i++; str += rawArgs[i++]; }
+          else { str += rawArgs[i++]; }
+        }
+        i++; // consume closing "
+        args.push(str);
+        continue;
+      }
+
+      // Single-quoted string: '...'
+      if (ch === "'") {
+        i++;
+        let str = "";
+        while (i < rawArgs.length && rawArgs[i] !== "'") {
+          if (rawArgs[i] === "\\") { i++; str += rawArgs[i++]; }
+          else { str += rawArgs[i++]; }
+        }
+        i++; // consume closing '
+        args.push(str.replace(/\\'/g, "'"));
+        continue;
+      }
+
+      // Any other token (numeric literal, identifier, etc.) — skip
+      i++;
+    }
+
+    return { action, args };
+  }
+
+  async execute(script: string | undefined | null, label: string | undefined | null): Promise<ActionResponse | undefined> {
+    // ✅ Guard: missing step_script — actionable error instead of crash
+    if (!script || typeof script !== "string" || !script.trim()) {
+      const msg =
+        "step_script is missing or empty. " +
+        "Your steps contain only step_name and value — they are RAW database objects. " +
+        "You must call prepareSteps(scriptUid) in your main app BEFORE sending to the framework. " +
+        "prepareSteps() resolves obj_uid → locator → step_script for each step.";
+      this.log.error(msg);
+      return { status: "Fail", comments: msg };
+    }
+
+    const parsed = this.parsedStepScript(script);
+    if (!parsed) {
+      this.log.error(`Cannot parse: "${script}"`);
+      return {
+        status:   "Fail",
+        comments: `Invalid script format: "${script}". Expected: tSetup.actionName('arg1', ...)`,
+      };
+    }
+
+    // Resolve __testData__:KEY markers produced by the parser for
+    // tSetup.testData['KEY'] arguments — looks up the live value from the store
+    const resolvedArgs = parsed.args.map((arg) => {
+      if (typeof arg === "string" && arg.startsWith("__testData__:")) {
+        const key = arg.slice("__testData__:".length);
+        try {
+          return String(this.tConfig.testData.get(key));
+        } catch {
+          this.log.warn(`testData key "${key}" not found — passing empty string`);
+          return "";
+        }
+      }
+      return arg;
+    });
+
+    this.log.info(`→ ${parsed.action}(${resolvedArgs.join(", ")})`);
+
+    const result = await this.registry.execute(parsed.action, resolvedArgs, label ?? undefined);
+
+    if (!result) {
+      return {
+        status:   "Fail",
+        comments: `Unknown action: "${parsed.action}". Call GET /api/actions to list all available actions.`,
+      };
+    }
+    return result;
+  }
+
+  private registerBrowserActions(): void {
+    const bm = this.browserManager;
+    this.registry.register({
+      getActions: () => ({
+        openbrowser:            async (a) => {
+          const result = await bm.openBrowser(a[0] || "chromium");
+          if (result.status === "Pass") this.registerPageHandlers();
+          return result;
+        },
+        closebrowser:           ()  => bm.closeBrowser(),
+        navigatetourl:          (a) => bm.navigateToURL(a[0]),
+        navigateback:           ()  => bm.navigateBack(),
+        navigateforward:        ()  => bm.navigateForward(),
+        refreshpage:            ()  => bm.refreshPage(),
+        gettitle:               (a) => bm.getTitle(a[0]),
+        verifytitle:            (a) => bm.verifyTitle(a[0]),
+        verifypartialtitle:     (a) => bm.verifyPartialTitle(a[0]),
+        getcurrenturl:          ()  => bm.getCurrentURL(),
+        maximizewindow:         ()  => bm.maximizeWindow(),
+        setwindowsize:          (a) => bm.setWindowSize(a[0], a[1]),
+        switchtotab:            (a) => bm.switchToTab(a[0]),
+        opennewtab:             (a) => bm.openNewTab(a[0]),
+        closecurrenttab:        ()  => bm.closeCurrentTab(),
+        acceptalert:            (a) => bm.acceptAlert(a[0]),
+        dismissalert:           ()  => bm.dismissAlert(),
+        getalerttext:           (a) => bm.getAlertText(a[0]),
+        switchtoframe:          (a) => bm.switchToFrame(a[0]),
+        executescript:          (a) => bm.executeScript(a[0]),
+        scrolltobottom:         ()  => bm.scrollToBottom(),
+        scrolltotop:            ()  => bm.scrollToTop(),
+        deleteallcookies:       ()  => bm.deleteAllCookies(),
+        clearlocalstorage:      ()  => bm.clearLocalStorage(),
+        clearsessionstorage:    ()  => bm.clearSessionStorage(),
+        takescreenshot:         ()  => bm.takeScreenshot(),
+      }),
+    });
+  }
+
+  private registerPageHandlers(): void {
+    const page = this.browserManager.getPage();
+    const cfg  = this.tConfig;
+    this.registry.register(new InputHandler(cfg, page));
+    this.registry.register(new ClickHandler(cfg, page));
+    this.registry.register(new DropdownHandler(cfg, page));
+    this.registry.register(new AssertionHandler(cfg, page));
+    this.registry.register(new WaitHandler(cfg, page));
+    this.registry.register(new KeyboardHandler(cfg, page));
+    this.registry.register(new CheckboxHandler(cfg, page));
+    this.registry.register(new TableHandler(cfg, page));
+
+    this.registry.register(new CustomCodeHandler(cfg, page));
+    this.log.info(`Registered ${this.registry.listActions().length} actions`);
+  }
+  async getPageSource(): Promise<string> {
+    const resp = await this.browserManager.getPageSource();
+    return resp?.data?.pagesource || "";
+  }
+
+  async getCurrentURL(): Promise<string> {
+    const resp = await this.browserManager.getCurrentURL();
+    return resp?.data?.url || "";
+  }
+
+  async forceClose(): Promise<void> {
+    try { await this.browserManager.closeBrowser(); } catch { /* ignore */ }
+  }
+
+  getRegisteredActions(): string[] { return this.registry.listActions(); }
+}

package/src/core/ScreenshotManager.ts

@@ -0,0 +1,25 @@
+import { Page } from "playwright";
+import { ScreenshotMode } from "../types/types";
+
+export class ScreenshotManager {
+  private readonly mode: ScreenshotMode;
+  constructor(mode: ScreenshotMode = "on_failure") { this.mode = mode; }
+
+  async onPass(page?: Page | null): Promise<string | undefined> {
+    return this.mode === "always" ? this.capture(page) : undefined;
+  }
+  async onFail(page?: Page | null): Promise<string | undefined> {
+    return this.mode !== "never" ? this.capture(page) : undefined;
+  }
+  async force(page?: Page | null): Promise<string | undefined> {
+    return this.capture(page);
+  }
+
+  private async capture(page?: Page | null): Promise<string | undefined> {
+    if (!page || page.isClosed()) return undefined;
+    try {
+      const buf = await page.screenshot({ type: "png", fullPage: false });
+      return buf.toString("base64");
+    } catch { return undefined; }
+  }
+}

package/src/core/TestData.ts

@@ -0,0 +1,25 @@
+import { ITestData } from "../types/types";
+
+export class TestData implements ITestData {
+  private store: Record<string, unknown> = {};
+
+  set(key: string, value: unknown): void    { this.store[key] = value; }
+  has(key: string): boolean                 { return key in this.store; }
+  getAll(): Record<string, unknown>         { return { ...this.store }; }
+  delete(key: string): void                 { delete this.store[key]; }
+  clear(): void                             { this.store = {}; }
+
+  get(key: string): unknown {
+    if (!(key in this.store))
+      throw new Error(`TestData: key "${key}" not found. Available: [${Object.keys(this.store).join(", ")}]`);
+    return this.store[key];
+  }
+
+  /** Resolve testdata("key") references in arg strings */
+  resolve(value: unknown): unknown {
+    if (typeof value !== "string") return value;
+    const m = value.match(/^testdata\("(.+?)"\)$/i);
+    if (m) return this.get(m[1]);
+    return value;
+  }
+}