@dev-blinq/cucumber_client 1.0.1437-stage → 1.0.1438-stage

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/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,6 +756,7 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     if (recordingStep.type === Types.COMPLETE) {
       return;
     }
+    socketLogger.info(`Generating code for step: ${recordingStep.type}`, undefined, "generateCode");
 
     // if (process.env.TEMP_RUN === "true") {
     //   codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
@@ -758,9 +768,11 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     //   codeLines.push(...generateReportCommand("end", recordingStep.cmdId));
     // }
     if (result.elements) {
+      socketLogger.info(`Updating elements with ${Object.keys(result.elements)}`, undefined, "generateCode");
       elements = result.elements;
     }
     if (result.elementIdentifier) {
+      socketLogger.info(`Adding locator metadata for ${result.elementIdentifier}`, undefined, "generateCode");
       locatorsMetadata[result.elementIdentifier] = result.allStrategyLocators;
     }
   });
@@ -797,7 +809,7 @@ const generatePageName = (url) => {
     }
     // join by _
     return lowerCaseParts.join("_");
-  } catch (err) {
+  } catch {
     return "default";
   }
 };

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,46 +291,6 @@ 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);
-    },
-    "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);
     },

package/bin/client/recorderv3/bvt_recorder.js

@@ -1,19 +1,19 @@
 // define the jsdoc type for the input
 import { closeContext, initContext, _getDataFile, resetTestData } from "automation_model";
-import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
-import path from "path";
-import url from "url";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import url from "node:url";
 import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
-import { NamesService, RemoteBrowserService, PublishService } from "./services.js";
+import { NamesService, PublishService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
-import { readFile, writeFile } from "fs/promises";
+import { readFile, writeFile } from "node:fs/promises";
 import { loadStepDefinitions, getCommandsForImplementedStep } from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort } from "../utils/index.js";
-import socketLogger from "../utils/socket_logger.js";
+import socketLogger, { getErrorMessage } from "../utils/socket_logger.js";
 import { tmpdir } from "os";
 import { faker } from "@faker-js/faker/locale/en_US";
 import { chromium } from "playwright-core";
@@ -361,8 +361,7 @@ async function findNestedFrameSelector(frame, obj) {
     }, frameElement);
     return findNestedFrameSelector(parent, { children: obj, selectors });
   } catch (e) {
-    socketLogger.error(`Error in findNestedFrameSelector: ${e}`);
-    console.error(e);
+    socketLogger.error(`Error in script evaluation: ${getErrorMessage(e)}`, undefined, "findNestedFrameSelector");
   }
 }
 const transformFillAction = (action, el) => {
@@ -507,7 +506,7 @@ export class BVTRecorder {
     this.workspaceService = new PublishService(this.TOKEN);
     this.pageSet = new Set();
     this.lastKnownUrlPath = "";
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
     this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
@@ -650,7 +649,7 @@ export class BVTRecorder {
     }
 
     // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -702,17 +701,6 @@ export class BVTRecorder {
     this.web.tryAllStrategies = true;
     this.page = bvtContext.page;
     this.pageSet.add(this.page);
-    if (process.env.REMOTE_RECORDER === "true") {
-      this.browserEmitter = new RemoteBrowserService({
-        CDP_CONNECT_URL: `http://localhost:${this.#remoteDebuggerPort}`,
-        context: this.context,
-      });
-      this.browserEmitter.on(this.events.browserStateSync, (state) => {
-        this.page = this.browserEmitter.getSelectedPage();
-        this.sendEvent(this.events.browserStateSync, state);
-      });
-    }
-
     this.lastKnownUrlPath = this._updateUrlPath();
     const browser = await this.context.browser();
     this.browser = browser;
@@ -722,8 +710,10 @@ export class BVTRecorder {
       await this.context.exposeBinding(name, handler);
     }
     this._watchTestData();
-    this.web.onRestoreSaveState = (url) => {
-      this._initBrowser({ url });
+    this.web.onRestoreSaveState = async (url) => {
+      await this._initBrowser({ url });
+      this._addPagelisteners(this.context);
+      this._addFrameNavigateListener(this.page);
     };
 
     // create a second browser for locator generation
@@ -1154,7 +1144,7 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => { });
+    await this.watcher.close().then(() => {});
     this.watcher = null;
     this.previousIndex = null;
     this.previousHistoryLength = null;
@@ -1313,9 +1303,7 @@ export class BVTRecorder {
       this.bvtContext.navigate = false;
     }
   }
-  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env }) {
-    // await updateStepDefinitions({ scenario, featureName, projectDir: this.projectDir }); // updates mjs files
-    // if (!isSingleStep) await updateFeatureFile({ featureName, scenario, override, projectDir: this.projectDir }); // updates gherkin files
+  async saveScenario({ scenario, featureName, override, isSingleStep, branch, isEditing, env, AICode }) {
     const res = await this.workspaceService.saveScenario({
       scenario,
       featureName,
@@ -1499,7 +1487,7 @@ export class BVTRecorder {
 
     const steps = [];
     const parameters = [];
-    const datasets = []
+    const datasets = [];
     if (scenario.examples && scenario.examples.length > 0) {
       const example = scenario.examples[0];
       example?.tableHeader?.cells.forEach((cell, index) => {
@@ -1507,7 +1495,7 @@ export class BVTRecorder {
           key: cell.value,
           value: unEscapeNonPrintables(example.tableBody[0].cells[index].value),
         });
-        // datasets.push({ 
+        // datasets.push({
         //   data: example.tableBody[]
         // })
       });
@@ -1951,7 +1939,7 @@ export class BVTRecorder {
       await page
         .context()
         .grantPermissions(["clipboard-read", "clipboard-write"])
-        .catch(() => { });
+        .catch(() => {});
       await page.evaluate(async (clipboardPayload) => {
         const toArrayBuffer = (base64) => {
           if (!base64) {

package/bin/client/recorderv3/step_runner.js

@@ -67,8 +67,7 @@ export class BVTStepRunner {
           resolve();
         }
       } else {
-        console.warn(`No paused command found for cmdId: ${cmdId}`);
-        socketLogger.error(`No paused command found for cmdId: ${cmdId}`);
+        socketLogger.error(`No paused command found for cmdId: ${cmdId}`, undefined, "BVTStepRunner.resumeExecution");
       }
     }
   }
@@ -335,6 +334,7 @@ export class BVTStepRunner {
           projectDir: this.projectDir,
           stepsDefinitions,
           parametersMap,
+          logger: socketLogger,
         });
         if (codePage) {
           await codePage.save(stepDefsFilePath);