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

package/bin/client/local_agent.js

@@ -696,6 +696,7 @@ class LocalAgent {
               stepDiff: stepResult,
             });
             page.removeUnusedElements();
+            page.mergeSimilarElements();
             agent.scenarioReport.updateLastStep({
               code: {
                 cleanFileNames: page.cleanFileNames,

package/bin/client/recorderv3/bvt_init.js

@@ -0,0 +1,305 @@
+import { io } from "socket.io-client";
+import { BVTRecorder } from "./bvt_recorder.js";
+import { compareWithScenario } from "../code_gen/duplication_analysis.js";
+import { getAppDataDir } from "../utils/app_dir.js";
+import { readdir } from "fs/promises";
+import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
+
+let port = process.env.EDITOR_PORT || 3003;
+const WS_URL = process.env.WORKER_WS_SERVER_URL || "http://localhost:" + port;
+
+const responseSize = (response) => {
+  try {
+    if (typeof response !== "string") {
+      return new Blob([JSON.stringify(response)]).size;
+    } else {
+      return new Blob([response]).size;
+    }
+  } catch {
+    return -1;
+  }
+};
+
+class PromisifiedSocketServer {
+  constructor(socket, routes) {
+    this.socket = socket;
+    this.routes = routes;
+  }
+  init() {
+    this.socket.on("request", async (data) => {
+      const { event, input, id, roomId, socketId } = data;
+      if (event !== "recorderWindow.getCurrentChromiumPath") {
+        socketLogger.info("Received request", { event, input, id, roomId, socketId });
+      }
+      try {
+        const handler = this.routes[event];
+        if (!handler) {
+          socketLogger.error(`No handler found for event: ${event}`, undefined, event);
+          return;
+        }
+        const response = await handler(input);
+        if (event !== "recorderWindow.getCurrentChromiumPath") {
+          socketLogger.info(`Sending response for ${event}, ${responseSize(response)} bytes`);
+        }
+        this.socket.emit("response", { id, value: response, roomId, socketId });
+      } catch (error) {
+        socketLogger.error(
+          "Error handling request",
+          {
+            input,
+            id,
+            roomId,
+            socketId,
+            error: error instanceof Error ? `${error.message}\n${error.stack}` : error,
+          },
+          event
+        );
+        this.socket.emit("response", {
+          id,
+          error: {
+            message: error?.message,
+            code: error?.code,
+            info: error?.info,
+            stack: error?.stack,
+          },
+          roomId,
+          socketId,
+        });
+      }
+    });
+  }
+}
+
+const timeOutForFunction = async (promise, timeout = 5000) => {
+  const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
+
+  try {
+    const res = await Promise.race([promise, timeoutPromise]);
+    return res;
+  } catch (error) {
+    socketLogger.error(error, undefined, "timeOutForFunction");
+    throw error;
+  }
+};
+
+const CLIENT_IDENTIFIER = "cucumber_client/bvt_recorder";
+
+async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = null }) {
+  console.log(`Connecting to ${WS_URL}`);
+  socket = socket || io(WS_URL);
+  socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
+  socket.on("connect", () => {
+    socketLogger.info(`${roomId} Connected to BVTRecorder server`);
+  });
+  socket.on("disconnect", (reason) => {
+    socketLogger.info(`${roomId} Disconnected from server: ${reason}`);
+  });
+  socket.emit("joinRoom", { id: roomId, window: CLIENT_IDENTIFIER });
+  const recorder = new BVTRecorder({
+    envName,
+    projectDir,
+    TOKEN,
+    sendEvent: (event, data) => {
+      socketLogger.info("Sending event", { event, data, roomId });
+      socket.emit(event, data, roomId);
+    },
+    logger: socketLogger,
+  });
+  // emit connected event for every 50 ms until connection_ack message is recieved
+  let connected = false;
+  const interval = setInterval(() => {
+    if (connected) {
+      clearInterval(interval);
+      return;
+    }
+    socket.emit("BVTRecorder.connected", { roomId, window: "cucumber_client/bvt_recorder" }, roomId);
+  }, 50);
+
+  const promisifiedSocketServer = new PromisifiedSocketServer(socket, {
+    "recorderWindow.connectionAck": async (input) => {
+      connected = true;
+      clearInterval(interval);
+    },
+    "recorderWindow.openBrowser": async (input) => {
+      return recorder
+        .openBrowser(input)
+        .then(() => {
+          socketLogger.info("BVTRecorder.browserOpened");
+          socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
+        })
+        .catch((e) => {
+          socketLogger.error(`Error opening browser: ${getErrorMessage(e)}`, undefined, "recorderWindow.openBrowser");
+          socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
+        });
+    },
+    "recorderWindow.closeBrowser": async (input) => {
+      return recorder.closeBrowser(input);
+    },
+    "recorderWindow.reOpenBrowser": async (input) => {
+      return recorder
+        .reOpenBrowser(input)
+        .then(() => {
+          socketLogger.info("BVTRecorder.browserOpened");
+          socket.emit("BVTRecorder.browserOpened", null, roomId);
+        })
+        .catch((e) => {
+          socketLogger.error(
+            `Error reopening browser: ${getErrorMessage(e)}`,
+            undefined,
+            "recorderWindow.reOpenBrowser"
+          );
+          socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+        });
+    },
+    "recorderWindow.startRecordingInput": async (input) => {
+      return timeOutForFunction(recorder.startRecordingInput(input));
+    },
+    "recorderWindow.stopRecordingInput": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingInput(input));
+    },
+    "recorderWindow.startRecordingText": async (input) => {
+      // console.log("--- {{ }} -- : recorderWindow.startRecordingText", input);
+      return timeOutForFunction(recorder.startRecordingText(input));
+    },
+    "recorderWindow.stopRecordingText": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingText(input));
+    },
+    "recorderWindow.startRecordingContext": async (input) => {
+      return timeOutForFunction(recorder.startRecordingContext(input));
+    },
+    "recorderWindow.stopRecordingContext": async (input) => {
+      return timeOutForFunction(recorder.stopRecordingContext(input));
+    },
+    "recorderWindow.runStep": async (input) => {
+      return recorder.runStep(input);
+    },
+    "recorderWindow.saveScenario": async (input) => {
+      return recorder.saveScenario(input);
+    },
+    "recorderWindow.getImplementedSteps": async (input) => {
+      return (await recorder.getImplementedSteps(input)).implementedSteps;
+    },
+    "recorderWindow.getImplementedScenarios": async (input) => {
+      return (await recorder.getImplementedSteps(input)).scenarios;
+    },
+    "recorderWindow.getCurrentChromiumPath": async () => {
+      return await recorder.getCurrentChromiumPath();
+    },
+    "recorderWindow.overwriteTestData": async (input) => {
+      return await recorder.overwriteTestData(input);
+    },
+    "recorderWindow.generateStepName": async (input) => {
+      return recorder.generateStepName(input);
+    },
+    "recorderWindow.getFeatureAndScenario": async (input) => {
+      return recorder.generateScenarioAndFeatureNames(input);
+    },
+    "recorderWindow.generateCommandName": async (input) => {
+      return recorder.generateCommandName(input);
+    },
+    "recorderWindow.loadTestData": async (input) => {
+      return recorder.loadTestData(input);
+    },
+    "recorderWindow.discard": async (input) => {
+      return await recorder.discardTestData(input);
+    },
+    "recorderWindow.addToTestData": async (input) => {
+      return await recorder.addToTestData(input);
+    },
+    "recorderWindow.getScenarios": async () => {
+      return recorder.getScenarios();
+    },
+    "recorderWindow.setShouldTakeScreenshot": async (input) => {
+      return recorder.setShouldTakeScreenshot(input);
+    },
+    "recorderWindow.compareWithScenario": async ({ projectDir, scenario }, roomId) => {
+      return await compareWithScenario(getAppDataDir(projectDir), scenario);
+    },
+    "recorderWindow.getCommandsForImplementedStep": async (input) => {
+      return recorder.getCommandsForImplementedStep(input);
+    },
+    "recorderWindow.getNumberOfOccurrences": async (input) => {
+      return recorder.getNumberOfOccurrences(input);
+    },
+    "recorderWindow.getFakeParams": async ({ parametersMap }) => {
+      return recorder.fakeParams(parametersMap);
+    },
+    "recorderWindow.abortExecution": async (input) => {
+      return recorder.abortExecution(input);
+    },
+    "recorderWindow.pauseExecution": async (input) => {
+      return recorder.pauseExecution(input);
+    },
+    "recorderWindow.resumeExecution": async (input) => {
+      return recorder.resumeExecution(input);
+    },
+    "recorderWindow.loadExistingScenario": async (input) => {
+      return recorder.loadExistingScenario(input);
+    },
+    "recorderWindow.findRelatedTextInAllFrames": async (input) => {
+      return recorder.findRelatedTextInAllFrames(input);
+    },
+    "recorderWindow.getReportFolder": async (input) => {
+      return recorder.getReportFolder();
+    },
+    "recorderWindow.getSnapshotFiles": async (input) => {
+      const snapshotFolder = recorder.getSnapshotFolder();
+      if (snapshotFolder) {
+        const files = await readdir(snapshotFolder);
+        const ymlFiles = files.filter((file) => file.endsWith(".yml") || file.endsWith(".yaml"));
+        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;
+      if (deselect === true) {
+        return await recorder.deselectAriaElements();
+      }
+      if (snapshot !== null) {
+        return await recorder.processAriaSnapshot(snapshot);
+      }
+    },
+    "recorderWindow.revertMode": async () => {
+      await recorder.revertMode();
+    },
+    "recorderWindow.setMode": async (input) => {
+      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);
+    },
+    "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);
+    },
+    "recorderWindow.stopRecordingNetwork": async (input) => {
+      return recorder.stopRecordingNetwork(input);
+    },
+    "recorderWindow.cleanup": async (input) => {
+      return recorder.cleanup(input);
+    },
+  });
+
+  socket.on("targetBrowser.command.event", async (input) => {
+    return recorder.onAction(input);
+  });
+  promisifiedSocketServer.init();
+}
+
+export { BVTRecorderInit };