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

package/bin/client/recorderv3/step_runner.js

@@ -1,6 +1,5 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import path from "path";
-import fs from "fs";
 import { generatePageName } from "../code_gen/playwright_codeget.js";
 import {
   executeStep,
@@ -12,48 +11,72 @@ import {
   saveRoutes,
 } from "./step_utils.js";
 import { escapeString, getExamplesContent } from "./update_feature.js";
+import fs from "fs";
 import { locateDefinitionPath } from "../cucumber/steps_definitions.js";
 import { tmpdir } from "os";
+import socketLogger from "../utils/socket_logger.js";
 
-// let copiedCodeToTemp = false;
-async function withAbort(fn, signal) {
-  if (!signal) {
-    return await fn();
-  }
-  return new Promise((resolve, reject) => {
-    const abortHandler = () => reject(new Error("Aborted"));
-    signal.addEventListener("abort", abortHandler, { once: true });
-
-    fn()
-      .then(resolve)
-      .catch(reject)
-      .finally(() => {
-        signal.removeEventListener("abort", abortHandler);
-      });
-  });
-}
 export class BVTStepRunner {
-  #currentStepController;
+  #currentStepController = null;
   #port;
-  constructor({ projectDir, sendExecutionStatus }) {
+  #lastAttemptedCmdId = null;
+
+  constructor({ projectDir, sendExecutionStatus, bvtContext }) {
     this.projectDir = projectDir;
     this.sendExecutionStatus = sendExecutionStatus;
+    this.bvtContext = bvtContext;
+    this.liveExecutionMap = new Map();
   }
+
   setRemoteDebugPort(port) {
     this.#port = port;
   }
+
+  // Abort the current cucumber step execution by signaling the wrapper
   async abortExecution() {
+    if (this.bvtContext.web.pausedCmd) {
+      this.bvtContext.web.pausedCmd = null;
+    }
+    this.liveExecutionMap.clear();
     if (this.#currentStepController) {
       this.#currentStepController.abort();
     }
   }
 
+  async pauseExecution(cmdId) {
+    if (this.bvtContext.web) {
+      this.bvtContext.web.pausedCmd = {
+        id: cmdId,
+        ...this.liveExecutionMap.get(cmdId),
+      };
+    }
+  }
+
+  async resumeExecution(cmdId) {
+    if (this.bvtContext.web.pausedCmd) {
+      const { resolve } = this.bvtContext.web.pausedCmd;
+      if (resolve) {
+        resolve();
+      }
+      this.bvtContext.web.pausedCmd = null;
+    } else {
+      socketLogger.warn(`bvtContext.web.pausedCmd is null`);
+      if (this.liveExecutionMap.has(cmdId)) {
+        const { resolve } = this.liveExecutionMap.get(cmdId);
+        if (resolve) {
+          resolve();
+        }
+      } else {
+        console.warn(`No paused command found for cmdId: ${cmdId}`);
+        socketLogger.error(`No paused command found for cmdId: ${cmdId}`);
+      }
+    }
+  }
+
   async copyCodetoTempFolder({ step, parametersMap, tempFolderPath }) {
-    // const tempFolderPath = path.join(this.projectDir, "__temp_features");
     if (!fs.existsSync(tempFolderPath)) {
       fs.mkdirSync(tempFolderPath);
     }
-    //copy all files from "./features" "./temp" folder
     if (fs.existsSync(tempFolderPath)) {
       fs.rmSync(tempFolderPath, { recursive: true });
     }
@@ -61,12 +84,10 @@ export class BVTStepRunner {
       overwrite: true,
       recursive: true,
     });
-    // copiedCodeToTemp = true;
   }
 
   async writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags }) {
     const tFilePath = path.join(tempFolderPath, "__temp.feature");
-    // console.log(tFilePath);
     let tFileContent = `# temp feature file
     Feature: Temp feature
     ${tags ? tags.join(" ") : ""}
@@ -78,236 +99,300 @@ export class BVTStepRunner {
     return tFilePath;
   }
 
-  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
-    if (!options) {
-      options = {
-        skipAfter: true,
+  // Generate wrapper code that integrates AbortSignal into cucumber step definitions
+  generateWrapperCode() {
+    return `
+    import {setDefinitionFunctionWrapper} from "@dev-blinq/cucumber-js";
+    
+    setDefinitionFunctionWrapper((fn) => {
+  return async function (...args) {
+    const signal = global.__BVT_STEP_ABORT_SIGNAL;
+    if (signal) {
+      signal.throwIfAborted?.();
+      const abortHandler = () => {
+        throw new Error("Aborted");
       };
+      signal.addEventListener("abort", abortHandler, { once: true });
+      try {
+        return await fn.apply(this, args);
+      } finally {
+        signal.removeEventListener("abort", abortHandler);
+      }
     }
-    const environment = {
-      ...process.env,
-    };
+    return await fn.apply(this, args);
+  };
+});
 
-    try {
-      const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
-      const { runConfiguration } = await loadConfiguration(
-        {
-          provided: {
-            name: [scenario],
-            paths: [feature_file_path],
-            import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
-            // format: ["bvt"],
-          },
+    `;
+  }
+
+  // Write the wrapper code to temp folder
+  async writeWrapperCode(tempFolderPath, abortSignal) {
+    // tempFolderPath/step_definitions/utils.mjs -> Make a file name that follows this file but always before the next file
+    let fileName = "utils" + Math.random().toString(36).substring(2, 7) + ".mjs";
+    while (existsSync(path.join(tempFolderPath, "step_definitions", fileName))) {
+      fileName = "utils" + Math.random().toString(36).substring(2, 7) + ".mjs";
+    }
+    const wrapperCode = this.generateWrapperCode();
+
+    // Ensure directory exists
+    const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
+    if (!existsSync(stepDefinitionFolderPath)) {
+      mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    }
+
+    writeFileSync(path.join(stepDefinitionFolderPath, fileName), wrapperCode);
+
+    // Set the abort signal globally so the wrapper can access it
+    global.__BVT_STEP_ABORT_SIGNAL = abortSignal;
+
+    return path.join(stepDefinitionFolderPath, fileName);
+  }
+
+  // Execute cucumber step - simplified without abort signal handling at this level
+  async executeStepWithAbort({ feature_file_path, scenario, tempFolderPath, stepText, config }, options) {
+    const { skipAfter = true, skipBefore = true } = options || {};
+
+    const environment = { ...process.env };
+    const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
+
+    const { runConfiguration } = await loadConfiguration(
+      {
+        provided: {
+          name: [scenario],
+          paths: [feature_file_path],
+          import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
         },
-        { cwd: process.cwd(), env: environment }
-      );
-      // const files = glob.sync(path.join(tempFolderPath, "step_definitions", "**", "*.mjs"));
-      // console.log("Files found:", files);
-      const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
-      // console.log("found ", support.stepDefinitions.length, "step definitions");
-      // support.stepDefinitions.map((step) => {
-      //   console.log("step", step.pattern);
-      // });
-
-      if (options.skipAfter) {
-        // ignore afterAll/after hooks
-        support.afterTestCaseHookDefinitions = [];
-        support.afterTestRunHookDefinitions = [];
-      }
+      },
+      { cwd: process.cwd(), env: environment }
+    );
 
-      let errorMesssage = null;
-      let info = null;
-      let errInfo = null;
-      const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
-        if (message.testStepFinished) {
-          const { testStepFinished } = message;
-          const { testStepResult } = testStepFinished;
-          if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
-            if (!errorMesssage) {
-              errorMesssage = testStepResult.message;
-              if (info) {
-                errInfo = info;
-              }
-            }
-          }
-          if (testStepResult.status === "UNDEFINED") {
-            if (!errorMesssage) {
-              errorMesssage = stepText ? `step ${JSON.stringify(stepText)} is ${testStepResult.status}` : testStepResult.message;
-              if (info) {
-                errInfo = info;
-              }
+    const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
+
+    support.afterTestRunHookDefinitions = [];
+    if (skipAfter) {
+      support.afterTestCaseHookDefinitions = [];
+    }
+    if (skipBefore && !config.legacySyntax) {
+      support.beforeTestCaseHookDefinitions = support.beforeTestCaseHookDefinitions.filter((hook) => {
+        return hook.uri.endsWith("_hooks.mjs");
+      });
+    }
+    support.beforeTestRunHookDefinitions = [];
+
+    let errorMessage = null;
+    let info = null;
+    let errInfo = null;
+
+    const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
+      if (message.testStepFinished) {
+        const { testStepFinished } = message;
+        const { testStepResult } = testStepFinished;
+        if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
+          if (!errorMessage) {
+            errorMessage = testStepResult.message;
+            if (info) {
+              errInfo = info;
             }
           }
         }
-        if (message.attachment) {
-          const attachment = message.attachment;
-          if (attachment.mediaType === "application/json" && attachment.body) {
-            const body = JSON.parse(attachment.body);
-            info = body.info;
-            const result = body.result;
-
-            if (result.status === "PASSED") {
-              this.sendExecutionStatus({
-                type: "cmdExecutionSuccess",
-                cmdId: body.cmdId,
-              });
-            } else {
-              this.sendExecutionStatus({
-                type: "cmdExecutionError",
-                cmdId: body.cmdId,
-                error: result.error,
-              });
+        if (testStepResult.status === "UNDEFINED") {
+          if (!errorMessage) {
+            errorMessage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+            if (info) {
+              errInfo = info;
             }
-            // if (body && body.payload) {
-            //   const payload = body.payload;
-            //   const content = payload.content;
-            //   const type = payload.type;
-            //   if (type === "cmdReport") {
-            //     if (content) {
-            //       const report = JSON.parse(content);
-            //       switch (report.status) {
-            //         case "start":
-            //           this.sendExecutionStatus({
-            //             type: "cmdExecutionStart",
-            //             cmdId: report.cmdId,
-            //           });
-            //           break;
-            //         case "end":
-            //           this.sendExecutionStatus({
-            //             type: "cmdExecutionSuccess",
-            //             cmdId: report.cmdId,
-            //           });
-            //           break;
-            //         default:
-            //           console.warn("Unknown command report status:", report.status);
-            //       }
-            //     }
-            //   }
-            // }
           }
         }
-      });
-      if (errorMesssage) {
-        const bvtError = new Error(errorMesssage);
-        Object.assign(bvtError, { info: errInfo });
-        throw bvtError;
       }
+      if (message.attachment) {
+        const attachment = message.attachment;
+        if (attachment.mediaType === "application/json" && attachment.body) {
+          const body = JSON.parse(attachment.body);
+          info = body.info;
+          const result = body.result;
 
-      return {
-        result,
-        info,
-      };
-    } catch (error) {
-      console.error("Error running cucumber-js", error);
-      throw error;
-    }
-  };
-
-  async runStep({ step, parametersMap, envPath, tags }, bvtContext, options) {
-    let cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
-    if (bvtContext.web) {
-      bvtContext.web.getCmdId = () => {
-        if (cmdIDs.length === 0) {
-          cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+          if (result.status === "PASSED") {
+            this.sendExecutionStatus({
+              type: "cmdExecutionSuccess",
+              cmdId: body.cmdId,
+              info,
+              selectedStrategy: info?.selectedStrategy,
+            });
+          } else {
+            this.sendExecutionStatus({
+              type: "cmdExecutionError",
+              cmdId: body.cmdId,
+              error: {
+                message: result.message,
+                info,
+              },
+            });
+          }
+        } else if (attachment.mediaType === "application/json+intercept-results" && attachment.body) {
+          const body = JSON.parse(attachment.body);
+          if (body) {
+            this.sendExecutionStatus({
+              type: "interceptResults",
+              interceptResults: body,
+            });
+          }
         }
-        const cId = cmdIDs.shift();
-        this.sendExecutionStatus({
-          type: "cmdExecutionStart",
-          cmdId: cId,
-        })
-        return cId;
       }
+    });
+
+    if (errorMessage) {
+      const bvtError = new Error(errorMessage);
+      Object.assign(bvtError, { info: errInfo });
+      throw bvtError;
     }
-    let codePage; // = getCodePage();
-    // const tempFolderPath = process.env.tempFeaturesFolderPath;
-    const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
-    const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
-    process.env.tempFeaturesFolderPath = __temp_features_FolderName;
-    process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
-    // if (!copiedCodeToTemp) {
-    // await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
-    // }
-    await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
-    // console.log({ feature_file_path });
-    let stepsDefinitions = loadStepDefinitions(this.projectDir, false, true);
-    // console.log({ stepsDefinitions });
-    const cucumberStep = getCucumberStep({ step });
-    if (cucumberStep.parameters && Array.isArray(cucumberStep.parameters)) {
-      cucumberStep.parameters.forEach((param) => {
-        if (param.variableName) {
-          param.callValue = parametersMap[param.variableName];
-        }
-      });
-    }
 
-    if (!step.isImplemented && step.commands.length > 0) {
-      const pageName = generatePageName(step.startFrame?.url ?? "default");
-      const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
-      if (!existsSync(stepDefinitionFolderPath)) {
-        mkdirSync(stepDefinitionFolderPath, { recursive: true });
+    return { result, info };
+  }
+
+  async runStep({ step, parametersMap, envPath, tags, config }, bvtContext, options) {
+    // Create a new AbortController for this specific step execution
+    this.#currentStepController = new AbortController();
+    const { signal } = this.#currentStepController;
+
+    try {
+      this.#lastAttemptedCmdId = null;
+      let cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId ?? cmd.id);
+      bvtContext.web.pausedCmd = null;
+
+      // Clear the liveExecutionMap and set up new entries for this step
+      this.liveExecutionMap.clear();
+
+      for (const cmdId of cmdIDs) {
+        this.liveExecutionMap.set(cmdId, {
+          resolve: () => {},
+          reject: () => {},
+        });
       }
-      const stepDefsFilePath = locateDefinitionPath(tempFolderPath, pageName);
-      //path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
-      codePage = getCodePage(stepDefsFilePath);
-      codePage = await saveRecording({ step, cucumberStep, codePage, projectDir: this.projectDir, stepsDefinitions });
-      if (codePage) {
-        await codePage.save(stepDefsFilePath);
-        // console.log("saved code page: ", stepDefsFilePath);
+
+      if (bvtContext.web) {
+        bvtContext.web.getCmdId = () => {
+          if (cmdIDs.length === 0) {
+            cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId ?? cmd.id);
+          }
+          const cId = cmdIDs.shift();
+          this.sendExecutionStatus({
+            type: "cmdExecutionStart",
+            cmdId: cId,
+          });
+          this.#lastAttemptedCmdId = cId;
+          return cId;
+        };
       }
-      if (!codePage) {
-        codePage = getUtilsCodePage(this.projectDir);
+
+      const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
+      const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+      process.env.tempFeaturesFolderPath = __temp_features_FolderName;
+      process.env.TESTCASE_REPORT_FOLDER_PATH = tempFolderPath;
+
+      await this.copyCodetoTempFolder({ step, parametersMap, tempFolderPath });
+
+      // Write abort wrapper code with this step's signal
+      await this.writeWrapperCode(tempFolderPath, signal);
+
+      let stepsDefinitions = loadStepDefinitions(this.projectDir, false, true);
+      const cucumberStep = getCucumberStep({ step });
+
+      if (cucumberStep.parameters && Array.isArray(cucumberStep.parameters)) {
+        cucumberStep.parameters.forEach((param) => {
+          if (param.variableName) {
+            param.callValue = parametersMap[param.variableName];
+          }
+        });
       }
-    } else {
-      let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
-      if (process.env.TEMP_RUN === "true") {
-        console.log("Save routes in temp folder for running:", routesPath);
-        if (existsSync(routesPath)) {
-          console.log("Removing existing temp_routes_folder:", routesPath);
-          rmSync(routesPath, { recursive: true });
+
+      if (!step.isImplemented && step.commands.length > 0) {
+        const pageName = generatePageName(step.startFrame?.url ?? "default");
+        const stepDefinitionFolderPath = path.join(tempFolderPath, "step_definitions");
+        if (!existsSync(stepDefinitionFolderPath)) {
+          mkdirSync(stepDefinitionFolderPath, { recursive: true });
+        }
+        const stepDefsFilePath = locateDefinitionPath(tempFolderPath, pageName);
+        let codePage = getCodePage(stepDefsFilePath);
+        codePage = await saveRecording({
+          step,
+          cucumberStep,
+          codePage,
+          projectDir: this.projectDir,
+          stepsDefinitions,
+          parametersMap,
+        });
+        if (codePage) {
+          await codePage.save(stepDefsFilePath);
+        }
+        if (!codePage) {
+          codePage = getUtilsCodePage(this.projectDir);
         }
-        mkdirSync(routesPath, { recursive: true });
-        console.log("Created temp_routes_folder:", routesPath);
-        saveRoutes({ step, folderPath: routesPath });
       } else {
-        console.log("Saving routes in project directory:", this.projectDir);
-        if (existsSync(routesPath)) {
-          // remove the folder
-          try {
+        let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+        if (process.env.TEMP_RUN === "true") {
+          if (existsSync(routesPath)) {
             rmSync(routesPath, { recursive: true });
-            console.log("Removed temp_routes_folder:", routesPath);
-          } catch (error) {
-            console.error("Error removing temp_routes folder", error);
           }
-        }
-        routesPath = path.join(this.projectDir, "data", "routes");
-        console.log("Saving routes to:", routesPath);
-        if (!existsSync(routesPath)) {
           mkdirSync(routesPath, { recursive: true });
+          saveRoutes({ step, folderPath: routesPath });
+        } else {
+          if (existsSync(routesPath)) {
+            try {
+              rmSync(routesPath, { recursive: true });
+            } catch (error) {
+              console.error("Error removing temp_routes folder", error);
+            }
+          }
+          routesPath = path.join(this.projectDir, "data", "routes");
+          if (!existsSync(routesPath)) {
+            mkdirSync(routesPath, { recursive: true });
+          }
+          saveRoutes({ step, folderPath: routesPath });
         }
-        saveRoutes({ step, folderPath: routesPath });
       }
-    }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath, tags });
-    // console.log({ feature_file_path, step_text: step.text });
 
-    const stepExecController = new AbortController();
-    this.#currentStepController = stepExecController;
-    const { result, info } = await withAbort(async () => {
-      return await stepsDefinitions.executeStepRemote(
+      const feature_file_path = await this.writeTempFeatureFile({
+        step,
+        parametersMap,
+        tempFolderPath,
+        tags,
+      });
+
+      // Execute the cucumber step - if wrapper throws "Aborted", it will propagate up
+      const { result, info } = await this.executeStepWithAbort(
         {
           feature_file_path,
           tempFolderPath,
           stepText: step.text,
           scenario: "Temp Scenario",
+          config,
         },
         options
       );
-    }, stepExecController.signal).finally(() => {
-      // rm temp folder
-      if (fs.existsSync(tempFolderPath)) {
-        fs.rmSync(tempFolderPath, { recursive: true });
+
+      return { result, info };
+    } catch (error) {
+      if (error.message && error.message.includes("Aborted")) {
+        throw new Error("Aborted");
+      } else throw error;
+    } finally {
+      // Clean up this step's controller and global reference
+      this.#currentStepController = null;
+      global.__BVT_STEP_ABORT_SIGNAL = null;
+
+      try {
+        // Clean up temp folder
+        const __temp_features_FolderName = process.env.tempFeaturesFolderPath;
+        if (__temp_features_FolderName) {
+          const tempFolderPath = path.join(this.projectDir, __temp_features_FolderName);
+          if (fs.existsSync(tempFolderPath)) {
+            fs.rmSync(tempFolderPath, { recursive: true });
+          }
+        }
+      } catch (error) {
+        console.error("Error cleaning up temp folder", error);
       }
-    });
-    return { result, info };
+    }
   }
 }