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

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

package/bin/client/recorderv3/bvt_recorder.js

@@ -3,8 +3,7 @@ import { closeContext, initContext, _getDataFile, resetTestData } from "automati
 import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
 import path from "path";
 import url from "url";
-import pkg from "../../min/injectedScript.min.cjs";
-import { getImplementedSteps, getStepsAndCommandsForScenario } from "./implemented_steps.js";
+import { getImplementedSteps, parseRouteFiles } from "./implemented_steps.js";
 import { NamesService } from "./services.js";
 import { BVTStepRunner } from "./step_runner.js";
 import { readFile, writeFile } from "fs/promises";
@@ -16,41 +15,21 @@ import chokidar from "chokidar";
 import logger from "../../logger.js";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort } from "../utils/index.js";
+import { Step } from "../cucumber/feature.js";
+
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const { source: injectedScriptSource } = pkg;
+
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-export function getInitScript(config) {
-  const popupHandlers = config?.popupHandlers ?? [];
-
-  const disableHighlight = config?.disableHighlight ?? false;
-
-  const disableMultipleLocators = config?.disableMultipleLocators ?? false;
-
-  const popupScript = `
-  window.__bvt_Recorder.setPopupHandlers(${JSON.stringify(popupHandlers)}); 
-  window.__bvt_Recorder.setDisableHighlight(${JSON.stringify(disableHighlight)});
-  window.__bvt_Recorder.setImproviseLocators(${JSON.stringify(!disableMultipleLocators)});`;
-  return (
-    [
-      path.join(__dirname, "..", "..", "assets", "preload", "accessibility.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "dom-utils.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "generateSelector.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "locators.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "unique_locators.js"),
-      // path.join(__dirname, "..", "..", "assets", "preload", "pw_locators.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "climb.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "text-locator.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "toolbar.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "recording-tool.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "find_context.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "recorderv3.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "findElementText.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "css_gen.js"),
-      path.join(__dirname, "..", "..", "assets", "preload", "yaml.js"),
-    ]
-      .map((filePath) => readFileSync(filePath, "utf8"))
-      .join("\n") + popupScript
+export function getInitScript(config, options) {
+  const preScript = `
+  window.__bvt_Recorder_config = ${JSON.stringify(config ?? null)};
+  window.__PW_options = ${JSON.stringify(options ?? null)};
+  `;
+  const recorderScript = readFileSync(
+    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
+    "utf8"
   );
+  return preScript + recorderScript;
 }
 
 async function evaluate(frame, script) {
@@ -71,7 +50,7 @@ async function findNestedFrameSelector(frame, obj) {
     const frameElement = await frame.frameElement();
     if (!frameElement) return;
     const selectors = await parent.evaluate((element) => {
-      return window.getPWLocators(element);
+      return window.__bvt_Recorder.locatorGenerator.getElementLocators(element, { excludeText: true }).locators;
     }, frameElement);
     return findNestedFrameSelector(parent, { children: obj, selectors });
   } catch (e) {
@@ -198,6 +177,7 @@ export class BVTRecorder {
     this.logger = logger;
     this.screenshotMap = new Map();
     this.snapshotMap = new Map();
+    this.scenariosStepsMap = new Map();
     this.namesService = new NamesService({
       screenshotMap: this.screenshotMap,
       TOKEN: this.TOKEN,
@@ -206,12 +186,36 @@ 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);
+              this.sendEvent(this.events.cmdExecutionStart, data);
+              break;
+            case "cmdExecutionSuccess":
+              console.log("Sending cmdExecutionSuccess event for cmdId:", data);
+              this.sendEvent(this.events.cmdExecutionSuccess, data);
+              break;
+            case "cmdExecutionError":
+              console.log("Sending cmdExecutionError event for cmdId:", data);
+              this.sendEvent(this.events.cmdExecutionError, data);
+              break;
+            case "interceptResults":
+              console.log("Sending interceptResults event");
+              this.sendEvent(this.events.interceptResults, data);
+              break;
+            default:
+              console.warn("Unknown command execution status type:", data.type);
+              break;
+          }
+        }
+      },
     });
     this.pageSet = new Set();
-
     this.lastKnownUrlPath = "";
     // TODO: what is world?
-    this.world = { attach: () => {} };
+    this.world = { attach: () => { } };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
   }
@@ -224,6 +228,10 @@ export class BVTRecorder {
     onStepDetails: "BVTRecorder.onStepDetails",
     getTestData: "BVTRecorder.getTestData",
     onGoto: "BVTRecorder.onGoto",
+    cmdExecutionStart: "BVTRecorder.cmdExecutionStart",
+    cmdExecutionSuccess: "BVTRecorder.cmdExecutionSuccess",
+    cmdExecutionError: "BVTRecorder.cmdExecutionError",
+    interceptResults: "BVTRecorder.interceptResults",
   };
   bindings = {
     __bvt_recordCommand: async ({ frame, page, context }, event) => {
@@ -299,22 +307,15 @@ export class BVTRecorder {
     return result;
   }
   getInitScripts(config) {
-    return getInitScript(config);
-    // const scripts = []
-    // scripts.push(...this.getPWScript());
-    // scripts.push(...this.getRecorderScripts());
-
-    // const popupHandlers = config?.popupHandlers ?? [];
-    // const disableHighlight = config?.disableHighlight ?? false;
-    // const disableMultipleLocators = config?.disableMultipleLocators ?? false;
-
-    // const inlineScript = `
-    // window.__bvt_Recorder.setPopupHandlers(${JSON.stringify(popupHandlers)});
-    // window.__bvt_Recorder.setDisableHighlight(${JSON.stringify(disableHighlight)});
-    // window.__bvt_Recorder.setImproviseLocators(${JSON.stringify(!disableMultipleLocators)});
-    // `
-    // scripts.push(inlineScript);
-    // return scripts;
+    return getInitScript(config, {
+      sdkLanguage: "javascript",
+      testIdAttributeName: "blinq-test-id",
+      stableRafCount: 0,
+      browserName: this.browser?.browserType().name(),
+      inputFileRoleTextbox: false,
+      customEngines: [],
+      isUnderTest: true,
+    });
   }
 
   async _initBrowser({ url }) {
@@ -322,7 +323,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 = {};
@@ -333,8 +334,9 @@ export class BVTRecorder {
         console.error("Error reading ai_config.json", error);
       }
     }
+    this.config = ai_config;
     const initScripts = {
-      recorderCjs: injectedScriptSource,
+      // recorderCjs: injectedScriptSource,
       scripts: [
         this.getInitScripts(ai_config),
         `\ndelete Object.getPrototypeOf(navigator).webdriver;${process.env.WINDOW_DEBUGGER ? "window.debug=true;\n" : ""}`,
@@ -349,6 +351,7 @@ export class BVTRecorder {
     const context = bvtContext.playContext;
     this.context = context;
     this.web = bvtContext.stable || bvtContext.web;
+    this.web.tryAllStrategies = true;
     this.page = bvtContext.page;
 
     this.pageSet.add(this.page);
@@ -461,6 +464,75 @@ export class BVTRecorder {
       }
     });
   }
+
+  hasHistoryReplacementAtIndex(previousEntries, currentEntries, index) {
+    if (!previousEntries || !currentEntries) return false;
+    if (index >= previousEntries.length || index >= currentEntries.length) return false;
+
+    const prevEntry = previousEntries[index];
+    // console.log("prevEntry", prevEntry);
+    const currEntry = currentEntries[index];
+    // console.log("currEntry", currEntry);
+
+    // Check if the entry at this index has been replaced
+    return prevEntry.id !== currEntry.id;
+  }
+
+  // Even simpler approach for your specific case
+  analyzeTransitionType(entries, currentIndex, currentEntry) {
+    // console.log("Analyzing transition type");
+    // console.log("===========================");
+    // console.log("Current Index:", currentIndex);
+    // console.log("Current Entry:", currentEntry);
+    // console.log("Current Entries:", entries);
+    // console.log("Current entries length:", entries.length);
+    // console.log("===========================");
+    // console.log("Previous Index:", this.previousIndex);
+    // // console.log("Previous Entry:", this.previousEntries[this.previousIndex]);
+    // console.log("Previous Entries:", this.previousEntries);
+    // console.log("Previous entries length:", this.previousHistoryLength);
+
+    if (this.previousIndex === null || this.previousHistoryLength === null || !this.previousEntries) {
+      return {
+        action: "initial",
+      };
+    }
+
+    const indexDiff = currentIndex - this.previousIndex;
+    const lengthDiff = entries.length - this.previousHistoryLength;
+
+    // Backward navigation
+    if (indexDiff < 0) {
+      return { action: "back" };
+    }
+
+    // Forward navigation
+    if (indexDiff > 0 && lengthDiff === 0) {
+      // Check if the entry at current index is the same as before
+      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+
+      if (entryReplaced) {
+        return { action: "navigate" }; // New navigation that replaced forward history
+      } else {
+        return { action: "forward" }; // True forward navigation
+      }
+    }
+
+    // New navigation (history grew)
+    if (lengthDiff > 0) {
+      return { action: "navigate" };
+    }
+
+    // Same position, same length
+    if (lengthDiff <= 0) {
+      const entryReplaced = this.hasHistoryReplacementAtIndex(this.previousEntries, entries, currentIndex);
+
+      return entryReplaced ? { action: "navigate" } : { action: "reload" };
+    }
+
+    return { action: "unknown" };
+  }
+
   async getCurrentTransition() {
     if (this?.web?.browser?._name !== "chromium") {
       return;
@@ -469,29 +541,70 @@ export class BVTRecorder {
 
     try {
       const result = await client.send("Page.getNavigationHistory");
-      // console.log("result", result);
+      // console.log("Navigation History:", result);
       const entries = result.entries;
       const currentIndex = result.currentIndex;
 
       // ignore if currentIndex is not the last entry
-      if (currentIndex !== entries.length - 1) return;
+      // if (currentIndex !== entries.length - 1) return;
 
       const currentEntry = entries[currentIndex];
-      return currentEntry;
+      const transitionInfo = this.analyzeTransitionType(entries, currentIndex, currentEntry);
+      this.previousIndex = currentIndex;
+      this.previousHistoryLength = entries.length;
+      this.previousUrl = currentEntry.url;
+      this.previousEntries = [...entries]; // Store a copy of current entries
+
+      return {
+        currentEntry,
+        navigationAction: transitionInfo.action,
+      };
     } catch (error) {
-      console.error("Error in getTransistionType event");
+      console.error("Error in getTransistionType event", error);
     } finally {
       await client.detach();
     }
   }
-  userInitiatedTranistionTypes = ["typed", "address_bar"];
+  userInitiatedTransitionTypes = ["typed", "address_bar"];
   async handlePageTransition() {
     const transition = await this.getCurrentTransition();
     if (!transition) return;
-    // console.log("transitionType", transition.transitionType);
-    if (this.userInitiatedTranistionTypes.includes(transition.transitionType)) {
-      // console.log("User initiated transition");
-      this.sendEvent(this.events.onGoto, { url: transition.userTypedURL });
+
+    const { currentEntry, navigationAction } = transition;
+
+    switch (navigationAction) {
+      case "initial":
+        // console.log("Initial navigation, no action taken");
+        return;
+      case "navigate":
+        // console.log("transitionType", transition.transitionType);
+        // console.log("sending onGoto event", { url: currentEntry.url,
+        // type: "navigate", });
+        if (this.userInitiatedTransitionTypes.includes(currentEntry.transitionType)) {
+          const env = JSON.parse(readFileSync(this.envName), "utf8");
+          const baseUrl = env.baseUrl;
+          let url = currentEntry.userTypedURL;
+          if (baseUrl && url.startsWith(baseUrl)) {
+            url = url.replace(baseUrl, "{{env.baseUrl}}");
+          }
+          // console.log("User initiated transition");
+          this.sendEvent(this.events.onGoto, { url, type: "navigate" });
+        }
+        return;
+      case "back":
+        // console.log("User navigated back");
+        // console.log("sending onGoto event", {
+        //   type: "back",
+        // });
+        this.sendEvent(this.events.onGoto, { type: "back" });
+        return;
+      case "forward":
+        // console.log("User navigated forward"); console.log("sending onGoto event", { type: "forward", });
+        this.sendEvent(this.events.onGoto, { type: "forward" });
+        return;
+      default:
+        this.sendEvent(this.events.onGoto, { type: "unknown" });
+        return;
     }
   }
 
@@ -618,8 +731,13 @@ 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;
+    this.previousUrl = null;
+    this.previousEntries = null;
+
     await closeContext();
     this.pageSet.clear();
   }
@@ -671,6 +789,7 @@ export class BVTRecorder {
   }
 
   async startRecordingInput() {
+    console.log("startRecordingInput");
     await this.setMode("recordingInput");
   }
   async stopRecordingInput() {
@@ -694,6 +813,7 @@ export class BVTRecorder {
   }
 
   async abortExecution() {
+    this.bvtContext.web.abortedExecution = true;
     await this.stepRunner.abortExecution();
   }
   async dealyedRevertMode() {
@@ -702,34 +822,47 @@ export class BVTRecorder {
     }, 100);
     this.timerId = timerId;
   }
-  async runStep({ step, parametersMap }, options) {
+  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
+    const { skipAfter = true, skipBefore = !isFirstStep } = 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;
+    this.bvtContext.loadedRoutes = null;
+    this.bvtContext.web.abortedExecution = false;
     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 {
-      await this.stepRunner.runStep(
+      const { result, info } = await this.stepRunner.runStep(
         {
           step,
           parametersMap,
           envPath: this.envName,
+          tags,
+          config: this.config,
         },
         this.bvtContext,
-        options
+        {
+          skipAfter,
+          skipBefore,
+        }
       );
       await this.revertMode();
+      return { info };
     } catch (error) {
       await this.revertMode();
       throw error;
@@ -740,22 +873,42 @@ export class BVTRecorder {
       this.bvtContext.navigate = false;
     }
   }
-  async runScenario({ steps, parametersMap }) {
-    for (const step of steps) {
-      await this.runStep({ step, parametersMap });
-    }
-  }
   async saveScenario({ scenario, featureName, override, isSingleStep }) {
     await updateStepDefinitions({ scenario, featureName, projectDir: this.projectDir }); // updates mjs files
     if (!isSingleStep) await updateFeatureFile({ featureName, scenario, override, projectDir: this.projectDir }); // updates gherkin files
-    await this.cleanup();
+    await this.cleanup({ tags: scenario.tags });
   }
   async getImplementedSteps() {
-    return getImplementedSteps(this.projectDir);
+    const stepsAndScenarios = await getImplementedSteps(this.projectDir);
+    const implementedSteps = stepsAndScenarios.implementedSteps;
+    const scenarios = stepsAndScenarios.scenarios;
+    for (const scenario of scenarios) {
+      this.scenariosStepsMap.set(scenario.name, scenario.steps);
+      delete scenario.steps;
+    }
+    return {
+      implementedSteps,
+      scenarios,
+    };
   }
   async getStepsAndCommandsForScenario({ name, featureName }) {
-    return getStepsAndCommandsForScenario({ name, featureName, projectDir: this.projectDir });
+    const steps = this.scenariosStepsMap.get(name) || [];
+    for (const step of steps) {
+      if (step.isImplemented) {
+        step.commands = this.getCommandsForImplementedStep({ stepName: step.text });
+      } else {
+        step.commands = [];
+      }
+    }
+    return steps;
+    // return getStepsAndCommandsForScenario({
+    //   name,
+    //   featureName,
+    //   projectDir: this.projectDir,
+    //   map: this.scenariosStepsMap,
+    // });
   }
+
   async generateStepName({ commands, stepsNames, parameters, map }) {
     return await this.namesService.generateStepName({ commands, stepsNames, parameters, map });
   }
@@ -838,9 +991,9 @@ export class BVTRecorder {
     }
   }
 
-  async discardTestData() {
+  async discardTestData({ tags }) {
     resetTestData(this.envName, this.world);
-    await this.cleanup();
+    await this.cleanup({ tags });
   }
   async addToTestData(obj) {
     if (!existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
@@ -879,6 +1032,7 @@ export class BVTRecorder {
     const stepParams = parseStepTextParameters(stepName);
     return getCommandsForImplementedStep(stepName, step_definitions, stepParams).commands;
   }
+
   loadExistingScenario({ featureName, scenarioName }) {
     const step_definitions = loadStepDefinitions(this.projectDir);
     const featureFilePath = path.join(this.projectDir, "features", featureName);
@@ -907,6 +1061,7 @@ export class BVTRecorder {
         ..._s,
         keyword: step.keyword.trim(),
       };
+      parseRouteFiles(this.projectDir, _step);
       steps.push(_step);
     }
     return {
@@ -946,7 +1101,7 @@ export class BVTRecorder {
     }
     return result;
   }
-  async cleanup() {
+  async cleanup({ tags }) {
     const noopStep = {
       text: "Noop",
       isImplemented: true,
@@ -960,6 +1115,7 @@ export class BVTRecorder {
         {
           step: noopStep,
           parametersMap: {},
+          tags: tags || [],
         },
         {
           skipAfter: false,
@@ -998,6 +1154,47 @@ export class BVTRecorder {
       return false;
     }
   }
+  async initExecution({ tags = [] }) {
+    // run before hooks
+    const noopStep = {
+      text: "Noop",
+      isImplemented: true,
+    };
+    await this.runStep(
+      {
+        step: noopStep,
+        parametersMap: {},
+        tags,
+      },
+      {
+        skipBefore: false,
+        skipAfter: true,
+      }
+    );
+  }
+  async cleanupExecution({ tags = [] }) {
+    // run after hooks
+    const noopStep = {
+      text: "Noop",
+      isImplemented: true,
+    };
+    await this.runStep(
+      {
+        step: noopStep,
+        parametersMap: {},
+        tags,
+      },
+      {
+        skipBefore: true,
+        skipAfter: false,
+      }
+    );
+  }
+  async resetExecution({ tags = [] }) {
+    // run after hooks followed by before hooks
+    await this.cleanupExecution({ tags });
+    await this.initExecution({ tags });
+  }
 }
 
 const parseFeatureFile = (featureFilePath) => {