artes 1.1.45 → 1.1.48

package/cucumber.config.js

@@ -30,6 +30,21 @@ const finalFormats = [
   ]),
 ];
 
+function resolveEnv(artesConfig) {
+  if (typeof artesConfig.baseURL === "object" && artesConfig.baseURL !== null) {
+    if (process.env.ENV && artesConfig.baseURL.hasOwnProperty(process.env.ENV.trim())) {
+      return process.env.ENV.trim();
+    } else if (artesConfig.env && artesConfig.baseURL.hasOwnProperty(artesConfig.env.trim())) {
+      return artesConfig.env.trim();
+    } else {
+      return Object.keys(artesConfig.baseURL)[0];
+    }
+  }
+
+  return process.env.ENV || artesConfig.env || "";
+}
+const env = resolveEnv(artesConfig);
+
 module.exports = {
   default: {
     // File paths and patterns
@@ -116,17 +131,7 @@ module.exports = {
     // World parameters
     worldParameters: artesConfig.worldParameters || {}, // Custom world parameters
   },
-  env: (typeof artesConfig.baseURL === "object" && artesConfig.baseURL !== null
-    ? (
-        process.env.ENV && artesConfig.baseURL.hasOwnProperty(process.env.ENV.trim())
-          ? process.env.ENV.trim()
-          : (
-              artesConfig.env && artesConfig.baseURL.hasOwnProperty(artesConfig.env.trim())
-                ? artesConfig.env.trim()
-                : Object.keys(artesConfig.baseURL)[0]
-            )
-      )
-    : (process.env.ENV || artesConfig.env || "")),
+  env: env,
   baseURL: process.env.BASE_URL
     ? JSON.parse(process.env.BASE_URL)
     : artesConfig?.baseURL

package/executer.js

@@ -55,22 +55,8 @@ const height = args[args.indexOf("--height") + 1];
 const timeout = args[args.indexOf("--timeout") + 1];
 const slowMo = args[args.indexOf("--slowMo") + 1];
 
-if (flags.env) {
-  const envCandidate = env.trim();
-  if (typeof artesConfig.baseURL === "object" && artesConfig.baseURL !== null) {
-    if (artesConfig.baseURL.hasOwnProperty(envCandidate)) {
-      process.env.ENV = JSON.stringify(envCandidate);
-      console.log("Running env:", envCandidate);
-    } else {
-      const firstKey = Object.keys(artesConfig.baseURL)[0];
-      process.env.ENV = JSON.stringify(firstKey);
-      console.log(`Env "${envCandidate}" not found, falling back to:`, firstKey);
-    }
-  } else {
-    process.env.ENV = JSON.stringify(envCandidate);
-    console.log("Running env:", envCandidate);
-  }
-}
+
+flags.env ? (process.env.ENV = env) : ""
 
 flags.reportWithTrace ||
 artesConfig.reportWithTrace ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.1.45",
+  "version": "1.1.48",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {

package/src/helper/contextManager/browserManager.js

@@ -8,12 +8,7 @@ const invokeBrowser = async () => {
 
   if (typeof cucumberConfig.baseURL === "object") {
     const env = (cucumberConfig.env || "").trim();
-    if (env && cucumberConfig.baseURL.hasOwnProperty(env)) {
       baseURL = cucumberConfig.baseURL[env];
-    } else {
-      const firstKey = Object.keys(cucumberConfig.baseURL)[0];
-      baseURL = cucumberConfig.baseURL[firstKey];
-    }
   } else {
     baseURL = cucumberConfig.baseURL;
   }

package/src/helper/contextManager/requestManager.js

@@ -5,12 +5,7 @@ let baseURL = "";
 
 if (typeof cucumberConfig.baseURL === "object") {
   const env = (cucumberConfig.env || "").trim();
-  if (env && cucumberConfig.baseURL.hasOwnProperty(env)) {
     baseURL = cucumberConfig.baseURL[env];
-  } else {
-    const firstKey = Object.keys(cucumberConfig.baseURL)[0];
-    baseURL = cucumberConfig.baseURL[firstKey];
-  }
 } else {
   baseURL = cucumberConfig.baseURL;
 }

package/src/helper/controller/elementController.js

@@ -134,17 +134,42 @@ function saveVar(value, customName, path) {
 }
 
 function resolveVariable(template) {
-  if (typeof template !== "string") return template;
-  return template.replace(/{{\s*(\w+)\s*}}/g, (_, varName) => {
-    let value = context.vars[varName];
-    if (typeof value === "string") {
-      value = value
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r")
-        .replace(/\t/g, "\\t");
+  if (typeof template === "string") {
+    return template.replace(/{{\s*(\w+)\s*}}/g, (_, varName) => {
+      let value = context.vars[varName];
+
+      if (value !== undefined) {
+        if (typeof value !== "string") {
+          try {
+            value = JSON.stringify(value);
+          } catch {
+            value = String(value);
+          }
+        }
+
+        return value
+          .replace(/\n/g, "\\n")
+          .replace(/\r/g, "\\r")
+          .replace(/\t/g, "\\t");
+      }
+
+      return `{{${varName}}}`;
+    });
+  }
+
+  if (Array.isArray(template)) {
+    return template.map((item) => resolveVariable(item));
+  }
+
+  if (template && typeof template === "object") {
+    const result = {};
+    for (const key in template) {
+      result[key] = resolveVariable(template[key]);
     }
-    return value !== undefined ? value : `{{${varName}}}`;
-  });
+    return result;
+  }
+
+  return template;
 }
 
 module.exports = {

package/src/helper/controller/pomCollector.js

@@ -1,6 +1,7 @@
 const { addElements } = require("./elementController");
 const cucumberConfig = require("../../../cucumber.config");
 const fs = require("fs");
+
 function pomCollector() {
   if (fs.existsSync(cucumberConfig.default.pomPath)) {
     fs.readdir(`${cucumberConfig.default.pomPath}`, (err, files) => {

package/src/helper/stepFunctions/browserActions.js

@@ -12,6 +12,7 @@ const browser = {
     }
 
     cookieData = Array.isArray(cookieData) ? cookieData : [cookieData];
+
     await context.browserContext.addCookies(cookieData);
   },
 };

package/src/stepDefinitions/keyboardActions.steps.js

@@ -190,6 +190,21 @@ When('User types random fullname in {string}', async (input) => {
   await element(input).fill(`${randomFirstName} ${randomLastName}`)
 })
 
+When('User types random first name in {string}', async (input) => {
+  const randomFirstName = await random.person.firstName()
+  await element(input).fill(randomFirstName)
+})
+
+When('User types random last name in {string}', async (input) => {
+  const randomLastName = await random.person.lastName()
+  await element(input).fill(randomLastName)
+})
+
+When('User types random middle name in {string}', async (input) => {
+  const randomMiddleName = await random.person.middleName()
+  await element(input).fill(randomMiddleName)
+})
+
 When('User types random date between {int} and {int} in {string}', async (fromYear, toYear, input) => {
   const year = Math.floor(Math.random() * (toYear - fromYear + 1)) + fromYear
   const month = Math.floor(Math.random() * 12) + 1

package/src/stepDefinitions/random.steps.js

@@ -1,4 +1,4 @@
-const { Given, context, random } = require("../helper/imports/commons");
+const { Given, context, random, time } = require("../helper/imports/commons");
 const { api } = require("../helper/stepFunctions/exporter");
 
 Given("User sets random word as {string}", async (key) => {
@@ -16,8 +16,8 @@ Given(
 
 Given(
   "User sets random word that has character between {int} and {int} as {string}",
-  async (key, from, to) => {
-    const word = random.lorem.word({ length: { min: from, max: to } });
+  async (from, to, key) => {
+    const word = random.lorem.word({ min: from, max: to });
     context.vars[key] = word;
   },
 );
@@ -37,12 +37,17 @@ Given(
 
 Given(
   "User sets random words that range between {int} and {int} as {string}",
-  async (key, from, to) => {
+  async (from, to, key) => {
     const words = random.lorem.words({ min: from, max: to });
     context.vars[key] = words;
   },
 );
 
+Given('User sets random number as {string}', async (key) => {
+  const randomNumber = random.number.int();
+  context.vars[key] = randomNumber;
+});
+
 Given(
   "User sets random number from {int} to {int} as {string}",
   async (from, to, key) => {
@@ -86,4 +91,69 @@ Given("User sets random value from given {string} array as {string}", async (arr
   const parsedArray = JSON.parse(array.replace(/'/g, '"'));
   const randomValue = parsedArray[Math.floor(Math.random() * parsedArray.length)];
   context.vars[key] = randomValue;
-});
+});
+
+Given('User sets random paragraph as {string}', async (key) => {
+  const randomParagraph = random.lorem.paragraph();
+  context.vars[key] = randomParagraph;
+});
+
+Given(
+"User sets random paragraph that range between {int} and {int} as {string}",
+async (from, to, key) => {
+  const words = random.lorem.paragraph({ min: from, max: to });
+  context.vars[key] = words;
+},
+);
+
+Given('User sets random characters from {string} as {string}', async (chars, key) => {
+      const randomCharacters = random.string.fromCharacters(chars,10);
+      context.vars[key] = randomCharacters;
+    })
+
+Given('User sets random alphanumeric in range from {int} to {int} as {string}', async (from,to, key) => {
+  const randomWords = await random.string.alphanumeric({ min: from, max: to })
+  context.vars[key] = randomWords;
+})
+
+Given('User sets random fullname as {string}', async (key) => {
+  const randomFirstName = await random.person.firstName()
+  const randomLastName = await random.person.lastName()
+  context.vars[key] = `${randomFirstName} ${randomLastName}`
+})
+
+Given('User sets random first name as {string}', async (key) => {
+  const randomFirstName = await random.person.firstName()
+  context.vars[key] = randomFirstName;
+})
+
+Given('User sets random last name as {string}', async (key) => {
+  const randomLastName = await random.person.lastName()
+  context.vars[key] = randomLastName;
+})
+
+Given('User sets random middle name as {string}', async (key) => {
+  const randomMiddleName = await random.person.middleName()
+  context.vars[key] = randomMiddleName;
+})
+
+Given('User sets random date between {int} and {int} as {string}', async (fromYear, toYear, key) => {
+  const year = Math.floor(Math.random() * (toYear - fromYear + 1)) + fromYear
+  const month = Math.floor(Math.random() * 12) + 1
+  const day = Math.floor(Math.random() * 28) + 1
+  const pad = (num) => num.toString().padStart(2, '0')
+  const dateStr = `${pad(day)}.${pad(month)}.${year}`
+  context.vars[key] = dateStr;
+})
+
+Given('User sets date {int} days after today as {string}', async (day, key) => {
+  const now = new time();
+  const afterDate = now.add(day, 'day').format("DD-MM-YYYY");
+  context.vars[key] = afterDate;
+})
+
+Given('User sets date {int} days before today as {string}', async (day, key) => {
+  const now = new time();
+  const beforeDate = now.subtract(day, 'day').format("DD-MM-YYYY");
+  context.vars[key] = beforeDate;
+})