@dev-blinq/cucumber_client 1.0.1301-dev → 1.0.1301-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,9 +9,425 @@ 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));
 
+const convertToIdentifier = (text) => {
+  // replace all invalid characters with _
+  return text.replace(/[^a-zA-Z0-9_]/g, "_");
+};
+
+export const isVariable = (text) => {
+  if (typeof text !== "string") return false;
+  const isParametric = text.startsWith("<") && text.endsWith(">");
+  if (!isParametric) return false;
+  const l = text.length;
+  if (l < 2) return false;
+  const leftindex = text.indexOf("<");
+  const rightindex = text.indexOf(">");
+  return leftindex === 0 && rightindex === l - 1;
+};
+
+export const extractQuotes = (text) => {
+  const stringRegex = /"([^"]*)"/g;
+  const matches = text.match(stringRegex);
+  if (!matches) return [];
+  const quotes = [];
+  for (const match of matches) {
+    const value = match.slice(1, -1);
+    quotes.push(value);
+  }
+  return quotes;
+};
+
+const replaceLastOccurence = (str, search, replacement) => {
+  const lastIndex = str.lastIndexOf(search);
+  if (lastIndex === -1) return str;
+  return str.substring(0, lastIndex) + replacement + str.substring(lastIndex + search.length);
+};
+
+const _toRecordingStep = (cmd) => {
+  switch (cmd.type) {
+    case "hover_element": {
+      return {
+        type: "hover_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "click_element": {
+      return {
+        type: "click_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "context_click": {
+      return {
+        type: "context_click",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        label: cmd.label,
+        value: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        text: cmd.text,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "parameterized_click": {
+      return {
+        type: "parameterized_click",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        label: cmd.label,
+        value: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        count: cmd.count ?? 1,
+      };
+    }
+    case "fill_element": {
+      return {
+        type: "fill_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value, cmd.enter ?? false],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "select_combobox": {
+      return {
+        type: "select_combobox",
+        element: {
+          role: "combobox",
+          name: cmd.label,
+        },
+        selectMode: "select",
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_page_contains_text": {
+      return {
+        type: "verify_page_contains_text",
+        parameters: [cmd.value, cmd.isRegex],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_element_contains_text": {
+      return {
+        type: "verify_element_contains_text",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value, cmd.climb],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "close_page": {
+      return {
+        type: "close_page",
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "check_element": {
+      return {
+        type: "check_element",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        check: cmd.check,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "press_key": {
+      return {
+        type: "press_key",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        key: cmd.value,
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "load_user": {
+      return {
+        type: "load_data",
+        parameters: ["users", cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "load_csv": {
+      return {
+        type: "load_data",
+        parameters: ["csv", `${cmd.label}:${cmd.value}`],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "set_date_time": {
+      return {
+        type: "set_date_time",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "set_input": {
+      return {
+        type: "set_input",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        value: cmd.value,
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "extract_attribute": {
+      return {
+        type: "extract_attribute",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.variableName],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        regex: cmd.regex,
+        trimSpaces: cmd.trimSpaces,
+      };
+    }
+    case "extract_property": {
+      return {
+        type: "extract_property",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.variableName],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+        regex: cmd.regex,
+        trimSpaces: cmd.trimSpaces,
+      };
+    }
+    case "verify_element_attribute": {
+      return {
+        type: "verify_element_attribute",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_element_property": {
+      return {
+        type: "verify_element_property",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "conditional_wait": {
+      return {
+        type: "conditional_wait",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.timeout, cmd.selectedField, cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "navigate": {
+      return {
+        type: "navigate",
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "browser_go_back": {
+      return {
+        type: "browser_go_back",
+      };
+    }
+    case "browser_go_forward": {
+      return {
+        type: "browser_go_forward",
+      };
+    }
+    case "set_input_files": {
+      return {
+        type: "set_input_files",
+        element: {
+          role: cmd.role,
+          name: cmd.label,
+        },
+        parameters: [cmd.files],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+    case "verify_page_snapshot": {
+      return {
+        type: "verify_page_snapshot",
+        parameters: [cmd.value],
+        selectors: cmd.selectors,
+      };
+    }
+    default: {
+      return {
+        type: cmd.type,
+        parameters: [cmd.value],
+        lastKnownUrlPath: cmd.lastKnownUrlPath,
+      };
+    }
+  }
+};
+
+function getBestStrategy(allStrategyLocators) {
+  const orderedPriorities = ["custom", "context", "basic", "text_with_index", "ignore_digit", "no_text"];
+  for (const strategy of orderedPriorities) {
+    if (allStrategyLocators[strategy] && allStrategyLocators[strategy].length > 0) {
+      return strategy;
+    }
+  }
+  return null;
+}
+
+const _parameterizeLocators = (locators, replacementFromValue, replacementToValue) => {
+  for (const loc of locators) {
+    if (loc?.css?.includes(replacementFromValue)) {
+      loc.css = loc.css.replaceAll(replacementFromValue, replacementToValue);
+    }
+    if (loc?.text?.includes(replacementFromValue)) {
+      loc.text = loc.text.replaceAll(replacementFromValue, replacementToValue);
+    }
+    if (loc?.climb && typeof loc.climb === "string" && loc.climb?.includes(replacementFromValue)) {
+      loc.climb = loc.climb.replaceAll(replacementFromValue, replacementToValue);
+    }
+  }
+  return locators;
+};
+const parameterizeLocators = ({ cmd, locs, isValueVariable, isTextVariable, parametersMap }) => {
+  if (isValueVariable) {
+    const variable = cmd.value.slice(1, -1);
+    const val = parametersMap[variable];
+    const replacementFromValue = val.trim();
+    const replacementToValue = `{${variable}}`;
+    locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+  }
+  if (isTextVariable) {
+    const variable = cmd.text.slice(1, -1);
+    const val = parametersMap[variable];
+    const replacementFromValue = val.trim();
+    const replacementToValue = `{${variable}}`;
+    locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+  }
+  return locs;
+};
+
+//TODO: IMPORTAN
+export const toRecordingStep = (cmd, parametersMap) => {
+  if (cmd.type === "api") {
+    return {
+      type: "api",
+      value: cmd.value,
+    };
+  }
+  const step = _toRecordingStep(cmd);
+  const cmdID = {
+    cmdId: cmd.id,
+  };
+  Object.assign(step, cmdID);
+
+  const locatorsObject = JSON.parse(JSON.stringify(cmd.locators ?? null));
+
+  if (!locatorsObject) return step;
+
+  const element_name = cmd?.locators?.element_name ?? `${cmd.label} ${cmd.role ?? "Text"}`;
+  locatorsObject.element_name = element_name;
+
+  const isValueVariable = isVariable(cmd.value);
+  const isTextVariable = isVariable(cmd.text);
+  const allStrategyLocators = JSON.parse(JSON.stringify(cmd?.allStrategyLocators ?? null));
+  step.locators = locatorsObject;
+  step.allStrategyLocators = allStrategyLocators;
+  step.isLocatorsAssigned = true;
+
+  if (!isValueVariable && !isTextVariable) {
+    return step;
+  }
+
+  if (isValueVariable) {
+    step.dataSource = "parameters";
+    step.dataKey = convertToIdentifier(cmd.value.slice(1, -1));
+  }
+
+  if (!allStrategyLocators) {
+    let locs = locatorsObject.locators;
+    locs = parameterizeLocators({
+      cmd,
+      locs,
+      isValueVariable,
+      isTextVariable,
+      parametersMap,
+    });
+    locatorsObject.locators = locs;
+    return {
+      ...step,
+      locators: locatorsObject,
+    };
+  }
+
+  for (const key in allStrategyLocators) {
+    if (key === "strategy") continue;
+    if (key === "no_text" || key === "custom") continue;
+    const locators = allStrategyLocators[key];
+    if (locators.length === 0) continue;
+    parameterizeLocators({
+      cmd,
+      locs: locators,
+      isValueVariable,
+      isTextVariable,
+      parametersMap,
+    });
+  }
+
+  locatorsObject.locators = allStrategyLocators[allStrategyLocators.strategy] ?? locatorsObject.locators;
+
+
+  return {
+    ...step,
+    locators: locatorsObject,
+    allStrategyLocators,
+    isLocatorsAssigned: true,
+  };
+};
+
 export const toMethodName = (str) => {
   // Remove any non-word characters (excluding underscore) and trim spaces
   let cleanStr = str.trim().replace(/[^\w\s]/gi, "");
@@ -68,22 +484,82 @@ function makeStepTextUnique(step, stepsDefinitions) {
   step.text = stepText;
 }
 
-export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions, parametersMap }) {
+  if (step.commands && Array.isArray(step.commands)) {
+    step.commands = step.commands.map((cmd) => toRecordingStep(cmd, parametersMap));
+  }
+  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;
 
   recording.loadFromObject({ steps, step: cucumberStep });
@@ -108,6 +584,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,6 +609,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
+
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
         name: step.text,
@@ -139,6 +617,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         source: "recorder",
       });
     }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -156,12 +635,18 @@ 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
     );
@@ -183,6 +668,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     }
 
     codePage.removeUnusedElements();
+    codePage.mergeSimilarElements();
     cucumberStep.methodName = methodName;
     if (generateCodeResult.locatorsMetadata) {
       codePage.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
@@ -312,6 +798,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);
@@ -327,6 +819,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 });
@@ -334,7 +855,14 @@ 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 });
+    codePage = await saveRecording({
+      step,
+      cucumberStep,
+      codePage,
+      projectDir,
+      stepsDefinitions,
+      parametersMap: scenario.parametersMap,
+    });
     if (!codePage) {
       continue;
     }
@@ -345,3 +873,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);
+  }
+}