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

package/bin/assets/templates/_hooks_template.txt

@@ -0,0 +1,37 @@
+import {
+  After,
+  setDefaultTimeout,
+  Before,
+  AfterStep,
+  BeforeStep,
+} from "@dev-blinq/cucumber-js";
+import { closeContext, initContext, navigate, executeBrunoRequest, verifyFileExists } from "automation_model";
+setDefaultTimeout(60 * 1000);
+
+const url = null;
+
+const elements = {};
+
+let context = null;
+Before(async function (scenario) {
+  context = await initContext(url, false, false, this);
+  await navigate(url);
+  await context.web.beforeScenario(this, scenario);
+});
+After(async function (scenario) {
+  await context.web.afterScenario(this, scenario);
+  await closeContext();
+  context = null;
+});
+
+BeforeStep(async function (step) {
+  if (context) {
+    await context.web.beforeStep(this, step);
+  }
+});
+
+AfterStep(async function (step) {
+  if (context) {
+    await context.web.afterStep(this, step);
+  }
+});

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

@@ -2,55 +2,10 @@ import {
   Given,
   When,
   Then,
-  After,
-  setDefaultTimeout,
-  Before,
   defineStep,
-  AfterStep,
-  BeforeStep,
 } from "@dev-blinq/cucumber-js";
-import { closeContext, initContext, navigate, executeBrunoRequest, verifyFileExists } from "automation_model";
+import { closeContext, initContext, navigate, executeBrunoRequest, verifyFileExists, TestContext as context } from "automation_model";
 import path from "path";
-setDefaultTimeout(60 * 1000);
-
-const url = null;
-
-const elements = {};
-
-let context = null;
-Before(async function (scenario) {
-  if (!context) {
-    context = await initContext(url, false, false, this);
-  }
-  await navigate(url);
-  await context.web.beforeScenario(this, scenario);
-});
-After(async function (scenario) {
-  await context.web.afterScenario(this, scenario);
-  await closeContext();
-  context = null;
-});
-
-BeforeStep(async function (step) {
-  if (context) {
-    await context.web.beforeStep(this, step);
-  }
-});
-
-AfterStep(async function (step) {
-  if (context) {
-    await context.web.afterStep(this, step);
-  }
-});
-
-/**
- * Load test data for a user
- * @param {string} user name of the user to load test data for
- * @protect
- */
-async function loadUserData(user) {
-  await context.web.loadTestDataAsync("users", user, this);
-}
 
 /**
  * Verify text exsits in page
@@ -60,7 +15,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);
 
 /**
@@ -87,6 +41,7 @@ async function fillElement(elementDescription, value) {
 }
 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 +62,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 +114,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 +123,6 @@ Then(
 async function runBrunoRequest(requestName) {
   await executeBrunoRequest(requestName, {}, context, this);
 }
-
 When("Bruno - {string}", runBrunoRequest);
 When("bruno - {string}", runBrunoRequest);
 
@@ -163,41 +136,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(){})
-
 /**
-* Verify the page url is "<url>"
-* @param {string} url URL to be verified against current URL
-* @protect
-*/
+ *  Noop step for running only hooks
+ */
+When("Noop", async function () {});
 
-async function verify_page_url(url){
-  await context.web.verifyPagePath(url,{}, this);
+/**
+ * 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){
+ * 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)
+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
-*/
+ * 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);
+Then("Sleep for {string} ms", { timeout: -1 }, sleep);

package/bin/client/apiTest/apiTest.js

@@ -75,6 +75,12 @@ class ApiTest {
       const utilsTemplateFilePath = path.join(__dirname, "../../assets", "templates", "utils_template.txt");
       const utilsContent = readFileSync(utilsTemplateFilePath, "utf8");
       writeFileSync(utilsFilePath, utilsContent, "utf8");
+      const hooksTemplateFilePath = path.join(__dirname, "../../assets", "templates", "_hooks_template.txt");
+      if (existsSync(hooksTemplateFilePath)) {
+        const hooksFilePath = path.join(stepDefinitionFolderPath, "_hooks.mjs");
+        const hooksContent = readFileSync(hooksTemplateFilePath, "utf8");
+        writeFileSync(hooksFilePath, hooksContent, "utf8");
+      }
     } catch (error) {
       console.log("error", error);
     }

package/bin/client/cli_helpers.js

@@ -1,17 +1,15 @@
-
 const validateCLIArg = (arg, name) => {
   if (!arg) {
-    throw new Error(`${name} is required`)
+    throw new Error(`${name} is required`);
   }
-}
+};
 const showUsage = (error, usage) => {
-  console.error(error.message)
-  console.info(usage)
-  process.exit(1)
-}
-const loadArgs = ()=>{
-  const args = process.argv.slice(2)
-  return args
-}
-
-export { validateCLIArg, loadArgs, showUsage };
+  console.error(error.message);
+  console.info(usage);
+  process.exit(1);
+};
+const loadArgs = () => {
+  const args = process.argv.slice(2);
+  return args;
+};
+export { validateCLIArg, loadArgs, showUsage };

package/bin/client/code_cleanup/utils.js

@@ -7,10 +7,11 @@ const { default: traverse } = pkg;
 import pkg1 from "@babel/generator";
 const { default: generate } = pkg1;
 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";
+import socketLogger from "../utils/socket_logger.js";
+
 const STEP_KEYWORDS = new Set(["Given", "When", "Then"]);
 
 /**
@@ -307,14 +308,17 @@ export function getDefaultPrettierConfig() {
       const configContent = readFileSync(prettierConfigPath, "utf-8");
       prettierConfig = JSON.parse(configContent);
     } catch (error) {
+      socketLogger.error("Error parsing Prettier config file", 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");
+      socketLogger.info(`Created default Prettier config at ${prettierConfigPath}`);
       console.log(`Created default Prettier config at ${prettierConfigPath}`);
     } catch (error) {
+      socketLogger.error(`Error writing Prettier config file: ${error}`);
       console.error(`Error writing Prettier config file: ${error}`);
     }
   }

package/bin/client/code_gen/code_inversion.js

@@ -310,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;
@@ -366,10 +374,15 @@ const invertStableCommand = (call, elements, stepParams) => {
     }
     case "verifyTextRelatedToText": {
       step.type = Types.VERIFY_TEXT_RELATED_TO_TEXT;
-      const textAnchor = parseDataSource(call.arguments[0], stepParams);
-      const climb = parseDataSource(call.arguments[1], stepParams);
-      const textToVerify = parseDataSource(call.arguments[2], stepParams);
-      step.parameters = [textAnchor.value, +climb.value, textToVerify.value];
+      const textAnchorParse = parseDataSource(call.arguments[0], stepParams);
+      const textAnchor =
+        textAnchorParse.type === "literal" ? textAnchorParse.value : toVariableName(textAnchorParse.dataKey);
+      const climbParse = parseDataSource(call.arguments[1], stepParams);
+      const climb = climbParse.type === "literal" ? climbParse.value : toVariableName(climbParse.dataKey);
+      const textToVerifyParse = parseDataSource(call.arguments[2], stepParams);
+      const textToVerify =
+        textToVerifyParse.type === "literal" ? textToVerifyParse.value : toVariableName(textToVerifyParse.dataKey);
+      step.parameters = [textAnchor, climb, textToVerify];
       break;
     }
     case "setInputFiles": {
@@ -418,6 +431,50 @@ const invertStableCommand = (call, elements, stepParams) => {
       }
       break;
     }
+    case "verifyProperty": {
+      step.type = Types.VERIFY_PROPERTY;
+      step.element = extractElement(call.arguments[0]);
+      const property = call.arguments[1].value;
+      const value = parseDataSource(call.arguments[2], stepParams);
+      if (value.type === "literal") {
+        step.parameters = [property, value.value];
+      } else {
+        step.dataSource = value.dataSource;
+        step.dataKey = value.dataKey;
+        step.parameters = [property, toVariableName(value.dataKey)];
+      }
+      break;
+    }
+    case "extractProperty": {
+      step.type = Types.EXTRACT_PROPERTY;
+      step.element = extractElement(call.arguments[0]);
+      const attribute = call.arguments[1].value;
+      const variable = parseDataSource(call.arguments[2], stepParams);
+      if (variable.type === "literal") {
+        step.parameters = [attribute, variable.value];
+      } else {
+        step.dataSource = variable.dataSource;
+        step.dataKey = variable.dataKey;
+        step.parameters = [attribute, toVariableName(variable.dataKey)];
+      }
+      if (call.arguments[4].type === "ObjectExpression") {
+        const properties = call.arguments[4].properties;
+        const regexProp = properties.findIndex((prop) => prop.key.name === "regex");
+        if (regexProp !== -1) {
+          const regex = properties[regexProp].value.value;
+          step.regex = regex;
+        }
+        const trimSpacesProp = properties.findIndex((prop) => prop.key.name === "trimSpaces");
+        if (trimSpacesProp !== -1) {
+          const trimSpaces = properties[trimSpacesProp].value.value;
+          step.trimSpaces = trimSpaces;
+        }
+      } else {
+        step.regex = "";
+        step.trimSpaces = false;
+      }
+      break;
+    }
     default:
       return; // Skip if no matching method
   }