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

package/bin/client/parse_feature_file.js

@@ -1,37 +1,34 @@
-import {
-  AstBuilder,
-  GherkinClassicTokenMatcher,
-  Parser,
-} from '@cucumber/gherkin'
-import { readFileSync, writeFileSync } from 'fs'
-import { loadArgs, showUsage, validateCLIArg } from './cli_helpers.js'
-let id =0;
-const uuidFn = () => (++id).toString(16) 
-const builder = new AstBuilder(uuidFn)
-const matcher = new GherkinClassicTokenMatcher()
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import { readFileSync, writeFileSync } from "fs";
+import { loadArgs, showUsage, validateCLIArg } from "./cli_helpers.js";
+let id = 0;
+const uuidFn = () => (++id).toString(16);
+const builder = new AstBuilder(uuidFn);
+const matcher = new GherkinClassicTokenMatcher();
 
-const parser = new Parser(builder, matcher)
+const parser = new Parser(builder, matcher);
 
 const parseFeatureFile = (featureFilePath) => {
-  const source = readFileSync(featureFilePath, 'utf8')
-  const gherkinDocument = parser.parse(source)
-  return gherkinDocument
-}
+  const source = readFileSync(featureFilePath, "utf8");
+  const gherkinDocument = parser.parse(source);
+  return gherkinDocument;
+};
 
-const args = loadArgs()
-const featureFilePath = args[0]
-const outputFilePath = args[1]
-const usage = 'Usage: node parse_feature_file.js <featureFilePath> [<outputFilePath>] \n\nExample: node parseFeatureFile.js ./features/my.feature ./features/my.feature.json\n\n'
+const args = loadArgs();
+const featureFilePath = args[0];
+const outputFilePath = args[1];
+const usage =
+  "Usage: node parse_feature_file.js <featureFilePath> [<outputFilePath>] \n\nExample: node parseFeatureFile.js ./features/my.feature ./features/my.feature.json\n\n";
 try {
-  validateCLIArg(featureFilePath, 'featureFilePath')
+  validateCLIArg(featureFilePath, "featureFilePath");
 } catch (error) {
-  showUsage(error, usage)
+  showUsage(error, usage);
 }
-const gherkinDocument = parseFeatureFile(featureFilePath)
+const gherkinDocument = parseFeatureFile(featureFilePath);
 if (outputFilePath) {
-  writeFileSync(outputFilePath, JSON.stringify(gherkinDocument, null, 2))
+  writeFileSync(outputFilePath, JSON.stringify(gherkinDocument, null, 2));
 } else {
-  console.log(JSON.stringify(gherkinDocument, null, 2))
+  console.log(JSON.stringify(gherkinDocument, null, 2));
 }
 
-export { parseFeatureFile }
+export { parseFeatureFile };

package/bin/client/playground/projects/env.json

@@ -1,3 +1,3 @@
 {
-    "baseUrl": "https://google.com"
-}
+  "baseUrl": "https://google.com"
+}

package/bin/client/recorderv3/bvt_init.js

@@ -0,0 +1,363 @@
+import { io } from "socket.io-client";
+import { BVTRecorder } from "./bvt_recorder.js";
+import { compareWithScenario } from "../code_gen/duplication_analysis.js";
+import { getAppDataDir } from "./app_dir.js";
+import { readdir } from "fs/promises";
+import socketLogger 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) {
+          console.error(`No handler found for event: ${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) {
+        console.error(`Error handling request for event: ${JSON.stringify(event, null, 2)}`, error);
+        socketLogger.error("Error handling request", {
+          event,
+          input,
+          id,
+          roomId,
+          socketId,
+          error: error instanceof Error ? `${error.message}\n${error.stack}` : error,
+        });
+        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) {
+    console.error(error);
+    socketLogger.error(error);
+    throw error;
+  }
+};
+
+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`);
+    console.log(`${roomId} Connected to BVTRecorder server`);
+  });
+  socket.on("disconnect", () => {
+    socketLogger.info(`${roomId} Disconnected from server`);
+    console.log(`${roomId} Disconnected from server`);
+  });
+  socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
+  const recorder = new BVTRecorder({
+    envName,
+    projectDir,
+    TOKEN,
+    sendEvent: (event, data) => {
+      socketLogger.info("Sending event", { event, data, roomId });
+      socket.emit(event, data, roomId);
+    },
+    logger: socketLogger,
+  });
+  // try {
+  //   await recorder.openBrowser();
+  //   socketLogger.info("BVTRecorder.browserOpened");
+  //   socket.emit("BVTRecorder.browserOpened", null, roomId);
+  // } catch (e) {
+  //   if (e instanceof Error) {
+  //     socketLogger.error("BVTRecorder.browserLaunchFailed", e);
+  //     socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
+  //   } else {
+  //     socketLogger.error("BVTRecorder.browserLaunchFailed", JSON.stringify(e));
+  //     socket.emit("BVTRecorder.browserLaunchFailed", JSON.stringify(e), roomId);
+  //   }
+  //   console.error("Browser launch failed", e);
+  // }
+
+  // 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");
+          console.info("BVTRecorder.browserOpened");
+          socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
+        })
+        .catch((e) => {
+          socketLogger.error("Error opening browser", e);
+          console.error("BVTRecorder.browserLaunchFailed", e);
+          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");
+          console.log("BVTRecorder.browserOpened");
+          socket.emit("BVTRecorder.browserOpened", null, roomId);
+        })
+        .catch((e) => {
+          socketLogger.info("BVTRecorder.browserLaunchFailed");
+          console.error("BVTRecorder.browserLaunchFailed", e);
+          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) => {
+      // console.log("recorderWindow.getImplementedSteps", input);
+      return (await recorder.getImplementedSteps(input)).implementedSteps;
+    },
+    "recorderWindow.getImplementedScenarios": async (input) => {
+      // console.log("recorderWindow.getImplementedScenarios", input);
+      return (await recorder.getImplementedSteps(input)).scenarios;
+    },
+    "recorderWindow.getCurrentChromiumPath": async () => {
+      // console.log("recorderWindow.getCurrentChromiumPath");
+      return await recorder.getCurrentChromiumPath();
+    },
+    "recorderWindow.overwriteTestData": async (input) => {
+      // console.log("recorderWindow.overwriteTestData");
+      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 (input) => {
+      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);
+    },
+    "browserUI.requestState": async (input) => {
+      console.log("Received browserUI.requestState");
+      await recorder.getBrowserState();
+    },
+    "browserUI.createTab": async (input) => {
+      console.log("Received browserUI.createTab", input);
+      await recorder.createTab(input);
+    },
+    "browserUI.closeTab": async (input) => {
+      console.log("Received browserUI.closeTab", input);
+      await recorder.closeTab(input);
+    },
+    "browserUI.selectTab": async (input) => {
+      console.log("Received browserUI.selectTab", input);
+      await recorder.selectTab(input);
+    },
+    "browserUI.navigateTab": async (input) => {
+      console.log("Received browserUI.navigateTab", input);
+      await recorder.navigateTab(input);
+    },
+    "browserUI.reloadTab": async (input) => {
+      console.log("Received browserUI.reloadTab", input);
+      await recorder.reloadTab(input);
+    },
+    "browserUI.goBack": async (input) => {
+      console.log("Received browserUI.goBack", input);
+      await recorder.goBack(input);
+    },
+    "browserUI.goForward": async (input) => {
+      console.log("Received browserUI.goForward", input);
+      await recorder.goForward(input);
+    },
+    "browserUI.writeToClipboard": async (input) => {
+      console.log("Received browserUI.writeToClipboard");
+      await recorder.applyClipboardPayload(input);
+    },
+    "browserUI.readToClipboard": async (input) => {
+      console.log("Received browserUI.readToClipboard");
+      await recorder.readClipboardPayload(input);
+    },
+    "recorderWindow.cleanup": async (input) => {
+      return recorder.cleanup(input);
+    },
+  });
+
+  socket.on("targetBrowser.command.event", async (input) => {
+    return recorder.onAction(input);
+  });
+  promisifiedSocketServer.init();
+}
+
+export { BVTRecorderInit };