pw-automation-framework 2.0.1

package/src/core/handlers/ClickHandler.ts

@@ -0,0 +1,482 @@
+import { Page } from "playwright";
+import { ActionResponse, TestCaseConfig } from "../../types/types";
+import { pass, fail, failElementNotFound } from "../../utils/response";
+import { buildLocatorString } from "../../utils/locatorHelper";
+import { BaseHandler } from "./BaseHandler";
+
+export class ClickHandler extends BaseHandler {
+  constructor(tConfig: TestCaseConfig, page: Page) { super(tConfig, page); }
+
+  getActions() {
+    return {
+      clickelement:      this.clickElement.bind(this),
+      selectRadioButton: this.selectRadioButton.bind(this),
+      check_checkbox:    this.check_checkbox.bind(this),
+      doubleclick:       this.doubleClick.bind(this),
+      rightclick:        this.rightClick.bind(this),
+      hover:             this.hover.bind(this),
+      clickbyjs:         this.clickByJS.bind(this),
+      clickifpresent:    this.clickIfPresent.bind(this),
+      draganddrop:       this.dragAndDrop.bind(this),
+      clickandwait:      this.clickAndWait.bind(this),
+      clickbytext:       this.clickByText.bind(this),
+      clicknthelement:   this.clickNthElement.bind(this),
+      scrollandclick:    this.scrollAndClick.bind(this),
+    };
+  }
+
+  async clickElement(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("clickElement needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "click", `Clicking`);
+
+    await el.click({ timeout: this.timeout });
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Clicked ${displayLabel}`,
+      sc,
+      { expected_result: `"${displayLabel}" clicked successfully` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const msg = error.message.toLowerCase();
+    if (msg.includes("waiting for locator") || msg.includes("timeout") || msg.includes("no element")) {
+      return failElementNotFound(displayLabel, sc);
+    }
+    return fail(`Failed click on "${displayLabel}" — ${error.message}`, undefined, sc, { expected_result: `"${displayLabel}" clicked successfully` });
+}
+  }
+// async clickElement(args: string[], slabel?: string): Promise<ActionResponse> {
+//   const [strategy, locator] = args;
+//   const displayLabel = slabel || "unknown";
+
+//   if (!strategy || !locator) {
+//     return fail("clickElement needs: strategy, locator", "Missing args");
+//   }
+
+//   const ls = buildLocatorString(strategy, locator);
+
+//   try {
+//     const el = this.page.locator(ls);
+//     await el.waitFor({ state: "visible", timeout: this.timeout });
+
+//     await this.highlight(ls, "click", "Clicking");
+
+//     await el.click({ timeout: this.timeout });
+
+//     await this.unhighlight();
+
+//     const sc = await this.shots.onPass(this.page);
+
+//     return pass(
+//       `Clicked ${displayLabel}`,
+//       sc,
+//       { expected_result: `"${displayLabel}" clicked successfully` }
+//     );
+
+//   } catch (error: any) {
+//     await this.unhighlight();
+//     const sc = await this.shots.onFail(this.page);
+
+//     const msg = error.message.toLowerCase();
+//     let errorMsg = "";
+
+
+//     if (msg.includes("waiting for locator") || msg.includes("no element")) {
+//       errorMsg = `"${displayLabel}" not found`;
+
+//     } else if (msg.includes("not visible")) {
+//       errorMsg = `"${displayLabel}" is not visible`;
+
+//     } else if (msg.includes("not enabled")) {
+//       errorMsg = `"${displayLabel}" is disabled`;
+
+//     } else if (msg.includes("not attached")) {
+//       errorMsg = `"${displayLabel}" is not attached to DOM`;
+
+//     } else if (msg.includes("strict mode")) {
+//       errorMsg = `Multiple elements found for "${displayLabel}"`;
+
+//     } else if (msg.includes("timeout")) {
+//       errorMsg = `Timeout while clicking "${displayLabel}"`;
+
+//     } else {
+//       errorMsg = `Failed click on "${displayLabel}" — ${error.message}`;
+//     }
+
+//     return fail(
+//       errorMsg,
+//       undefined,
+//       sc,
+//       { expected_result: `"${displayLabel}" clicked successfully` }
+//     );
+//   }
+// }
+async selectRadioButton(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("selectRadioButton needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "checkbox", "Selecting radio button");
+
+    await el.check({ timeout: this.timeout });
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Selected radio button ${displayLabel}`,
+      sc,
+      { expected_result: `"${displayLabel}" radio button selected successfully` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    // ✅ YOUR LOGIC (as requested)
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed selectRadioButton "${displayLabel}" — ${error.message}`;
+
+    return fail(
+      errorMsg,
+      undefined,
+      sc,
+      { expected_result: `"${displayLabel}" radio button selected successfully` }
+    );
+  }
+}
+async check_checkbox(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("check_checkbox needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "checkbox", "Checking checkbox");
+
+    await el.check({ timeout: this.timeout });
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(
+      `Checked checkbox ${displayLabel}`,
+      sc,
+      { expected_result: `"${displayLabel}" checkbox checked successfully` }
+    );
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    // ✅ SAME LOGIC (as you asked)
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    const errorMsg = isNotFound
+      ? `"${displayLabel}" not found`
+      : `Failed check_checkbox "${displayLabel}" — ${error.message}`;
+
+    return fail(
+      errorMsg,
+      undefined,
+      sc,
+      { expected_result: `"${displayLabel}" checkbox checked successfully` }
+    );
+  }
+}
+ async doubleClick(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("doubleClick needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "click", "Double clicking");
+
+    await el.dblclick({ timeout: this.timeout });
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`Double-clicked ${displayLabel}`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    return fail(
+      isNotFound ? `"${displayLabel}" not found` : `Failed doubleClick ${displayLabel} — ${error.message}`,
+      undefined,
+      sc
+    );
+  }
+}
+
+  async rightClick(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("rightClick needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "click", "Right clicking");
+
+    await el.click({ button: "right" });
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`Right-clicked ${displayLabel}`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    return fail(
+      isNotFound ? `"${displayLabel}" not found` : `Failed rightClick ${displayLabel} — ${error.message}`,
+      undefined,
+      sc
+    );
+  }
+}
+  async hover(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("hover needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "visible", timeout: this.timeout });
+
+    await this.highlight(ls, "click", "Hovering");
+
+    await el.hover();
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`Hovered ${displayLabel}`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    return fail(
+      isNotFound ? `"${displayLabel}" not found` : `Failed hover ${displayLabel} — ${error.message}`,
+      undefined,
+      sc
+    );
+  }
+}
+
+ async clickByJS(args: string[], slabel?: string): Promise<ActionResponse> {
+  const [strategy, locator] = args;
+  const displayLabel = slabel || "unknown";
+
+  if (!strategy || !locator) {
+    return fail("clickByJS needs: strategy, locator", "Missing args");
+  }
+
+  const ls = buildLocatorString(strategy, locator);
+
+  try {
+    const el = this.page.locator(ls);
+    await el.waitFor({ state: "attached", timeout: this.timeout });
+
+    await this.highlight(ls, "click", "JS Click");
+
+    await el.evaluate((node: HTMLElement) => node.click());
+
+    await this.unhighlight();
+
+    const sc = await this.shots.onPass(this.page);
+
+    return pass(`JS clicked ${displayLabel}`, sc);
+
+  } catch (error: any) {
+    await this.unhighlight();
+    const sc = await this.shots.onFail(this.page);
+
+    const isNotFound = /timeout|waiting for locator|not visible|not found/i.test(error.message);
+
+    return fail(
+      isNotFound ? `"${displayLabel}" not found` : `Failed clickByJS ${displayLabel} — ${error.message}`,
+      undefined,
+      sc
+    );
+  }
+}
+  // tSetup.clickIfPresent('xpath', '//button[...]')
+  async clickIfPresent(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [strategy, locator] = args;
+    if (!strategy || !locator) return fail("clickIfPresent needs: strategy, locator", "Missing args");
+    try {
+      const el    = this.page.locator(buildLocatorString(strategy, locator));
+      const count = await el.count();
+      if (count > 0 && await el.first().isVisible()) {
+        await el.first().click({ timeout: this.timeout });
+        const sc = await this.shots.onPass(this.page);
+        return pass(`Clicked (was present): [${strategy}=${locator}] in ${slabel || 'unknown'}`, sc);
+      }
+      return pass(`Element not present, skipped: [${strategy}=${locator}] in ${slabel || 'unknown'}`);
+    } catch {
+      return pass(`Element not clickable, skipped: [${strategy}=${locator}] in ${slabel || 'unknown'}`);
+    }
+  }
+
+  // tSetup.dragAndDrop('xpath', '//src', 'xpath', '//target')
+  async dragAndDrop(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [ss, sl, ts, tl] = args;
+    if (!ss || !sl || !ts || !tl) return fail("dragAndDrop needs: srcStrategy, srcLocator, tgtStrategy, tgtLocator", "Missing args");
+    try {
+      const src = this.page.locator(buildLocatorString(ss, sl));
+      const tgt = this.page.locator(buildLocatorString(ts, tl));
+      await src.waitFor({ state: "visible", timeout: this.timeout });
+      await src.dragTo(tgt, { timeout: this.timeout });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Dragged [${ss}=${sl}] → [${ts}=${tl}] in ${slabel || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail("Failed dragAndDrop", error.message, sc);
+    }
+  }
+
+  // tSetup.clickAndWait('xpath', '//button[...]', 'networkidle')
+  async clickAndWait(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [strategy, locator, waitState] = args;
+    if (!strategy || !locator) return fail("clickAndWait needs: strategy, locator, [waitState]", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      const state = (waitState as any) || "domcontentloaded";
+      await Promise.all([
+        this.page.waitForLoadState(state, { timeout: this.timeout }),
+        el.click({ timeout: this.timeout }),
+      ]);
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Clicked and waited for ${state} in ${slabel || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed clickAndWait ${slabel || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.clickByText('Sign In')
+  async clickByText(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [text, exact] = args;
+    if (!text) return fail("clickByText needs: text, [exact=true|false]", "Missing args");
+    try {
+      const isExact = exact !== "false";
+      const el = this.page.getByText(text, { exact: isExact });
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.click({ timeout: this.timeout });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Clicked by text: "${text}" in ${slabel || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed clickByText: "${text}" in ${slabel || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.clickNthElement('xpath', '//li', '2')
+  async clickNthElement(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [strategy, locator, nthStr] = args;
+    const nth = parseInt(nthStr || "0", 10);
+    if (!strategy || !locator) return fail("clickNthElement needs: strategy, locator, nth", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator)).nth(nth);
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.click({ timeout: this.timeout });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Clicked nth(${nth}) in ${slabel || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed clickNthElement in ${slabel || 'unknown'}`, error.message, sc);
+    }
+  }
+
+  // tSetup.scrollAndClick('xpath', '//button[...]')
+  async scrollAndClick(args: string[], slabel?: string): Promise<ActionResponse> {
+    const [strategy, locator] = args;
+    if (!strategy || !locator) return fail("scrollAndClick needs: strategy, locator", "Missing args");
+    try {
+      const el = this.page.locator(buildLocatorString(strategy, locator));
+      await el.waitFor({ state: "visible", timeout: this.timeout });
+      await el.scrollIntoViewIfNeeded({ timeout: this.timeout });
+      await el.click({ timeout: this.timeout });
+      const sc = await this.shots.onPass(this.page);
+      return pass(`Scrolled and clicked  ${slabel || 'unknown'}`, sc);
+    } catch (error: any) {
+      const sc = await this.shots.onFail(this.page);
+      return fail(`Failed scrollAndClick ${slabel || 'unknown'}`, error.message, sc);
+    }
+  }
+}

package/src/core/handlers/CustomCodeHandler.ts

@@ -0,0 +1,123 @@
+import { Page } from "playwright";
+import { ActionResponse, TestCaseConfig } from "../../types/types";
+import { pass, fail } from "../../utils/response";
+import { buildLocatorString } from "../../utils/locatorHelper";
+import { BaseHandler } from "./BaseHandler";
+import { Logger } from "../../utils/logger";
+
+/**
+ * CustomCodeHandler
+ * -----------------
+ * Mirrors the Python runCustomCode() behaviour:
+ *
+ *   tSetup.runCustomCode('<JS code>', '<returnVariable>', '<optional xpath>')
+ *
+ * The code string runs inside an async Function with two injected helpers:
+ *   - tSetup  : the Page object (so you can call Playwright APIs from code)
+ *   - testData: the shared TestData store (read/write mid-script variables)
+ *
+ * Rules:
+ *   1. Declare a variable whose name matches returnVariable — its value is
+ *      captured, stored in TestData under that key, and returned in data.value.
+ *   2. If an xpath is supplied the captured value is also typed into that field.
+ *   3. If no returnVariable is supplied the code still runs; pass is returned.
+ *   4. On any exception the step fails with the error message + screenshot.
+ *
+ * Example step_script values:
+ *   tSetup.runCustomCode('const result = "LN" + Math.floor(Math.random()*1000);', 'result', '//input[@id="ref"]')
+ *   tSetup.runCustomCode('const otp = String(1000 + Math.floor(Math.random()*9000));', 'otp')
+ *   tSetup.runCustomCode('await page.waitForTimeout(500); const ts = Date.now();', 'ts')
+ */
+
+export class CustomCodeHandler extends BaseHandler {
+  protected log: Logger;
+
+  constructor(tConfig: TestCaseConfig, page: Page) {
+    super(tConfig, page);
+    this.log = Logger.create("CustomCodeHandler", tConfig.executionId);
+  }
+
+  getActions() {
+    return {
+      runcustomcode: this.runCustomCode.bind(this),
+    };
+  }
+
+  // ─── runCustomCode(codeStr, returnVariable?, xpath?) ──────────────────────
+
+  async runCustomCode(args: string[]): Promise<ActionResponse> {
+    const [codeStr, returnVariable, xpath] = args;
+
+    if (!codeStr || !codeStr.trim()) {
+      return fail("runCustomCode: codeStr (arg 1) is required");
+    }
+
+    this.log.info(`runCustomCode | returnVar="${returnVariable || "none"}" | xpath="${xpath || "none"}"`);
+
+    try {
+      // Build context — same idea as Python's context = {"tSetup": self}
+      const context: Record<string, unknown> = {
+        page:     this.page,
+        tSetup:   this.page,          // alias so people can write tSetup.xxx inside the code
+        testData: this.testData,
+      };
+
+      // Execute the code string as an async function so `await` works inside
+      const wrappedCode = `
+        "use strict";
+        const { page, tSetup, testData } = __ctx__;
+        ${codeStr}
+        return typeof ${returnVariable || "__undefined__"} !== "undefined"
+          ? ${returnVariable || "undefined"}
+          : undefined;
+      `;
+
+      // eslint-disable-next-line no-new-func
+      const fn     = new Function("__ctx__", `return (async (__ctx__) => { ${wrappedCode} })(__ctx__)`);
+      const value  = await fn(context);
+
+      // ── Capture return value ───────────────────────────────────────────────
+      if (returnVariable && value !== undefined && value !== null) {
+        // Store in shared TestData so later steps can reference it
+        this.testData.set(returnVariable, value);
+
+        const strValue = String(value);
+        this.log.info(`runCustomCode → ${returnVariable} = ${strValue}`);
+
+        // If xpath provided, type the value into the field
+        if (xpath && xpath.trim()) {
+          try {
+            const el = this.page.locator(buildLocatorString("xpath", xpath));
+            await el.waitFor({ state: "visible", timeout: this.timeout });
+            await el.clear();
+            await el.fill(strValue);
+            this.log.info(`runCustomCode: typed "${strValue}" into [xpath=${xpath}]`);
+          } catch (fillErr: any) {
+            // Typing failed — still pass the code execution, but warn
+            this.log.warn(`runCustomCode: value generated but fill failed — ${fillErr.message}`);
+          }
+        }
+
+        const sc = await this.shots.onPass(this.page);
+        return pass(
+          `Custom code executed. ${returnVariable} = ${strValue}`,
+          sc,
+          { returnVariable, value, type: typeof value }
+        );
+      }
+
+      // ── No return variable — code ran for side-effects only ───────────────
+      const sc = await this.shots.onPass(this.page);
+      return pass("Custom code executed successfully.", sc);
+
+    } catch (error: any) {
+      this.log.error(`runCustomCode failed: ${error.message}`);
+      const sc = await this.shots.onFail(this.page);
+      return fail(
+        `Exception occurred during custom code execution`,
+        error.message,
+        sc
+      );
+    }
+  }
+}