@dev-blinq/cucumber_client 1.0.1175-dev → 1.0.1175-stage

package/bin/client/recorderv3/index.js

@@ -51,6 +51,37 @@ class PromisifiedSocketServer {
   }
 }
 
+function memorySizeOf(obj) {
+  var bytes = 0;
+
+  function sizeOf(obj) {
+    if (obj !== null && obj !== undefined) {
+      switch (typeof obj) {
+        case "number":
+          bytes += 8;
+          break;
+        case "string":
+          bytes += obj.length * 2;
+          break;
+        case "boolean":
+          bytes += 4;
+          break;
+        case "object":
+          var objClass = Object.prototype.toString.call(obj).slice(8, -1);
+          if (objClass === "Object" || objClass === "Array") {
+            for (var key in obj) {
+              if (!obj.hasOwnProperty(key)) continue;
+              sizeOf(obj[key]);
+            }
+          } else bytes += obj.toString().length * 2;
+          break;
+      }
+    }
+    return bytes;
+  }
+  return sizeOf(obj);
+}
+
 const init = ({ envName, projectDir, roomId, TOKEN }) => {
   console.log("connecting to " + WS_URL);
   const socket = io(WS_URL);
@@ -66,6 +97,7 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     projectDir,
     TOKEN,
     sendEvent: (event, data) => {
+      console.log("Size of data", memorySizeOf(data), "bytes");
       console.log("----", event, data, "roomId", roomId);
       socket.emit(event, data, roomId);
     },
@@ -77,7 +109,7 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       socket.emit("BVTRecorder.browserOpened", null, roomId);
     })
     .catch((e) => {
-      socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
     });
   const timeOutForFunction = async (promise, timeout = 5000) => {
     const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
@@ -139,9 +171,6 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.runStep": async (input) => {
       return recorder.runStep(input);
     },
-    "recorderWindow.runScenario": async (input) => {
-      return recorder.runScenario(input);
-    },
     "recorderWindow.saveScenario": async (input) => {
       return recorder.saveScenario(input);
     },
@@ -216,6 +245,12 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
         return { folder: snapshotFolder, files: ymlFiles };
       } else return { folder: null, files: [] };
     },
+    "recorderWindow.getCurrentPageTitle": async (input) => {
+      return await recorder.getCurrentPageTitle();
+    },
+    "recorderWindow.getCurrentPageUrl": async (input) => {
+      return await recorder.getCurrentPageUrl();
+    },
     "recorderWindow.sendAriaSnapshot": async (input) => {
       const snapshot = input?.snapshot;
       const deselect = input?.deselect;
@@ -233,6 +268,12 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       const mode = input?.mode;
       return recorder.setMode(mode);
     },
+    "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
+      return await recorder.getStepsAndCommandsForScenario(input);
+    },
+    "recorderWindow.getNetworkEvents": async (input) => {
+      return await recorder.getNetworkEvents(input);
+    },
   });
   socket.on("targetBrowser.command.event", async (input) => {
     return recorder.onAction(input);

package/bin/client/recorderv3/network.js

@@ -0,0 +1,299 @@
+/**
+ * @typedef {Object} NetworkEvent
+ * @property {import('playwright').Request} request
+ * @property {import('playwright').Response|null} response
+ * @property {string} id
+ * @property {number} timestamp
+ * @property {string} status - 'completed', 'failed'
+ */
+
+class NetworkMonitor {
+  constructor() {
+    this.networkId = 0;
+    /** @type {Map<string, NetworkEvent>} */
+    this.requestIdMap = new Map();
+    this.networkEvents = new Map();
+    /** @type {Map<import('playwright').Page, {responseListener: Function, requestFailedListener: Function}>} */
+    this.pageListeners = new Map();
+  }
+
+  /**
+   * Add network event listeners to a page
+   * @param {import('playwright').Page} page
+   */
+  addNetworkEventListener(page) {
+    // Create the listener functions
+    const responseListener = async (response) => {
+      const request = response.request();
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response,
+        timestamp: Date.now(),
+        status: "completed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+
+    const requestFailedListener = (request) => {
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response: null,
+        timestamp: Date.now(),
+        status: "failed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+    // Store the listeners for later removal
+    this.pageListeners.set(page, {
+      responseListener,
+      requestFailedListener,
+    });
+
+    // Add the listeners to the page
+    page.on("response", responseListener);
+    page.on("requestfailed", requestFailedListener);
+  }
+
+  /**
+   * Remove network event listeners from a specific page
+   * @param {import('playwright').Page} page
+   */
+  removeNetworkEventListener(page) {
+    const listeners = this.pageListeners.get(page);
+    if (listeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+      this.pageListeners.delete(page);
+      console.log("Network event listeners removed from page");
+    }
+  }
+
+  /**
+   * Remove network event listeners from all pages
+   */
+  removeAllNetworkEventListeners() {
+    for (const [page, listeners] of this.pageListeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+    }
+    this.pageListeners.clear();
+    console.log("All network event listeners removed");
+  }
+
+  /**
+   * Check if a page has active listeners
+   * @param {import('playwright').Page} page
+   * @returns {boolean}
+   */
+  hasListeners(page) {
+    return this.pageListeners.has(page);
+  }
+
+  /**
+   * Get the number of pages with active listeners
+   * @returns {number}
+   */
+  getActiveListenersCount() {
+    return this.pageListeners.size;
+  }
+
+  /**
+   * Get all network events until now
+   */
+  getAllNetworkEvents() {
+    return Array.from(this.networkEvents.values());
+  }
+
+  /**
+   * Get network events within a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsInRange(startId, endId) {
+    const events = [];
+    for (let i = startId; i <= endId; i++) {
+      const event = this.networkEvents.get(i.toString());
+      if (event) {
+        events.push(event);
+      }
+    }
+    return events;
+  }
+
+  /**
+   * Get network events since a specific ID
+   * @param {number} sinceId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsSince(sinceId) {
+    return this.getNetworkEventsInRange(sinceId + 1, this.networkId);
+  }
+
+  /**
+   * Get events by status
+   * @param {string} status - 'completed', 'failed'
+   * @returns {NetworkEvent[]}
+   */
+  getEventsByStatus(status) {
+    return Array.from(this.networkEvents.values()).filter((event) => event.status === status);
+  }
+
+  /**
+   * Get current network ID (latest)
+   * @returns {number}
+   */
+  getCurrentNetworkId() {
+    return this.networkId;
+  }
+
+  getCurrentNetworkEventsLength() {
+    return this.networkEvents.size;
+  }
+
+  /**
+   * Get statistics about stored events
+   * @returns {Object}
+   */
+  getStats() {
+    const events = Array.from(this.networkEvents.values());
+    return {
+      total: events.length,
+      completed: events.filter((e) => e.status === "completed").length,
+      failed: events.filter((e) => e.status === "failed").length,
+      oldestTimestamp: events.length > 0 ? Math.min(...events.map((e) => e.timestamp)) : null,
+      newestTimestamp: events.length > 0 ? Math.max(...events.map((e) => e.timestamp)) : null,
+    };
+  }
+
+  /**
+   * Marshall network event for serialization
+   * @param {NetworkEvent} networkEvent
+   * @returns {Promise<Object>}
+   */
+  async marshallNetworkEvent(networkEvent) {
+    const { request, response } = networkEvent;
+
+    try {
+      const url = new URL(request.url());
+      const marshalledEvent = {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: url.href,
+        method: request.method(),
+        statusCode: response?.status() ?? null,
+        statusText: response?.statusText() ?? null,
+        queryParams: Object.fromEntries(url.searchParams.entries()),
+      };
+
+      // Try to get response body safely (only for successful responses)
+      if (response && networkEvent.status === "completed") {
+        try {
+          const isBinary =
+            !response.headers()["content-type"]?.includes("application/json") &&
+            !response.headers()["content-type"]?.includes("text");
+          let body;
+          if (isBinary) {
+            body = await response.body();
+          } else {
+            body = await response.text();
+          }
+          let json;
+          try {
+            if (typeof body === "string") {
+              json = JSON.parse(body); // Check if body is valid JSON
+            }
+          } catch (_) {
+            //Ignore
+          }
+          const responseBody = isBinary ? body : json ? JSON.stringify(json) : body;
+          marshalledEvent.contentType = isBinary ? "binary" : json ? "json" : "text";
+          marshalledEvent.responseBody = responseBody;
+        } catch (error) {
+          marshalledEvent.responseBody = `[Error reading response: ${error.message}]`;
+        }
+      } else if (networkEvent.status === "failed") {
+        marshalledEvent.failureReason = request.failure()?.errorText || "Unknown error";
+      }
+
+      console.log("Marshalled network event:", marshalledEvent);
+
+      return marshalledEvent;
+    } catch (error) {
+      console.error("Error marshalling network event:", error);
+      return {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: request.url(),
+        method: request.method(),
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   *@returns {Promise<Object[]>}
+   * Get all marshalled network events
+   * This is useful for sending to the server or saving to a file.
+   *   */
+  async getAllMarshalledNetworkEvents() {
+    const events = this.getAllNetworkEvents();
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events since this ID
+   * @returns {Promise<Object[]>}
+   * @param {number} sinceId
+   */
+  async getMarshalledNetworkEvents(sinceId) {
+    const events = this.getNetworkEventsSince(sinceId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events in a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {Promise<Object[]>}
+   */
+  async getMarshalledNetworkEventsInRange(startId, endId) {
+    const events = this.getNetworkEventsInRange(startId, endId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Clear all network events
+   */
+  clearNetworkEvents() {
+    this.networkEvents.clear();
+    this.networkId = 0;
+  }
+}
+
+export default NetworkMonitor;

package/bin/client/recorderv3/step_runner.js

@@ -1,6 +1,5 @@
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import path from "path";
-import fs from "fs";
 import { generatePageName } from "../code_gen/playwright_codeget.js";
 import {
   executeStep,
@@ -9,26 +8,36 @@ import {
   getUtilsCodePage,
   loadStepDefinitions,
   saveRecording,
+  saveRoutes,
 } from "./step_utils.js";
 import { escapeString, getExamplesContent } from "./update_feature.js";
+import fs from "fs";
+import { locateDefinitionPath } from "../cucumber/steps_definitions.js";
+import { tmpdir } from "os";
 
 // let copiedCodeToTemp = false;
 async function withAbort(fn, signal) {
   if (!signal) {
     return await fn();
   }
+  return new Promise((resolve, reject) => {
+    const abortHandler = () => reject(new Error("Aborted"));
+    signal.addEventListener("abort", abortHandler, { once: true });
 
-  const abortPromise = new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
+    fn()
+      .then(resolve)
+      .catch(reject)
+      .finally(() => {
+        signal.removeEventListener("abort", abortHandler);
+      });
   });
-
-  return await Promise.race([fn(), abortPromise]);
 }
 export class BVTStepRunner {
   #currentStepController;
   #port;
-  constructor({ projectDir }) {
+  constructor({ projectDir, sendExecutionStatus }) {
     this.projectDir = projectDir;
+    this.sendExecutionStatus = sendExecutionStatus;
   }
   setRemoteDebugPort(port) {
     this.#port = port;
@@ -55,11 +64,12 @@ export class BVTStepRunner {
     // copiedCodeToTemp = true;
   }
 
-  async writeTempFeatureFile({ step, parametersMap, tempFolderPath }) {
+  async writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags }) {
     const tFilePath = path.join(tempFolderPath, "__temp.feature");
     // console.log(tFilePath);
     let tFileContent = `# temp feature file
     Feature: Temp feature
+    ${tags ? tags.join(" ") : ""}
     Scenario Outline: Temp Scenario
       Given ${escapeString(step.text)}
     `;
@@ -67,7 +77,132 @@ export class BVTStepRunner {
     writeFileSync(tFilePath, tFileContent);
     return tFilePath;
   }
-  async runStep({ step, parametersMap, envPath }, bvtContext, options) {
+
+  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
+    if (!options) {
+      options = {
+        skipAfter: true,
+      };
+    }
+    const environment = {
+      ...process.env,
+    };
+
+    try {
+      const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
+      const { runConfiguration } = await loadConfiguration(
+        {
+          provided: {
+            name: [scenario],
+            paths: [feature_file_path],
+            import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
+            // format: ["bvt"],
+          },
+        },
+        { cwd: process.cwd(), env: environment }
+      );
+      // const files = glob.sync(path.join(tempFolderPath, "step_definitions", "**", "*.mjs"));
+      // console.log("Files found:", files);
+      const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
+      // console.log("found ", support.stepDefinitions.length, "step definitions");
+      // support.stepDefinitions.map((step) => {
+      //   console.log("step", step.pattern);
+      // });
+
+      if (options.skipAfter) {
+        // ignore afterAll/after hooks
+        support.afterTestCaseHookDefinitions = [];
+        support.afterTestRunHookDefinitions = [];
+      }
+
+      let errorMesssage = null;
+      let info = null;
+      let errInfo = null;
+      const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
+        if (message.testStepFinished) {
+          const { testStepFinished } = message;
+          const { testStepResult } = testStepFinished;
+          if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
+            if (!errorMesssage) {
+              errorMesssage = testStepResult.message;
+              if (info) {
+                errInfo = info;
+              }
+            }
+          }
+          if (testStepResult.status === "UNDEFINED") {
+            if (!errorMesssage) {
+              errorMesssage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+              if (info) {
+                errInfo = info;
+              }
+            }
+          }
+        }
+        if (message.attachment) {
+          const attachment = message.attachment;
+          if (attachment.mediaType === "application/json" && attachment.body) {
+            const body = JSON.parse(attachment.body);
+            info = body.info;
+            const result = body.result;
+
+            if (result.status === "PASSED") {
+              this.sendExecutionStatus({
+                type: "cmdExecutionSuccess",
+                cmdId: body.cmdId,
+              });
+            } else {
+              this.sendExecutionStatus({
+                type: "cmdExecutionError",
+                cmdId: body.cmdId,
+                error: {
+                  message: result.message,
+                  info,
+                },
+              });
+            }
+          } else if (attachment.mediaType === "application/json+intercept-results" && attachment.body) {
+            const body = JSON.parse(attachment.body);
+            if (body) {
+              this.sendExecutionStatus({
+                type: "interceptResults",
+                interceptResults: body,
+              });
+            }
+          }
+        }
+      });
+      if (errorMesssage) {
+        const bvtError = new Error(errorMesssage);
+        Object.assign(bvtError, { info: errInfo });
+        throw bvtError;
+      }
+
+      return {
+        result,
+        info,
+      };
+    } catch (error) {
+      console.error("Error running cucumber-js", error);
+      throw error;
+    }
+  };
+
+  async runStep({ step, parametersMap, envPath, tags }, bvtContext, options) {
+    let cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+    if (bvtContext.web) {
+      bvtContext.web.getCmdId = () => {
+        if (cmdIDs.length === 0) {
+          cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+        }
+        const cId = cmdIDs.shift();
+        this.sendExecutionStatus({
+          type: "cmdExecutionStart",
+          cmdId: cId,
+        });
+        return cId;
+      };
+    }
     let codePage; // = getCodePage();
     // const tempFolderPath = process.env.tempFeaturesFolderPath;
     const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
@@ -96,7 +231,8 @@ export class BVTStepRunner {
       if (!existsSync(stepDefinitionFolderPath)) {
         mkdirSync(stepDefinitionFolderPath, { recursive: true });
       }
-      const stepDefsFilePath = path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
+      const stepDefsFilePath = locateDefinitionPath(tempFolderPath, pageName);
+      //path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
       codePage = getCodePage(stepDefsFilePath);
       codePage = await saveRecording({ step, cucumberStep, codePage, projectDir: this.projectDir, stepsDefinitions });
       if (codePage) {
@@ -106,14 +242,43 @@ export class BVTStepRunner {
       if (!codePage) {
         codePage = getUtilsCodePage(this.projectDir);
       }
+    } else {
+      let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+      if (process.env.TEMP_RUN === "true") {
+        // console.log("Save routes in temp folder for running:", routesPath);
+        if (existsSync(routesPath)) {
+          // console.log("Removing existing temp_routes_folder:", routesPath);
+          rmSync(routesPath, { recursive: true });
+        }
+        mkdirSync(routesPath, { recursive: true });
+        // console.log("Created temp_routes_folder:", routesPath);
+        saveRoutes({ step, folderPath: routesPath });
+      } else {
+        // console.log("Saving routes in project directory:", this.projectDir);
+        if (existsSync(routesPath)) {
+          // remove the folder
+          try {
+            rmSync(routesPath, { recursive: true });
+            // console.log("Removed temp_routes_folder:", routesPath);
+          } catch (error) {
+            // console.error("Error removing temp_routes folder", error);
+          }
+        }
+        routesPath = path.join(this.projectDir, "data", "routes");
+        // console.log("Saving routes to:", routesPath);
+        if (!existsSync(routesPath)) {
+          mkdirSync(routesPath, { recursive: true });
+        }
+        saveRoutes({ step, folderPath: routesPath });
+      }
     }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath });
+    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags });
     // console.log({ feature_file_path, step_text: step.text });
 
     const stepExecController = new AbortController();
     this.#currentStepController = stepExecController;
-    await withAbort(async () => {
-      await stepsDefinitions.executeStepRemote(
+    const { result, info } = await withAbort(async () => {
+      return await this.executeStepRemote(
         {
           feature_file_path,
           tempFolderPath,
@@ -128,5 +293,6 @@ export class BVTStepRunner {
         fs.rmSync(tempFolderPath, { recursive: true });
       }
     });
+    return { result, info };
   }
 }