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

package/bin/assets/templates/page_template.txt

@@ -1,20 +1,6 @@
-import { Given, When, Then, After, setDefaultTimeout, Before} from "@dev-blinq/cucumber-js";
-import { closeContext, initContext, navigate } from "automation_model";
-setDefaultTimeout(60 * 1000);
-
-const path = null;
+import { Given, When, Then, After, setDefaultTimeout, Before } from "@dev-blinq/cucumber-js";
+import { closeContext, initContext, navigate, TestContext as context } from "automation_model";
 
 const elements = {
 };
 
-let context = null;
-Before(async function () {
-  if (!context) {
-    context = await initContext(path, false, false, this);
-  }
-  await navigate(path);
-});
-After(async function () {
-  await closeContext();
-  context = null;
-});

package/bin/assets/templates/utils_template.txt

@@ -19,9 +19,7 @@ const elements = {};
 
 let context = null;
 Before(async function (scenario) {
-  if (!context) {
-    context = await initContext(url, false, false, this);
-  }
+  context = await initContext(url, false, false, this);
   await navigate(url);
   await context.web.beforeScenario(this, scenario);
 });
@@ -33,20 +31,21 @@ After(async function (scenario) {
 
 BeforeStep(async function (step) {
   if (context) {
-    await context.web.beforeStep(this, step);
+    await context.stable.beforeStep(this, step);
   }
 });
 
 AfterStep(async function (step) {
   if (context) {
-    await context.web.afterStep(this, step);
+    await context.stable.afterStep(this, step);
   }
 });
 
+
 /**
  * Load test data for a user
  * @param {string} user name of the user to load test data for
- * @protect
+ * @returns
  */
 async function loadUserData(user) {
   await context.web.loadTestDataAsync("users", user, this);
@@ -60,7 +59,6 @@ async function loadUserData(user) {
 async function verifyTextExistsInPage(text) {
   await context.web.verifyTextExistInPage(text, null, this);
 }
-
 Then("Verify the text {string} can be found in the page", verifyTextExistsInPage);
 
 /**
@@ -69,7 +67,7 @@ Then("Verify the text {string} can be found in the page", verifyTextExistsInPage
  * @protect
  */
 async function clickOnElement(elementDescription) {
-  await context.web.simpleClick(elementDescription, null, null, this);
+  await context.stable.simpleClick(elementDescription, null, null, this);
 }
 When("click on {string}", clickOnElement);
 When("click {string}", clickOnElement);
@@ -83,10 +81,11 @@ When("Click {string}", clickOnElement);
  * @protect
  */
 async function fillElement(elementDescription, value) {
-  await context.web.simpleClickType(elementDescription, value, null, null, this);
+  await context.stable.simpleClickType(elementDescription, value, null, null, this);
 }
 When("fill {string} with {string}", fillElement);
 When("Fill {string} with {string}", fillElement);
+
 /**
  * Verify text does not exist in page
  * @param {string} text the text to verify does not exist in page
@@ -107,6 +106,24 @@ async function navigateTo(url) {
 }
 When("Navigate to {string}", navigateTo);
 
+/**
+ * Navigate to the current page
+ * @protect
+ */
+async function browserNavigateBack() {
+  await context.web.goBack({}, this);
+}
+Then("Browser navigate back", browserNavigateBack);
+
+/**
+ * Navigate forward in browser history
+ * @protect
+ */
+async function browserNavigateForward() {
+  await context.web.goForward({}, this);
+}
+Then("Browser navigate forward", browserNavigateForward);
+
 /**
  * Store browser session "<path>"
  * @param {string} filePath the file path or empty to store in the test data file
@@ -141,6 +158,7 @@ Then(
   "Identify the text {string}, climb {string} levels in the page, validate text {string} can be found in the context",
   verifyTextRelatedToText
 );
+
 /**
  * execute bruno single request given the bruno project is placed in a folder called bruno under the root of the cucumber project
  * @requestName the name of the bruno request file
@@ -149,7 +167,7 @@ Then(
 async function runBrunoRequest(requestName) {
   await executeBrunoRequest(requestName, {}, context, this);
 }
-
+When("Bruno - {string}", runBrunoRequest);
 When("bruno - {string}", runBrunoRequest);
 
 /**
@@ -162,6 +180,41 @@ async function verify_the_downloaded_file_exists(fileName) {
   const downloadFile = path.join(downloadFolder, fileName);
   await verifyFileExists(downloadFile, {}, context, this);
 }
-
 Then("Verify the file {string} exists", { timeout: 60000 }, verify_the_downloaded_file_exists);
-When("Noop", async function(){})
+
+/**
+ *  Noop step for running only hooks
+ */
+When("Noop", async function () {});
+
+/**
+ * Verify the page url is "<url>"
+ * @param {string} url URL to be verified against current URL
+ * @protect
+ */
+async function verify_page_url(url) {
+  await context.web.verifyPagePath(url, {}, this);
+}
+Then("Verify the page url is {string}", verify_page_url);
+
+/**
+ * Verify the page title is "<title>"
+ * @param {string} title Title to be verified against current Title
+ * @protect
+ */
+async function verify_page_title(title) {
+  await context.web.verifyPageTitle(title, {}, this);
+}
+Then("Verify the page title is {string}", verify_page_title);
+
+/**
+ * Explicit wait/sleep function that pauses execution for a specified duration
+ * @param {duration} - Duration to sleep in milliseconds (default: 1000ms)
+ * @param {options} - Optional configuration object
+ * @param {world} - Optional world context
+ * @returns Promise that resolves after the specified duration
+ */
+async function sleep(duration) {
+  await context.web.sleep(duration, {}, null);
+}
+Then("Sleep for {string} ms", { timeout: -1 }, sleep);

package/bin/client/cli_helpers.js

@@ -13,5 +13,4 @@ const loadArgs = ()=>{
   const args = process.argv.slice(2)
   return args
 }
-
 export { validateCLIArg, loadArgs, showUsage };

package/bin/client/code_cleanup/utils.js

@@ -10,6 +10,8 @@ import * as t from "@babel/types";
 
 import { CucumberExpression, ParameterTypeRegistry } from "@cucumber/cucumber-expressions";
 import { existsSync, readFileSync, writeFileSync } from "fs";
+
+import { getAiConfig } from "../code_gen/page_reflection.js";
 const STEP_KEYWORDS = new Set(["Given", "When", "Then"]);
 
 /**
@@ -286,14 +288,50 @@ export function removeUnusedElementsKeys(ast, supportFilePath) {
     }
   }
 }
-
+export function getDefaultPrettierConfig() {
+  let prettierConfig = {
+    parser: "babel",
+    trailingComma: "es5",
+    tabWidth: 2,
+    semi: true,
+    singleQuote: false,
+    bracketSpacing: true,
+    arrowParens: "always",
+    embeddedLanguageFormatting: "auto",
+    endOfLine: "lf",
+    printWidth: 120,
+  };
+  // check if .prettierrc file exists
+  const prettierConfigPath = ".prettierrc";
+  if (existsSync(prettierConfigPath)) {
+    try {
+      const configContent = readFileSync(prettierConfigPath, "utf-8");
+      prettierConfig = JSON.parse(configContent);
+    } catch (error) {
+      console.error(`Error parsing Prettier config file: ${error}`);
+    }
+  } else {
+    // save the default config to .prettierrc
+    try {
+      writeFileSync(prettierConfigPath, JSON.stringify(prettierConfig, null, 2), "utf-8");
+      // console.log(`Created default Prettier config at ${prettierConfigPath}`);
+    } catch (error) {
+      console.error(`Error writing Prettier config file: ${error}`);
+    }
+  }
+  return prettierConfig;
+}
 /**
  * Remove unused step definitions from a file.
  * @param {string} filePath
  * @param {Array<{keyword: string, pattern: string}>} stepDefinitions
  */
 export async function removeUnusedStepDefinitions(filePath, stepDefinitions) {
-  const supportFilePath = filePath.replace(".mjs", ".json");
+  let supportFilePath = filePath.replace(".mjs", ".json");
+  const config = getAiConfig();
+  if (config && config.locatorsMetadataDir) {
+    supportFilePath = path.join(config.locatorsMetadataDir, path.basename(supportFilePath));
+  }
   const ast = await parse(filePath);
   removeStepDefinitions(stepDefinitions, ast);
   removeUnusedDeclarations(ast);
@@ -301,19 +339,10 @@ export async function removeUnusedStepDefinitions(filePath, stepDefinitions) {
   // removeUnusedImports(ast);
   let code = generateCode(ast);
 
+  // configuration object
+  const prettierConfig = getDefaultPrettierConfig();
   // Format the code using Prettier
-  code = await prettier.format(code, {
-    parser: "babel",
-    trailingComma: "es5",
-    tabWidth: 2,
-    semi: true,
-    singleQuote: false,
-    bracketSpacing: true,
-    arrowParens: "always",
-    embeddedLanguageFormatting: "auto",
-    endOfLine: "lf",
-    printWidth: 120,
-  });
+  code = await prettier.format(code, prettierConfig);
 
   await fs.writeFile(filePath, code, "utf-8");
   console.log(`Removed unused step definitions from ${filePath}`);

package/bin/client/code_gen/code_inversion.js

@@ -109,13 +109,13 @@ const invertStableCommand = (call, elements, stepParams) => {
 
     case "click":
       // Handle different click scenarios
+      step.type = Types.CLICK;
+      step.element = extractElement(call.arguments[0]);
       if (call.arguments.length > 2 && call.arguments[2]?.type === "ObjectExpression") {
         // Context click
-        step.type = "context_click";
-        step.element = extractElement(call.arguments[0]);
-
         const contextProp = call.arguments[2].properties.find((prop) => prop.key.name === "context");
         if (contextProp) {
+          step.type = "context_click";
           const contextValue = parseDataSource(contextProp.value, stepParams);
           if (contextValue.type === "literal") {
             step.value = contextValue.value;
@@ -125,9 +125,10 @@ const invertStableCommand = (call, elements, stepParams) => {
             step.value = toVariableName(contextValue.dataKey);
           }
         }
-      } else {
-        step.type = Types.CLICK;
-        step.element = extractElement(call.arguments[0]);
+        const clickCountProp = call.arguments[2].properties.find((prop) => prop.key.name === "clickCount");
+        if (clickCountProp) {
+          step.count = clickCountProp.value.value;
+        }
       }
       break;
 
@@ -309,6 +310,14 @@ const invertStableCommand = (call, elements, stepParams) => {
       break;
     }
 
+    case "goBack":
+      step.type = Types.GO_BACK;
+      break;
+
+    case "goForward":
+      step.type = Types.GO_FORWARD;
+      break;
+
     case "reloadPage":
       step.type = Types.RELOAD;
       break;
@@ -320,14 +329,14 @@ const invertStableCommand = (call, elements, stepParams) => {
     case "simpleClick":
       // step.type = Types.CLICK_SIMPLE;
       // step.elementDescription = call.arguments[0].value;
-      throw new Error("simpleClick action is not supported in the recorder");
+      throw new Error("Action is not supported in the recorder");
 
     case "simpleClickType":
       // step.type = Types.FILL_SIMPLE;
       // step.elementDescription = call.arguments[0].value;
       // step.value = call.arguments[1].value;
       // break;
-      throw new Error("simpleClickType action is not supported in the recorder");
+      throw new Error("Action is not supported in the recorder");
 
     case "hover":
       step.type = Types.HOVER;
@@ -384,7 +393,6 @@ const invertStableCommand = (call, elements, stepParams) => {
       }
       break;
     }
-
     case "snapshotValidation": {
       step.type = Types.VERIFY_PAGE_SNAPSHOT;
       const inputParam = parseDataSource(call.arguments[1], stepParams);
@@ -394,6 +402,30 @@ const invertStableCommand = (call, elements, stepParams) => {
       step.selectors = call.arguments[0].value;
       break;
     }
+    case "verifyPageTitle": {
+      step.type = Types.VERIFY_PAGE_TITLE;
+      const text = parseDataSource(call.arguments[0], stepParams);
+      if (text.type === "literal") {
+        step.parameters = [text.value];
+      } else {
+        step.dataSource = text.dataSource;
+        step.dataKey = text.dataKey;
+        step.parameters = [toVariableName(text.dataKey)];
+      }
+      break;
+    }
+    case "verifyPagePath": {
+      step.type = Types.VERIFY_PAGE_PATH;
+      const path = parseDataSource(call.arguments[0], stepParams);
+      if (path.type === "literal") {
+        step.parameters = [path.value];
+      } else {
+        step.dataSource = path.dataSource;
+        step.dataKey = path.dataKey;
+        step.parameters = [toVariableName(path.dataKey)];
+      }
+      break;
+    }
     default:
       return; // Skip if no matching method
   }
@@ -521,9 +553,9 @@ const invertCodeToCommand = (codeString, elements = {}, stepParams, stepsDefinit
     if (propName === "web" || propName === "stable") {
       const step = invertStableCommand(call, elements, stepParams);
       if (step) steps.push(step);
-      // } else if (propName === "api") {
-      //   const step = invertApiCommand(stepsDefinitions, codePage, stepName);
-      //   if (step) steps.push(step);
+    } else if (propName === "api") {
+      const step = invertApiCommand(stepsDefinitions, codePage, stepName);
+      if (step) steps.push(step);
     } else {
       return;
     }

package/bin/client/code_gen/index.js

@@ -58,6 +58,9 @@ for (let i = 0; i < scenarioReport.stepsProgress.length; i++) {
   page.addCucumberStep(keyword, step.cucumberLine, methodName, step.recording.steps.length);
 
   page.removeUnusedElements();
+  if (generateCodeResult.locatorsMetadata) {
+    page.addLocatorsMetadata(generateCodeResult.locatorsMetadata);
+  }
   await page.save();
   set.add(page.sourceFileName);
 }

package/bin/client/code_gen/page_reflection.js

@@ -6,6 +6,7 @@ import logger from "../../logger.js";
 import { convertToIdentifier } from "./utils.js";
 import prettier from "prettier";
 import url from "url";
+import { getDefaultPrettierConfig } from "../code_cleanup/utils.js";
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 const CodeStatus = {
   ADD: "add",
@@ -22,6 +23,21 @@ function unescapeFromComment(text) {
     .replace(/\*\\/g, "*/") // Unescape comment-closing sequence
     .replace(/\\\\/g, "\\"); // Unescape backslashes
 }
+let ai_config = null;
+export function getAiConfig() {
+  if (ai_config) {
+    return ai_config;
+  }
+  try {
+    ai_config = JSON.parse(readFileSync("ai_config.json", "utf8"));
+  } catch (e) {
+    ai_config = {};
+  }
+  if (!ai_config.locatorsMetadataDir) {
+    ai_config.locatorsMetadataDir = "features/step_definitions/locators";
+  }
+  return ai_config;
+}
 class CodePage {
   constructor(sourceFileName = null) {
     this.sourceFileName = sourceFileName;
@@ -45,18 +61,7 @@ class CodePage {
     if (this.sourceFileName !== null) {
       // format the code before saving
       try {
-        const fileContentNew = await prettier.format(this.fileContent, {
-          parser: "babel",
-          trailingComma: "es5",
-          tabWidth: 2,
-          semi: true,
-          singleQuote: false,
-          bracketSpacing: true,
-          arrowParens: "always",
-          embeddedLanguageFormatting: "auto",
-          endOfLine: "lf",
-          printWidth: 120,
-        });
+        const fileContentNew = await prettier.format(this.fileContent, getDefaultPrettierConfig());
         this._init();
         this.generateModel(fileContentNew);
       } catch (e) {
@@ -224,25 +229,28 @@ this.imports[2].node.source.value
                 params = paramsObj.map((param) => param.name);
               }
               firstFind = false;
-            } 
+            }
             stepPaths.push(method.path);
-
           }
         }
         if (foundMethod) {
-          templates.push({ pattern, methodName, params, stepType, paths: stepPaths});
+          templates.push({ pattern, methodName, params, stepType, paths: stepPaths });
         }
       }
     }
     return templates;
   }
-  getExpectedTimeout(expectedNumofCmds) {
+  getExpectedTimeout(expectedNumofCmds, finalTimeout) {
+    const timeoutNum = parseFloat(finalTimeout);
+    if (finalTimeout && !isNaN(timeoutNum)) {
+      return -1;
+    }
     return expectedNumofCmds * 60 * 1000;
   }
-  addCucumberStep(type, cucumberLine, method, expectedNumofCmds) {
+  addCucumberStep(type, cucumberLine, method, expectedNumofCmds, finalTimeout) {
     const result = {};
     let code = "\n";
-    code += `${type}(${JSON.stringify(cucumberLine)}, ${expectedNumofCmds ? `{ timeout: ${this.getExpectedTimeout(expectedNumofCmds)}}, ` : ""}${method});\n`;
+    code += `${type}(${JSON.stringify(cucumberLine)}, ${expectedNumofCmds ? `{ timeout: ${this.getExpectedTimeout(expectedNumofCmds, finalTimeout)}}, ` : ""}${method});\n`;
     let existCodePart = null;
     for (let i = 0; i < this.cucumberCalls.length; i++) {
       if (
@@ -481,7 +489,16 @@ this.imports[2].node.source.value
   }
   addLocatorsMetadata(locatorsMetadata) {
     // create a file name based on the source file name replace .mjs with .json
-    const locatorsMetadataFileName = this.sourceFileName.replace(".mjs", ".json");
+    let locatorsMetadataFileName = this.sourceFileName.replace(".mjs", ".json");
+    const config = getAiConfig();
+    if (config && config.locatorsMetadataDir) {
+      // if config.locatorsMetadataDir is set, use it to create the file path
+      locatorsMetadataFileName = path.join(config.locatorsMetadataDir, path.basename(locatorsMetadataFileName));
+      // check if the directory exists, if not create it
+      if (!existsSync(path.dirname(locatorsMetadataFileName))) {
+        mkdirSync(path.dirname(locatorsMetadataFileName), { recursive: true });
+      }
+    }
     let metadata = {};
     // try to read the file to metadata, protect with try catch
     try {
@@ -782,7 +799,7 @@ function getPath(comment) {
   if (index === -1) {
     return null;
   }
-  return comment.substring(index).split('\n')[0].substring(6);
+  return comment.substring(index).split("\n")[0].substring(6);
 }
 
 class CodePart {