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

package/bin/client/recorderv3/step_utils.js

@@ -14,6 +14,428 @@ 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,
+        data: cmd.data,
+      };
+    }
+    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, isTargetValueVariable, parametersMap }) => {
+  if (isValueVariable) {
+    const variable = cmd.value.slice(1, -1);
+    // const val = parametersMap[variable];
+    if (typeof cmd.text === "string") {
+      const replacementFromValue = cmd.text.trim().replace(/\s+/g, " ") ?? ""; // val.trim();
+      if (replacementFromValue.length > 0) {
+        const replacementToValue = `{${variable}}`;
+        locs = _parameterizeLocators(locs, replacementFromValue, replacementToValue);
+      }
+    }
+  }
+  if (isTargetValueVariable) {
+    const variable = cmd.targetValue.slice(1, -1);
+    // const val = parametersMap[variable];
+    if (typeof cmd.targetText === "string") {
+      const replacementFromValue = cmd.targetText.trim().replace(/\s+/g, " ") ?? ""; // val.trim();
+      if (replacementFromValue.length > 0) {
+        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 isTargetValueVariable = isVariable(cmd.targetValue);
+  const allStrategyLocators = JSON.parse(JSON.stringify(cmd?.allStrategyLocators ?? null));
+  step.locators = locatorsObject;
+  step.allStrategyLocators = allStrategyLocators;
+  step.isLocatorsAssigned = true;
+
+  if (!isValueVariable && !isTargetValueVariable) {
+    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,
+      isTargetValueVariable,
+      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,
+      isTargetValueVariable,
+      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, "");
@@ -54,7 +476,7 @@ export function getCucumberStep({ step }) {
 
 function makeStepTextUnique(step, stepsDefinitions) {
   // const utilsFilePath = path.join("features", "step_definitions", "utils.mjs");
-  let stepText = step.text;
+  let stepText = step.renamedText ? step.renamedText : step.text;
   let stepIndex = 1;
   // console.log("makeStepTextUnique", step.text);
   let stepDef = stepsDefinitions.findMatchingStep(stepText);
@@ -70,10 +492,13 @@ function makeStepTextUnique(step, stepsDefinitions) {
   step.text = stepText;
 }
 
-export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
+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) {
+  if (process.env.TEMP_RUN === "true") {
     if (existsSync(routesPath)) {
       rmSync(routesPath, { recursive: true });
     }
@@ -84,9 +509,9 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       // 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)) {
@@ -107,32 +532,36 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
 
     if (isUtilStep) {
-      return;
+      if (!step.renamedText) {
+        return;
+      }
+      const { functionName } = stepsDefinitions.findMatchingStep(step.renamedText);
+      step.renamedText = functionName;
+      const newImportLine = `import { ${functionName} } from "./utils.mjs";\n`;
+
+      if (!codePage.fileContent.includes(newImportLine)) {
+        codePage.fileContent = newImportLine + codePage.fileContent;
+      }
     }
   }
 
+  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 });
     }
@@ -141,13 +570,14 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
 
   cucumberStep.text = step.text;
   const recording = new Recording();
+
   const steps = step.commands;
 
   recording.loadFromObject({ steps, step: cucumberStep });
 
   const userData = {}; // TODO: get user data
 
-  let methodName = toMethodName(step.text);
+  let methodName = step.renamedText ? step.renamedText : toMethodName(step.text);
   if (step.isApiStep) {
     const {
       url,
@@ -191,13 +621,11 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       stepsDefinitions
     );
 
-    if (!step.isImplemented) {
-      stepsDefinitions.addStep({
-        name: step.text,
-        file: result.codePage.sourceFileName,
-        source: "recorder",
-      });
-    }
+    stepsDefinitions.addStep({
+      name: step.text,
+      file: result.codePage.sourceFileName,
+      source: "recorder",
+    });
 
     cucumberStep.methodName = result.methodName;
     return result.codePage;
@@ -209,7 +637,10 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
     }
     codePage = generateCodeResult.page;
     methodName = generateCodeResult.methodName;
-    codePage.insertElements(generateCodeResult.elements);
+
+    if (!step.renamedText) {
+      codePage.insertElements(generateCodeResult.elements);
+    }
 
     const description = cucumberStep.text;
     let path = null;
@@ -222,15 +653,17 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         protect = true;
       }
     }
-    const infraResult = codePage.addInfraCommand(
-      methodName,
-      description,
-      cucumberStep.getVariablesList(),
-      generateCodeResult.codeLines,
-      protect,
-      "recorder",
-      path
-    );
+    if (!step.renamedText) {
+      const infraResult = codePage.addInfraCommand(
+        methodName,
+        description,
+        cucumberStep.getVariablesList(),
+        generateCodeResult.codeLines,
+        protect,
+        "recorder",
+        path
+      );
+    }
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
     const stepResult = codePage.addCucumberStep(
       keyword,
@@ -240,15 +673,14 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.finalTimeout
     );
 
-    if (!step.isImplemented) {
-      stepsDefinitions.addStep({
-        name: step.text,
-        file: codePage.sourceFileName,
-        source: "recorder",
-      });
-    }
+    stepsDefinitions.addStep({
+      name: step.text,
+      file: codePage.sourceFileName,
+      source: "recorder",
+    });
 
     codePage.removeUnusedElements();
+    codePage.mergeSimilarElements();
     cucumberStep.methodName = methodName;
     if (generateCodeResult.locatorsMetadata) {
       codePage.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
@@ -300,26 +732,35 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
     if (error) {
       throw new Error(error);
     }
+    isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
 
     if (parametersNames.length !== stepParams.length) {
       // console.log("Parameters mismatch", parametersNames, stepParams);
       throw new Error("Parameters mismatch");
     }
-    for (let i = 0; i < parametersNames.length; i++) {
-      stepParams[i].argumentName = parametersNames[i];
-    }
 
-    isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
-    for (const { code } of codeCommands) {
-      const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
-      if (command === undefined || command.type === null) continue;
-      if (command.element) {
-        const key = command.element.key;
-        if (key && locatorsJson[key]) {
-          command.allStrategyLocators = locatorsJson[key];
+    const pattern = step.name;
+    if (isUtilStep && pattern === "Verify the file {string} exists") {
+      commands.push({
+        type: "verify_file_exists",
+        parameters: [stepParams[0].text],
+      });
+    } else {
+      for (let i = 0; i < parametersNames.length; i++) {
+        stepParams[i].argumentName = parametersNames[i];
+      }
+
+      for (const { code } of codeCommands) {
+        const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
+        if (command === undefined || command.type === null) continue;
+        if (command.element) {
+          const key = command.element.key;
+          if (key && locatorsJson[key]) {
+            command.allStrategyLocators = locatorsJson[key];
+          }
         }
+        commands.push(command);
       }
-      commands.push(command);
     }
   } catch (error) {
     console.error(error);
@@ -404,6 +845,7 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
         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 });
@@ -427,6 +869,9 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
         }
         saveRoutes({ step, folderPath: routesPath });
       }
+      if (step.commands && Array.isArray(step.commands)) {
+        step.commands = step.commands.map((cmd) => toRecordingStep(cmd, scenario.parametersMap));
+      }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
@@ -434,7 +879,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;
     }

package/bin/client/recorderv3/update_feature.js

@@ -129,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");
     }
   }
 
@@ -231,7 +235,7 @@ const GherkinToObject = (gherkin) => {
     skipEmptyLines();
 
     if (idx >= lines.length) {
-      return -1;
+      return scenario;
     }
 
     while (