@dev-blinq/cucumber_client 1.0.1690-dev → 1.0.1692-dev

package/bin/client/code_cleanup/utils.js

@@ -10,7 +10,7 @@ import * as t from "@babel/types";
 import { CucumberExpression, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { getAiConfig } from "../code_gen/page_reflection.js";
-import socketLogger from "../utils/socket_logger.js";
+import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
 
 const STEP_KEYWORDS = new Set(["Given", "When", "Then"]);
 
@@ -308,18 +308,27 @@ export function getDefaultPrettierConfig() {
       const configContent = readFileSync(prettierConfigPath, "utf-8");
       prettierConfig = JSON.parse(configContent);
     } catch (error) {
-      socketLogger.error("Error parsing Prettier config file", error);
-      console.error(`Error parsing Prettier config file: ${error}`);
+      socketLogger.error(
+        `Error parsing Prettier config file: ${getErrorMessage(error)}`,
+        undefined,
+        "getDefaultPrettierConfig"
+      );
     }
   } else {
     // save the default config to .prettierrc
     try {
       writeFileSync(prettierConfigPath, JSON.stringify(prettierConfig, null, 2), "utf-8");
-      socketLogger.info(`Created default Prettier config at ${prettierConfigPath}`);
-      console.log(`Created default Prettier config at ${prettierConfigPath}`);
+      socketLogger.info(
+        `Created default Prettier config at ${prettierConfigPath}`,
+        undefined,
+        "getDefaultPrettierConfig"
+      );
     } catch (error) {
-      socketLogger.error(`Error writing Prettier config file: ${error}`);
-      console.error(`Error writing Prettier config file: ${error}`);
+      socketLogger.error(
+        `Error writing Prettier config file: ${getErrorMessage(error)}`,
+        undefined,
+        "getDefaultPrettierConfig"
+      );
     }
   }
   return prettierConfig;

package/bin/client/code_gen/duplication_analysis.js

@@ -4,6 +4,7 @@ import path from "path";
 import { CodePage } from "./page_reflection.js";
 import { compareElements, generateSignature } from "./function_signature.js";
 import { updateStepDefinitions } from "../recorderv3/step_utils.js";
+import socketLoggerInstance from "../utils/socket_logger.js";
 /**
  * DuplicationAnalizer class
  * How to use:
@@ -101,7 +102,7 @@ async function compareWithScenario(projectDir, scenario) {
   analyzerExisting.load();
   // generate a temporary folder
   const folder = fs.mkdtempSync(path.join(os.tmpdir(), "blinq-"));
-  await updateStepDefinitions({ scenario, featureName: "temp", projectDir: folder });
+  await updateStepDefinitions({ scenario, featureName: "temp", projectDir: folder, logger: socketLoggerInstance });
   const analyzerScenario = new DuplicationAnalizer(folder);
   analyzerScenario.load();
   const compareResults = [];

package/bin/client/code_gen/page_reflection.js

@@ -455,6 +455,46 @@ export class CodePage {
         code += "}\n";
         return this._injectMethod(methodName, code);
     }
+    _replaceSelectedCode(code, injectIndexEnd) {
+        const newFileContent = this.fileContent.substring(0, injectIndexEnd - 2) +
+            "\n  " +
+            code +
+            "\n}\n" +
+            this.fileContent.substring(injectIndexEnd);
+        this._init();
+        this.generateModel(newFileContent);
+    }
+    _injectOneCommand(methodName, code) {
+        const result = { methodName };
+        code = code.trim();
+        const existMethod = this.methods.find((m) => m.name === methodName);
+        if (!existMethod) {
+            throw new Error(`method ${methodName} not found for injection`);
+        }
+        const oldCode = existMethod.codePart.trim();
+        this._replaceSelectedCode(code, existMethod.end);
+        result.status = CodeStatus.UPDATED;
+        result.oldCode = oldCode;
+        result.newCode = code;
+        return result;
+    }
+    _removeSelectedCode(commands, injectIndexStart, injectIndexEnd) {
+        let newFileContent = this.fileContent.substring(injectIndexStart, injectIndexEnd);
+        commands.forEach((cmd) => {
+            newFileContent = newFileContent.replace(cmd, "");
+        });
+        newFileContent =
+            this.fileContent.substring(0, injectIndexStart) + newFileContent + this.fileContent.substring(injectIndexEnd);
+        this._init();
+        this.generateModel(newFileContent);
+    }
+    _removeCommands(methodName, commands) {
+        const existMethod = this.methods.find((m) => m.name === methodName);
+        if (!existMethod) {
+            throw new Error(`method ${methodName} not found for removal`);
+        }
+        this._removeSelectedCode(commands, existMethod.start, existMethod.end);
+    }
     _injectMethod(methodName, code) {
         const result = { methodName };
         code = code.trim();

package/bin/client/code_gen/playwright_codeget.js

@@ -69,12 +69,23 @@ const _isCodeGenerationStep = (step) => {
     step.type === Types.VERIFY_PROPERTY ||
     step.type === Types.SET_INPUT_FILES ||
     step.type === Types.VERIFY_PAGE_SNAPSHOT ||
-    step.type === Types.CONDITIONAL_WAIT
+    step.type === Types.CONDITIONAL_WAIT ||
+    step.type === Types.CLOSE_PAGE
   ) {
     return true;
   }
   return false;
 };
+
+const _isLocatorStrategyStep = (step) => {
+  switch (step.type) {
+    case Types.VERIFY_PAGE_SNAPSHOT:
+    case Types.CLOSE_PAGE:
+      return false;
+    default:
+      return true;
+  }
+};
 // Note: this function is used to exclude a key from an object
 // Please move it to utils and use it as a reusable function  ...
 function excludeKey(obj, keyToRemove) {
@@ -112,7 +123,7 @@ const _generateCodeFromCommand = (step, elements, userData) => {
   if (_isCodeGenerationStep(step) === false)
     return { codeLines, elements: elementsChanged ? elements : null, elementIdentifier, allStrategyLocators };
 
-  if (_isCodeGenerationStep(step) && step.type !== Types.VERIFY_PAGE_SNAPSHOT) {
+  if (_isCodeGenerationStep(step) && _isLocatorStrategyStep(step)) {
     allStrategyLocators = step.allStrategyLocators ?? splitToLocatorsGroups(step.locators);
     let node = null;
 
@@ -728,12 +739,10 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
       codePage = new CodePage(mjsFullPath);
       codePage.generateModel();
     }
-    //console.log("step found");
   }
   let elements = {};
   if (!codePage) {
-    socketLogger.info("CodePage is null");
-    console.log("codePage is null");
+    socketLogger.info("CodePage is null", undefined, "generateCode");
   } else {
     elements = codePage.getVariableDeclarationAsObject("elements");
   }
@@ -747,7 +756,7 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     if (recordingStep.type === Types.COMPLETE) {
       return;
     }
-    console.log("Generating code for step: ", recordingStep.type);
+    socketLogger.info(`Generating code for step: ${recordingStep.type}`, undefined, "generateCode");
 
     // if (process.env.TEMP_RUN === "true") {
     //   codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
@@ -759,11 +768,11 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     //   codeLines.push(...generateReportCommand("end", recordingStep.cmdId));
     // }
     if (result.elements) {
-      console.log("Updating elements with ", Object.keys(result.elements));
+      socketLogger.info(`Updating elements with ${Object.keys(result.elements)}`, undefined, "generateCode");
       elements = result.elements;
     }
     if (result.elementIdentifier) {
-      console.log("Adding locator metadata for ", result.elementIdentifier);
+      socketLogger.info(`Adding locator metadata for ${result.elementIdentifier}`, undefined, "generateCode");
       locatorsMetadata[result.elementIdentifier] = result.allStrategyLocators;
     }
   });
@@ -800,8 +809,8 @@ const generatePageName = (url) => {
     }
     // join by _
     return lowerCaseParts.join("_");
-  } catch (err) {
+  } catch {
     return "default";
   }
 };
-export { generateCode, generatePageName };
+export { generateCode, generatePageName, _generateCodeFromCommand };

package/bin/client/cucumber/feature.js

@@ -6,7 +6,6 @@ import os from "os";
 import path from "path";
 import { parseStepTextParameters, toCucumberExpression, unEscapeNonPrintables } from "./utils.js";
 import stream from "stream";
-import { testStringForRegex } from "../recorderv3/update_feature.js";
 import { generateTestData } from "./feature_data.js";
 import socketLogger from "../utils/socket_logger.js";
 class DataTable {
@@ -490,8 +489,8 @@ const scenarioResolution = async (featureFilePath) => {
     let result = generateTestData(featureFilePath);
     if (result.changed) {
       fs.writeFileSync(tmpFeatureFilePath, result.newContent);
-      console.log("Fake data was generated for this scenario");
-      console.log("Variables:");
+      socketLogger.info("Generated fake data for feature", undefined, "scenarioResolution");
+      socketLogger.info("Variables generated:", result.variables, "scenarioResolution");
       for (let key in result.variables) {
         console.log(`${key}: ${result.variables[key].fake}`);
       }
@@ -503,8 +502,7 @@ const scenarioResolution = async (featureFilePath) => {
       fs.copyFileSync(featureFilePath, tmpFeatureFilePath);
     }
     const writable = new stream.Writable({
-      write: function (chunk, encoding, next) {
-        //console.log(chunk.toString());
+      write: (chunk, encoding, next) => {
         next();
       },
     });
@@ -521,23 +519,12 @@ const scenarioResolution = async (featureFilePath) => {
     // load the support code upfront
     const support = await loadSupport(runConfiguration, environment);
     // run cucumber, using the support code we loaded already
-    await runCucumber({ ...runConfiguration, support }, environment, function (event) {
-      // if (event.source) {
-      //   scenarioInfo.source = event.source.data;
-      // }
-      // if (event.pickle && event.pickle.name === scenarioName) {
-      //   scenarioInfo.pickle = event.pickle;
-      // }
+    await runCucumber({ ...runConfiguration, support }, environment, (event) => {
       if (event.gherkinDocument) {
         gherkinDocument = event.gherkinDocument;
       }
-      //console.log(event);
-      //console.log(JSON.stringify(event, null, 2));
-      // console.log("");
     });
     const feature = new Feature(gherkinDocument, featureFileContent);
-    //const scenario = feature.getScenario(scenarioName);
-    //return scenario;
     return feature;
   } finally {
     try {

package/bin/client/recorderv3/bvt_init.js

@@ -1,9 +1,9 @@
 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 { getAppDataDir } from "../utils/app_dir.js";
 import { readdir } from "fs/promises";
-import socketLogger from "../utils/socket_logger.js";
+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;
@@ -34,7 +34,7 @@ class PromisifiedSocketServer {
       try {
         const handler = this.routes[event];
         if (!handler) {
-          console.error(`No handler found for event: ${event}`);
+          socketLogger.error(`No handler found for event: ${event}`, undefined, event);
           return;
         }
         const response = await handler(input);
@@ -43,15 +43,17 @@ class PromisifiedSocketServer {
         }
         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,
-        });
+        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: {
@@ -75,25 +77,24 @@ const timeOutForFunction = async (promise, timeout = 5000) => {
     const res = await Promise.race([promise, timeoutPromise]);
     return res;
   } catch (error) {
-    console.error(error);
-    socketLogger.error(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);
+  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.on("disconnect", (reason) => {
+    socketLogger.info(`${roomId} Disconnected from server: ${reason}`);
   });
-  socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
+  socket.emit("joinRoom", { id: roomId, window: CLIENT_IDENTIFIER });
   const recorder = new BVTRecorder({
     envName,
     projectDir,
@@ -104,21 +105,6 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
     },
     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(() => {
@@ -139,12 +125,10 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
         .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);
+          socketLogger.error(`Error opening browser: ${getErrorMessage(e)}`, undefined, "recorderWindow.openBrowser");
           socket.emit("BVTRecorder.browserLaunchFailed", { roomId, window: "cucumber_client/bvt_recorder" });
         });
     },
@@ -156,12 +140,14 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
         .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);
+          socketLogger.error(
+            `Error reopening browser: ${getErrorMessage(e)}`,
+            undefined,
+            "recorderWindow.reOpenBrowser"
+          );
           socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
         });
     },
@@ -191,19 +177,15 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
       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) => {
@@ -284,7 +266,7 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
         return await recorder.processAriaSnapshot(snapshot);
       }
     },
-    "recorderWindow.revertMode": async (input) => {
+    "recorderWindow.revertMode": async () => {
       await recorder.revertMode();
     },
     "recorderWindow.setMode": async (input) => {
@@ -309,48 +291,23 @@ async function BVTRecorderInit({ envName, projectDir, roomId, TOKEN, socket = nu
     "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);
+    "recorderWindow.cleanup": async (input) => {
+      return recorder.cleanup(input);
     },
-    "browserUI.goBack": async (input) => {
-      console.log("Received browserUI.goBack", input);
-      await recorder.goBack(input);
+    "recorderWindow.getStepCodeByScenario": async (input) => {
+      return await recorder.getStepCodeByScenario(input);
     },
-    "browserUI.goForward": async (input) => {
-      console.log("Received browserUI.goForward", input);
-      await recorder.goForward(input);
+    "recorderWindow.setStepCodeByScenario": async (input) => {
+      return await recorder.setStepCodeByScenario(input);
     },
-    "browserUI.writeToClipboard": async (input) => {
-      console.log("Received browserUI.writeToClipboard");
-      await recorder.applyClipboardPayload(input);
+    "recorderWindow.getRecorderContext": async (input) => {
+      return await recorder.getContext();
     },
-    "browserUI.readToClipboard": async (input) => {
-      console.log("Received browserUI.readToClipboard");
-      await recorder.readClipboardPayload(input);
+    "recorderWindow.addCommandToStepCode": async (input) => {
+      return await recorder.addCommandToStepCode(input);
     },
-    "recorderWindow.cleanup": async (input) => {
-      return recorder.cleanup(input);
+    "recorderWindow.deleteCommandFromStepCode": async (input) => {
+      return await recorder.deleteCommandFromStepCode(input);
     },
   });