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

package/bin/client/code_gen/playwright_codeget.js

@@ -47,21 +47,30 @@ const _isCodeGenerationStep = (step) => {
     step.type === Types.SELECT ||
     step.type === Types.HOVER ||
     step.type === Types.EXTRACT_ATTRIBUTE ||
+    step.type === Types.EXTRACT_PROPERTY ||
     step.type === Types.SET_DATE_TIME ||
     step.type === Types.CHECK ||
     step.type === Types.PRESS ||
     step.type === Types.SET_INPUT ||
     step.type === Types.FILL_UNKNOWN ||
-    step.type === "context_click" ||
-    step.type === "parameterized_click" ||
+    step.type === Types.CONTEXT_CLICK ||
+    step.type === Types.PARAMETERIZED_CLICK ||
     step.type === Types.VERIFY_ATTRIBUTE ||
+    step.type === Types.VERIFY_PROPERTY ||
     step.type === Types.SET_INPUT_FILES ||
-    step.type === Types.VERIFY_PAGE_SNAPSHOT
+    step.type === Types.VERIFY_PAGE_SNAPSHOT ||
+    step.type === Types.CONDITIONAL_WAIT
   ) {
     return true;
   }
   return false;
 };
+// Note: this function is used to exclude a key from an object
+// Please move it to utils and use it as a reusable function  ...
+function excludeKey(obj, keyToRemove) {
+  const { [keyToRemove]: _, ...rest } = obj;
+  return rest;
+}
 const splitToLocatorsGroups = (locators) => {
   const no_text = locators.locators.filter((locator) => locator.mode === "NO_TEXT");
   const ignore_digit = locators.locators.filter((locator) => locator.mode === "IGNORE_DIGIT");
@@ -131,7 +140,8 @@ const _generateCodeFromCommand = (step, elements, userData) => {
     if (!elementIdentifier) {
       elementIdentifier = findElementIdentifier(node, step, userData, elements);
     }
-    elements[elementIdentifier] = locatorObject;
+    const withoutAllStrategyLocators = excludeKey(locatorObject, "allStrategyLocators");
+    elements[elementIdentifier] = withoutAllStrategyLocators;
     elementsChanged = true;
   }
   let optionElement = null;
@@ -157,6 +167,7 @@ const _generateCodeFromCommand = (step, elements, userData) => {
   let variable = null;
   let format = null;
   let options = null;
+  let property = null;
   switch (step.type) {
     case Types.SET_INPUT:
       line = `await context.web.setInputValue(elements["${elementIdentifier}"], `;
@@ -181,19 +192,51 @@ const _generateCodeFromCommand = (step, elements, userData) => {
         line = `await context.web.setCheck(elements["${elementIdentifier}"], ${step.check}, _params, null, this);`;
         codeLines.push(line);
       } else {
-        if (element_name) {
-          comment = `// Click on ${element_name}`;
-          codeLines.push(escapeNonPrintables(comment));
+        switch (step.count) {
+          case 1:
+            if (element_name) {
+              comment = `// Click on ${element_name}`;
+              codeLines.push(escapeNonPrintables(comment));
+            }
+            line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
+            codeLines.push(line);
+            break;
+          case 2:
+            if (element_name) {
+              comment = `// Double click on ${element_name}`;
+              codeLines.push(escapeNonPrintables(comment));
+            }
+            line = `await context.web.click(elements["${elementIdentifier}"], _params, {clickCount:2}, this);`;
+            codeLines.push(line);
+            break;
+          default:
+            if (element_name) {
+              comment = `// Click on ${element_name}`;
+              codeLines.push(escapeNonPrintables(comment));
+            }
+            line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
+            codeLines.push(line);
+            break;
         }
-
-        line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
-        codeLines.push(line);
       }
       break;
-    case "parameterized_click":
-      comment = `//  Parameterized click on ${step.value}`;
-      codeLines.push(escapeNonPrintables(comment));
-      line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
+    case Types.PARAMETERIZED_CLICK:
+      switch (step.count) {
+        case 1:
+          comment = `//  Parameterized click on ${step.value}`;
+          codeLines.push(escapeNonPrintables(comment));
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
+          break;
+        case 2:
+          comment = `//  Parameterized double click on ${step.value}`;
+          codeLines.push(escapeNonPrintables(comment));
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, {clickCount:2}, this);`;
+          break;
+        default:
+          comment = `//  Parameterized click on ${step.value}`;
+          codeLines.push(escapeNonPrintables(comment));
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, null, this);`;
+      }
       codeLines.push(line);
       break;
     case Types.SET_DATE_TIME:
@@ -240,30 +283,32 @@ const _generateCodeFromCommand = (step, elements, userData) => {
       }
       codeLines.push(line);
       break;
-    case Types.FILL_UNKNOWN:
-      line = `await context.web.clickType(elements["${elementIdentifier}"], `;
-      // eslint-disable-next-line
-      input = `"${escapeNonPrintables(step.parameters[0])}"`;
+    case Types.EXTRACT_ATTRIBUTE: {
+      attribute = escapeNonPrintables(step.parameters[0]);
+      variable = escapeNonPrintables(step.parameters[1]);
+      input = `"${variable}"`;
       if (step.dataSource === "userData" || step.dataSource === "parameters") {
-        //parameters.push(step.dataKey);
         input = "_" + step.dataKey;
       }
-      if (step.parameters[1] === true) {
-        enter = "true";
-      } else if (step.parameters[1] === false || step.parameters[1] === undefined) {
-        enter = "false";
+      let options = "null";
+      if (step.regex !== "") {
+        options = `{regex: ${JSON.stringify(step.regex)},trimSpaces: ${step.trimSpaces}}`;
+      } else if (step.trimSpaces) {
+        options = `{trimSpaces: ${step.trimSpaces}}`;
       } else {
-        enter = '"' + step.parameters[1] + '"';
+        options = "null";
       }
-      line += `${input}, ${enter}, _params, null, this);`;
+      line = `await context.web.extractAttribute(elements["${elementIdentifier}"], "${attribute}", ${input}, _params,${options}, this);`;
+
       if (element_name) {
-        comment = `// Fill ${element_name} with "${input}"`;
+        comment = `// Extract attribute ${attribute} from ${element_name} to ${variable}`;
         codeLines.push(escapeNonPrintables(comment));
       }
       codeLines.push(line);
       break;
-    case Types.EXTRACT_ATTRIBUTE: {
-      attribute = escapeNonPrintables(step.parameters[0]);
+    }
+    case Types.EXTRACT_PROPERTY: {
+      property = escapeNonPrintables(step.parameters[0]);
       variable = escapeNonPrintables(step.parameters[1]);
       input = `"${variable}"`;
       if (step.dataSource === "userData" || step.dataSource === "parameters") {
@@ -277,10 +322,10 @@ const _generateCodeFromCommand = (step, elements, userData) => {
       } else {
         options = "null";
       }
-      line = `await context.web.extractAttribute(elements["${elementIdentifier}"], "${attribute}", ${input}, _params,${options}, this);`;
+      line = `await context.web.extractProperty(elements["${elementIdentifier}"], "${property}", ${input}, _params,${options}, this);`;
 
       if (element_name) {
-        comment = `// Extract attribute ${attribute} from ${element_name} to ${variable}`;
+        comment = `// Extract property ${property} from ${element_name} to ${variable}`;
         codeLines.push(escapeNonPrintables(comment));
       }
       codeLines.push(line);
@@ -288,10 +333,10 @@ const _generateCodeFromCommand = (step, elements, userData) => {
     }
     case Types.VERIFY_PAGE_SNAPSHOT:
       comment = step.nestFrmLoc
-        ? `// Verify page snapshot ${step.parameters[0]} in the frame ${step.nestFrmLoc}`
+        ? `// Verify page snapshot ${step.parameters[0]} in the frame ${step.selectors.iframe_src}`
         : `// Verify page snapshot ${step.parameters[0]}`;
       codeLines.push(escapeNonPrintables(comment));
-      line = `const frameLocator = ${JSON.stringify(step.nestFrmLoc ?? null)}`;
+      line = `const frameLocator = ${JSON.stringify(step.selectors ?? null)}`;
       codeLines.push(line);
       line = `await context.web.snapshotValidation(frameLocator, _param_0 , _params, ${JSON.stringify(options)}, this);`;
       codeLines.push(line);
@@ -396,7 +441,6 @@ const _generateCodeFromCommand = (step, elements, userData) => {
         throw new Error(`Unknown select mode ${step.selectMode}`);
       }
       break;
-
     case Types.COMPLETE:
       break;
     case Types.RELOAD:
@@ -507,15 +551,39 @@ const _generateCodeFromCommand = (step, elements, userData) => {
       line = `await context.web.clickType( elements["${elementIdentifier}"] ,"${step.key}",null, _params, {"press":true}, this);`;
       codeLines.push(line);
       break;
-    case "context_click":
-      comment = `//  Click on ${elementIdentifier ? elementIdentifier : step.label} in the context of ${escapeNonPrintables(step.value)}`;
-      codeLines.push(escapeNonPrintables(comment));
-      input = `"${escapeNonPrintables(step.value)}"`;
-      if (step.dataSource === "userData" || step.dataSource === "parameters") {
-        input = "_" + step.dataKey;
+    case Types.CONTEXT_CLICK:
+      switch (step.count) {
+        case 1:
+          comment = `//  Click on ${elementIdentifier ? elementIdentifier : step.label} in the context of ${escapeNonPrintables(step.value)}`;
+          codeLines.push(escapeNonPrintables(comment));
+          input = `"${escapeNonPrintables(step.value.replaceAll('"', '\\"'))}"`;
+          if (step.dataSource === "userData" || step.dataSource === "parameters") {
+            input = "_" + step.dataKey;
+          }
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, {"context": ${input}}, this);`;
+          codeLines.push(line);
+          break;
+        case 2:
+          comment = `//  Double click on ${elementIdentifier ? elementIdentifier : step.label} in the context of ${escapeNonPrintables(step.value)}`;
+          codeLines.push(escapeNonPrintables(comment));
+          input = `"${escapeNonPrintables(step.value.replaceAll('"', '\\"'))}"`;
+          if (step.dataSource === "userData" || step.dataSource === "parameters") {
+            input = "_" + step.dataKey;
+          }
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, {"context": ${input}, clickCount:2}, this);`;
+          codeLines.push(line);
+          break;
+        default:
+          comment = `//  Click on ${elementIdentifier ? elementIdentifier : step.label} in the context of ${escapeNonPrintables(step.value)}`;
+          codeLines.push(escapeNonPrintables(comment));
+          input = `"${escapeNonPrintables(step.value.replaceAll('"', '\\"'))}"`;
+          if (step.dataSource === "userData" || step.dataSource === "parameters") {
+            input = "_" + step.dataKey;
+          }
+          line = `await context.web.click(elements["${elementIdentifier}"], _params, {"context": ${input}}, this);`;
+          codeLines.push(line);
+          break;
       }
-      line = `await context.web.click(elements["${elementIdentifier}"], _params, {"context": ${input}}, this);`;
-      codeLines.push(line);
       break;
     case "popup_close":
       break;
@@ -541,6 +609,24 @@ const _generateCodeFromCommand = (step, elements, userData) => {
       codeLines.push(line);
       break;
     }
+    case Types.VERIFY_PROPERTY: {
+      // Only execute if codeLine is empty/undefined
+      line = `await context.web.verifyProperty(elements["${elementIdentifier}"], `;
+      input = "_param_0";
+      if (step.dataSource === "userData" || step.dataSource === "parameters") {
+        input = "_" + step.dataKey;
+      }
+      line += `"${step.parameters[0]}", ${input}, _params, null, this);`;
+      codeLines.push(line);
+      break;
+    }
+    case Types.CONDITIONAL_WAIT: {
+      line = `await context.web.conditionalWait(elements["${elementIdentifier}"], `;
+      input = "_param_0";
+      line += `"${step.parameters[1]}", ${input}, _params, null, this);`;
+      codeLines.push(line);
+      break;
+    }
     case Types.SET_INPUT_FILES: {
       line = `await context.web.setInputFiles(elements["${elementIdentifier}"], `;
       let files = step.parameters[0];
@@ -566,6 +652,22 @@ const _generateCodeFromCommand = (step, elements, userData) => {
   return { codeLines, elements: elementsChanged ? elements : null, elementIdentifier, allStrategyLocators };
 };
 
+/**
+ * Generates a report command based on the given position.
+ * @param {"start"|"end"} position
+ */
+const generateReportCommand = (position, cmdId) => {
+  const codeLines = [];
+  if (position === "start") {
+    const line = `await context.web.addCommandToReport("${cmdId}", "PASSED", '{"status":"start","cmdId":"${cmdId}"}', {type:"cmdReport"},this);`;
+    codeLines.push(line);
+  } else if (position === "end") {
+    const line = `await context.web.addCommandToReport("${cmdId}", "PASSED", '{"status":"end","cmdId":"${cmdId}"}', {type:"cmdReport"},this);`;
+    codeLines.push(line);
+  }
+  return codeLines;
+};
+
 const generateCode = (recording, codePage, userData, projectDir, methodName) => {
   const stepsDefinitions = new StepsDefinitions(projectDir);
   stepsDefinitions.load(false);
@@ -590,6 +692,7 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     }
     //console.log("step found");
   }
+
   let elements = {};
   if (!codePage) {
     console.log("codePage is null");
@@ -606,12 +709,15 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
     if (recordingStep.type === Types.COMPLETE) {
       return;
     }
-    // if (!recordingStep.element) {
-    //   logger.info(`Step ${recordingStep.type} doesn't have an element, ignoring`);
-    //   return;
+
+    // if (process.env.TEMP_RUN === "true") {
+    //   codeLines.push(...generateReportCommand("start", recordingStep.cmdId));
     // }
     const result = _generateCodeFromCommand(recordingStep, elements, userData);
     codeLines.push(...result.codeLines);
+    // if (process.env.TEMP_RUN === "true") {
+    //   codeLines.push(...generateReportCommand("end", recordingStep.cmdId));
+    // }
     if (result.elements) {
       elements = result.elements;
     }
@@ -656,4 +762,4 @@ const generatePageName = (url) => {
     return "default";
   }
 };
-export { generateCode, generatePageName };
+export { generateCode, generatePageName };

package/bin/client/cucumber/feature.js

@@ -1,11 +1,11 @@
 import { loadConfiguration, loadSupport, runCucumber } from "@dev-blinq/cucumber-js/api";
 import fs from "fs";
-
+import os from "os";
+import path from "path";
 import { parseStepTextParameters, toCucumberExpression, unEscapeNonPrintables } from "./utils.js";
-import { AstBuilder, GherkinClassicTokenMatcher, Parser, compile } from "@cucumber/gherkin";
-import { IdGenerator } from "@cucumber/messages";
+import stream from "stream";
 import { testStringForRegex } from "../recorderv3/update_feature.js";
-
+import { generateTestData } from "./feature_data.js";
 class DataTable {
   constructor(dataTableDocument) {
     if (!dataTableDocument) {
@@ -289,7 +289,7 @@ class Feature {
     }
     return scenarios;
   }
-  generateStracture(stepsDefinitions, fileName, scenarioName = null) {
+  generateStracture(stepsDefinitions, fileName, scenarioName = null, errorsInParsing = [], parseFailedFiles = false) {
     const document = {};
     document.featureName = this.feature.name;
     document.fileName = fileName;
@@ -317,6 +317,28 @@ class Feature {
           stepInfo.functionName = stepDef.functionName;
           stepInfo.implemented_at = stepDef.implemented_at;
         }
+        if (!stepDef && parseFailedFiles) {
+          //Check if the stepName exists in one of the failedToParseFiles
+          try {
+            const stepName = stepsDefinitions._stepNameToTemplate(stepInfo.template);
+            if (errorsInParsing && errorsInParsing.length > 0) {
+              for (let k = 0; k < errorsInParsing.length; k++) {
+                const failedFile = errorsInParsing[k].file;
+                //Read File content, and check if the stepName exists in the file
+                const fileContent = fs.readFileSync(failedFile, "utf8");
+                if (fileContent.includes(stepName)) {
+                  stepInfo.implemented = true;
+                  stepInfo.mjsFile = failedFile.slice(path.normalize(failedFile).indexOf("features/step_definitions"));
+                  stepInfo.functionName = stepName;
+                  stepInfo.error = errorsInParsing[k].error;
+                  break;
+                }
+              }
+            }
+          } catch (e) {
+            console.error(`Error while checking step ${stepInfo.template} in failed files:`, e);
+          }
+        }
       }
       document.scenarios.push(scenarioInfo);
     }
@@ -431,43 +453,75 @@ const scenarioResolution = async (featureFilePath) => {
   if (!fs.existsSync(featureFilePath)) {
     throw new Error(`Feature file ${featureFilePath} does not exist`);
   }
-  const newId = IdGenerator.uuid();
-  const builder = new AstBuilder(newId);
-  const matcher = new GherkinClassicTokenMatcher();
-
-  const parser = new Parser(builder, matcher);
-
-  // normalize the path to start with featuers/ if it's not cut the featureFielPath to only the part after features/
-  let uri = featureFilePath.startsWith("features/")
-    ? featureFilePath
-    : "features/" + featureFilePath.split("features/")[1];
-
   const featureFileContent = fs.readFileSync(featureFilePath, "utf8");
-  const gherkinDocument = parser.parse(featureFileContent, newId);
-
-  const feature = new Feature(gherkinDocument, featureFileContent);
-  //const scenario = feature.getScenario(scenarioName);
-  //return scenario;
-  return feature;
-};
-const getDocumentAndPickel = (featureName, featureContent, scenarioName) => {
-  const newId = IdGenerator.uuid();
-  const builder = new AstBuilder(newId);
-  const matcher = new GherkinClassicTokenMatcher();
-
-  const parser = new Parser(builder, matcher);
-
-  // normalize the path to start with featuers/ if it's not cut the featureFielPath to only the part after features/
-  let uri = `features/${featureName}.feature`;
-
-  const gherkinDocument = parser.parse(featureContent, newId);
-  const pickles = compile(gherkinDocument, uri, newId);
+  let tmpDir = null;
+  try {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-qa"));
+    const tmpFeaturePath = path.join(tmpDir, "features");
+    fs.mkdirSync(tmpFeaturePath);
+    const tmpFeatureFilePath = path.join(tmpFeaturePath, path.basename(featureFilePath));
+    let result = generateTestData(featureFilePath);
+    if (result.changed) {
+      fs.writeFileSync(tmpFeatureFilePath, result.newContent);
+      console.log("Fake data was generated for this scenario");
+      console.log("Variables:");
+      for (let key in result.variables) {
+        console.log(`${key}: ${result.variables[key].fake}`);
+      }
+      console.log("Other fake data:");
+      for (let i = 0; i < result.otherFakeData.length; i++) {
+        console.log(`${result.otherFakeData[i].var}: ${result.otherFakeData[i].fake}`);
+      }
+    } else {
+      fs.copyFileSync(featureFilePath, tmpFeatureFilePath);
+    }
+    const writable = new stream.Writable({
+      write: function (chunk, encoding, next) {
+        //console.log(chunk.toString());
+        next();
+      },
+    });
+    const environment = { cwd: tmpDir, stdout: writable, stderr: writable };
+    // load configuration from a particular file, and override a specific option
+    const provided = {
+      default: "--publish-quiet",
+      require: [tmpDir],
+      failFast: false,
+    };
 
-  // Step 3: Find the specific scenario Pickle
-  const pickle = pickles.find((pickle) => {
-    return pickle.name === scenarioName;
-  });
-  return { gherkinDocument, pickle };
+    let gherkinDocument = null;
+    const { runConfiguration } = await loadConfiguration({ provided }, environment);
+    // load the support code upfront
+    const support = await loadSupport(runConfiguration, environment);
+    // run cucumber, using the support code we loaded already
+    await runCucumber({ ...runConfiguration, support }, environment, function (event) {
+      // if (event.source) {
+      //   scenarioInfo.source = event.source.data;
+      // }
+      // if (event.pickle && event.pickle.name === scenarioName) {
+      //   scenarioInfo.pickle = event.pickle;
+      // }
+      if (event.gherkinDocument) {
+        gherkinDocument = event.gherkinDocument;
+      }
+      //console.log(event);
+      //console.log(JSON.stringify(event, null, 2));
+      // console.log("");
+    });
+    const feature = new Feature(gherkinDocument, featureFileContent);
+    //const scenario = feature.getScenario(scenarioName);
+    //return scenario;
+    return feature;
+  } finally {
+    try {
+      if (tmpDir) {
+        fs.rmSync(tmpDir, { recursive: true });
+      }
+    } catch (e) {
+      console.error(
+        `An error has occurred while removing the temp folder at ${tmpDir}. Please remove it manually. Error: ${e}`
+      );
+    }
+  }
 };
-
-export { Feature, Scenario, Step, DataTable, Examples, scenarioResolution, getDocumentAndPickel };
+export { Feature, Scenario, Step, DataTable, Examples, scenarioResolution };

package/bin/client/cucumber/project_to_document.js

@@ -4,14 +4,14 @@ import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherki
 import { Feature } from "./feature.js";
 import { StepsDefinitions } from "./steps_definitions.js";
 
-export const projectDocument = (folder, featureName = null, scenarioName = null) => {
+export const projectDocument = (folder, featureName = null, scenarioName = null, supressErrors = false, errors = []) => {
   const uuidFn = () => (23212).toString(16);
   const builder = new AstBuilder(uuidFn);
   const matcher = new GherkinClassicTokenMatcher();
   const parser = new Parser(builder, matcher);
-  const stepDefinition = new StepsDefinitions(folder);
-  stepDefinition.load(false);
-
+  // load the step definitions from the project folder under steps folder
+  const stepDefinition = new StepsDefinitions(folder, false);
+  stepDefinition.load(false, supressErrors, errors);
   // read all the feature files in the project folder under features folder
   let featureFiles = [];
   const featuresDir = path.join(folder, "features");
@@ -27,7 +27,7 @@ export const projectDocument = (folder, featureName = null, scenarioName = null)
     if (featureName && feature.feature.name !== featureName && featureFile !== featureName) {
       continue;
     }
-    const document = feature.generateStracture(stepDefinition, featureFile, scenarioName);
+    const document = feature.generateStracture(stepDefinition, featureFile, scenarioName, errors, supressErrors);
     if (scenarioName && document.scenarios.length === 0) {
       continue;
     }
@@ -55,7 +55,8 @@ export const projectDocument = (folder, featureName = null, scenarioName = null)
 //     scenarioName = arg.substring(9);
 //   }
 // }
-// const documents = projectDocument(projectDir, featureName, scenarioName);
+// let errors = [];
+// const documents = projectDocument(projectDir, featureName, scenarioName, true, errors);
 // const args = process.argv.slice(2);
 
-// console.log(JSON.stringify(projectDocument(args[0])));
+// console.log(JSON.stringify(documents));

package/bin/client/cucumber/steps_definitions.js

@@ -54,7 +54,7 @@ class StepsDefinitions {
       }
     }
   }
-  load(print = true) {
+  load(print = true, supressErrors = false, errors = []) {
     const mjsFiles = findFilesWithExtension(
       path.join(this.baseFolder, this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features"),
       "mjs"
@@ -62,18 +62,24 @@ class StepsDefinitions {
     // console.log({ mjsFiles });
     for (let i = 0; i < mjsFiles.length; i++) {
       const mjsFile = mjsFiles[i];
-      const codePage = new CodePage(
-        path.join(
-          this.baseFolder,
-          this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features",
-          mjsFile
-        )
+      const filePath = path.join(
+        this.baseFolder,
+        this.isTemp ? process.env.tempFeaturesFolderPath ?? "__temp_features" : "features",
+        mjsFile
       );
+      const codePage = new CodePage(filePath);
       try {
         codePage.generateModel();
       } catch (error) {
-        logger.info("unable to generate model for file", mjsFile);
-        throw error;
+        logger.info("unable to generate model for", mjsFile, error);
+        if (supressErrors) {
+          errors.push({
+            file: filePath,
+            error: error.message,
+          });
+        } else {
+          continue;
+        }
       }
       this.initPage(codePage, mjsFile);
     }
@@ -518,12 +524,8 @@ class StepsDefinitions {
     // );
   };
 
-  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
-    if (!options) {
-      options = {
-        skipAfter: true,
-      };
-    }
+  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText, onCommandResult }, options) => {
+    const { skipAfter = true, skipBefore = true } = options || {};
     const environment = {
       ...process.env,
     };
@@ -549,11 +551,18 @@ class StepsDefinitions {
       //   console.log("step", step.pattern);
       // });
 
-      if (options.skipAfter) {
+      if (skipAfter) {
         // ignore afterAll/after hooks
         support.afterTestCaseHookDefinitions = [];
         support.afterTestRunHookDefinitions = [];
       }
+      // if (skipBefore) {
+      //   // ignore beforeAll/before hooks
+      //   support.beforeTestCaseHookDefinitions = support.beforeTestCaseHookDefinitions.filter((hook) => {
+      //     return hook.uri.endsWith("utils.mjs")
+      //   });
+      //   support.beforeTestRunHookDefinitions = [];
+      // }
 
       let errorMesssage = null;
       let info = null;
@@ -592,6 +601,11 @@ class StepsDefinitions {
         Object.assign(bvtError, { info: errInfo });
         throw bvtError;
       }
+
+      return {
+        result,
+        info,
+      };
     } catch (error) {
       console.error("Error running cucumber-js", error);
       throw error;
@@ -626,4 +640,23 @@ function findFilesWithExtension(folderPath, extension, rootFolder = null) {
 
   return result;
 }
+export function locateDefinitionPath(featureFolder, pageName) {
+  if (!pageName) {
+    return null;
+  }
+  if (!pageName.endsWith("_page.mjs")) {
+    pageName = pageName + "_page.mjs";
+  }
+  // search for files with the pageName
+  const stepDefinitionFolderPath = path.join(featureFolder, "step_definitions");
+  const files = findFilesWithExtension(stepDefinitionFolderPath, "mjs");
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (file.includes(pageName)) {
+      return path.join(stepDefinitionFolderPath, file);
+    }
+  }
+  return path.join(stepDefinitionFolderPath, pageName);
+}
+
 export { StepsDefinitions, findFilesWithExtension };