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

package/bin/client/local_agent.js

@@ -32,7 +32,6 @@ const MAX_SIZE_LIMIT = 1e7 * 3;
 
 import { getJsonReport } from "./bvt_json_report.js";
 import { profile } from "./profiler.js";
-import { getDocumentAndPickel } from "./cucumber/feature.js";
 winCA({});
 
 class Client {
@@ -383,7 +382,7 @@ class LocalAgent {
             error: command.data.errorMessage,
           });
           agent.stepFailResolve(command.data.errorMessage);
-          logger.info("Step fail, " + command.data.errorMessage);
+          logger.error("Step fail, " + command.data.errorMessage);
         } else {
           agent.stepEndResolve();
           logger.info("Step end");
@@ -655,6 +654,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 +707,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 +970,7 @@ class LocalAgent {
   async createNewStepLocal(
     featureName,
     cucumberStep,
-    feature,
+    comments,
     userData,
     firstStep,
     previousTasks,
@@ -1056,9 +1059,8 @@ class LocalAgent {
     //stepText = _replaceWithLocalData(stepText, testData);
 
     logger.info("\x1b[38;5;208mCreate new step:\x1b[0m " + stepText);
-    const stepObject = getDocumentAndPickel(featureName, featureFileText, scenarioDocument.name);
-    if (this.context && this.context.web) {
-      await this.context.web.beforeStep(null, stepObject);
+    if (this.context && this.context.stable) {
+      await this.context.stable.beforeStep(null, cucumberStep);
     }
     //this.pageName = pageName;
     this.cucumberStep = cucumberStep;
@@ -1083,7 +1085,7 @@ class LocalAgent {
             previousTasks,
             scenarioDocument,
             scenarioStepIndex,
-            comments: feature.comments,
+            comments,
             featureFileText,
             recover,
             dumpConfig: this.dumpConfig,

package/bin/client/operations/dump_tree.js

@@ -48,18 +48,13 @@ const _openCDP = async (context) => {
   // let result = await cdp.send("DOM.getDocument", { depth: -1, pierce: true });
   // console.log("result", JSON.stringify(result, null, 2));
 };
+
 const getAccessibilityTree = async (context, dumpConfig) => {
   for (let i = 0; i < 3; i++) {
     await _closeCDP();
     try {
       await _openCDP(context);
-      if (dumpConfig && dumpConfig.supress_errors === true) {
-        process.env.SUPRESS_ERRORS = "true";
-      }
       //wait for 2 seconds
-      // if (dumpConfig && dumpConfig.independentThought === true) {
-      //   context.INDEPENDENT_THOUGHT = "true";
-      // }
       if (dumpConfig && dumpConfig.load_all_lazy === true) {
         await context.page.evaluate(() => {
           // document.addEventListener("load", () => {
@@ -86,6 +81,7 @@ const getAccessibilityTree = async (context, dumpConfig) => {
             break;
           }
         }
+
         await context.page.evaluate(() => {
           const { top, left } = window.originalScroll || { top: 0, left: 0 };
           window.scrollTo(left, top);
@@ -381,6 +377,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) {
@@ -391,7 +462,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,
@@ -408,8 +480,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/playground/playground.js

@@ -190,7 +190,7 @@ class Playground {
         .createNewStepLocal(
           "untitled",
           cucumberStep,
-          this.feature,
+          this.feature.comments,
           userData,
           false,
           this.previousTasks,

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 = [];