@dev-blinq/cucumber_client 1.0.1318-dev → 1.0.1320-dev

package/bin/client/code_gen/playwright_codeget.js

@@ -731,14 +731,21 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
       return;
     }
 
-    if (process.env.TEMP_RUN === "true") {
-      codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
-    }
+    // if (process.env.TEMP_RUN === "true") {
+    //   codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
+    // }
     const result = _generateCodeFromCommand(recordingStep, elements, userData);
-    codeLines.push(...result.codeLines);
-    if (process.env.TEMP_RUN === "true") {
-      codeLines.push(...generateReportCommand("end", recordingStep.cmdId));
+    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));
+    // }
     if (result.elements) {
       elements = result.elements;
     }

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));
 
@@ -190,16 +190,16 @@ export class BVTRecorder {
         if (data && data.type) {
           switch (data.type) {
             case "cmdExecutionStart":
-              console.log("Sending cmdExecutionStart event for cmdId:", data.cmdId);
-              this.sendEvent(this.events.cmdExecutionStart, data.cmdId);
+              console.log("Sending cmdExecutionStart event for cmdId:", data);
+              this.sendEvent(this.events.cmdExecutionStart, data);
               break;
             case "cmdExecutionSuccess":
-              console.log("Sending cmdExecutionSuccess event for cmdId:", data.cmdId);
-              this.sendEvent(this.events.cmdExecutionSuccess, data.cmdId);
+              console.log("Sending cmdExecutionSuccess event for cmdId:", data);
+              this.sendEvent(this.events.cmdExecutionSuccess, data);
               break;
             case "cmdExecutionFailure":
-              console.log("Sending cmdExecutionFailure event for cmdId:", data.cmdId);
-              this.sendEvent(this.events.cmdExecutionFailure, data.cmdId);
+              console.log("Sending cmdExecutionFailure event for cmdId:", data);
+              this.sendEvent(this.events.cmdExecutionFailure, data);
               break;
             default:
               console.warn("Unknown command execution status type:", data.type);
@@ -209,10 +209,9 @@ export class BVTRecorder {
       },
     });
     this.pageSet = new Set();
-    this.networkMonitor = new NetworkMonitor();
     this.lastKnownUrlPath = "";
     // TODO: what is world?
-    this.world = { attach: () => {} };
+    this.world = { attach: () => { } };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
   }
@@ -320,7 +319,7 @@ export class BVTRecorder {
     process.env.CDP_LISTEN_PORT = this.#remoteDebuggerPort;
 
     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 = {};
@@ -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();
   }
@@ -726,7 +725,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;
@@ -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) {
@@ -130,7 +132,7 @@ export class BVTStepRunner {
           }
           if (testStepResult.status === "UNDEFINED") {
             if (!errorMesssage) {
-              errorMesssage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+              errorMesssage = stepText ? `step ${JSON.stringify(stepText)} is ${testStepResult.status}` : testStepResult.message;
               if (info) {
                 errInfo = info;
               }
@@ -142,33 +144,46 @@ export class BVTStepRunner {
           if (attachment.mediaType === "application/json" && attachment.body) {
             const body = JSON.parse(attachment.body);
             info = body.info;
+            const result = body.result;
 
-            if (body && body.payload) {
-              const payload = body.payload;
-              const content = payload.content;
-              const type = payload.type;
-              if (type === "cmdReport") {
-                if (content) {
-                  const report = JSON.parse(content);
-                  switch (report.status) {
-                    case "start":
-                      this.sendExecutionStatus({
-                        type: "cmdExecutionStart",
-                        cmdId: report.cmdId,
-                      });
-                      break;
-                    case "end":
-                      this.sendExecutionStatus({
-                        type: "cmdExecutionSuccess",
-                        cmdId: report.cmdId,
-                      });
-                      break;
-                    default:
-                      console.warn("Unknown command report status:", report.status);
-                  }
-                }
-              }
+            if (result.status === "PASSED") {
+              this.sendExecutionStatus({
+                type: "cmdExecutionSuccess",
+                cmdId: body.cmdId,
+              });
+            } else {
+              this.sendExecutionStatus({
+                type: "cmdExecutionError",
+                cmdId: body.cmdId,
+                error: result.error,
+              });
             }
+            // if (body && body.payload) {
+            //   const payload = body.payload;
+            //   const content = payload.content;
+            //   const type = payload.type;
+            //   if (type === "cmdReport") {
+            //     if (content) {
+            //       const report = JSON.parse(content);
+            //       switch (report.status) {
+            //         case "start":
+            //           this.sendExecutionStatus({
+            //             type: "cmdExecutionStart",
+            //             cmdId: report.cmdId,
+            //           });
+            //           break;
+            //         case "end":
+            //           this.sendExecutionStatus({
+            //             type: "cmdExecutionSuccess",
+            //             cmdId: report.cmdId,
+            //           });
+            //           break;
+            //         default:
+            //           console.warn("Unknown command report status:", report.status);
+            //       }
+            //     }
+            //   }
+            // }
           }
         }
       });
@@ -189,6 +204,20 @@ export class BVTStepRunner {
   };
 
   async runStep({ step, parametersMap, envPath, tags }, bvtContext, options) {
+    let cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+    if (bvtContext.web) {
+      bvtContext.web.getCmdId = () => {
+        if (cmdIDs.length === 0) {
+          cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+        }
+        const cId = cmdIDs.shift();
+        this.sendExecutionStatus({
+          type: "cmdExecutionStart",
+          cmdId: cId,
+        })
+        return cId;
+      }
+    }
     let codePage; // = getCodePage();
     // const tempFolderPath = process.env.tempFeaturesFolderPath;
     const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
@@ -228,6 +257,35 @@ export class BVTStepRunner {
       if (!codePage) {
         codePage = getUtilsCodePage(this.projectDir);
       }
+    } 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 });
+      }
     }
     const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags });
     // console.log({ feature_file_path, step_text: step.text });
@@ -235,7 +293,7 @@ export class BVTStepRunner {
     const stepExecController = new AbortController();
     this.#currentStepController = stepExecController;
     const { result, info } = await withAbort(async () => {
-      return await this.executeStepRemote(
+      return await stepsDefinitions.executeStepRemote(
         {
           feature_file_path,
           tempFolderPath,

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.1318-dev",
+  "version": "1.0.1320-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",