@dev-blinq/cucumber_client 1.0.1711-dev → 1.0.1713-dev

package/bin/client/recorderv3/bvt_init.js

@@ -3,318 +3,300 @@ 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;
+import socketLogger, { getErrorMessage, responseSize } from "../utils/socket_logger.js";
+const 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;
-  }
+const SocketIOEvents = {
+    REQUEST: "request",
+    RESPONSE: "response",
+    CONNECT: "connect",
+    DISCONNECT: "disconnect",
+    CREATE_ROOM: "createRoom",
+    JOIN_ROOM: "joinRoom",
 };
-
 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,
+    socket;
+    routes;
+    constructor(socket, routes) {
+        this.socket = socket;
+        this.routes = routes;
+    }
+    init() {
+        this.socket.on(SocketIOEvents.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(SocketIOEvents.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(SocketIOEvents.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 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);
-    },
-    "recorderWindow.getStepCodeByScenario": async (input) => {
-      return await recorder.getStepCodeByScenario(input);
-    },
-    "recorderWindow.setStepCodeByScenario": async (input) => {
-      return await recorder.setStepCodeByScenario(input);
-    },
-    "recorderWindow.getRecorderContext": async (input) => {
-      return await recorder.getContext();
-    },
-    "recorderWindow.addCommandToStepCode": async (input) => {
-      return await recorder.addCommandToStepCode(input);
-    },
-    "recorderWindow.deleteCommandFromStepCode": async (input) => {
-      return await recorder.deleteCommandFromStepCode(input);
-    },
-  });
-
-  socket.on("targetBrowser.command.event", async (input) => {
-    return recorder.onAction(input);
-  });
-  promisifiedSocketServer.init();
+    console.log(`Connecting to ${WS_URL}`);
+    socket = socket || io(WS_URL);
+    socketLogger.init(socket, { context: "BVTRecorder", eventName: "BVTRecorder.log" });
+    socket.on(SocketIOEvents.CONNECT, () => {
+        socketLogger.info(`${roomId} Connected to BVTRecorder server`);
+    });
+    socket.on(SocketIOEvents.DISCONNECT, (reason) => {
+        socketLogger.info(`${roomId} Disconnected from server: ${reason}`);
+    });
+    socket.emit(SocketIOEvents.JOIN_ROOM, { 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 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 (_) => {
+            return recorder.abortExecution();
+        },
+        "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 () => {
+            return await recorder.getCurrentPageTitle();
+        },
+        "recorderWindow.getCurrentPageUrl": async () => {
+            return 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.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);
+        },
+        "recorderWindow.getStepCodeByScenario": async (input) => {
+            return await recorder.getStepCodeByScenario(input);
+        },
+        "recorderWindow.setStepCodeByScenario": async (input) => {
+            return await recorder.setStepCodeByScenario(input);
+        },
+        "recorderWindow.getRecorderContext": async () => {
+            return await recorder.getContext();
+        },
+        "recorderWindow.addCommandToStepCode": async (input) => {
+            return await recorder.addCommandToStepCode(input);
+        },
+        "recorderWindow.deleteCommandFromStepCode": async (input) => {
+            return await recorder.deleteCommandFromStepCode(input);
+        },
+    });
+    socket.on("targetBrowser.command.event", async (input) => {
+        return recorder.onAction(input);
+    });
+    promisifiedSocketServer.init();
 }
-
 export { BVTRecorderInit };