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

package/bin/client/recorderv3/step_utils.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import url from "url";
 import logger from "../../logger.js";
@@ -9,6 +9,8 @@ import { Step } from "../cucumber/feature.js";
 import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
+import { tmpdir } from "os";
+import { createHash } from "crypto";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -69,19 +71,75 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+  let routesPath = path.join(tmpdir(), "blinq_temp_routes");
+
+  if (process.env.TEMP_RUN === "true") {
+    if (existsSync(routesPath)) {
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    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");
+      if (!existsSync(routesPath)) {
+        mkdirSync(routesPath, { recursive: true });
+      }
+      saveRoutes({ step, folderPath: routesPath });
+    }
+  }
+
   if (step.isImplementedWhileRecording && !process.env.TEMP_RUN) {
     return;
   }
+
   if (step.isImplemented && step.shouldOverride) {
     let stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+
     if (isUtilStep) {
       return;
     }
   }
+
+  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:", 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();
   const steps = step.commands;
@@ -108,6 +166,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,6 +191,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
+
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
         name: step.text,
@@ -139,6 +199,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         source: "recorder",
       });
     }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -156,17 +217,29 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     if (step.commands && step.commands.length > 0 && step.commands[0]) {
       path = step.commands[0].lastKnownUrlPath;
     }
+    let protect = false;
+    if (step.commands && step.commands.length > 0 && step.commands[0].type) {
+      if (step.commands[0].type === "verify_element_property" || step.commands[0].type === "conditional_wait") {
+        protect = true;
+      }
+    }
     const infraResult = codePage.addInfraCommand(
       methodName,
       description,
       cucumberStep.getVariablesList(),
       generateCodeResult.codeLines,
-      false,
+      protect,
       "recorder",
       path
     );
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
-    const stepResult = codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), methodName, steps.length);
+    const stepResult = codePage.addCucumberStep(
+      keyword,
+      cucumberStep.getTemplate(),
+      methodName,
+      steps.length,
+      step.finalTimeout
+    );
 
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
@@ -177,6 +250,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     }
 
     codePage.removeUnusedElements();
+    codePage.mergeSimilarElements();
     cucumberStep.methodName = methodName;
     if (generateCodeResult.locatorsMetadata) {
       codePage.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
@@ -306,6 +380,12 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   const utilsTemplateFilePath = path.join(__dirname, "../../assets", "templates", "utils_template.txt");
   const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
   writeFileSync(utilsFilePath, utilsContent, "utf8");
+  const hooksTemplateFilePath = path.join(__dirname, "../../assets", "templates", "_hooks_template.txt");
+  if (existsSync(hooksTemplateFilePath)) {
+    const hooksFilePath = path.join(stepDefinitionFolderPath, "_hooks.mjs");
+    const hooksContent = readFileSync(hooksTemplateFilePath, "utf8");
+    writeFileSync(hooksFilePath, hooksContent, "utf8");
+  }
   const steps = scenario.steps;
 
   const stepsDefinitions = new StepsDefinitions(projectDir);
@@ -321,6 +401,35 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
       }
     }
     if ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0) {
+      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);
+          routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+          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 });
+      }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
@@ -328,7 +437,6 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
     const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
     // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
-
     codePage = await saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions });
     if (!codePage) {
       continue;
@@ -340,3 +448,45 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   }
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
+
+export function saveRoutes({ step, folderPath }) {
+  const routeItems = step.routeItems;
+  if (!routeItems || routeItems.length === 0) {
+    return;
+  }
+  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;
+    });
+    const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
+    return {
+      ...routeItem,
+      filters: newFilters,
+    };
+  });
+
+  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 });
+  }
+  try {
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
+    console.log("Saved routes to", routesFilePath);
+  } catch (error) {
+    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+  }
+}

package/bin/client/recorderv3/update_feature.js

@@ -64,7 +64,7 @@ const escapeNonPrintables = (text) => {
 export function getCommandContent(command) {
   switch (command.type) {
     case "click_element": {
-      return `click on ${escapeNonPrintables(command.element.name)}`;
+      return `${command.count === 2 ? "Double click" : "Click"} on ${escapeNonPrintables(command.element.name)}`;
     }
     case "fill_element": {
       return `fill ${escapeNonPrintables(command.element.name)} with ${escapeNonPrintables(command.parameters[0])}${command.parameters[1] ? ` and press enter key` : ""}`;
@@ -82,7 +82,7 @@ export function getCommandContent(command) {
       return `verify the element ${escapeNonPrintables(command.element.name)} contains text ${escapeNonPrintables(command.parameters[0])}`;
     }
     case "context_click": {
-      return `click on ${escapeNonPrintables(command.label)} in the context of ${escapeNonPrintables(command.value)}`;
+      return `${command.count === 2 ? "Double click" : "Click"} on ${escapeNonPrintables(command.label)} in the context of ${escapeNonPrintables(command.value)}`;
     }
     case "hover_element": {
       return `hover over ${escapeNonPrintables(command.element.name)}`;
@@ -99,6 +99,9 @@ export function getCommandContent(command) {
     case "verify_page_snapshot": {
       return `verify page snapshot stored in ${command.parameters[0]}`;
     }
+    case "parameterized_click": {
+      return `${command.count === 2 ? "Parameterized double click" : "Parameterized click"} on ${escapeNonPrintables(command.element.name)}`;
+    }
     default: {
       return "";
     }
@@ -126,10 +129,14 @@ export function getExamplesContent(parametersMap) {
 function getTagsContent(scenario, featureFileObject) {
   let oldTags = featureFileObject?.scenarios?.find((s) => s.name === scenario.name)?.tags ?? [];
   for (const tag of scenario.tags) {
-    if (oldTags.includes(tag)) {
-      oldTags = oldTags.filter((t) => t !== tag);
-    } else {
-      oldTags.push(tag);
+    if (tag === "global_test_data") {
+      if (!oldTags.includes("global_test_data")) {
+        oldTags.push("global_test_data");
+      }
+    }
+
+    if (tag === "remove_global_test_data") {
+      oldTags = oldTags.filter((t) => t !== "global_test_data");
     }
   }
 
@@ -210,14 +217,12 @@ const GherkinToObject = (gherkin) => {
       steps: [],
     };
     while (idx < lines.length && lines[idx].startsWith("@")) {
-      skipEmptyLines();
       const tags = [...lines[idx].matchAll(/@([^@]+)/g)].map((match) => match[1].trim());
       scenario.tags.push(...(tags ?? []));
       idx++;
+      skipEmptyLines();
     }
 
-    skipEmptyLines();
-
     if (idx < lines.length && (lines[idx].startsWith("Scenario:") || lines[idx].startsWith("Scenario Outline:"))) {
       scenario.name = lines[idx].substring(lines[idx].indexOf(":") + 1).trim();
       idx++;
@@ -240,32 +245,32 @@ const GherkinToObject = (gherkin) => {
       !lines[idx].startsWith("@")
     ) {
       const line = lines[idx++];
-      if (line.startsWith("#")) {
-        const comment = line;
-        if (comment) {
-          const command = {
-            type: "comment",
-            text: comment,
-          };
-          scenario.steps.push(command);
-        }
-      } else if (line.startsWith("Examples:")) {
-        obj.hasParams = true;
-        const command = {
+      let command;
+      if (line.startsWith("Examples:")) {
+        scenario.hasParams = true;
+        command = {
           type: "examples",
           lines: [],
         };
-
         while (idx < lines.length && lines[idx].startsWith("|")) {
           const line = lines[idx++];
           command.lines.push(line);
         }
       } else {
-        scenario.steps.push({
-          type: "step",
-          text: line,
-        });
+        if (line.startsWith("#")) {
+          command = {
+            type: "comment",
+            text: line,
+          };
+        } else {
+          command = {
+            type: "step",
+            text: line,
+          };
+        }
       }
+      scenario.steps.push(command);
+      skipEmptyLines();
     }
 
     return scenario;
@@ -274,7 +279,6 @@ const GherkinToObject = (gherkin) => {
   while (idx < lines.length) {
     const scenario = getScenario();
     if (scenario === -1) break;
-
     if (scenario.error) {
       return {
         error: scenario.error,
@@ -300,8 +304,7 @@ function updateExistingScenario({ featureFileContent, scenarioName, scenarioCont
       skipScenarioIndex = i;
       continue;
     }
-    let scenarioContent = `${featureFileObject.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
-
+    let scenarioContent = `${scenario.hasParams ? "Scenario Outline" : "Scenario"}: ${scenario.name}`;
     let tagsLine;
     if (scenario.tags?.length > 0) {
       tagsLine = `${scenario.tags.map((t) => `@${t}`).join(" ")}`;
@@ -324,7 +327,6 @@ function updateExistingScenario({ featureFileContent, scenarioName, scenarioCont
   if (skipScenarioIndex !== -1) {
     finalContent = results.join("\n") + "\n" + scenarioContent;
   }
-
   return finalContent;
 }
 export async function updateFeatureFile({ featureName, scenario, override, projectDir }) {

package/bin/client/recording.js

@@ -52,6 +52,7 @@ const Types = {
   VERIFY_FILE_EXISTS: "verify_file_exists",
   SET_INPUT_FILES: "set_input_files",
   VERIFY_PAGE_SNAPSHOT: "verify_page_snapshot",
+  CONDITIONAL_WAIT: "conditional_wait",
 };
 class Recording {
   steps = [];

package/bin/client/run_cucumber.js

@@ -131,6 +131,10 @@ const runCucumber = async (
   } else if (!process.env.NODE_ENV_BLINQ) {
     serviceUrl = "https://logic.blinq.io";
     logger.info("Running in prod mode");
+  } else if (process.env.WHITELABEL === "true") {
+    // if it's a whitelabel it will use "api" instead of "logic"
+    serviceUrl = process.env.NODE_ENV_BLINQ;
+    logger.info("Running in custom mode: " + serviceUrl);
   } else {
     serviceUrl = process.env.NODE_ENV_BLINQ.replace("api", "logic");
     logger.info("Running in custom mode: " + serviceUrl);
@@ -355,7 +359,7 @@ const runCucumber = async (
           await aiAgent.createNewStepLocal(
             featureName,
             cucumberStep,
-            feature,
+            feature.comments,
             userData,
             first,
             previousTasks,

package/bin/client/scenario_report.js

@@ -33,17 +33,12 @@ const findNextIdInFolder = (folder) => {
 // get temp file path from --temp-file arg
 const getTempFilePath = () => {
   let tempFilePath = null;
-
   for (const arg of process.argv) {
     const [key, path] = arg.split("=");
     if (key === "--temp-file" && !!path) {
       tempFilePath = path;
     }
   }
-
-  if (tempFilePath === null) {
-    tempFilePath = process.env.TEMP_FILE_PATH;
-  }
   return tempFilePath;
 };
 

package/bin/client/test_scenario.js

@@ -267,7 +267,6 @@ try {
     }
     if (validatePath !== "null") {
       await prevrunResult.context.stable.verifyPagePath(validatePath);
-
     }
     //finalCompare = true;
   } catch (e) {

package/bin/client/utils/socket_logger.js

@@ -0,0 +1,132 @@
+/**
+ * @typedef {Object} SocketLoggerEventPayload
+ * @property {string} level        Log level (e.g. "info", "warn", "error", "debug")
+ * @property {string} context      Log context/subsystem (e.g. "BVTRecorder")
+ * @property {*}      data         The log message payload (string, object, etc)
+ * @property {string} timestamp    ISO string when the log was emitted
+ * @property {number} dataSize     Size of data in bytes (-1 if unknown)
+ */
+
+/**
+ * @typedef {Object} SocketLoggerInitOptions
+ * @property {string=} context     Default context for all logs (optional)
+ * @property {string=} eventName   Default event name (default: "recorder.log")
+ */
+
+/**
+ * SocketLogger - Singleton for structured socket-based logging.
+ *
+ * @namespace SocketLogger
+ * @property {function(import('socket.io-client').Socket|import('socket.io').Socket, SocketLoggerInitOptions=):void} init
+ * @property {function(string, (string|*), Object=, string=, string=):void} log
+ * @property {function((string|*), Object=):void} info
+ * @property {function((string|*), Object=):void} warn
+ * @property {function((string|*), Object=):void} debug
+ * @property {function((string|*), Object=):void} error
+ *
+ * @example
+ *   import logger from "./socket_logger.js";
+ *   logger.init(socket, { context: "BVTRecorder" });
+ *   logger.info("Step started", { step: 2 });
+ *   logger.error("Failed!", { error: "bad stuff" });
+ */
+const SocketLogger = (function () {
+  /** @type {import('socket.io-client').Socket|import('socket.io').Socket|null} */
+  let socket = null;
+  /** @type {string} */
+  let defaultContext = "";
+  /** @type {string} */
+  let defaultEventName = "recorder.log";
+
+  /**
+   * Initialize the logger (call once).
+   * @param {import('socket.io-client').Socket|import('socket.io').Socket} sock
+   * @param {SocketLoggerInitOptions=} opts
+   */
+  function init(sock, opts) {
+    socket = sock;
+    defaultContext = (opts && opts.context) || "";
+    defaultEventName = (opts && opts.eventName) || "recorder.log";
+  }
+
+  /**
+   * Low-level log method (most users use info/warn/debug/error).
+   * @param {string} level         Log level ("info", "warn", "debug", "error")
+   * @param {string|*} message     The log message or object
+   * @param {Object=} extra        Extra fields (will be merged into log payload)
+   * @param {string=} eventName    Override event name for this log (default: "recorder.log")
+   * @param {string=} context      Override log context for this log (default: set in init)
+   */
+  function log(level, message, extra, eventName, context) {
+    if (!socket || typeof socket.emit !== "function") return;
+    /** @type {*} */
+    var data = typeof message === "object" ? message : { message: message };
+    /** @type {number} */
+    var dataSize = 0;
+    try {
+      dataSize = Buffer.byteLength(JSON.stringify(data || ""), "utf8");
+    } catch (e) {
+      dataSize = -1;
+    }
+    /** @type {SocketLoggerEventPayload} */
+    var eventPayload = Object.assign(
+      {
+        level: level,
+        context: context || defaultContext,
+        data: data,
+        timestamp: new Date().toISOString(),
+        dataSize: dataSize,
+      },
+      extra || {}
+    );
+    // @ts-ignore
+    try {
+      if (socket) {
+        socket.emit(eventName || defaultEventName, eventPayload);
+      }
+    } catch (e) {
+      console.error("Socket logging error:", e);
+      console.log("Socket event payload:", eventPayload);
+    }
+  }
+
+  /**
+   * Write an info-level log event.
+   * @param {string|*} msg      The message or object
+   * @param {Object=} ext       Any extra fields/metadata
+   */
+  function info(msg, ext) {
+    log("info", msg, ext);
+  }
+
+  /**
+   * Write a warn-level log event.
+   * @param {string|*} msg      The message or object
+   * @param {Object=} ext       Any extra fields/metadata
+   */
+  function warn(msg, ext) {
+    log("warn", msg, ext);
+  }
+
+  /**
+   * Write a debug-level log event.
+   * @param {string|*} msg      The message or object
+   * @param {Object=} ext       Any extra fields/metadata
+   */
+  function debug(msg, ext) {
+    log("debug", msg, ext);
+  }
+
+  /**
+   * Write an error-level log event.
+   * @param {string|*} msg      The message or object
+   * @param {Object=} ext       Any extra fields/metadata
+   */
+  function error(msg, ext) {
+    log("error", msg, ext);
+  }
+
+  return { init, log, info, warn, debug, error };
+})();
+
+export default SocketLogger;

package/bin/index.js

@@ -13,4 +13,5 @@ export * from "./client/cucumber/feature_data.js";
 export * from "./client/cucumber/steps_definitions.js";
 export * from "./client/profiler.js";
 export * from "./client/code_cleanup/utils.js";
+
 export * from "./client/code_cleanup/find_step_definition_references.js";

package/bin/logger.js

@@ -17,8 +17,8 @@ function formatWithInspect(val) {
 let alignColorsAndTime = null;
 let fileRotateTransport = null;
 let errorFileRotateTransport = null;
-export let logger = null;
 function initLogger() {
+  let logger = null;
   try {
     alignColorsAndTime = format.combine(
       format.timestamp({
@@ -59,9 +59,10 @@ function initLogger() {
     console.log(error);
     logger = console;
   }
+  return logger;
 }
 
-initLogger();
+export const logger = initLogger();
 const changeToTaskLogger = (logFile) => {
   logger.remove(fileRotateTransport);
   fileRotateTransport.filename = logFile;