@dev-blinq/cucumber_client 1.0.1266-dev → 1.0.1267-dev

package/bin/assets/templates/utils_template.txt

@@ -60,7 +60,6 @@ async function loadUserData(user) {
 async function verifyTextExistsInPage(text) {
   await context.web.verifyTextExistInPage(text, null, this);
 }
-
 Then("Verify the text {string} can be found in the page", verifyTextExistsInPage);
 
 /**
@@ -87,6 +86,7 @@ async function fillElement(elementDescription, value) {
 }
 When("fill {string} with {string}", fillElement);
 When("Fill {string} with {string}", fillElement);
+
 /**
  * Verify text does not exist in page
  * @param {string} text the text to verify does not exist in page
@@ -107,6 +107,24 @@ async function navigateTo(url) {
 }
 When("Navigate to {string}", navigateTo);
 
+/**
+ * Navigate to the current page
+ * @protect
+ */
+async function browserNavigateBack() {
+  await context.web.goBack({}, this);
+}
+Then("Browser navigate back", browserNavigateBack);
+
+/**
+ * Navigate forward in browser history
+ * @protect
+ */
+async function browserNavigateForward() {
+  await context.web.goForward({}, this);
+}
+Then("Browser navigate forward", browserNavigateForward);
+
 /**
  * Store browser session "<path>"
  * @param {string} filePath the file path or empty to store in the test data file
@@ -141,6 +159,7 @@ Then(
   "Identify the text {string}, climb {string} levels in the page, validate text {string} can be found in the context",
   verifyTextRelatedToText
 );
+
 /**
  * execute bruno single request given the bruno project is placed in a folder called bruno under the root of the cucumber project
  * @requestName the name of the bruno request file
@@ -149,7 +168,6 @@ Then(
 async function runBrunoRequest(requestName) {
   await executeBrunoRequest(requestName, {}, context, this);
 }
-
 When("Bruno - {string}", runBrunoRequest);
 When("bruno - {string}", runBrunoRequest);
 
@@ -163,41 +181,41 @@ async function verify_the_downloaded_file_exists(fileName) {
   const downloadFile = path.join(downloadFolder, fileName);
   await verifyFileExists(downloadFile, {}, context, this);
 }
-
 Then("Verify the file {string} exists", { timeout: 60000 }, verify_the_downloaded_file_exists);
 
-When("Noop", async function(){})
-
 /**
-* Verify the page url is "<url>"
-* @param {string} url URL to be verified against current URL
-* @protect
-*/
+ *  Noop step for running only hooks
+ */
+When("Noop", async function () {});
 
-async function verify_page_url(url){
-  await context.web.verifyPagePath(url,{}, this);
+/**
+ * Verify the page url is "<url>"
+ * @param {string} url URL to be verified against current URL
+ * @protect
+ */
+async function verify_page_url(url) {
+  await context.web.verifyPagePath(url, {}, this);
 }
 Then("Verify the page url is {string}", verify_page_url);
 
 /**
-* Verify the page title is "<title>"
-* @param {string} title Title to be verified against current Title
-* @protect
-*/
-async function verify_page_title(title){
+ * Verify the page title is "<title>"
+ * @param {string} title Title to be verified against current Title
+ * @protect
+ */
+async function verify_page_title(title) {
   await context.web.verifyPageTitle(title, {}, this);
 }
-Then("Verify the page title is {string}",verify_page_title)
+Then("Verify the page title is {string}", verify_page_title);
 
 /**
-* Explicit wait/sleep function that pauses execution for a specified duration
-* @param {duration} - Duration to sleep in milliseconds (default: 1000ms)
-* @param {options} - Optional configuration object
-* @param {world} - Optional world context
-* @returns Promise that resolves after the specified duration
-*/
+ * Explicit wait/sleep function that pauses execution for a specified duration
+ * @param {duration} - Duration to sleep in milliseconds (default: 1000ms)
+ * @param {options} - Optional configuration object
+ * @param {world} - Optional world context
+ * @returns Promise that resolves after the specified duration
+ */
 async function sleep(duration) {
   await context.web.sleep(duration, {}, null);
 }
-
-Then("Sleep for {string} ms", {timeout: -1}, sleep);
+Then("Sleep for {string} ms", { timeout: -1 }, sleep);

package/bin/client/code_gen/code_inversion.js

@@ -310,6 +310,14 @@ const invertStableCommand = (call, elements, stepParams) => {
       break;
     }
 
+    case "goBack":
+      step.type = Types.GO_BACK;
+      break;
+
+    case "goForward":
+      step.type = Types.GO_FORWARD;
+      break;
+
     case "reloadPage":
       step.type = Types.RELOAD;
       break;

package/bin/client/recorderv3/bvt_recorder.js

@@ -24,11 +24,11 @@ export function getInitScript(config, options) {
   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
+  const recorderScript = readFileSync(
+    path.join(__dirname, "..", "..", "assets", "bundled_scripts", "recorder.js"),
+    "utf8"
   );
+  return preScript + recorderScript;
 }
 
 async function evaluate(frame, script) {
@@ -190,7 +190,7 @@ export class BVTRecorder {
 
     this.lastKnownUrlPath = "";
     // TODO: what is world?
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
   }
@@ -294,7 +294,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 = {};
@@ -433,6 +433,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;
@@ -441,35 +510,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)) {
-      const env = JSON.parse(readFileSync(this.envName), "utf8");
-      const baseUrl = env.baseUrl;
-      let url = transition.userTypedURL;
-      if (baseUrl && url.startsWith(baseUrl)) {
-        url = url.replace(baseUrl, "{{env.baseUrl}}");
-      }
-      // console.log("User initiated transition");
-      this.sendEvent(this.events.onGoto, { url });
+
+    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;
     }
   }
 
@@ -596,8 +700,14 @@ 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();
   }

package/bin/client/recording.js

@@ -11,6 +11,8 @@ const Types = {
   PARAMETERIZED_CLICK: "parameterized_click",
   CONTEXT_CLICK: "context_click",
   NAVIGATE: "navigate",
+  GO_BACK: "browser_go_back",
+  GO_FORWARD: "browser_go_forward",
   FILL: "fill_element",
   FILL_SIMPLE: "fill_simple",
   EXECUTE: "execute_page_method",

package/package.json

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