@dev-blinq/cucumber_client 1.0.1311-dev → 1.0.1313-dev

package/bin/assets/scripts/unique_locators.js

@@ -34,6 +34,11 @@ function cssEscapeCharacter(s, i) {
 		return s.charAt(i);
 	return "\\" + s.charAt(i);
 }
+function escapeRegexForSelector(re) {
+	if (re.unicode || re.unicodeSets)
+		return String(re);
+	return String(re).replace(/(^|[^\\])(\\\\)*(["'`])/g, "$1$2\\$3").replace(/>>/g, "\\>\\>");
+}
 class LocatorGenerator {
 	constructor(injectedScript, options = {}) {
 		this.locatorStrategies = {
@@ -213,102 +218,107 @@ class LocatorGenerator {
 			return [];
 		}
 		const result = [];
-		const textSet = new Set();
-		for (const locator of locators) {
-			const selector = locator.css;
-			if (!selector || typeof selector !== "string") {
-				console.error("Locator must have a valid css selector");
-				continue;
-			}
-			const parseResult = this.injectedScript.parseSelector(selector);
-			const parts = parseResult.parts;
-			if (!parts || !Array.isArray(parts) || parts.length === 0) {
-				console.error("Locator must have a valid css selector");
-				continue;
-			}
-			// ignore parts.length < 3
-			if (parts.length < 3) {
-				// console.warn("Locator must have at least 3 parts to be a context locator");
-				continue;
-			}
-			const firstPart = parts[0];
-			if (firstPart.name !== "internal:text") {
-				// console.warn("Locator must have internal:text as the first part to be a context locator");
-				continue;
-			}
-			const textBody = firstPart.body;
-			if (!textBody || typeof textBody !== "string" || textBody.length === 0) {
-				console.error("Locator must have a valid text in the first part to be a context locator");
-				continue;
-			}
-			const secondPart = parts[1];
-			if (secondPart.name !== "xpath") {
-				continue;
-			}
-			const xpath = secondPart.body;
-			if (!xpath || typeof xpath !== "string" || xpath.length === 0) {
-				// console.error("Locator must have a valid xpath in the second part to be a context locator");
-				continue;
-			}
-			const climbString = secondPart.body;
-			if (!climbString || typeof climbString !== "string" || climbString.length === 0) {
-				continue;
-			}
-			const climbStringRegex = /(\.\.)(\/\.\.)*/;
-			try {
-				const match = climbStringRegex.test(climbString);
-				if (match) {
-					const climbCount = climbString.split("..").length - 1;
-					const lastIndex = selector.indexOf(climbString);
-					const restOfSelector = selector.substring(lastIndex + climbString.length + 3).trim();
-					if (restOfSelector.length === 0) {
-						// console.warn("Locator must have a valid rest of selector after the xpath part to
-						// be a context locator");
-						continue;
-					}
+		try {
 
-					const textLocator = `internal:text=${textBody}`;
-					const elements = this.getMatchingElements(textLocator, {});
-					if (elements.length !== 1) {
-						// throw new Error("Context locator must have exactly one element matching the text part");
-						console.error("Context locator must have exactly one element matching the text part");
-						continue;
-					}
-					const textElement = elements[0];
-					// const text = this.PW.selectorUtils.elementText(textElement);
-					const text = this.injectedScript.utils.elementText(new Map(), textElement).full;
-
-					const fullSelector = `${textLocator} >> xpath=${xpath} >> ${restOfSelector}`;
-					const fullElements = this.getMatchingElements(fullSelector, {});
-					if (fullElements.length !== 1) {
-						// throw new Error("Context locator must have exactly one element matching the full selector");
-						console.error("Context locator must have exactly one element matching the full selector");
-						continue;
-					}
-					const fullElement = fullElements[0];
-					if (fullElement !== element) {
-						// throw new Error("Context locator must have the text element as the full element");
-						console.error("Context locator must have the text element as the full element");
-						continue;
-					}
-					if (!textSet.has(text)) {
-						textSet.add(text);
-						const loc = {
-							css: restOfSelector,
-							climb: climbCount,
-							text,
-							priority: 1,
-						};
-						if (locator.index !== undefined) {
-							loc.index = locator.index;
+			const textSet = new Set();
+			for (const locator of locators) {
+				const selector = locator.css;
+				if (!selector || typeof selector !== "string") {
+					console.error("Locator must have a valid css selector");
+					continue;
+				}
+				const parseResult = this.injectedScript.parseSelector(selector);
+				const parts = parseResult.parts;
+				if (!parts || !Array.isArray(parts) || parts.length === 0) {
+					console.error("Locator must have a valid css selector");
+					continue;
+				}
+				// ignore parts.length < 3
+				if (parts.length < 3) {
+					// console.warn("Locator must have at least 3 parts to be a context locator");
+					continue;
+				}
+				const firstPart = parts[0];
+				if (firstPart.name !== "internal:text") {
+					// console.warn("Locator must have internal:text as the first part to be a context locator");
+					continue;
+				}
+				const textBody = firstPart.body;
+				if (!textBody || typeof textBody !== "string" || textBody.length === 0) {
+					console.error("Locator must have a valid text in the first part to be a context locator");
+					continue;
+				}
+				const secondPart = parts[1];
+				if (secondPart.name !== "xpath") {
+					continue;
+				}
+				const xpath = secondPart.body;
+				if (!xpath || typeof xpath !== "string" || xpath.length === 0) {
+					// console.error("Locator must have a valid xpath in the second part to be a context locator");
+					continue;
+				}
+				const climbString = secondPart.body;
+				if (!climbString || typeof climbString !== "string" || climbString.length === 0) {
+					continue;
+				}
+				const climbStringRegex = /(\.\.)(\/\.\.)*/;
+				try {
+					const match = climbStringRegex.test(climbString);
+					if (match) {
+						const climbCount = climbString.split("..").length - 1;
+						const lastIndex = selector.indexOf(climbString);
+						const restOfSelector = selector.substring(lastIndex + climbString.length + 3).trim();
+						if (restOfSelector.length === 0) {
+							// console.warn("Locator must have a valid rest of selector after the xpath part to
+							// be a context locator");
+							continue;
+						}
+
+						const textLocator = `internal:text=${textBody}`;
+						const elements = this.getMatchingElements(textLocator, {});
+						if (elements.length !== 1) {
+							// throw new Error("Context locator must have exactly one element matching the text part");
+							console.error("Context locator must have exactly one element matching the text part");
+							continue;
+						}
+						const textElement = elements[0];
+						// const text = this.PW.selectorUtils.elementText(textElement);
+						const text = this.injectedScript.utils.elementText(new Map(), textElement).full;
+
+						const fullSelector = `${textLocator} >> xpath=${xpath} >> ${restOfSelector}`;
+						const fullElements = this.getMatchingElements(fullSelector, {});
+						if (fullElements.length !== 1) {
+							// throw new Error("Context locator must have exactly one element matching the full selector");
+							console.error("Context locator must have exactly one element matching the full selector");
+							continue;
+						}
+						const fullElement = fullElements[0];
+						if (fullElement !== element) {
+							// throw new Error("Context locator must have the text element as the full element");
+							console.error("Context locator must have the text element as the full element");
+							continue;
+						}
+						if (!textSet.has(text)) {
+							textSet.add(text);
+							const loc = {
+								css: restOfSelector,
+								climb: climbCount,
+								text,
+								priority: 1,
+							};
+							if (locator.index !== undefined) {
+								loc.index = locator.index;
+							}
+							result.push(loc);
 						}
-						result.push(loc);
 					}
+				} catch (error) {
+					console.error("Error parsing climb string:", error);
+					continue;
 				}
-			} catch (error) {
-				console.error("Error parsing climb string:", error);
-				continue;
 			}
+		} catch (error) {
+			console.error("Error generating context locators:", error);
 		}
 		// Sort by text length to prioritize shorter texts
 		result.sort((a, b) => a.text.length - b.text.length);
@@ -316,65 +326,71 @@ class LocatorGenerator {
 	}
 	getDigitIgnoreLocators(element, locators) {
 		const result = [];
-		if (!locators || !Array.isArray(locators)) {
-			console.error("Locators must be an array");
-			return [];
-		}
-
-		for (const locator of locators) {
-			const selector = locator.css;
-			if (!selector || typeof selector !== "string") {
-				console.error("Locator must have a valid css selector");
-				continue;
-			}
-			const parseresult = this.injectedScript.parseSelector(selector);
-			const parts = parseresult.parts;
-			if (!parts || !Array.isArray(parts) || parts.length === 0) {
-				console.error("Locator must have a valid css selector");
-				continue;
+		try {
+			if (!locators || !Array.isArray(locators)) {
+				console.error("Locators must be an array");
+				return [];
 			}
-			let finalSelector = "";
-			let hasDigitsInText = false;
-			for (const part of parts) {
-				if (part.name !== "internal:text") {
-					finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+
+			for (const locator of locators) {
+				const selector = locator.css;
+				if (!selector || typeof selector !== "string") {
+					console.error("Locator must have a valid css selector");
 					continue;
 				}
-				if (typeof part.body !== "string" || part.body.length === 0) {
-					// console.error("Locator must have a valid text in the first part to be a digit ignore locator");
-					finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+				const parseresult = this.injectedScript.parseSelector(selector);
+				const parts = parseresult.parts;
+				if (!parts || !Array.isArray(parts) || parts.length === 0) {
+					console.error("Locator must have a valid css selector");
 					continue;
 				}
-				const text = part.body;
-				const digitsRegex = /\d+/g;
-				hasDigitsInText = digitsRegex.test(text);
+				let finalSelector = "";
+				let hasDigitsInText = false;
+				for (const part of parts) {
+					if (part.name !== "internal:text") {
+						finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+						continue;
+					}
+					if (typeof part.body !== "string" || part.body.length === 0) {
+						// console.error("Locator must have a valid text in the first part to be a digit ignore locator");
+						finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+						continue;
+					}
+					const text = part.body;
+					const digitsRegex = /\d+/g;
+					hasDigitsInText = digitsRegex.test(text);
 
-				let pattern = this.PW.stringUtils.escapeRegExp(text.substring(1, text.length - 2));
-				pattern = pattern.replace(digitsRegex, "\\d+");
-				finalSelector += `internal:text=/${pattern}/ >> `;
-			}
-			if (!hasDigitsInText) {
-				continue;
-			}
-			if (finalSelector.endsWith(` >> `)) {
-				finalSelector = finalSelector.slice(0, -4);
-			}
-			if (finalSelector) {
-				const elements = this.getMatchingElements(finalSelector, {});
-				if (elements.length !== 1) {
-					console.error("Digit ignore locator must have exactly one element matching the final selector");
-					continue;
+					let pattern = this.PW.stringUtils.escapeRegExp(text.substring(1, text.length - 2));
+					const re = new RegExp("^" + pattern + "$");
+
+					finalSelector += `internal:text=${escapeRegexForSelector(re)} >> `;
 				}
-				if (elements[0] !== element) {
-					console.error("Digit ignore locator must match the original element");
+				if (!hasDigitsInText) {
 					continue;
 				}
-				result.push({
-					css: finalSelector,
-					priority: locator.priority || 1,
-				});
+				if (finalSelector.endsWith(` >> `)) {
+					finalSelector = finalSelector.slice(0, -4);
+				}
+				if (finalSelector) {
+					const elements = this.getMatchingElements(finalSelector, {});
+					if (elements.length !== 1) {
+						console.error("Digit ignore locator must have exactly one element matching the final selector");
+						continue;
+					}
+					if (elements[0] !== element) {
+						console.error("Digit ignore locator must match the original element");
+						continue;
+					}
+					result.push({
+						css: finalSelector,
+						priority: locator.priority || 1,
+					});
+				}
 			}
+		} catch (error) {
+			console.error("Error generating digit ignore locators:", error);
 		}
+
 		return result;
 	}
 	getTextwithIndexLocators(locators) {
@@ -383,17 +399,22 @@ class LocatorGenerator {
 			return [];
 		}
 		const result = [];
-		for (const locator of locators) {
-			if (!locator || !locator.css || typeof locator.css !== "string") {
-				console.error("Locator must have a valid css selector");
-				continue;
-			}
-			const index = locator.index;
-			if (typeof index !== "number" || index < 0) {
-				console.error("Locator must have a valid index");
-				continue;
+		try {
+			for (const locator of locators) {
+				if (!locator || !locator.css || typeof locator.css !== "string") {
+					console.error("Locator must have a valid css selector");
+					continue;
+				}
+				const index = locator.index;
+				if (typeof index !== "number" || index < 0) {
+					// console.error("Locator must have a valid index");
+					continue;
+				}
+				result.push(locator);
 			}
-			result.push(locator);
+
+		} catch (error) {
+			console.error("Error getting text with index locators:", error);
 		}
 		return result;
 	}
@@ -417,28 +438,33 @@ class LocatorGenerator {
 	categorizeLocators(element, locators, options) {
 		const unique = [];
 		const nonUnique = [];
-		for (const locator of locators) {
-			const elements = this.getMatchingElements(locator.css, options);
-			if (elements.length === 0) {
-				console.warn(`No elements found for locator: ${locator.css}`);
-				continue;
-			} else if (elements.length === 1) {
-				if (element === elements[0]) {
-					locator.priority = 1;
-					unique.push(locator);
-				} else if (element.contains(elements[0])) {
-					locator.priority = 1;
-					const climb = this.dom_Parent.getClimbCountToParent(elements[0], element);
-					const climbSelector = this.getXPathSelector(climb);
-					const newSelector = `${locator.css} >> ${climbSelector}`;
-					locator.css = newSelector;
-					unique.push(locator);
+		try {
+
+			for (const locator of locators) {
+				const elements = this.getMatchingElements(locator.css, options);
+				if (elements.length === 0) {
+					console.warn(`No elements found for locator: ${locator.css}`);
+					continue;
+				} else if (elements.length === 1) {
+					if (element === elements[0]) {
+						locator.priority = 1;
+						unique.push(locator);
+					} else if (element.contains(elements[0])) {
+						locator.priority = 1;
+						const climb = this.dom_Parent.getClimbCountToParent(elements[0], element);
+						const climbSelector = this.getXPathSelector(climb);
+						const newSelector = `${locator.css} >> ${climbSelector}`;
+						locator.css = newSelector;
+						unique.push(locator);
+					}
+				} else {
+					locator.priority = 2;
+					locator.elements = elements;
+					nonUnique.push(locator);
 				}
-			} else {
-				locator.priority = 2;
-				locator.elements = elements;
-				nonUnique.push(locator);
 			}
+		} catch (error) {
+			console.error("Error categorizing locators:", error);
 		}
 		return { unique, nonUnique };
 	}

package/bin/client/code_gen/playwright_codeget.js

@@ -674,6 +674,22 @@ const _generateCodeFromCommand = (step, elements, userData) => {
   return { codeLines, elements: elementsChanged ? elements : null, elementIdentifier, allStrategyLocators };
 };
 
+/**
+ * Generates a report command based on the given position.
+ * @param {"start"|"end"} position
+ */
+const generateReportCommand = (position, cmdId) => {
+  const codeLines = [];
+  if (position === "start") {
+    const line = `await context.web.addCommandToReport("${cmdId}", "PASSED", '{"status":"start","cmdId":"${cmdId}"}', {type:"cmdReport"},this);`;
+    codeLines.push(line);
+  } else if (position === "end") {
+    const line = `await context.web.addCommandToReport("${cmdId}", "PASSED", '{"status":"end","cmdId":"${cmdId}"}', {type:"cmdReport"},this);`;
+    codeLines.push(line);
+  }
+  return codeLines;
+};
+
 const generateCode = (recording, codePage, userData, projectDir, methodName) => {
   const stepsDefinitions = new StepsDefinitions(projectDir);
   stepsDefinitions.load(false);
@@ -714,12 +730,15 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     if (recordingStep.type === Types.COMPLETE) {
       return;
     }
-    // if (!recordingStep.element) {
-    //   logger.info(`Step ${recordingStep.type} doesn't have an element, ignoring`);
-    //   return;
-    // }
+
+    if (process.env.TEMP_RUN === "true") {
+      codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
+    }
     const result = _generateCodeFromCommand(recordingStep, elements, userData);
     codeLines.push(...result.codeLines);
+    if (process.env.TEMP_RUN === "true") {
+      codeLines.push(...generateReportCommand("end", recordingStep.cmdId));
+    }
     if (result.elements) {
       elements = result.elements;
     }

package/bin/client/recorderv3/bvt_recorder.js

@@ -1,6 +1,6 @@
 // define the jsdoc type for the input
 import { closeContext, initContext, _getDataFile, resetTestData } from "automation_model";
-import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
+import { existsSync, mkdir, mkdirSync, readdirSync, readFileSync, rmSync } from "fs";
 import path from "path";
 import url from "url";
 import { getImplementedSteps, getStepsAndCommandsForScenario } from "./implemented_steps.js";
@@ -15,6 +15,7 @@ import chokidar from "chokidar";
 import logger from "../../logger.js";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort } from "../utils/index.js";
+import NetworkMonitor from "./network.js";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -185,12 +186,33 @@ export class BVTRecorder {
     });
     this.stepRunner = new BVTStepRunner({
       projectDir: this.projectDir,
+      sendExecutionStatus: (data) => {
+        if (data && data.type) {
+          switch (data.type) {
+            case "cmdExecutionStart":
+              console.log("Sending cmdExecutionStart event for cmdId:", data.cmdId);
+              this.sendEvent(this.events.cmdExecutionStart, data.cmdId);
+              break;
+            case "cmdExecutionSuccess":
+              console.log("Sending cmdExecutionSuccess event for cmdId:", data.cmdId);
+              this.sendEvent(this.events.cmdExecutionSuccess, data.cmdId);
+              break;
+            case "cmdExecutionFailure":
+              console.log("Sending cmdExecutionFailure event for cmdId:", data.cmdId);
+              this.sendEvent(this.events.cmdExecutionFailure, data.cmdId);
+              break;
+            default:
+              console.warn("Unknown command execution status type:", data.type);
+              break;
+          }
+        }
+      },
     });
     this.pageSet = new Set();
-
+    this.networkMonitor = new NetworkMonitor();
     this.lastKnownUrlPath = "";
     // TODO: what is world?
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
   }
@@ -203,6 +225,9 @@ export class BVTRecorder {
     onStepDetails: "BVTRecorder.onStepDetails",
     getTestData: "BVTRecorder.getTestData",
     onGoto: "BVTRecorder.onGoto",
+    cmdExecutionStart: "BVTRecorder.cmdExecutionStart",
+    cmdExecutionSuccess: "BVTRecorder.cmdExecutionSuccess",
+    cmdExecutionFailure: "BVTRecorder.cmdExecutionFailure",
   };
   bindings = {
     __bvt_recordCommand: async ({ frame, page, context }, event) => {
@@ -294,7 +319,7 @@ export class BVTRecorder {
     process.env.CDP_LISTEN_PORT = this.#remoteDebuggerPort;
 
     this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -700,7 +725,7 @@ export class BVTRecorder {
   }
   async closeBrowser() {
     delete process.env.TEMP_RUN;
-    await this.watcher.close().then(() => { });
+    await this.watcher.close().then(() => {});
     this.watcher = null;
     this.previousIndex = null;
     this.previousHistoryLength = null;
@@ -789,30 +814,34 @@ export class BVTRecorder {
     }, 100);
     this.timerId = timerId;
   }
-  async runStep({ step, parametersMap, tags, isFirstStep }, options) {
+  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
     const _env = {
       TOKEN: this.TOKEN,
       TEMP_RUN: true,
       REPORT_FOLDER: this.bvtContext.reportFolder,
       BLINQ_ENV: this.envName,
+      STORE_DETAILED_NETWORK_DATA: listenNetwork ? "true" : "false",
+      CURRENT_STEP_ID: step.id,
     };
 
     this.bvtContext.navigate = true;
     for (const [key, value] of Object.entries(_env)) {
       process.env[key] = value;
     }
+
     if (this.timerId) {
       clearTimeout(this.timerId);
       this.timerId = null;
     }
     await this.setMode("running");
+
     try {
       const { result, info } = await this.stepRunner.runStep(
         {
           step,
           parametersMap,
           envPath: this.envName,
-          tags
+          tags,
         },
         this.bvtContext,
         options ? { ...options, skipBefore: !isFirstStep } : { skipBefore: !isFirstStep }

package/bin/client/recorderv3/index.js

@@ -51,6 +51,37 @@ class PromisifiedSocketServer {
   }
 }
 
+function memorySizeOf(obj) {
+  var bytes = 0;
+
+  function sizeOf(obj) {
+    if (obj !== null && obj !== undefined) {
+      switch (typeof obj) {
+        case "number":
+          bytes += 8;
+          break;
+        case "string":
+          bytes += obj.length * 2;
+          break;
+        case "boolean":
+          bytes += 4;
+          break;
+        case "object":
+          var objClass = Object.prototype.toString.call(obj).slice(8, -1);
+          if (objClass === "Object" || objClass === "Array") {
+            for (var key in obj) {
+              if (!obj.hasOwnProperty(key)) continue;
+              sizeOf(obj[key]);
+            }
+          } else bytes += obj.toString().length * 2;
+          break;
+      }
+    }
+    return bytes;
+  }
+  return sizeOf(obj);
+}
+
 const init = ({ envName, projectDir, roomId, TOKEN }) => {
   console.log("connecting to " + WS_URL);
   const socket = io(WS_URL);
@@ -66,8 +97,10 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     projectDir,
     TOKEN,
     sendEvent: (event, data) => {
+      console.log("Size of data", memorySizeOf(data), "bytes");
       console.log("----", event, data, "roomId", roomId);
       socket.emit(event, data, roomId);
+      console.log("Successfully sent event", event, "to room", roomId);
     },
   });
   recorder
@@ -77,7 +110,7 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
       socket.emit("BVTRecorder.browserOpened", null, roomId);
     })
     .catch((e) => {
-      socket.emit("BVTRecorder.browserLaunchFailed", null, roomId);
+      socket.emit("BVTRecorder.browserLaunchFailed", e, roomId);
     });
   const timeOutForFunction = async (promise, timeout = 5000) => {
     const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(), timeout));
@@ -239,6 +272,9 @@ const init = ({ envName, projectDir, roomId, TOKEN }) => {
     "recorderWindow.getStepsAndCommandsForScenario": async (input) => {
       return await recorder.getStepsAndCommandsForScenario(input);
     },
+    "recorderWindow.getNetworkEvents": async (input) => {
+      return await recorder.getNetworkEvents(input);
+    },
   });
   socket.on("targetBrowser.command.event", async (input) => {
     return recorder.onAction(input);