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

package/bin/client/recorderv3/implemented_steps.js

@@ -1,9 +1,9 @@
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
 import path from "path";
 import url from "url";
 import { findFilesWithExtension, StepsDefinitions } from "../cucumber/steps_definitions.js";
-import { Feature } from "../cucumber/feature.js";
+import { Feature, Step } from "../cucumber/feature.js";
 import { CodePage } from "../code_gen/page_reflection.js";
 import { getCommandsForImplementedStep, loadStepDefinitions } from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
@@ -13,7 +13,6 @@ const uuidFn = () => (++id).toString(16);
 const builder = new AstBuilder(uuidFn);
 const matcher = new GherkinClassicTokenMatcher();
 const parser = new Parser(builder, matcher);
-
 let i = 0;
 const getImplId = () => {
   return `I-${i++}`;
@@ -57,6 +56,53 @@ function memorySizeOf(obj) {
   return sizeOf(obj);
 }
 
+export function parseRouteFiles(projectDir, step) {
+  const routeFolder = path.join(projectDir, "data", "routes");
+  const templateRouteMap = new Map();
+
+  if (!existsSync(routeFolder)) {
+    step.routeItems = null;
+    return;
+  }
+
+  // Go over all the files in the route folder and parse them
+  const routeFiles = readdirSync(routeFolder).filter((file) => file.endsWith(".json"));
+  for (const file of routeFiles) {
+    const filePath = path.join(routeFolder, file);
+    const routeData = JSON.parse(readFileSync(filePath, "utf8"));
+    if (routeData && routeData.template) {
+      const template = routeData.template;
+      const routes = routeData.routes;
+
+      templateRouteMap.set(template, routes);
+    }
+  }
+
+  if (!existsSync(routeFolder)) {
+    return null;
+  } else if (step && step.text) {
+    // Convert the step text to cucumber template
+    const cucumberStep = new Step();
+    cucumberStep.text = step.text;
+    const template = cucumberStep.getTemplate();
+    if (templateRouteMap.has(template)) {
+      const routeItems = templateRouteMap.get(template);
+      routeItems.forEach((item) => {
+        const filters = item.filters || {};
+        const queryParams = filters?.queryParams || {};
+        const queryParamsArray = Object.keys(queryParams).map((key) => ({
+          key: key,
+          value: queryParams[key],
+        }));
+        filters.queryParams = queryParamsArray || [];
+      });
+      step.routeItems = routeItems;
+    } else {
+      step.routeItems = null;
+    }
+  }
+}
+
 export const getImplementedSteps = async (projectDir) => {
   const foundErrors = [];
   try {
@@ -168,7 +214,10 @@ export const getImplementedSteps = async (projectDir) => {
       }
       stepLineSet.add(stepLine);
       step.templateIndex = implementedSteps.length;
-      implementedSteps.push({
+
+      parseRouteFiles(projectDir, step);
+
+      const implementedStep = {
         keyword: step.keyword.trim(),
         keywordAlias: step.keywordAlias?.trim(),
         text: updateStepText(template.pattern, step.parameters),
@@ -179,7 +228,10 @@ export const getImplementedSteps = async (projectDir) => {
         templateIndex: step.templateIndex,
         pattern: template.pattern,
         paths: template.paths,
-      });
+        routeItems: step.routeItems,
+      };
+
+      implementedSteps.push(implementedStep);
     }
   }
 
@@ -233,17 +285,20 @@ export const getImplementedSteps = async (projectDir) => {
     delete scenario.featureText;
     delete scenario.scenarioDocument;
     delete scenario.examples;
-    delete scenario.steps;
     for (const tag of scenario.tags) {
       delete tag.location;
     }
-    // const steps = scenario.steps;
-    // for (const step of steps) {
-    //   const index = implementedSteps.findIndex((istep) => {
-    //     return stepsDefinitions._stepNameToTemplate(step.text) === istep.pattern;
-    //   });
-    //   step.templateIndex = index;
-    // }
+    for (const scenario of scenarios) {
+      for (const step of scenario.steps) {
+        if (step.templateIndex === undefined) {
+          const cleanStepName = stepsDefinitions._stepNameToTemplate(step.text);
+          const index = implementedSteps.findIndex((istep) => {
+            return cleanStepName === istep.pattern;
+          });
+          step.templateIndex = index;
+        }
+      }
+    }
   }
   if (foundErrors.length > 0) {
     console.log("foundErrors", foundErrors);
@@ -253,7 +308,7 @@ export const getImplementedSteps = async (projectDir) => {
   return { implementedSteps, scenarios };
 };
 
-export const getStepsAndCommandsForScenario = ({ name, featureName, projectDir }) => {
+export const getStepsAndCommandsForScenario = ({ name, featureName, projectDir, map }) => {
   const stepsDefinitions = new StepsDefinitions(projectDir);
   const step_definitions = loadStepDefinitions(projectDir);
   stepsDefinitions.load();

package/bin/client/recorderv3/index.js

@@ -16,7 +16,7 @@ class PromisifiedSocketServer {
   init() {
     this.socket.on("request", async (data) => {
       const { event, input, id, roomId, socketId } = data;
-      // console.log("request", { event, input, id, roomId, socketId });
+      console.log("request", { event, input, id, roomId, socketId });
       try {
         const handler = this.routes[event];
         if (!handler) {
@@ -51,14 +51,45 @@ 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);
   socket.on("connect", () => {
-    // console.log('connected to server')
+    console.log("connected to server");
   });
   socket.on("disconnect", () => {
-    // console.log('disconnected from server')
+    console.log("disconnected from server");
   });
   socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
   const recorder = new BVTRecorder({
@@ -66,8 +97,10 @@ 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);
+      console.log("Successfully sent event", event, "to room", roomId);
     },
   });
   recorder
@@ -77,7 +110,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 +172,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);
     },
@@ -242,6 +272,18 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
       return await recorder.getStepsAndCommandsForScenario(input);
     },
+    "recorderWindow.getNetworkEvents": async (input) => {
+      return await recorder.getNetworkEvents(input);
+    },
+    "recorderWindow.initExecution": async (input) => {
+      return await recorder.initExecution(input);
+    },
+    "recorderWindow.cleanupExecution": async (input) => {
+      return await recorder.cleanupExecution(input);
+    },
+    "recorderWindow.resetExecution": async (input) => {
+      return await recorder.resetExecution(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;