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

package/bin/client/code_gen/playwright_codeget.js

@@ -4,6 +4,7 @@ import { StepsDefinitions } from "../cucumber/steps_definitions.js";
 import path from "path";
 import { CodePage } from "./page_reflection.js";
 import { convertToIdentifier, escapeNonPrintables } from "./utils.js";
+import socketLogger from "../utils/socket_logger.js";
 const findElementIdentifier = (node, step, userData, elements) => {
   if (node.key) {
     // incase of rerunning implemented steps
@@ -12,6 +13,13 @@ const findElementIdentifier = (node, step, userData, elements) => {
 
   let elementIdentifier = null;
   const keys = Object.keys(elements);
+
+  for (let i = 0; i < keys.length; i++) {
+    const element_key = keys[i];
+    const element = elements[element_key];
+    element["element_key"] = element_key;
+  }
+
   let name = node.name;
   if (!name && step.dataKey) {
     name = step.dataKey;
@@ -58,7 +66,8 @@ const _isCodeGenerationStep = (step) => {
     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;
   }
@@ -91,7 +100,7 @@ const splitToLocatorsGroups = (locators) => {
 const _generateCodeFromCommand = (step, elements, userData) => {
   let elementsChanged = false;
 
-  let elementIdentifier = null;
+  let elementIdentifier = step.locators?.element_key;
   let locatorObject = step.locators;
   // handle element
   let element_name = null;
@@ -129,18 +138,20 @@ const _generateCodeFromCommand = (step, elements, userData) => {
     let locatorObjectClone = JSON.parse(JSON.stringify(locatorObject));
     element_name = locatorObjectClone.element_name;
     delete locatorObjectClone.element_name;
-    keys.forEach((key) => {
-      let elementClone = JSON.parse(JSON.stringify(elements[key]));
-      delete elementClone.element_name;
-      if (JSON.stringify(elementClone) === JSON.stringify(locatorObjectClone)) {
-        elementIdentifier = key;
-      }
-    });
+    if (!elementIdentifier) {
+      keys.forEach((key) => {
+        let elementClone = JSON.parse(JSON.stringify(elements[key]));
+        delete elementClone.element_name;
+        if (JSON.stringify(elementClone) === JSON.stringify(locatorObjectClone)) {
+          elementIdentifier = key;
+        }
+      });
+    }
     if (!elementIdentifier) {
       elementIdentifier = findElementIdentifier(node, step, userData, elements);
     }
     const withoutAllStrategyLocators = excludeKey(locatorObject, "allStrategyLocators");
-    elements[elementIdentifier] = withoutAllStrategyLocators;
+    elements[elementIdentifier] = { ...withoutAllStrategyLocators, element_key: elementIdentifier };
     elementsChanged = true;
   }
   let optionElement = null;
@@ -641,6 +652,13 @@ const _generateCodeFromCommand = (step, elements, userData) => {
       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];
@@ -666,6 +684,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);
@@ -692,6 +726,7 @@ const generateCode = (recording, codePage, userData, projectDir, methodName) =>
   }
   let elements = {};
   if (!codePage) {
+    socketLogger.info("CodePage is null");
     console.log("codePage is null");
   } else {
     elements = codePage.getVariableDeclarationAsObject("elements");
@@ -706,12 +741,16 @@ 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;
     }

package/bin/client/cucumber/feature.js

@@ -1,11 +1,14 @@
+import { IdGenerator } from "@cucumber/messages";
+import { AstBuilder, GherkinClassicTokenMatcher, Parser, compile } from "@cucumber/gherkin";
 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 path from 'path';
+import { generateTestData } from "./feature_data.js";
+import socketLogger from "../utils/socket_logger.js";
 class DataTable {
   constructor(dataTableDocument) {
     if (!dataTableDocument) {
@@ -372,6 +375,11 @@ class Examples {
       return null;
     }
     let value = this.tableBody[0].cells[parameterIndex].value;
+    if (!value) {
+      console.warn(`Parameter ${parameterName} not found in examples table body, or it is empty`);
+      return null;
+    }
+
     return unEscapeNonPrintables(value); // While editing in recorder, we need to remove backslashes
   }
 }
@@ -449,29 +457,7 @@ class Scenario {
     return this.scenarioText;
   }
 }
-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);
@@ -484,12 +470,88 @@ const getDocumentAndPickel = (featureName, featureContent, scenarioName) => {
 
   const gherkinDocument = parser.parse(featureContent, newId);
   const pickles = compile(gherkinDocument, uri, newId);
-
   // Step 3: Find the specific scenario Pickle
   const pickle = pickles.find((pickle) => {
     return pickle.name === scenarioName;
   });
   return { gherkinDocument, pickle };
 };
+const scenarioResolution = async (featureFilePath) => {
+  if (!fs.existsSync(featureFilePath)) {
+    throw new Error(`Feature file ${featureFilePath} does not exist`);
+  }
+  const featureFileContent = fs.readFileSync(featureFilePath, "utf8");
+  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,
+    };
 
+    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) {
+      socketLogger.error(
+        `An error has occurred while removing the temp folder at ${tmpDir}. Please remove it manually. Error: ${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 };

package/bin/client/cucumber/project_to_document.js

@@ -15,7 +15,7 @@ export const projectDocument = (folder, featureName = null, scenarioName = null,
   // read all the feature files in the project folder under features folder
   let featureFiles = [];
   const featuresDir = path.join(folder, "features");
-  featureFiles = fs.readdirSync(featuresDir).filter((file) => {
+  featureFiles = fs.readdirSync(featuresDir, { recursive: true }).filter((file) => {
     return file.endsWith(".feature");
   });
   const documents = [];

package/bin/client/cucumber/steps_definitions.js

@@ -523,86 +523,94 @@ class StepsDefinitions {
     //   }
     // );
   };
+  //! Deprecated, not removing until stepRunner.executeStepRemote is stable
+  // executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText, onCommandResult }, options) => {
+  // //   const { skipAfter = true, skipBefore = true } = options || {};
+  //   const environment = {
+  //     ...process.env,
+  //   };
 
-  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
-    if (!options) {
-      options = {
-        skipAfter: true,
-      };
-    }
-    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);
+  //     // });
 
-    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);
-      // });
+  //     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 = [];
+  //     // }
 
-      if (options.skipAfter) {
-        // ignore afterAll/after hooks
-        support.afterTestCaseHookDefinitions = [];
-        support.afterTestRunHookDefinitions = [];
-      }
+  //     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;
+  //         }
+  //       }
+  //     });
+  //     if (errorMesssage) {
+  //       const bvtError = new Error(errorMesssage);
+  //       Object.assign(bvtError, { info: errInfo });
+  //       throw bvtError;
+  //     }
 
-      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;
-          }
-        }
-      });
-      if (errorMesssage) {
-        const bvtError = new Error(errorMesssage);
-        Object.assign(bvtError, { info: errInfo });
-        throw bvtError;
-      }
-    } catch (error) {
-      console.error("Error running cucumber-js", error);
-      throw error;
-    }
-  };
+  //     return {
+  //       result,
+  //       info,
+  //     };
+  //   } catch (error) {
+  //     console.error("Error running cucumber-js", error);
+  //     throw error;
+  //   }
+  // };
 }
 function findFilesWithExtension(folderPath, extension, rootFolder = null) {
   let result = [];

package/bin/client/cucumber_selector.js

@@ -6,6 +6,7 @@ import crypto from "crypto";
 import { findFilesWithExtension } from "./cucumber/steps_definitions.js";
 import fs from "fs";
 //import { spawn } from "child_process";
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
 
 if (process.argv.length < 3) {
   console.log("Usage: node cucumber_selector.js <projectsDir> --all");
@@ -100,8 +101,8 @@ if (process.argv.includes("--scenario-name")) {
 }
 const projectName = selectedScenario.featureFile.split(path.sep)[0];
 let deleteMjsFiles = readlineSync.keyInYN("Delete mjs file?");
+let stepsPath = path.join(selectedScenario.projectsDir, projectName, "features", "step_definitions");
 if (deleteMjsFiles) {
-  let stepsPath = path.join(selectedScenario.projectsDir, projectName, "features", "step_definitions");
   if (fs.existsSync(stepsPath)) {
     // delete all the *.mjs files
     let files = fs.readdirSync(stepsPath);
@@ -112,6 +113,21 @@ if (deleteMjsFiles) {
     }
   }
 }
+// copy utils file to the steps directory
+const utilsPath = path.join(__dirname, "../assets/templates/utils_template.txt");
+const utilsContent = fs.readFileSync(utilsPath, "utf8");
+const utilsFileName = stepsPath + "/utils.mjs";
+// if stepsPath directory doesn't exist create it
+if (!fs.existsSync(stepsPath)) {
+  fs.mkdirSync(stepsPath, { recursive: true });
+}
+fs.writeFileSync(utilsFileName, utilsContent, "utf8");
+// copy hooks file to the steps directory
+const hooksTemplateFilePath = path.join(__dirname, "../assets/templates/_hooks_template.txt");
+const hooksContent = fs.readFileSync(hooksTemplateFilePath, "utf8");
+const hooksFilePath = path.join(stepsPath, "_hooks.mjs");
+fs.writeFileSync(hooksFilePath, hooksContent, "utf8");
+
 process.env.PROJECT_PATH = path.join(selectedScenario.projectsDir, projectName);
 //chanks[currentChank][index];
 console.log("Running scenario:");

package/bin/client/local_agent.js

@@ -267,7 +267,7 @@ class LocalAgent {
         null,
         true,
         null,
-        450,
+        -1,
         null,
         initScript
       );
@@ -696,6 +696,7 @@ class LocalAgent {
               stepDiff: stepResult,
             });
             page.removeUnusedElements();
+            page.mergeSimilarElements();
             agent.scenarioReport.updateLastStep({
               code: {
                 cleanFileNames: page.cleanFileNames,
@@ -971,7 +972,7 @@ class LocalAgent {
   async createNewStepLocal(
     featureName,
     cucumberStep,
-    feature,
+    comments,
     userData,
     firstStep,
     previousTasks,
@@ -1087,7 +1088,7 @@ class LocalAgent {
             previousTasks,
             scenarioDocument,
             scenarioStepIndex,
-            comments: feature.comments,
+            comments,
             featureFileText,
             recover,
             dumpConfig: this.dumpConfig,
@@ -1099,7 +1100,7 @@ class LocalAgent {
     if (this.context && this.context.web) {
       await this.context.web.afterStep(
         {
-          attach: (data, mimeType) => {},
+          attach: (data, mimeType) => { },
         },
         this.cucumberStep
       );