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

package/bin/client/cucumber/steps_definitions.js

@@ -36,6 +36,19 @@ class StepsDefinitions {
     //   }
     // });
     const { expressions, methods } = codePage;
+
+    if (codePage.fileContent.includes('from "./utils.mjs"')) {
+      const filePath = path.join(
+        this.baseFolder,
+        this.isTemp ? (process.env.tempFeaturesFolderPath ?? "__temp_features") : "features",
+        "step_definitions",
+        "utils.mjs"
+      );
+      const utilsCodePage = new CodePage(filePath);
+      utilsCodePage.generateModel();
+      methods.push(...utilsCodePage.methods);
+    }
+
     for (let i = 0; i < expressions.length; i++) {
       const expression = expressions[i];
       const pattern = expression.pattern;

package/bin/client/local_agent.js

@@ -1100,7 +1100,7 @@ class LocalAgent {
     if (this.context && this.context.web) {
       await this.context.web.afterStep(
         {
-          attach: (data, mimeType) => { },
+          attach: (data, mimeType) => {},
         },
         this.cucumberStep
       );

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, 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 SocketIOEvents = {
+    REQUEST: "request",
+    RESPONSE: "response",
+    CONNECT: "connect",
+    DISCONNECT: "disconnect",
+    CREATE_ROOM: "createRoom",
+    JOIN_ROOM: "joinRoom",
+};
+class PromisifiedSocketServer {
+    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 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(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 (input) => {
+            return await recorder.getContext();
+        },
+        "recorderWindow.addCommandToStepCode": async (input) => {
+            return await recorder.addCommandToStepCode(input);
+        },
+        "recorderWindow.deleteCommandFromStepCode": async (input) => {
+            return await recorder.deleteCommandFromStepCode(input);
+        },
+        "recorderWindow.generateLocatorSummaries": async (input) => {
+            return await recorder.generateLocatorSummaries(input);
+        }
+    });
+    socket.on("targetBrowser.command.event", async (input) => {
+        return recorder.onAction(input);
+    });
+    promisifiedSocketServer.init();
+}
+export { BVTRecorderInit };