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

package/bin/client/recorderv3/bvt_recorder.js

@@ -3,7 +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 { 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";
@@ -12,10 +12,10 @@ import { updateFeatureFile } from "./update_feature.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
 import chokidar from "chokidar";
-import logger from "../../logger.js";
 import { unEscapeNonPrintables } from "../cucumber/utils.js";
 import { findAvailablePort } from "../utils/index.js";
-
+import socketLogger from "../utils/socket_logger.js";
+import { tmpdir } from "os";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -44,15 +44,15 @@ async function evaluate(frame, script) {
 async function findNestedFrameSelector(frame, obj) {
   try {
     const parent = frame.parentFrame();
-    if (parent) console.log(`Parent frame: ${JSON.stringify(parent)}`);
     if (!parent) return { children: 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) {
+    socketLogger.error(`Error in findNestedFrameSelector: ${e}`);
     console.error(e);
   }
 }
@@ -149,6 +149,7 @@ const transformAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode,
       };
     }
     default: {
+      socketLogger.error(`Action not supported: ${action.name}`);
       console.log("action not supported", action);
       throw new Error("action not supported");
     }
@@ -160,6 +161,7 @@ const transformAction = (action, el, isVerify, isPopupCloseClick, isInHoverMode,
  * @property {string} projectDir
  * @property {string} TOKEN
  * @property {(name:string, data:any)=> void} sendEvent
+ * @property {Object} logger
  */
 export class BVTRecorder {
   #currentURL = "";
@@ -173,7 +175,6 @@ export class BVTRecorder {
    */
   constructor(initialState) {
     Object.assign(this, initialState);
-    this.logger = logger;
     this.screenshotMap = new Map();
     this.snapshotMap = new Map();
     this.scenariosStepsMap = new Map();
@@ -183,16 +184,16 @@ export class BVTRecorder {
       projectDir: this.projectDir,
       logger: this.logger,
     });
-    this.stepRunner = new BVTStepRunner({
-      projectDir: this.projectDir,
-    });
     this.pageSet = new Set();
-
+    this.pageMetaDataSet = new Set();
     this.lastKnownUrlPath = "";
-    // TODO: what is world?
-    this.world = { attach: () => { } };
+    this.world = { attach: () => {} };
     this.shouldTakeScreenshot = true;
     this.watcher = null;
+    this.networkEventsFolder = path.join(tmpdir(), "blinq_network_events");
+    if (existsSync(this.networkEventsFolder)) {
+      rmSync(this.networkEventsFolder, { recursive: true, force: true });
+    }
   }
   events = {
     onFrameNavigate: "BVTRecorder.onFrameNavigate",
@@ -203,12 +204,16 @@ 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) => {
       this.#activeFrame = frame;
       const nestFrmLoc = await findNestedFrameSelector(frame);
-      console.log(`Time taken for action: ${event.statistics.time}`);
+      this.logger.info(`Time taken for action: ${event.statistics.time}`);
       await this.onAction({ ...event, nestFrmLoc });
     },
     __bvt_getMode: async () => {
@@ -227,8 +232,7 @@ export class BVTRecorder {
       await this.onClosePopup();
     },
     __bvt_log: async (src, message) => {
-      // this.logger.info(message);
-      console.log(`Inside Browser: ${message}`);
+      this.logger.info(`Inside Browser: ${message}`);
     },
     __bvt_getObject: (_src, obj) => {
       this.processObject(obj);
@@ -290,11 +294,12 @@ export class BVTRecorder {
   }
 
   async _initBrowser({ url }) {
+    socketLogger.info("Only present in 1.0.1293-stage");
     this.#remoteDebuggerPort = await findAvailablePort();
     process.env.CDP_LISTEN_PORT = this.#remoteDebuggerPort;
 
-    this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
-    this.world = { attach: () => { } };
+    // this.stepRunner.setRemoteDebugPort(this.#remoteDebuggerPort);
+    this.world = { attach: () => {} };
 
     const ai_config_file = path.join(this.projectDir, "ai_config.json");
     let ai_config = {};
@@ -302,9 +307,10 @@ export class BVTRecorder {
       try {
         ai_config = JSON.parse(readFileSync(ai_config_file, "utf8"));
       } catch (error) {
-        console.error("Error reading ai_config.json", error);
+        this.logger.error("Error reading ai_config.json", error);
       }
     }
+    this.config = ai_config;
     const initScripts = {
       // recorderCjs: injectedScriptSource,
       scripts: [
@@ -313,16 +319,37 @@ export class BVTRecorder {
       ],
     };
 
-    let startTime = Date.now();
     const bvtContext = await initContext(url, false, false, this.world, 450, initScripts, this.envName);
-    let stopTime = Date.now();
-    this.logger.info(`Browser launched in ${(stopTime - startTime) / 1000} s`);
     this.bvtContext = bvtContext;
+    this.stepRunner = new BVTStepRunner({
+      projectDir: this.projectDir,
+      sendExecutionStatus: (data) => {
+        if (data && data.type) {
+          switch (data.type) {
+            case "cmdExecutionStart":
+              this.sendEvent(this.events.cmdExecutionStart, data);
+              break;
+            case "cmdExecutionSuccess":
+              this.sendEvent(this.events.cmdExecutionSuccess, data);
+              break;
+            case "cmdExecutionError":
+              this.sendEvent(this.events.cmdExecutionError, data);
+              break;
+            case "interceptResults":
+              this.sendEvent(this.events.interceptResults, data);
+              break;
+            default:
+              break;
+          }
+        }
+      },
+      bvtContext: this.bvtContext,
+    });
     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);
     this.lastKnownUrlPath = this._updateUrlPath();
     const browser = await this.context.browser();
@@ -350,13 +377,15 @@ export class BVTRecorder {
         }
         return;
       } catch (error) {
-        console.error("Error evaluting in context:", error);
+        // console.error("Error evaluting in context:", error);
+        this.logger.error("Error evaluating in context:", error);
       }
     }
   }
 
   getMode() {
-    console.log("getMode", this.#mode);
+    // console.log("getMode", this.#mode);
+    this.logger.info("Current mode:", this.#mode);
     return this.#mode;
   }
 
@@ -398,6 +427,8 @@ export class BVTRecorder {
           this.sendEvent(this.events.onBrowserClose);
         }
       } catch (error) {
+        this.logger.error("Error in page close event");
+        this.logger.error(error);
         console.error("Error in page close event");
         console.error(error);
       }
@@ -408,8 +439,10 @@ export class BVTRecorder {
         if (frame !== page.mainFrame()) return;
         this.handlePageTransition();
       } catch (error) {
+        this.logger.error("Error in handlePageTransition event");
+        this.logger.error(error);
         console.error("Error in handlePageTransition event");
-        // console.error(error);
+        console.error(error);
       }
       try {
         if (frame !== this.#activeFrame) return;
@@ -428,6 +461,8 @@ export class BVTRecorder {
         // await this._setRecordingMode(frame);
         // await this._initPage(page);
       } catch (error) {
+        this.logger.error("Error in frame navigate event");
+        this.logger.error(error);
         console.error("Error in frame navigate event");
         // console.error(error);
       }
@@ -510,13 +545,9 @@ export class BVTRecorder {
 
     try {
       const result = await client.send("Page.getNavigationHistory");
-      // 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;
-
       const currentEntry = entries[currentIndex];
       const transitionInfo = this.analyzeTransitionType(entries, currentIndex, currentEntry);
       this.previousIndex = currentIndex;
@@ -529,6 +560,8 @@ export class BVTRecorder {
         navigationAction: transitionInfo.action,
       };
     } catch (error) {
+      this.logger.error("Error in getCurrentTransition event");
+      this.logger.error(error);
       console.error("Error in getTransistionType event", error);
     } finally {
       await client.detach();
@@ -597,6 +630,8 @@ export class BVTRecorder {
         // add listener for frame navigation on new tab
         this._addFrameNavigateListener(page);
       } catch (error) {
+        this.logger.error("Error in page event");
+        this.logger.error(error);
         console.error("Error in page event");
         console.error(error);
       }
@@ -638,6 +673,7 @@ export class BVTRecorder {
       const { data } = await client.send("Page.captureScreenshot", { format: "png" });
       return data;
     } catch (error) {
+      this.logger.error("Error in taking browser screenshot");
       console.error("Error in taking browser screenshot", error);
     } finally {
       await client.detach();
@@ -700,7 +736,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;
@@ -783,13 +819,23 @@ export class BVTRecorder {
   async abortExecution() {
     await this.stepRunner.abortExecution();
   }
+
+  async pauseExecution({ cmdId }) {
+    await this.stepRunner.pauseExecution(cmdId);
+  }
+
+  async resumeExecution({ cmdId }) {
+    await this.stepRunner.resumeExecution(cmdId);
+  }
+
   async dealyedRevertMode() {
     const timerId = setTimeout(async () => {
       await this.revertMode();
     }, 100);
     this.timerId = timerId;
   }
-  async runStep({ step, parametersMap, tags, isFirstStep }, options) {
+  async runStep({ step, parametersMap, tags, isFirstStep, listenNetwork }, options) {
+    const { skipAfter = true, skipBefore = !isFirstStep } = options || {};
     const _env = {
       TOKEN: this.TOKEN,
       TEMP_RUN: true,
@@ -798,27 +844,39 @@ export class BVTRecorder {
     };
 
     this.bvtContext.navigate = true;
+    this.bvtContext.loadedRoutes = null;
+    if (listenNetwork) {
+      this.bvtContext.STORE_DETAILED_NETWORK_DATA = true;
+    } else {
+      this.bvtContext.STORE_DETAILED_NETWORK_DATA = 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 {
       const { result, info } = await this.stepRunner.runStep(
         {
           step,
           parametersMap,
           envPath: this.envName,
-          tags
+          tags,
+          config: this.config,
         },
         this.bvtContext,
-        options ? { ...options, skipBefore: !isFirstStep } : { skipBefore: !isFirstStep }
+        {
+          skipAfter,
+          skipBefore,
+        }
       );
       await this.revertMode();
-      return { result, info };
+      return { info };
     } catch (error) {
       await this.revertMode();
       throw error;
@@ -856,6 +914,7 @@ export class BVTRecorder {
         step.commands = [];
       }
     }
+    return steps;
     // return getStepsAndCommandsForScenario({
     //   name,
     //   featureName,
@@ -863,6 +922,7 @@ export class BVTRecorder {
     //   map: this.scenariosStepsMap,
     // });
   }
+
   async generateStepName({ commands, stepsNames, parameters, map }) {
     return await this.namesService.generateStepName({ commands, stepsNames, parameters, map });
   }
@@ -914,10 +974,11 @@ export class BVTRecorder {
     if (existsSync(_getDataFile(this.world, this.bvtContext, this.web))) {
       try {
         const testData = JSON.parse(readFileSync(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
-        this.logger.info("Test data", testData);
+        // this.logger.info("Test data", testData);
         this.sendEvent(this.events.getTestData, testData);
       } catch (e) {
-        this.logger.error("Error reading test data file", e);
+        // this.logger.error("Error reading test data file", e);
+        console.log("Error reading test data file", e);
       }
     }
 
@@ -926,10 +987,12 @@ export class BVTRecorder {
     this.watcher.on("all", async (event, path) => {
       try {
         const testData = JSON.parse(await readFile(_getDataFile(this.world, this.bvtContext, this.web), "utf8"));
-        this.logger.info("Test data", testData);
+        // this.logger.info("Test data", testData);
+        console.log("Test data changed", testData);
         this.sendEvent(this.events.getTestData, testData);
       } catch (e) {
-        this.logger.error("Error reading test data file", e);
+        // this.logger.error("Error reading test data file", e);
+        console.log("Error reading test data file", e);
       }
     });
   }
@@ -962,7 +1025,7 @@ export class BVTRecorder {
       .filter((file) => file.endsWith(".feature"))
       .map((file) => path.join(this.projectDir, "features", file));
     try {
-      const parsedFiles = featureFiles.map((file) => parseFeatureFile(file));
+      const parsedFiles = featureFiles.map((file) => this.parseFeatureFile(file));
       const output = {};
       parsedFiles.forEach((file) => {
         if (!file.feature) return;
@@ -986,10 +1049,11 @@ 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);
-    const gherkinDoc = parseFeatureFile(featureFilePath);
+    const gherkinDoc = this.parseFeatureFile(featureFilePath);
     const scenario = gherkinDoc.feature.children.find((child) => child.scenario.name === scenarioName)?.scenario;
 
     const steps = [];
@@ -1014,6 +1078,7 @@ export class BVTRecorder {
         ..._s,
         keyword: step.keyword.trim(),
       };
+      parseRouteFiles(this.projectDir, _step);
       steps.push(_step);
     }
     return {
@@ -1106,20 +1171,68 @@ 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) => {
-  try {
-    let id = 0;
-    const uuidFn = () => (++id).toString(16);
-    const builder = new AstBuilder(uuidFn);
-    const matcher = new GherkinClassicTokenMatcher();
-    const parser = new Parser(builder, matcher);
-    const source = readFileSync(featureFilePath, "utf8");
-    const gherkinDocument = parser.parse(source);
-    return gherkinDocument;
-  } catch (e) {
-    console.log(e);
+  parseFeatureFile(featureFilePath) {
+    try {
+      let id = 0;
+      const uuidFn = () => (++id).toString(16);
+      const builder = new AstBuilder(uuidFn);
+      const matcher = new GherkinClassicTokenMatcher();
+      const parser = new Parser(builder, matcher);
+      const source = readFileSync(featureFilePath, "utf8");
+      const gherkinDocument = parser.parse(source);
+      return gherkinDocument;
+    } catch (e) {
+      this.logger.error(`Error parsing feature file: ${featureFilePath}`);
+      console.log(e);
+    }
+    return {};
   }
-  return {};
-};
+
+  stopRecordingNetwork(input) {
+    if (this.bvtContext) {
+      this.bvtContext.STORE_DETAILED_NETWORK_DATA = false;
+    }
+  }
+}

package/bin/client/recorderv3/implemented_steps.js

@@ -1,9 +1,9 @@
 import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
 import path from "path";
 import url from "url";
 import { findFilesWithExtension, StepsDefinitions } from "../cucumber/steps_definitions.js";
-import { Feature } from "../cucumber/feature.js";
+import { Feature, Step } from "../cucumber/feature.js";
 import { CodePage } from "../code_gen/page_reflection.js";
 import { getCommandsForImplementedStep, loadStepDefinitions } from "./step_utils.js";
 import { parseStepTextParameters } from "../cucumber/utils.js";
@@ -13,7 +13,6 @@ const uuidFn = () => (++id).toString(16);
 const builder = new AstBuilder(uuidFn);
 const matcher = new GherkinClassicTokenMatcher();
 const parser = new Parser(builder, matcher);
-
 let i = 0;
 const getImplId = () => {
   return `I-${i++}`;
@@ -57,6 +56,53 @@ function memorySizeOf(obj) {
   return sizeOf(obj);
 }
 
+export function parseRouteFiles(projectDir, step) {
+  const routeFolder = path.join(projectDir, "data", "routes");
+  const templateRouteMap = new Map();
+
+  if (!existsSync(routeFolder)) {
+    step.routeItems = null;
+    return;
+  }
+
+  // Go over all the files in the route folder and parse them
+  const routeFiles = readdirSync(routeFolder).filter((file) => file.endsWith(".json"));
+  for (const file of routeFiles) {
+    const filePath = path.join(routeFolder, file);
+    const routeData = JSON.parse(readFileSync(filePath, "utf8"));
+    if (routeData && routeData.template) {
+      const template = routeData.template;
+      const routes = routeData.routes;
+
+      templateRouteMap.set(template, routes);
+    }
+  }
+
+  if (!existsSync(routeFolder)) {
+    return null;
+  } else if (step && step.text) {
+    // Convert the step text to cucumber template
+    const cucumberStep = new Step();
+    cucumberStep.text = step.text;
+    const template = cucumberStep.getTemplate();
+    if (templateRouteMap.has(template)) {
+      const routeItems = templateRouteMap.get(template);
+      routeItems.forEach((item) => {
+        const filters = item.filters || {};
+        const queryParams = filters?.queryParams || {};
+        const queryParamsArray = Object.keys(queryParams).map((key) => ({
+          key: key,
+          value: queryParams[key],
+        }));
+        filters.queryParams = queryParamsArray || [];
+      });
+      step.routeItems = routeItems;
+    } else {
+      step.routeItems = null;
+    }
+  }
+}
+
 export const getImplementedSteps = async (projectDir) => {
   const foundErrors = [];
   try {
@@ -70,6 +116,12 @@ export const getImplementedSteps = async (projectDir) => {
     const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
     //console.log({ utilsContent });
     writeFileSync(utilsFilePath, utilsContent, "utf8");
+    const hooksTemplateFilePath = path.join(__dirname, "../../assets", "templates", "_hooks_template.txt");
+    if (existsSync(hooksTemplateFilePath)) {
+      const hooksFilePath = path.join(stepDefinitionFolderPath, "_hooks.mjs");
+      const hooksContent = readFileSync(hooksTemplateFilePath, "utf8");
+      writeFileSync(hooksFilePath, hooksContent, "utf8");
+    }
   } catch (error) {
     foundErrors.push({ error });
   }
@@ -168,7 +220,10 @@ export const getImplementedSteps = async (projectDir) => {
       }
       stepLineSet.add(stepLine);
       step.templateIndex = implementedSteps.length;
-      implementedSteps.push({
+
+      parseRouteFiles(projectDir, step);
+
+      const implementedStep = {
         keyword: step.keyword.trim(),
         keywordAlias: step.keywordAlias?.trim(),
         text: updateStepText(template.pattern, step.parameters),
@@ -179,7 +234,10 @@ export const getImplementedSteps = async (projectDir) => {
         templateIndex: step.templateIndex,
         pattern: template.pattern,
         paths: template.paths,
-      });
+        routeItems: step.routeItems,
+      };
+
+      implementedSteps.push(implementedStep);
     }
   }
 
@@ -236,17 +294,17 @@ export const getImplementedSteps = async (projectDir) => {
     for (const tag of scenario.tags) {
       delete tag.location;
     }
-    // for (const scenario of scenarios) {
-    //   for (const step of scenario.steps) {
-    //     if (step.templateIndex === undefined) {
-    //       const cleanStepName = stepsDefinitions._stepNameToTemplate(step.text);
-    //       const index = implementedSteps.findIndex((istep) => {
-    //         return cleanStepName === istep.pattern;
-    //       });
-    //       step.templateIndex = index;
-    //     }
-    //   }
-    // }
+    for (const scenario of scenarios) {
+      for (const step of scenario.steps) {
+        if (step.templateIndex === undefined) {
+          const cleanStepName = stepsDefinitions._stepNameToTemplate(step.text);
+          const index = implementedSteps.findIndex((istep) => {
+            return cleanStepName === istep.pattern;
+          });
+          step.templateIndex = index;
+        }
+      }
+    }
   }
   if (foundErrors.length > 0) {
     console.log("foundErrors", foundErrors);