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

package/bin/client/recorderv3/implemented_steps.js

@@ -116,6 +116,12 @@ export const getImplementedSteps = async (projectDir) => {
     const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
     //console.log({ utilsContent });
     writeFileSync(utilsFilePath, utilsContent, "utf8");
+    const hooksTemplateFilePath = path.join(__dirname, "../../assets", "templates", "_hooks_template.txt");
+    if (existsSync(hooksTemplateFilePath)) {
+      const hooksFilePath = path.join(stepDefinitionFolderPath, "_hooks.mjs");
+      const hooksContent = readFileSync(hooksTemplateFilePath, "utf8");
+      writeFileSync(hooksFilePath, hooksContent, "utf8");
+    }
   } catch (error) {
     foundErrors.push({ error });
   }
@@ -229,6 +235,7 @@ export const getImplementedSteps = async (projectDir) => {
         pattern: template.pattern,
         paths: template.paths,
         routeItems: step.routeItems,
+        isApiStep: template.source === "api",
       };
 
       implementedSteps.push(implementedStep);
@@ -254,6 +261,7 @@ export const getImplementedSteps = async (projectDir) => {
           mjsFile: template.mjsFile,
           pattern: template.pattern,
           paths: template.paths,
+          isApiStep: template.source === "api",
         };
         // reconstruct the parameters
         const parameters = [];

package/bin/client/recorderv3/index.js

@@ -1,295 +1,5 @@
 import { loadArgs, showUsage, validateCLIArg } from "../cli_helpers.js";
-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";
-
-let port = process.env.EDITOR_PORT || 3003;
-const WS_URL = "http://localhost:" + port;
-
-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;
-      console.log("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);
-        // console.log("response", { id, value: response, roomId, socketId });
-        this.socket.emit("response", { id, value: response, roomId, socketId });
-      } catch (error) {
-        console.log("request", JSON.stringify({ event, input, id, roomId, socketId }));
-        console.error("response", { id, error, roomId, socketId });
-        // console.error({
-        //   message: error?.message,
-        //   code: error?.code,
-        //   info: error?.info,
-        //   stack: error?.stack,
-        // })
-        this.socket.emit("response", {
-          id,
-          error: {
-            message: error?.message,
-            code: error?.code,
-            info: error?.info,
-            stack: error?.stack,
-          },
-          roomId,
-          socketId,
-        });
-      }
-    });
-  }
-}
-
-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");
-  });
-  socket.on("disconnect", () => {
-    console.log("disconnected from server");
-  });
-  socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
-  const recorder = new BVTRecorder({
-    envName,
-    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
-    .openBrowser()
-    .then(() => {
-      // console.log("BVTRecorder.browserOpened");
-      socket.emit("BVTRecorder.browserOpened", null, roomId);
-    })
-    .catch((e) => {
-      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
-    });
-  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);
-      throw error;
-    }
-  };
-
-  const promisifiedSocketServer = new PromisifiedSocketServer(socket, {
-    "recorderWindow.openBrowser": async (input) => {
-      return recorder
-        .openBrowser(input)
-        .then(() => {
-          socket.emit("BVTRecorder.browserOpened", { roomId, window: "cucumber_client/bvt_recorder" });
-        })
-        .catch((e) => {
-          console.error(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(() => {
-          // console.log("BVTRecorder.browserOpened");
-          socket.emit("BVTRecorder.browserOpened", null, roomId);
-        })
-        .catch(() => {
-          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.abortExecution": async (input) => {
-      return recorder.abortExecution(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) {
-        // Get the list of filenames in the snapshot folder
-        const files = await readdir(snapshotFolder);
-        // Filter the files to only include .png files
-        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);
-    },
-  });
-  socket.on("targetBrowser.command.event", async (input) => {
-    return recorder.onAction(input);
-  });
-  promisifiedSocketServer.init();
-};
+import { BVTRecorderInit } from "./bvt_init.js";
 
 const usage = `Usage: node bvt_recorder.js <projectDir> <envName> <roomId>`;
 const args = loadArgs();
@@ -298,6 +8,7 @@ const envName = args[1].split("=")[1];
 const roomId = args[2];
 const shouldTakeScreenshot = args[3];
 const TOKEN = process.env.TOKEN;
+
 try {
   validateCLIArg(projectDir, "projectDir");
   validateCLIArg(envName, "envName");
@@ -309,15 +20,5 @@ try {
 } catch (error) {
   showUsage(error, usage);
 }
-try {
-  // console.log({ envName, projectDir, featureName, scenarioName, stepIndex, roomId })
-  init({
-    envName,
-    projectDir,
-    roomId,
-    TOKEN,
-    shouldTakeScreenshot: shouldTakeScreenshot ? shouldTakeScreenshot === "true" : false,
-  });
-} catch (error) {
-  console.error(error);
-}
+
+BVTRecorderInit({ envName, projectDir, roomId, TOKEN });

package/bin/client/recorderv3/scriptTest.js

@@ -2,4 +2,4 @@
 
 // getImplementedSteps('/Users/yash/Library/Application Support/blinq.io/67d7c7ffb099a8da65d7e204').then((implementedSteps) => {
 //     console.log(JSON.stringify(implementedSteps, null, 2));
-// });
+// });