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

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/cucumber/feature_data.js

@@ -41,10 +41,10 @@ const generateTestData = (featureFile) => {
       try {
         const fake = faker.helpers.fake(match[0]);
 
-        if(fake === match[0]){ 
+        if (fake === match[0]) {
           continue;
         }
-        
+
         otherFakeData.push({
           var: match[0],
           fake,

package/bin/client/cucumber/project_to_document.js

@@ -4,7 +4,13 @@ import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherki
 import { Feature } from "./feature.js";
 import { StepsDefinitions } from "./steps_definitions.js";
 
-export const projectDocument = (folder, featureName = null, scenarioName = null, supressErrors = false, errors = []) => {
+export const projectDocument = (
+  folder,
+  featureName = null,
+  scenarioName = null,
+  supressErrors = false,
+  errors = []
+) => {
   const uuidFn = () => (23212).toString(16);
   const builder = new AstBuilder(uuidFn);
   const matcher = new GherkinClassicTokenMatcher();
@@ -59,4 +65,4 @@ export const projectDocument = (folder, featureName = null, scenarioName = null,
 // const documents = projectDocument(projectDir, featureName, scenarioName, true, errors);
 // const args = process.argv.slice(2);
 
-// console.log(JSON.stringify(documents));
+// console.log(JSON.stringify(documents));

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;
@@ -45,7 +58,10 @@ class StepsDefinitions {
       if (method && expression.keyword && pattern && expression.methodName) {
         this.steps[pattern] = {
           // file: path.join(this.isTemp ? "__temp_features" : "features", mjsFile),
-          file: path.join(this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features", mjsFile),
+          file: path.join(
+            this.isTemp ? (process.env.tempFeaturesFolderPath ?? "__temp_features") : "features",
+            mjsFile
+          ),
           functionName: expression.methodName,
           name: pattern,
           source: this.findKey(method.codePart, "source"),
@@ -56,7 +72,7 @@ class StepsDefinitions {
   }
   load(print = true, supressErrors = false, errors = []) {
     const mjsFiles = findFilesWithExtension(
-      path.join(this.baseFolder, this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features"),
+      path.join(this.baseFolder, this.isTemp ? (process.env.tempFeaturesFolderPath ?? "__temp_features") : "features"),
       "mjs"
     );
     // console.log({ mjsFiles });
@@ -64,7 +80,7 @@ class StepsDefinitions {
       const mjsFile = mjsFiles[i];
       const filePath = path.join(
         this.baseFolder,
-        this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features",
+        this.isTemp ? (process.env.tempFeaturesFolderPath ?? "__temp_features") : "features",
         mjsFile
       );
       const codePage = new CodePage(filePath);

package/bin/client/local_agent.js

@@ -696,6 +696,7 @@ class LocalAgent {
               stepDiff: stepResult,
             });
             page.removeUnusedElements();
+            page.mergeSimilarElements();
             agent.scenarioReport.updateLastStep({
               code: {
                 cleanFileNames: page.cleanFileNames,
@@ -809,12 +810,12 @@ class LocalAgent {
           } catch (err) {
             logger.error("Error reading memory file: " + err.message);
           }
-          const screenshot = await agent.getScreenshot(agent.context);
+          //const screenshot = await agent.getScreenshot(agent.context);
           // check if the popup is open
           const popupResult = await agent.context.web.closeUnexpectedPopups(null, null);
           if (nodes) {
             nodes.memory = memory;
-            nodes.screenshot = screenshot;
+            //nodes.screenshot = screenshot;
             if (popupResult.rerun === true) {
               nodes.rerun = true;
             }

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,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 } 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) {
+          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("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("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("connect", () => {
+    socketLogger.info(`${roomId} Connected to BVTRecorder server`);
+  });
+  socket.on("disconnect", (reason) => {
+    socketLogger.info(`${roomId} Disconnected from server: ${reason}`);
+  });
+  socket.emit("joinRoom", { 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 await 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 (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 () => {
+      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);
+    },
+    "recorderWindow.cleanup": async (input) => {
+      return recorder.cleanup(input);
+    },
+  });
+
+  socket.on("targetBrowser.command.event", async (input) => {
+    return recorder.onAction(input);
+  });
+  promisifiedSocketServer.init();
+}
+
+export { BVTRecorderInit };