@dev-blinq/cucumber_client 1.0.1190-dev → 1.0.1190-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,26 +8,36 @@ 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();
   }
+  return new Promise((resolve, reject) => {
+    const abortHandler = () => reject(new Error("Aborted"));
+    signal.addEventListener("abort", abortHandler, { once: true });
 
-  const abortPromise = new Promise((_, reject) => {
-    signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
+    fn()
+      .then(resolve)
+      .catch(reject)
+      .finally(() => {
+        signal.removeEventListener("abort", abortHandler);
+      });
   });
-
-  return await Promise.race([fn(), abortPromise]);
 }
 export class BVTStepRunner {
   #currentStepController;
   #port;
-  constructor({ projectDir }) {
+  constructor({ projectDir, sendExecutionStatus }) {
     this.projectDir = projectDir;
+    this.sendExecutionStatus = sendExecutionStatus;
   }
   setRemoteDebugPort(port) {
     this.#port = port;
@@ -55,11 +64,12 @@ export class BVTStepRunner {
     // 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)}
     `;
@@ -67,7 +77,135 @@ export class BVTStepRunner {
     writeFileSync(tFilePath, tFileContent);
     return tFilePath;
   }
-  async runStep({ step, parametersMap, envPath }, bvtContext, options) {
+
+  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText, config }, options) => {
+    const { skipAfter = true, skipBefore = true } = options || {};
+    const environment = {
+      ...process.env,
+    };
+
+    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"],
+          },
+        },
+        { 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);
+      // });
+
+      support.afterTestRunHookDefinitions = [];
+      if (skipAfter) {
+        // ignore afterAll/after hooks
+        support.afterTestCaseHookDefinitions = [];
+      }
+      if (skipBefore && !config.legacySyntax) {
+        // ignore beforeAll/before hooks
+        support.beforeTestCaseHookDefinitions = support.beforeTestCaseHookDefinitions.filter((hook) => {
+          return hook.uri.endsWith("utils.mjs");
+        });
+      }
+      support.beforeTestRunHookDefinitions = [];
+
+      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 = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+              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: {
+                  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 (errorMesssage) {
+        const bvtError = new Error(errorMesssage);
+        Object.assign(bvtError, { info: errInfo });
+        throw bvtError;
+      }
+
+      return {
+        result,
+        info,
+      };
+    } catch (error) {
+      console.error("Error running cucumber-js", error);
+      throw error;
+    }
+  };
+
+  async runStep({ step, parametersMap, envPath, tags, config }, 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);
+        }
+        const cId = cmdIDs.shift();
+        this.sendExecutionStatus({
+          type: "cmdExecutionStart",
+          cmdId: cId,
+        });
+        return cId;
+      };
+    }
     let codePage; // = getCodePage();
     // const tempFolderPath = process.env.tempFeaturesFolderPath;
     const __temp_features_FolderName = "__temp_features" + Math.random().toString(36).substring(2, 7);
@@ -96,7 +234,8 @@ export class BVTStepRunner {
       if (!existsSync(stepDefinitionFolderPath)) {
         mkdirSync(stepDefinitionFolderPath, { recursive: true });
       }
-      const stepDefsFilePath = path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
+      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) {
@@ -106,19 +245,49 @@ export class BVTStepRunner {
       if (!codePage) {
         codePage = getUtilsCodePage(this.projectDir);
       }
+    } 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 });
+        }
+        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 {
+            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 });
+      }
     }
-    const feature_file_path = await this.writeTempFeatureFile({ step, parametersMap, tempFolderPath });
+    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;
-    await withAbort(async () => {
-      await stepsDefinitions.executeStepRemote(
+    const { result, info } = await withAbort(async () => {
+      return await this.executeStepRemote(
         {
           feature_file_path,
           tempFolderPath,
           stepText: step.text,
           scenario: "Temp Scenario",
+          config,
         },
         options
       );
@@ -128,5 +297,6 @@ export class BVTStepRunner {
         fs.rmSync(tempFolderPath, { recursive: true });
       }
     });
+    return { result, info };
   }
 }

package/bin/client/recorderv3/step_utils.js

@@ -1,14 +1,16 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import url from "url";
 import logger from "../../logger.js";
-import { CodePage } from "../code_gen/page_reflection.js";
+import { CodePage, getAiConfig } from "../code_gen/page_reflection.js";
 import { generateCode, generatePageName } from "../code_gen/playwright_codeget.js";
 import { invertCodeToCommand } from "../code_gen/code_inversion.js";
 import { Step } from "../cucumber/feature.js";
-import { StepsDefinitions } from "../cucumber/steps_definitions.js";
+import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
+import { tmpdir } from "os";
+import { createHash } from "crypto";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -69,19 +71,74 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+  let routesPath = path.join(tmpdir(), "blinq_temp_routes");
+
+  if (process.env.TEMP_RUN) {
+    if (existsSync(routesPath)) {
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        console.error("Error removing temp_routes folder", error);
+      }
+      routesPath = path.join(projectDir, "data", "routes");
+      if (!existsSync(routesPath)) {
+        mkdirSync(routesPath, { recursive: true });
+      }
+      saveRoutes({ step, folderPath: routesPath });
+    }
+  }
+
   if (step.isImplementedWhileRecording && !process.env.TEMP_RUN) {
     return;
   }
+
   if (step.isImplemented && step.shouldOverride) {
     let stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
   } else {
     const isUtilStep = makeStepTextUnique(step, stepsDefinitions);
+
     if (isUtilStep) {
       return;
     }
   }
+
+  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 });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    console.log("Created temp_routes_folder:", routesPath);
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    console.log("Saving routes in project directory:", projectDir);
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        console.error("Error removing temp_routes folder", error);
+      }
+    }
+    routesPath = path.join(projectDir, "data", "routes");
+    console.log("Saving routes to:", routesPath);
+    if (!existsSync(routesPath)) {
+      mkdirSync(routesPath, { recursive: true });
+    }
+    saveRoutes({ step, folderPath: routesPath });
+  }
+
   cucumberStep.text = step.text;
   const recording = new Recording();
   const steps = step.commands;
@@ -108,6 +165,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,11 +190,15 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
-    stepsDefinitions.addStep({
-      name: step.text,
-      file: result.codePage.sourceFileName,
-      source: "recorder",
-    });
+
+    if (!step.isImplemented) {
+      stepsDefinitions.addStep({
+        name: step.text,
+        file: result.codePage.sourceFileName,
+        source: "recorder",
+      });
+    }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -164,7 +226,13 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       path
     );
     const keyword = (cucumberStep.keywordAlias ?? cucumberStep.keyword).trim();
-    const stepResult = codePage.addCucumberStep(keyword, cucumberStep.getTemplate(), methodName, steps.length);
+    const stepResult = codePage.addCucumberStep(
+      keyword,
+      cucumberStep.getTemplate(),
+      methodName,
+      steps.length,
+      step.finalTimeout
+    );
 
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
@@ -185,7 +253,17 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
 
 const getLocatorsJson = (file) => {
   if (!file) return {};
-  const locatorsFilePath = file.replace(".mjs", ".json");
+  let locatorsFilePath = file.replace(".mjs", ".json");
+  const originLocatorsFilePath = locatorsFilePath;
+  const config = getAiConfig();
+  if (config && config.locatorsMetadataDir) {
+    // if config.locatorsMetadataDir is set, use it to create the file path
+    locatorsFilePath = path.join(config.locatorsMetadataDir, path.basename(locatorsFilePath));
+    if (!existsSync(locatorsFilePath)) {
+      // if the file does not exist in the config directory, use the original path
+      locatorsFilePath = originLocatorsFilePath;
+    }
+  }
   if (!existsSync(locatorsFilePath)) {
     return {};
   }
@@ -227,7 +305,7 @@ export const getCommandsForImplementedStep = (stepName, stepsDefinitions, stepPa
 
     isUtilStep = codePage.sourceFileName.endsWith("utils.mjs");
     for (const { code } of codeCommands) {
-      const command = invertCodeToCommand(code, elements, stepParams)[0];
+      const command = invertCodeToCommand(code, elements, stepParams, stepsDefinitions, codePage, stepName)[0];
       if (command === undefined || command.type === null) continue;
       if (command.element) {
         const key = command.element.key;
@@ -297,6 +375,7 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   const steps = scenario.steps;
 
   const stepsDefinitions = new StepsDefinitions(projectDir);
+  const featureFolder = path.join(projectDir, "features");
   stepsDefinitions.load(false);
   // const parameters = scenario.parameters;
   // await saveRecordings({ steps, parameters, codePage, projectDir });
@@ -308,13 +387,41 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
       }
     }
     if ((step.isImplemented && !step.shouldOverride) || step.commands.length === 0) {
+      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 });
+        }
+        mkdirSync(routesPath, { recursive: true });
+        console.log("Created temp_routes_folder:", routesPath);
+        saveRoutes({ step, folderPath: routesPath });
+      } else {
+        console.log("Saving routes in project directory:", projectDir);
+        if (existsSync(routesPath)) {
+          // remove the folder
+          try {
+            rmSync(routesPath, { recursive: true });
+            console.log("Removed temp_routes_folder:", routesPath);
+          } catch (error) {
+            console.error("Error removing temp_routes folder", error);
+          }
+        }
+        routesPath = path.join(projectDir, "data", "routes");
+        console.log("Saving routes to:", routesPath);
+        if (!existsSync(routesPath)) {
+          mkdirSync(routesPath, { recursive: true });
+        }
+        saveRoutes({ step, folderPath: routesPath });
+      }
       continue;
     }
     const cucumberStep = getCucumberStep({ step });
     const pageName = generatePageName(step.startFrame?.url ?? "default");
-    const stepDefsFilePath = path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
+    const stepDefsFilePath = locateDefinitionPath(featureFolder, pageName);
+    // path.join(stepDefinitionFolderPath, pageName + "_page.mjs");
     let codePage = getCodePage(stepDefsFilePath);
-
     codePage = await saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions });
     if (!codePage) {
       continue;
@@ -326,3 +433,45 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   }
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
+
+export function saveRoutes({ step, folderPath }) {
+  const routeItems = step.routeItems;
+  if (!routeItems || routeItems.length === 0) {
+    return;
+  }
+  const cucumberStep = getCucumberStep({ step });
+  const template = cucumberStep.getTemplate();
+  const stepNameHash = createHash("sha256").update(template).digest("hex");
+  console.log("Saving routes for step:", step.text, "with hash:", stepNameHash);
+
+  const routeItemsWithFilters = routeItems.map((routeItem) => {
+    const oldFilters = routeItem.filters;
+    const queryParamsObject = {};
+    oldFilters.queryParams.forEach((queryParam) => {
+      queryParamsObject[queryParam.key] = queryParam.value;
+    });
+    const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
+    return {
+      ...routeItem,
+      filters: newFilters,
+    };
+  });
+
+  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
+  console.log("Routes file path:", routesFilePath);
+  const routesData = {
+    template,
+    routes: routeItemsWithFilters,
+  };
+  console.log("Routes data to save:", routesData);
+
+  if (!existsSync(folderPath)) {
+    mkdirSync(folderPath, { recursive: true });
+  }
+  try {
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
+    console.log("Saved routes to", routesFilePath);
+  } catch (error) {
+    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+  }
+}