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

package/bin/client/cucumber/steps_definitions.js

@@ -54,7 +54,7 @@ class StepsDefinitions {
       }
     }
   }
-  load(print = true) {
+  load(print = true, supressErrors = false, errors = []) {
     const mjsFiles = findFilesWithExtension(
       path.join(this.baseFolder, this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features"),
       "mjs"
@@ -62,18 +62,24 @@ class StepsDefinitions {
     // console.log({ mjsFiles });
     for (let i = 0; i < mjsFiles.length; i++) {
       const mjsFile = mjsFiles[i];
-      const codePage = new CodePage(
-        path.join(
-          this.baseFolder,
-          this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features",
-          mjsFile
-        )
+      const filePath = path.join(
+        this.baseFolder,
+        this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features",
+        mjsFile
       );
+      const codePage = new CodePage(filePath);
       try {
         codePage.generateModel();
       } catch (error) {
-        logger.info("unable to generate model for file", mjsFile);
-        throw error;
+        logger.info("unable to generate model for", mjsFile, error);
+        if (supressErrors) {
+          errors.push({
+            file: filePath,
+            error: error.message,
+          });
+        } else {
+          continue;
+        }
       }
       this.initPage(codePage, mjsFile);
     }
@@ -517,86 +523,94 @@ class StepsDefinitions {
     //   }
     // );
   };
+  //! Deprecated, not removing until stepRunner.executeStepRemote is stable
+  // executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText, onCommandResult }, options) => {
+  // //   const { skipAfter = true, skipBefore = true } = options || {};
+  //   const environment = {
+  //     ...process.env,
+  //   };
 
-  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
-    if (!options) {
-      options = {
-        skipAfter: true,
-      };
-    }
-    const environment = {
-      ...process.env,
-    };
+  //   try {
+  //     const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
+  //     const { runConfiguration } = await loadConfiguration(
+  //       {
+  //         provided: {
+  //           name: [scenario],
+  //           paths: [feature_file_path],
+  //           import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
+  //           // format: ["bvt"],
+  //         },
+  //       },
+  //       { cwd: process.cwd(), env: environment }
+  //     );
+  //     // const files = glob.sync(path.join(tempFolderPath, "step_definitions", "**", "*.mjs"));
+  //     // console.log("Files found:", files);
+  //     const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
+  //     // console.log("found ", support.stepDefinitions.length, "step definitions");
+  //     // support.stepDefinitions.map((step) => {
+  //     //   console.log("step", step.pattern);
+  //     // });
 
-    try {
-      const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
-      const { runConfiguration } = await loadConfiguration(
-        {
-          provided: {
-            name: [scenario],
-            paths: [feature_file_path],
-            import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
-            // format: ["bvt"],
-          },
-        },
-        { cwd: process.cwd(), env: environment }
-      );
-      // const files = glob.sync(path.join(tempFolderPath, "step_definitions", "**", "*.mjs"));
-      // console.log("Files found:", files);
-      const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
-      // console.log("found ", support.stepDefinitions.length, "step definitions");
-      // support.stepDefinitions.map((step) => {
-      //   console.log("step", step.pattern);
-      // });
+  //     if (skipAfter) {
+  //       // ignore afterAll/after hooks
+  //       support.afterTestCaseHookDefinitions = [];
+  //       support.afterTestRunHookDefinitions = [];
+  //     }
+  //     // if (skipBefore) {
+  //     //   // ignore beforeAll/before hooks
+  //     //   support.beforeTestCaseHookDefinitions = support.beforeTestCaseHookDefinitions.filter((hook) => {
+  //     //     return hook.uri.endsWith("utils.mjs")
+  //     //   });
+  //     //   support.beforeTestRunHookDefinitions = [];
+  //     // }
 
-      if (options.skipAfter) {
-        // ignore afterAll/after hooks
-        support.afterTestCaseHookDefinitions = [];
-        support.afterTestRunHookDefinitions = [];
-      }
+  //     let errorMesssage = null;
+  //     let info = null;
+  //     let errInfo = null;
+  //     const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
+  //       if (message.testStepFinished) {
+  //         const { testStepFinished } = message;
+  //         const { testStepResult } = testStepFinished;
+  //         if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
+  //           if (!errorMesssage) {
+  //             errorMesssage = testStepResult.message;
+  //             if (info) {
+  //               errInfo = info;
+  //             }
+  //           }
+  //         }
+  //         if (testStepResult.status === "UNDEFINED") {
+  //           if (!errorMesssage) {
+  //             errorMesssage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+  //             if (info) {
+  //               errInfo = info;
+  //             }
+  //           }
+  //         }
+  //       }
+  //       if (message.attachment) {
+  //         const attachment = message.attachment;
+  //         if (attachment.mediaType === "application/json" && attachment.body) {
+  //           const body = JSON.parse(attachment.body);
+  //           info = body.info;
+  //         }
+  //       }
+  //     });
+  //     if (errorMesssage) {
+  //       const bvtError = new Error(errorMesssage);
+  //       Object.assign(bvtError, { info: errInfo });
+  //       throw bvtError;
+  //     }
 
-      let errorMesssage = null;
-      let info = null;
-      let errInfo = null;
-      const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
-        if (message.testStepFinished) {
-          const { testStepFinished } = message;
-          const { testStepResult } = testStepFinished;
-          if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
-            if (!errorMesssage) {
-              errorMesssage = testStepResult.message;
-              if (info) {
-                errInfo = info;
-              }
-            }
-          }
-          if (testStepResult.status === "UNDEFINED") {
-            if (!errorMesssage) {
-              errorMesssage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
-              if (info) {
-                errInfo = info;
-              }
-            }
-          }
-        }
-        if (message.attachment) {
-          const attachment = message.attachment;
-          if (attachment.mediaType === "application/json" && attachment.body) {
-            const body = JSON.parse(attachment.body);
-            info = body.info;
-          }
-        }
-      });
-      if (errorMesssage) {
-        const bvtError = new Error(errorMesssage);
-        Object.assign(bvtError, { info: errInfo });
-        throw bvtError;
-      }
-    } catch (error) {
-      console.error("Error running cucumber-js", error);
-      throw error;
-    }
-  };
+  //     return {
+  //       result,
+  //       info,
+  //     };
+  //   } catch (error) {
+  //     console.error("Error running cucumber-js", error);
+  //     throw error;
+  //   }
+  // };
 }
 function findFilesWithExtension(folderPath, extension, rootFolder = null) {
   let result = [];
@@ -626,4 +640,23 @@ function findFilesWithExtension(folderPath, extension, rootFolder = null) {
 
   return result;
 }
+export function locateDefinitionPath(featureFolder, pageName) {
+  if (!pageName) {
+    return null;
+  }
+  if (!pageName.endsWith("_page.mjs")) {
+    pageName = pageName + "_page.mjs";
+  }
+  // search for files with the pageName
+  const stepDefinitionFolderPath = path.join(featureFolder, "step_definitions");
+  const files = findFilesWithExtension(stepDefinitionFolderPath, "mjs");
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (file.includes(pageName)) {
+      return path.join(stepDefinitionFolderPath, file);
+    }
+  }
+  return path.join(stepDefinitionFolderPath, pageName);
+}
+
 export { StepsDefinitions, findFilesWithExtension };

package/bin/client/local_agent.js

@@ -655,6 +655,7 @@ class LocalAgent {
 
             let page = agent.project.getPage(agent.pageName, true);
             const generateCodeResult = generateCode(recording, page, userData, agent.project.rootFolder, methodName);
+
             if (generateCodeResult.simple === true) {
               agent.sendDone("generateStepCode", null);
               break;
@@ -707,6 +708,9 @@ class LocalAgent {
                 cucumberStep: agent.cucumberStep,
               },
             });
+            if (generateCodeResult.locatorsMetadata) {
+              page.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
+            }
             await page.save();
             agent.scenarioReport.updateLastStep({
               recording: command.data.recording,
@@ -967,7 +971,7 @@ class LocalAgent {
   async createNewStepLocal(
     featureName,
     cucumberStep,
-    feature,
+    comments,
     userData,
     firstStep,
     previousTasks,
@@ -1083,7 +1087,7 @@ class LocalAgent {
             previousTasks,
             scenarioDocument,
             scenarioStepIndex,
-            comments: feature.comments,
+            comments,
             featureFileText,
             recover,
             dumpConfig: this.dumpConfig,

package/bin/client/operations/dump_tree.js

@@ -378,6 +378,81 @@ const findLocatorByText = async (context, texts, backendNodeId) => {
     await _closeCDP();
   }
 };
+function classifyLocatorsByStrategy(locators) {
+  const locs = [];
+
+  const allStrategyLocators = {
+    basic: [],
+    no_text: [],
+    ignore_digit: [],
+    context: [],
+    strategy: "basic",
+  };
+
+  const regexRegex = /\/.*\\[d][+].*\//;
+  for (const locator of locators) {
+    if (locator.mode) {
+      const { mode, ...rest } = locator;
+      locs.push(rest);
+      allStrategyLocators[locator.mode.toLowerCase()].push(rest);
+    } else if (locator.text && locator.text.length > 0) {
+      locs.push({
+        ...locator,
+        mode: "CONTEXT",
+      });
+      allStrategyLocators["context"].push(locator);
+    } else if (regexRegex.test(locator.css)) {
+      locs.push({
+        ...locator,
+        mode: "IGNORE_DIGIT",
+      });
+      allStrategyLocators["ignore_digit"].push(locator);
+    } else if (locator.css.includes("text=") || locator.css.includes("[name=") || locator.css.includes("label=")) {
+      locs.push(locator);
+      allStrategyLocators["basic"].push(locator);
+    } else {
+      locs.push({
+        ...locator,
+        mode: "NO_TEXT",
+      });
+      allStrategyLocators["no_text"].push(locator);
+    }
+  }
+  if (allStrategyLocators["context"].length > 0) {
+    allStrategyLocators["strategy"] = "context";
+  } else if (allStrategyLocators["basic"].length === 0 && allStrategyLocators["no_text"].length > 0) {
+    allStrategyLocators["strategy"] = "no_text";
+  }
+
+  return {
+    locators: locs,
+    allStrategyLocators,
+  };
+}
+
+async function filterLocators(cssLocators, elObjectId) {
+  const kept = [];
+  for (const selector of cssLocators) {
+    // call window.findElement(selector) === el
+    const { result } = await cdp.send("Runtime.callFunctionOn", {
+      functionDeclaration: `
+        function(element,selector) {
+          console.log("filterLocators in progress");
+          console.log(element,selector);
+          return window.findElement(selector) === element;
+        }
+      `,
+      objectId: elObjectId,
+      arguments: [{ objectId: elObjectId }, { value: selector }],
+      returnByValue: true,
+    });
+
+    if (result.value) {
+      kept.push(selector);
+    }
+  }
+  return kept;
+}
 
 async function getRecorderLocators(context, backendNodeId) {
   if (!cdp) {
@@ -388,7 +463,8 @@ async function getRecorderLocators(context, backendNodeId) {
       backendNodeId: backendNodeId,
     });
     const objectId = domNode.object.objectId;
-    let res = await cdp.send("Runtime.callFunctionOn", {
+    let locators = [];
+    locators = await cdp.send("Runtime.callFunctionOn", {
       functionDeclaration:
         "function(element,options) { console.log(element,options); return window.getPWLocators(element,options); }",
       objectId: objectId,
@@ -405,8 +481,87 @@ async function getRecorderLocators(context, backendNodeId) {
       ],
       returnByValue: true,
     });
+    if (!locators || !locators.result || !locators.result.value) {
+      locators = [];
+    } else {
+      locators = locators.result?.value;
+    }
+    let cssLocators = [];
+    try {
+      let origenCss = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element) { console.log(element); return window.generateUniqueCSSSelector(element); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+        ],
+        returnByValue: true,
+      });
+      origenCss = origenCss.result?.value;
+      if (origenCss) {
+        cssLocators.push(origenCss);
+      }
+      let noClasses = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element,options) { console.log(element,options); return window.CssSelectorGenerator.getCssSelector(element,options); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+          {
+            value: {
+              blacklist: [/^(?!.*h\d).*?\d.*/, /\[style/, /\[data-input-id/, /\[blinq-container/],
+              combineWithinSelector: true,
+              combineBetweenSelectors: true,
+              selectors: ["id", "attribute", "tag", "nthchild", "nthoftype"],
+              maxCombinations: 100,
+            },
+          },
+        ],
+        returnByValue: true,
+      });
+      noClasses = noClasses.result?.value;
+      if (!cssLocators.includes(noClasses)) {
+        cssLocators.push(noClasses);
+      }
+      let withClasses = await cdp.send("Runtime.callFunctionOn", {
+        functionDeclaration:
+          "function(element,options) { console.log(element,options); return window.CssSelectorGenerator.getCssSelector(element,options); }",
+        objectId: objectId,
+        arguments: [
+          {
+            objectId: objectId,
+          },
+          {
+            value: {
+              blacklist: [/^(?!.*h\d).*?\d.*/, /\[style/, /\[data-input-id/, /\[blinq-container/],
+              combineWithinSelector: true,
+              combineBetweenSelectors: true,
+              selectors: ["id", "attribute", "tag", "nthchild", "nthoftype", "class"],
+              maxCombinations: 100,
+            },
+          },
+        ],
+        returnByValue: true,
+      });
+      withClasses = withClasses.result?.value;
+      if (!cssLocators.includes(withClasses)) {
+        cssLocators.push(withClasses);
+      }
+      cssLocators.sort((a, b) => a.length - b.length);
+
+      cssLocators = await filterLocators(cssLocators, objectId);
+    } catch (err) {
+      console.error("Error in generateUniqueCSSSelector", error);
+    }
+    locators?.push(...cssLocators.map((css) => ({ mode: "NO_TEXT", css })));
+
+    const result = classifyLocatorsByStrategy(locators);
 
-    return res.result;
+    return { ...result, element_name: "" };
   } finally {
     await _closeCDP();
   }

package/bin/client/project.js

@@ -4,6 +4,7 @@ import { CodePage } from "./code_gen/page_reflection.js";
 import logger from "../logger.js";
 import path from "path";
 import { fileURLToPath } from "url";
+import { findFilesWithExtension } from "./cucumber/steps_definitions.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -85,7 +86,10 @@ class Project {
       logger.error("Error loading utils_template");
     }
 
-    let files = readdirSync(this.stepsFolder);
+    const files = findFilesWithExtension(this.stepsFolder, "mjs");
+
+    //let files = readdirSync(this.stepsFolder);
+
     for (let i = 0; i < files.length; i++) {
       let file = files[i];
       if (file.startsWith("_")) {
@@ -100,7 +104,7 @@ class Project {
         this.pages.push(page);
       }
     }
-    return envFile;
+    return this.environment.name;
   }
   getPagesNames() {
     let result = [];