@dev-blinq/cucumber_client 1.0.1317-dev → 1.0.1319-dev

package/bin/client/code_gen/playwright_codeget.js

@@ -735,6 +735,13 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
       codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
     }
     const result = _generateCodeFromCommand(recordingStep, elements, userData);
+    if (process.env.TEMP_RUN) {
+      // Add try catch block to the generated code, should attach commandId to world object
+      result.codeLines.unshift(`try {`);
+      result.codeLines.push(
+        `} catch (err) { throw new Error("Error in command ${recordingStep.cmdId}: " + err.message); }`
+      );
+    }
     codeLines.push(...result.codeLines);
     if (process.env.TEMP_RUN === "true") {
       codeLines.push(...generateReportCommand("end", recordingStep.cmdId));

package/bin/client/recorderv3/bvt_recorder.js

@@ -15,7 +15,7 @@ import chokidar from "chokidar";
 import logger from "../../logger.js";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort } from "../utils/index.js";
-import NetworkMonitor from "./network.js";
+import { Step } from "../cucumber/feature.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -209,7 +209,6 @@ export class BVTRecorder {
       },
     });
     this.pageSet = new Set();
-    this.networkMonitor = new NetworkMonitor();
     this.lastKnownUrlPath = "";
     // TODO: what is world?
     this.world = { attach: () => {} };
@@ -619,7 +618,6 @@ export class BVTRecorder {
         this.pageSet.add(page);
 
         await page.waitForLoadState("domcontentloaded");
-
         // add listener for frame navigation on new tab
         this._addFrameNavigateListener(page);
       } catch (error) {
@@ -709,6 +707,7 @@ export class BVTRecorder {
     if (this.shouldTakeScreenshot) {
       await this.storeScreenshot(event);
     }
+    
     this.sendEvent(this.events.onNewCommand, cmdEvent);
     this._updateUrlPath();
   }
@@ -784,6 +783,7 @@ export class BVTRecorder {
   }
 
   async startRecordingInput() {
+    console.log("startRecordingInput");
     await this.setMode("recordingInput");
   }
   async stopRecordingInput() {
@@ -1016,6 +1016,53 @@ export class BVTRecorder {
     const stepParams = parseStepTextParameters(stepName);
     return getCommandsForImplementedStep(stepName, step_definitions, stepParams).commands;
   }
+
+  parseRouteFiles(step) {
+    const routeFolder = path.join(this.projectDir, "data", "routes");
+    const templateRouteMap = new Map();
+
+    // Go over all the files in the route folder and parse them
+    const routeFiles = readdirSync(routeFolder).filter((file) => file.endsWith(".json"));
+    for (const file of routeFiles) {
+      const filePath = path.join(routeFolder, file);
+      const routeData = JSON.parse(readFileSync(filePath, "utf8"));
+      if (routeData && routeData.template) {
+        const template = routeData.template;
+        const routes = routeData.routes;
+
+        templateRouteMap.set(template, routes);
+      }
+    }
+
+    if (!existsSync(routeFolder)) {
+      return null;
+    } else if (step && step.text) {
+      // Convert the step text to cucumber template
+      const cucumberStep = new Step();
+      cucumberStep.text = step.text;
+      const template = cucumberStep.getTemplate();
+      if (templateRouteMap.has(template)) {
+        const routeItems = templateRouteMap.get(template);
+        console.log("Route Items from template:", routeItems);
+        routeItems.forEach((item) => {
+          const filters = item.filters || {};
+          const queryParams = filters?.queryParams || {};
+          console.log("Query Params:", queryParams);
+          const queryParamsArray = Object.keys(queryParams).map((key) => ({
+            paramKey: key,
+            paramValue: queryParams[key],
+          }));
+          console.log("Query Params Array:", queryParamsArray);
+          filters.queryParams = queryParamsArray || [];
+        });
+        step.routeItems = routeItems;
+        console.log("Route Items:", step.routeItems);
+      } else {
+        step.routeItems = null;
+      }
+    }
+  }
+
   loadExistingScenario({ featureName, scenarioName }) {
     const step_definitions = loadStepDefinitions(this.projectDir);
     const featureFilePath = path.join(this.projectDir, "features", featureName);
@@ -1044,6 +1091,7 @@ export class BVTRecorder {
         ..._s,
         keyword: step.keyword.trim(),
       };
+      this.parseRouteFiles(_step);
       steps.push(_step);
     }
     return {

package/bin/client/recorderv3/index.js

@@ -16,7 +16,7 @@ class PromisifiedSocketServer {
   init() {
     this.socket.on("request", async (data) => {
       const { event, input, id, roomId, socketId } = data;
-      // console.log("request", { event, input, id, roomId, socketId });
+      console.log("request", { event, input, id, roomId, socketId });
       try {
         const handler = this.routes[event];
         if (!handler) {
@@ -86,10 +86,10 @@ 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')
+    console.log("connected to server");
   });
   socket.on("disconnect", () => {
-    // console.log('disconnected from server')
+    console.log("disconnected from server");
   });
   socket.emit("joinRoom", { id: roomId, window: "cucumber_client/bvt_recorder" });
   const recorder = new BVTRecorder({

package/bin/client/recorderv3/network.js

@@ -1,18 +1,8 @@
-/**
- * @typedef {Object} NetworkEvent
- * @property {import('playwright').Request} request
- * @property {import('playwright').Response|null} response
- * @property {string} id
- * @property {number} timestamp
- * @property {string} status - 'completed', 'failed'
- */
-
 class NetworkMonitor {
   constructor() {
     this.networkId = 0;
-    /** @type {Map<string, NetworkEvent>} */
-    this.requestIdMap = new Map();
     this.networkEvents = new Map();
+    this.requestIdMap = new Map();
     /** @type {Map<import('playwright').Page, {responseListener: Function, requestFailedListener: Function}>} */
     this.pageListeners = new Map();
   }
@@ -22,6 +12,7 @@ class NetworkMonitor {
    * @param {import('playwright').Page} page
    */
   addNetworkEventListener(page) {
+
     // Create the listener functions
     const responseListener = async (response) => {
       const request = response.request();
@@ -210,6 +201,7 @@ class NetworkMonitor {
       // Try to get response body safely (only for successful responses)
       if (response && networkEvent.status === "completed") {
         try {
+
           const isBinary =
             !response.headers()["content-type"]?.includes("application/json") &&
             !response.headers()["content-type"]?.includes("text");
@@ -237,6 +229,7 @@ class NetworkMonitor {
         marshalledEvent.failureReason = request.failure()?.errorText || "Unknown error";
       }
 
+
       console.log("Marshalled network event:", marshalledEvent);
 
       return marshalledEvent;
@@ -253,18 +246,7 @@ class NetworkMonitor {
     }
   }
 
-  /**
-   *@returns {Promise<Object[]>}
-   * Get all marshalled network events
-   * This is useful for sending to the server or saving to a file.
-   *   */
-  async getAllMarshalledNetworkEvents() {
-    const events = this.getAllNetworkEvents();
-    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
-    return marshalledEvents;
-  }
 
-  /**
    * Get marshalled network events since this ID
    * @returns {Promise<Object[]>}
    * @param {number} sinceId
@@ -281,6 +263,7 @@ class NetworkMonitor {
    * @param {number} endId
    * @returns {Promise<Object[]>}
    */
+
   async getMarshalledNetworkEventsInRange(startId, endId) {
     const events = this.getNetworkEventsInRange(startId, endId);
     const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));

package/bin/client/recorderv3/step_runner.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import fs from "fs";
 import { generatePageName } from "../code_gen/playwright_codeget.js";
@@ -9,9 +9,11 @@ import {
   getUtilsCodePage,
   loadStepDefinitions,
   saveRecording,
+  saveRoutes,
 } from "./step_utils.js";
 import { escapeString, getExamplesContent } from "./update_feature.js";
 import { locateDefinitionPath } from "../cucumber/steps_definitions.js";
+import { tmpdir } from "os";
 
 // let copiedCodeToTemp = false;
 async function withAbort(fn, signal) {
@@ -228,28 +230,57 @@ export class BVTStepRunner {
       if (!codePage) {
         codePage = getUtilsCodePage(this.projectDir);
       }
-    }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags });
-    // console.log({ feature_file_path, step_text: step.text });
-
-    const stepExecController = new AbortController();
-    this.#currentStepController = stepExecController;
-    const { result, info } = await withAbort(async () => {
-      return await this.executeStepRemote(
-        {
-          feature_file_path,
-          tempFolderPath,
-          stepText: step.text,
-          scenario: "Temp Scenario",
-        },
-        options
-      );
-    }, stepExecController.signal).finally(() => {
-      // rm temp folder
-      if (fs.existsSync(tempFolderPath)) {
-        fs.rmSync(tempFolderPath, { recursive: true });
+    } else {
+      let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+      if (process.env.TEMP_RUN === "true") {
+        console.log("Save routes in temp folder for running:", routesPath);
+        if (existsSync(routesPath)) {
+          console.log("Removing existing temp_routes_folder:", routesPath);
+          rmSync(routesPath, { recursive: true });
+        }
+        mkdirSync(routesPath, { recursive: true });
+        console.log("Created temp_routes_folder:", routesPath);
+        saveRoutes({ step, folderPath: routesPath });
+      } else {
+        console.log("Saving routes in project directory:", this.projectDir);
+        if (existsSync(routesPath)) {
+          // remove the folder
+          try {
+            rmSync(routesPath, { recursive: true });
+            console.log("Removed temp_routes_folder:", routesPath);
+          } catch (error) {
+            console.error("Error removing temp_routes folder", error);
+          }
+        }
+        routesPath = path.join(this.projectDir, "data", "routes");
+        console.log("Saving routes to:", routesPath);
+        if (!existsSync(routesPath)) {
+          mkdirSync(routesPath, { recursive: true });
+        }
+        saveRoutes({ step, folderPath: routesPath });
       }
-    });
-    return { result, info };
+      const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags });
+      // console.log({ feature_file_path, step_text: step.text });
+
+      const stepExecController = new AbortController();
+      this.#currentStepController = stepExecController;
+      const { result, info } = await withAbort(async () => {
+        return await stepsDefinitions.executeStepRemote(
+          {
+            feature_file_path,
+            tempFolderPath,
+            stepText: step.text,
+            scenario: "Temp Scenario",
+          },
+          options
+        );
+      }, stepExecController.signal).finally(() => {
+        // rm temp folder
+        if (fs.existsSync(tempFolderPath)) {
+          fs.rmSync(tempFolderPath, { recursive: true });
+        }
+      });
+      return { result, info };
+    }
   }
 }

package/bin/client/recorderv3/step_utils.js

@@ -71,6 +71,7 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
+
   let routesPath = path.join(tmpdir(), "blinq_temp_routes");
 
   if (process.env.TEMP_RUN) {
@@ -105,10 +106,39 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+
     if (isUtilStep) {
       return;
     }
   }
+  
+  if (process.env.TEMP_RUN === "true") {
+    console.log("Save routes in temp folder for running:", routesPath);
+    if (existsSync(routesPath)) {
+      console.log("Removing existing temp_routes_folder:", routesPath);
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    console.log("Created temp_routes_folder:", routesPath);
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    console.log("Saving routes in project directory:", projectDir);
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        console.error("Error removing temp_routes folder", error);
+      }
+    }
+    routesPath = path.join(projectDir, "data", "routes");
+    console.log("Saving routes to:", routesPath);
+    if (!existsSync(routesPath)) {
+      mkdirSync(routesPath, { recursive: true });
+    }
+    saveRoutes({ step, folderPath: routesPath });
+  }
 
   cucumberStep.text = step.text;
   const recording = new Recording();
@@ -385,11 +415,13 @@ export function saveRoutes({ step, folderPath }) {
   const cucumberStep = getCucumberStep({ step });
   const template = cucumberStep.getTemplate();
   const stepNameHash = createHash("sha256").update(template).digest("hex");
+  console.log("Saving routes for step:", step.text, "with hash:", stepNameHash);
+
   const routeItemsWithFilters = routeItems.map((routeItem) => {
     const oldFilters = routeItem.filters;
     const queryParamsObject = {};
     oldFilters.queryParams.forEach((queryParam) => {
-      queryParamsObject[queryParam.key] = queryParam.value;
+      queryParamsObject[queryParam.paramKey] = queryParam.paramValue;
     });
     const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
     return {
@@ -399,10 +431,13 @@ export function saveRoutes({ step, folderPath }) {
   });
 
   const routesFilePath = path.join(folderPath, stepNameHash + ".json");
+  console.log("Routes file path:", routesFilePath);
   const routesData = {
     template,
     routes: routeItemsWithFilters,
   };
+  console.log("Routes data to save:", routesData);
+
   if (!existsSync(folderPath)) {
     mkdirSync(folderPath, { recursive: true });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1317-dev",
+  "version": "1.0.1319-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -32,7 +32,7 @@
     "@cucumber/tag-expressions": "^6.1.1",
     "@dev-blinq/cucumber-js": "1.0.178-dev",
     "@faker-js/faker": "^8.1.0",
-    "automation_model": "1.0.776-dev",
+    "automation_model": "1.0.777-dev",
     "axios": "^1.7.4",
     "chokidar": "^3.6.0",
     "create-require": "^1.1.1",