@dev-blinq/cucumber_client 1.0.1195-dev → 1.0.1197-dev

package/bin/assets/preload/locators.js

@@ -697,6 +697,24 @@ function querySelector_shadow_aware(element, selector) {
 }
 window.querySelector_shadow_aware = querySelector_shadow_aware;
 
+function findElement(css, scope = document) {
+  // return null if no css provided
+  if (!css) return null;
+  const selector = window.__injectedScript.parseSelector(css);
+  try {
+    const elements = window.__injectedScript.querySelectorAll(selector, scope, true);
+    if (!elements) return null;
+    if (elements.length === 1) {
+      return elements[0];
+    } else {
+      return elements;
+    }
+  } catch (error) {
+    return null;
+  }
+}
+window.findElement = findElement;
+
 // export {
 // 	getUniqueLocators,
 // 	getBasicInfo,

package/bin/assets/preload/recorderv3.js

@@ -1355,7 +1355,8 @@ function countAccurances(css, scope = document) {
 }
 window.countAccurances = countAccurances;
 function findElement(css, scope = document) {
-  // return null if no css provided
+  // Note: If you change anything iin this function
+  // please change it in locators.js
   if (!css) return null;
   const selector = window.__injectedScript.parseSelector(css);
   try {

package/bin/client/cucumber/feature.js

@@ -289,7 +289,7 @@ class Feature {
     }
     return scenarios;
   }
-  generateStracture(stepsDefinitions, fileName, scenarioName = null) {
+  generateStracture(stepsDefinitions, fileName, scenarioName = null, errorsInParsing = [], parseFailedFiles = false) {
     const document = {};
     document.featureName = this.feature.name;
     document.fileName = fileName;
@@ -311,6 +311,29 @@ class Feature {
         stepInfo.template = step.getTemplate();
         scenarioInfo.steps.push(stepInfo);
         const stepDef = stepsDefinitions.findMatchingStep(stepInfo.template);
+        if (!stepDef && parseFailedFiles) {
+          //Check if the stepName exists in one of the failedToParseFiles
+          try {
+            const stepName = stepsDefinitions._stepNameToTemplate(stepInfo.template);
+            if (errorsInParsing && errorsInParsing.length > 0) {
+              for (let k = 0; k < errorsInParsing.length; k++) {
+                const failedFile = errorsInParsing[k].file;
+                //Read File content, and check if the stepName exists in the file
+                const fileContent = fs.readFileSync(failedFile, "utf8");
+                if (fileContent.includes(stepName)) {
+                  stepInfo.implemented = true;
+                  stepInfo.mjsFile = failedFile;
+                  stepInfo.functionName = stepName;
+                  stepInfo.error = errorsInParsing[k].error;
+                  console.log(JSON.stringify(stepInfo));
+                  break;
+                }
+              }
+            }
+          } catch (e) {
+            console.error(`Error while checking step ${stepInfo.template} in failed files:`, e);
+          }
+        }
         stepInfo.implemented = stepDef ? true : false;
         if (stepDef) {
           stepInfo.mjsFile = stepDef.file;

package/bin/client/cucumber/project_to_document.js

@@ -4,14 +4,14 @@ import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherki
 import { Feature } from "./feature.js";
 import { StepsDefinitions } from "./steps_definitions.js";
 
-export const projectDocument = (folder, featureName = null, scenarioName = null) => {
+export const projectDocument = (folder, featureName = null, scenarioName = null, supressErrors = false, errors = []) => {
   const uuidFn = () => (23212).toString(16);
   const builder = new AstBuilder(uuidFn);
   const matcher = new GherkinClassicTokenMatcher();
   const parser = new Parser(builder, matcher);
-  const stepDefinition = new StepsDefinitions(folder);
-  stepDefinition.load(false);
-
+  // load the step definitions from the project folder under steps folder
+  const stepDefinition = new StepsDefinitions(folder, false);
+  stepDefinition.load(false, supressErrors, errors);
   // read all the feature files in the project folder under features folder
   let featureFiles = [];
   const featuresDir = path.join(folder, "features");
@@ -27,7 +27,7 @@ export const projectDocument = (folder, featureName = null, scenarioName = null)
     if (featureName && feature.feature.name !== featureName && featureFile !== featureName) {
       continue;
     }
-    const document = feature.generateStracture(stepDefinition, featureFile, scenarioName);
+    const document = feature.generateStracture(stepDefinition, featureFile, scenarioName, errors, supressErrors);
     if (scenarioName && document.scenarios.length === 0) {
       continue;
     }
@@ -55,7 +55,8 @@ export const projectDocument = (folder, featureName = null, scenarioName = null)
 //     scenarioName = arg.substring(9);
 //   }
 // }
-// const documents = projectDocument(projectDir, featureName, scenarioName);
+// let errors = [];
+// const documents = projectDocument(projectDir, featureName, scenarioName, true, errors);
 // const args = process.argv.slice(2);
 
-// console.log(JSON.stringify(projectDocument(args[0])));
+// console.log(JSON.stringify(documents));

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,25 @@ 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
-        )
-      );
+      console.log("loading step definitions from file", 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;
+        if(supressErrors) {
+          errors.push({
+            file: filePath,
+            error: error.message,
+          });
+        }
+        else{
+          throw error;
+        }
       }
       this.initPage(codePage, mjsFile);
     }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1195-dev",
+  "version": "1.0.1197-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",