@dev-blinq/cucumber_client 1.0.1194-dev → 1.0.1196-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/code_gen/code_inversion.js

@@ -521,9 +521,9 @@ const invertCodeToCommand = (codeString, elements = {}, stepParams, stepsDefinit
     if (propName === "web" || propName === "stable") {
       const step = invertStableCommand(call, elements, stepParams);
       if (step) steps.push(step);
-      // } else if (propName === "api") {
-      //   const step = invertApiCommand(stepsDefinitions, codePage, stepName);
-      //   if (step) steps.push(step);
+    } else if (propName === "api") {
+      const step = invertApiCommand(stepsDefinitions, codePage, stepName);
+      if (step) steps.push(step);
     } else {
       return;
     }

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/recorderv3/bvt_recorder.js

@@ -214,7 +214,6 @@ export class BVTRecorder {
     this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
-    this.sendEvent("BVTRecorder.getTestData", {});
   }
   events = {
     onFrameNavigate: "BVTRecorder.onFrameNavigate",
@@ -619,9 +618,7 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => {
-      this.logger.info(`Closed current testData file`);
-    });
+    await this.watcher.close().then(() => {});
     this.watcher = null;
     await closeContext();
     this.pageSet.clear();

package/bin/client/recorderv3/cli.js

@@ -34,6 +34,7 @@ let recorder = null;
 const init = async ({ envName, projectDir, roomId }) => {
   console.log("connecting to " + WS_URL);
   const socket = io(WS_URL);
+  // Disconnect from the server when the process exits
   socket.on("connect", () => {
     // console.log('connected to server')
   });

package/bin/client/recorderv3/step_utils.js

@@ -132,11 +132,13 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
-    stepsDefinitions.addStep({
-      name: step.text,
-      file: result.codePage.sourceFileName,
-      source: "recorder",
-    });
+    if (!step.isImplemented) {
+      stepsDefinitions.addStep({
+        name: step.text,
+        file: result.codePage.sourceFileName,
+        source: "recorder",
+      });
+    }
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -227,7 +229,7 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
 
     isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
     for (const { code } of codeCommands) {
-      const command = invertCodeToCommand(code, elements, stepParams)[0];
+      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;

package/bin/client/recording.js

@@ -5,6 +5,7 @@ import { Step } from "../client/cucumber/feature.js";
 This list need to be in sync with the list exist in the commands.js file
 */
 const Types = {
+  API: "api",
   CLICK: "click_element",
   CLICK_SIMPLE: "click_simple",
   NAVIGATE: "navigate",

package/package.json

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