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

package/bin/client/recorderv3/step_runner.js

@@ -1,6 +1,5 @@
-import { existsSync, mkdirSync, writeFileSync } from "fs";
+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,
@@ -9,43 +8,72 @@ import {
   getUtilsCodePage,
   loadStepDefinitions,
   saveRecording,
+  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";
 
-// let copiedCodeToTemp = false;
-async function withAbort(fn, signal) {
-  if (!signal) {
-    return await fn();
-  }
-
-  const abortPromise = new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
-  });
-
-  return await Promise.race([fn(), abortPromise]);
-}
 export class BVTStepRunner {
-  #currentStepController;
+  #currentStepController = null;
   #port;
-  constructor({ projectDir }) {
+  #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 {
+      if (this.liveExecutionMap.has(cmdId)) {
+        const { resolve } = this.liveExecutionMap.get(cmdId);
+        if (resolve) {
+          resolve();
+        }
+      } else {
+        console.warn(`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 });
     }
@@ -53,14 +81,13 @@ export class BVTStepRunner {
       overwrite: true,
       recursive: true,
     });
-    // copiedCodeToTemp = true;
   }
 
-  async writeTempFeatureFile({ step, parametersMap, tempFolderPath }) {
+  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(" ") : ""}
     Scenario Outline: Temp Scenario
       Given ${escapeString(step.text)}
     `;
@@ -68,67 +95,295 @@ export class BVTStepRunner {
     writeFileSync(tFilePath, tFileContent);
     return tFilePath;
   }
-  async runStep({ step, parametersMap, envPath }, bvtContext, options) {
-    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];
-        }
+
+  // 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);
+      }
+    }
+    return await fn.apply(this, args);
+  };
+});
+
+    `;
+  }
+
+  // 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 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 = [];
 
-    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);
-      //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);
+    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 (testStepResult.status === "UNDEFINED") {
+          if (!errorMessage) {
+            errorMessage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+            if (info) {
+              errInfo = info;
+            }
+          }
+        }
       }
-      if (!codePage) {
-        codePage = getUtilsCodePage(this.projectDir);
+      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,
+              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,
+            });
+          }
+        }
       }
+    });
+
+    if (errorMessage) {
+      const bvtError = new Error(errorMessage);
+      Object.assign(bvtError, { info: errInfo });
+      throw bvtError;
     }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath });
-    // console.log({ feature_file_path, step_text: step.text });
 
-    const stepExecController = new AbortController();
-    this.#currentStepController = stepExecController;
-    await withAbort(async () => {
-      await stepsDefinitions.executeStepRemote(
+    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);
+      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: () => {},
+        });
+      }
+
+      if (bvtContext.web) {
+        bvtContext.web.getCmdId = () => {
+          if (cmdIDs.length === 0) {
+            cmdIDs = (step.commands || []).map((cmd) => cmd.cmdId);
+          }
+          const cId = cmdIDs.shift();
+          this.sendExecutionStatus({
+            type: "cmdExecutionStart",
+            cmdId: cId,
+          });
+          this.#lastAttemptedCmdId = cId;
+          return cId;
+        };
+      }
+
+      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];
+          }
+        });
+      }
+
+      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,
+        });
+        if (codePage) {
+          await codePage.save(stepDefsFilePath);
+        }
+        if (!codePage) {
+          codePage = getUtilsCodePage(this.projectDir);
+        }
+      } else {
+        let routesPath = path.join(tmpdir(), `blinq_temp_routes`);
+        if (process.env.TEMP_RUN === "true") {
+          if (existsSync(routesPath)) {
+            rmSync(routesPath, { recursive: true });
+          }
+          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 });
+        }
+      }
+
+      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;
+
+      // 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 });
+        }
       }
-    });
+    }
   }
 }