artes 1.4.2 → 1.4.3

package/cucumber.config.js

@@ -51,6 +51,15 @@ function resolveEnv(artesConfig) {
 }
 const env = resolveEnv(artesConfig);
 
+const resolveFeaturePaths = (basePath, value) => {
+  return value
+    .split(',')
+    .map(p => p.trim())
+    .filter(Boolean)
+    .map(p => path.join(basePath, p));
+};
+
+
 module.exports = {
   default: {
     // File paths and patterns
@@ -60,13 +69,13 @@ module.exports = {
     timeout: process.env.TIMEOUT
       ? Number(process.env.TIMEOUT) * 1000
       : artesConfig.timeout * 1000 || 30 * 1000, // Default timeout in seconds
-    paths: process.env.RERUN
-      ? [`${path.join("../../", process.env.RERUN)}`]
+      paths: process.env.RERUN
+      ? [path.join("../../", process.env.RERUN)]
       : process.env.FEATURES
-        ? [path.join(moduleConfig.projectPath, process.env.FEATURES)]
+        ? resolveFeaturePaths(moduleConfig.projectPath, process.env.FEATURES)
         : artesConfig.features
-          ? [path.join(moduleConfig.projectPath, artesConfig.features)]
-          : [moduleConfig.featuresPath], // Paths to feature files
+          ? resolveFeaturePaths(moduleConfig.projectPath, artesConfig.features)
+          : [moduleConfig.featuresPath], // Paths to feature files    
     require: [
       process.env.STEP_DEFINITIONS
         ? [path.join(moduleConfig.projectPath, process.env.STEP_DEFINITIONS)]

package/package.json

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

package/src/helper/controller/elementController.js

@@ -38,7 +38,10 @@ function selectorSeparator(element) {
   }
 }
 
-function getSelector(element) {
+ function getSelector(element) {
+
+  element = resolveVariable(element)
+
   const selector =
     elements?.[element]?.selector || elements?.[element] || element;
   return resolveVariable(selectorSeparator(selector));

package/src/helper/stepFunctions/assertions.js

@@ -1,4 +1,4 @@
-const { expect, element, context } = require("../imports/commons");
+const { expect, element, context, resolveVariable } = require("../imports/commons");
 const { elementInteractions } = require("./elementInteractions");
 const { frame } = require("../stepFunctions/frameActions");
 
@@ -77,6 +77,8 @@ const assert = {
   shouldContainText: async (selector, text, options) => {
     options = options ?? {};
 
+    text = await resolveVariable(text)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toContainText(text, options);
@@ -88,6 +90,8 @@ const assert = {
   ) => {
     options = options ?? {};
 
+    expectedText = await resolveVariable(expectedText)
+
     const count = await frame.count(elements);
 
     for (let i = 0; i < count; i++) {
@@ -101,6 +105,8 @@ const assert = {
   shouldHaveAccessibleDescription: async (selector, description, options) => {
     options = options ?? {};
 
+    description = await resolveVariable(description)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveAccessibleDescription(description, options);
@@ -108,6 +114,8 @@ const assert = {
   shouldHaveAccessibleName: async (selector, name, options) => {
     options = options ?? {};
 
+    name = await resolveVariable(name)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveAccessibleName(name, options);
@@ -115,6 +123,9 @@ const assert = {
   shouldHaveAttribute: async (selector, attribute, value, options) => {
     options = options ?? {};
 
+    attribute = await resolveVariable(attribute)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveAttribute(attribute, value, options);
@@ -122,6 +133,8 @@ const assert = {
   shouldHaveClass: async (selector, className, options) => {
     options = options ?? {};
 
+    className = await resolveVariable(className)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveClass(className, options);
@@ -129,6 +142,8 @@ const assert = {
   shouldHaveCount: async (selector, count, options) => {
     options = options ?? {};
 
+    count = await resolveVariable(count)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveCount(count, options);
@@ -136,6 +151,9 @@ const assert = {
   shouldHaveCSS: async (selector, property, value, options) => {
     options = options ?? {};
 
+    property = await resolveVariable(property)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveCSS(property, value, options);
@@ -143,6 +161,8 @@ const assert = {
   shouldHaveId: async (selector, id, options) => {
     options = options ?? {};
 
+    id = await resolveVariable(id)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveId(id, options);
@@ -150,6 +170,9 @@ const assert = {
   shouldHaveJSProperty: async (selector, property, value, options) => {
     options = options ?? {};
 
+    property = await resolveVariable(property)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveJSProperty(property, value, options);
@@ -157,6 +180,8 @@ const assert = {
   shouldHaveRole: async (selector, role, options) => {
     options = options ?? {};
 
+    role = await resolveVariable(role)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveRole(role, options);
@@ -171,6 +196,8 @@ const assert = {
   shouldHaveText: async (selector, text, options) => {
     options = options ?? {};
 
+    text = await resolveVariable(text)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveText(text, options);
@@ -178,6 +205,8 @@ const assert = {
   shouldHaveValue: async (selector, value, options) => {
     options = options ?? {};
 
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveValue(value, options);
@@ -185,6 +214,8 @@ const assert = {
   shouldHaveValues: async (selector, values, options) => {
     options = options ?? {};
 
+    values = values.map(value => resolveVariable(value))
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).toHaveValues(values, options);
@@ -197,11 +228,15 @@ const assert = {
   shouldPageHaveTitle: async (title, options) => {
     options = options ?? {};
 
+    title = await resolveVariable(title)
+
     await expect(context.page).toHaveTitle(title, options);
   },
   shouldPageHaveURL: async (url, options) => {
     options = options ?? {};
 
+    url = await resolveVariable(url)
+
     await expect(context.page).toHaveURL(url, options);
   },
   shouldResponseBeOK: async (response, options) => {
@@ -284,6 +319,8 @@ const assert = {
   shouldNotContainText: async (selector, text, options) => {
     options = options ?? {};
 
+    text = await resolveVariable(text)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toContainText(text, options);
@@ -295,6 +332,8 @@ const assert = {
   ) => {
     options = options ?? {};
 
+    description = await resolveVariable(description)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveAccessibleDescription(description, options);
@@ -302,6 +341,8 @@ const assert = {
   shouldNotHaveAccessibleName: async (selector, name, options) => {
     options = options ?? {};
 
+    name = await resolveVariable(name)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveAccessibleName(name, options);
@@ -309,6 +350,9 @@ const assert = {
   shouldNotHaveAttribute: async (selector, attribute, value, options) => {
     options = options ?? {};
 
+    attribute = await resolveVariable(attribute)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveAttribute(attribute, value, options);
@@ -316,12 +360,16 @@ const assert = {
   shouldNotHaveClass: async (selector, className, options) => {
     options = options ?? {};
 
+    className = await resolveVariable(className)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveClass(className, options);
   },
   shouldNotHaveCount: async (selector, count, options) => {
     options = options ?? {};
+  
+    count = await resolveVariable(count)
 
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
@@ -330,6 +378,9 @@ const assert = {
   shouldNotHaveCSS: async (selector, property, value, options) => {
     options = options ?? {};
 
+    property = await resolveVariable(property)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveCSS(property, value, options);
@@ -337,6 +388,8 @@ const assert = {
   shouldNotHaveId: async (selector, id, options) => {
     options = options ?? {};
 
+    id = await resolveVariable(id)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveId(id, options);
@@ -344,6 +397,9 @@ const assert = {
   shouldNotHaveJSProperty: async (selector, property, value, options) => {
     options = options ?? {};
 
+    property = await resolveVariable(property)
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveJSProperty(property, value, options);
@@ -351,6 +407,8 @@ const assert = {
   shouldNotHaveRole: async (selector, role, options) => {
     options = options ?? {};
 
+    role = await resolveVariable(role)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveRole(role, options);
@@ -365,6 +423,8 @@ const assert = {
   shouldNotHaveText: async (selector, text, options) => {
     options = options ?? {};
 
+      text = await resolveVariable(text)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveText(text, options);
@@ -372,6 +432,8 @@ const assert = {
   shouldNotHaveValue: async (selector, value, options) => {
     options = options ?? {};
 
+    value = await resolveVariable(value)
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveValue(value, options);
@@ -379,6 +441,8 @@ const assert = {
   shouldNotHaveValues: async (selector, values, options) => {
     options = options ?? {};
 
+    values = values.map(value => resolveVariable(value))
+
     await expect(
       typeof selector === "string" ? element(selector) : await selector,
     ).not.toHaveValues(values, options);
@@ -391,11 +455,15 @@ const assert = {
   shouldNotPageHaveTitle: async (title, options) => {
     options = options ?? {};
 
+      title = await resolveVariable(title)
+
     await expect(context.page).not.toHaveTitle(title, options);
   },
   shouldNotPageHaveURL: async (url, options) => {
     options = options ?? {};
 
+      url = await resolveVariable(url)
+
     await expect(context.page).not.toHaveURL(url, options);
   },
   shouldNotResponseBeOK: async (response, options) => {
@@ -408,6 +476,8 @@ const assert = {
   shouldBe: async (selector, expected, options) => {
     options = options ?? {};
 
+    expected = await resolveVariable(expected)
+
     await expect(await elementInteractions.textContent(selector)).toBe(
       expected,
       options,
@@ -416,6 +486,10 @@ const assert = {
   shouldBeCloseTo: async (selector, expected, precision, options) => {
     options = options ?? {};
 
+    expected = await resolveVariable(expected)
+    precision = await resolveVariable(precision)
+
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeCloseTo(expected, precision, options);
@@ -437,6 +511,8 @@ const assert = {
   shouldBeGreaterThan: async (selector, expected, options) => {
     options = options ?? {};
 
+        expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeGreaterThan(expected, options);
@@ -444,6 +520,8 @@ const assert = {
   shouldBeGreaterThanOrEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeGreaterThanOrEqual(expected, options);
@@ -451,6 +529,8 @@ const assert = {
   shouldBeInstanceOf: async (selector, constructor, options) => {
     options = options ?? {};
 
+        constructor = await resolveVariable(constructor)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).toBeInstanceOf(constructor, options);
@@ -458,6 +538,8 @@ const assert = {
   shouldBeLessThan: async (selector, expected, options) => {
     options = options ?? {};
 
+        expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeLessThan(expected, options);
@@ -465,6 +547,8 @@ const assert = {
   shouldBeLessThanOrEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+        expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeLessThanOrEqual(expected, options);
@@ -508,6 +592,8 @@ const assert = {
   shouldContainEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+            expected = await resolveVariable(expected)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).toContainEqual(expected, options);
@@ -515,6 +601,8 @@ const assert = {
   shouldEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+                expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toEqual(expected, options);
@@ -522,6 +610,8 @@ const assert = {
   shouldHaveLength: async (selector, length, options) => {
     options = options ?? {};
 
+      length = await resolveVariable(length)
+
     await expect(await elementInteractions.textContent(selector)).toHaveLength(
       length,
       options,
@@ -530,6 +620,8 @@ const assert = {
   shouldHaveProperty: async (selector, property, options) => {
     options = options ?? {};
 
+      property = await resolveVariable(property)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).toHaveProperty(property, options);
@@ -537,6 +629,8 @@ const assert = {
   shouldMatch: async (selector, regex, options) => {
     options = options ?? {};
 
+regex = await resolveVariable(regex)
+
     await expect(await elementInteractions.textContent(selector)).toMatch(
       regex,
       options,
@@ -545,6 +639,8 @@ const assert = {
   shouldMatchObject: async (selector, object, options) => {
     options = options ?? {};
 
+      object = await resolveVariable(object)
+
     await expect(await elementInteractions.textContent(selector)).toMatchObject(
       object,
       options,
@@ -553,6 +649,8 @@ const assert = {
   shouldStrictEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toStrictEqual(expected, options);
@@ -560,11 +658,15 @@ const assert = {
   shouldThrow: async (fn, options) => {
     options = options ?? {};
 
+    fn = await resolveVariable(fn)
+
     await expect(fn).toThrow(options);
   },
   shouldAny: async (selector, constructor, options) => {
     options = options ?? {};
 
+      constructor = await resolveVariable(constructor)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).any.toBeInstanceOf(constructor, options);
@@ -579,6 +681,8 @@ const assert = {
   shouldArrayContaining: async (selector, elements, options) => {
     options = options ?? {};
 
+      elements = elements.map(element => resolveVariable(element))
+
     await expect(await elementInteractions.textContent(selector)).toEqual(
       expect.arrayContaining(elements),
       options,
@@ -587,6 +691,9 @@ const assert = {
   shouldCloseTo: async (selector, expected, precision, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+      precision = await resolveVariable(precision)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).toBeCloseTo(expected, precision, options);
@@ -594,6 +701,8 @@ const assert = {
   shouldObjectContaining: async (selector, properties, options) => {
     options = options ?? {};
 
+      properties = await resolveVariable(properties)
+
     await expect(await elementInteractions.textContent(selector)).toEqual(
       expect.objectContaining(properties),
       options,
@@ -602,6 +711,8 @@ const assert = {
   shouldStringContaining: async (selector, substring, options) => {
     options = options ?? {};
 
+      substring = await resolveVariable(substring)
+
     await expect(await elementInteractions.textContent(selector)).toEqual(
       expect.stringContaining(substring),
       options,
@@ -610,6 +721,8 @@ const assert = {
   shouldStringMatching: async (selector, regex, options) => {
     options = options ?? {};
 
+      regex = await resolveVariable(regex)
+
     await expect(await elementInteractions.textContent(selector)).toEqual(
       expect.stringMatching(regex),
       options,
@@ -620,6 +733,8 @@ const assert = {
   shouldNotBe: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(await elementInteractions.textContent(selector)).not.toBe(
       expected,
       options,
@@ -628,6 +743,9 @@ const assert = {
   shouldNotBeCloseTo: async (selector, expected, precision, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+      precision = await resolveVariable(precision)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toBeCloseTo(expected, precision, options);
@@ -649,6 +767,8 @@ const assert = {
   shouldNotBeGreaterThan: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).not.toBeGreaterThan(expected, options);
@@ -656,6 +776,8 @@ const assert = {
   shouldNotBeGreaterThanOrEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toBeGreaterThanOrEqual(expected, options);
@@ -663,6 +785,8 @@ const assert = {
   shouldNotBeInstanceOf: async (selector, constructor, options) => {
     options = options ?? {};
 
+      constructor = await resolveVariable(constructor)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).not.toBeInstanceOf(constructor, options);
@@ -670,6 +794,8 @@ const assert = {
   shouldNotBeLessThan: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toBeLessThan(expected, options);
@@ -677,6 +803,8 @@ const assert = {
   shouldNotBeLessThanOrEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toBeLessThanOrEqual(expected, options);
@@ -712,6 +840,8 @@ const assert = {
   shouldNotContain: async (selector, substring, options) => {
     options = options ?? {};
 
+      substring = await resolveVariable(substring)
+
     await expect(await elementInteractions.textContent(selector)).not.toContain(
       substring,
       options,
@@ -720,6 +850,8 @@ const assert = {
   shouldNotContainEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toContainEqual(expected, options);
@@ -727,6 +859,8 @@ const assert = {
   shouldNotEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toEqual(expected, options);
@@ -734,6 +868,8 @@ const assert = {
   shouldNotHaveLength: async (selector, length, options) => {
     options = options ?? {};
 
+      length = await resolveVariable(length)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).not.toHaveLength(length, options);
@@ -741,6 +877,8 @@ const assert = {
   shouldNotHaveProperty: async (selector, property, options) => {
     options = options ?? {};
 
+      property = await resolveVariable(property)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).not.toHaveProperty(property, options);
@@ -748,6 +886,8 @@ const assert = {
   shouldNotMatch: async (selector, regex, options) => {
     options = options ?? {};
 
+      regex = await resolveVariable(regex)
+
     await expect(await elementInteractions.textContent(selector)).not.toMatch(
       regex,
       options,
@@ -756,6 +896,8 @@ const assert = {
   shouldNotMatchObject: async (selector, object, options) => {
     options = options ?? {};
 
+      object = await resolveVariable(object)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).not.toMatchObject(object, options);
@@ -763,6 +905,8 @@ const assert = {
   shouldNotStrictEqual: async (selector, expected, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toStrictEqual(expected, options);
@@ -770,11 +914,15 @@ const assert = {
   shouldNotThrow: async (fn, options) => {
     options = options ?? {};
 
+      fn = await resolveVariable(fn)
+
     await expect(fn).not.toThrow(options);
   },
   shouldNotAny: async (selector, constructor, options) => {
     options = options ?? {};
 
+      constructor = await await resolveVariable(constructor)
+
     await expect(
       await elementInteractions.textContent(selector),
     ).any.toBeInstanceOf(constructor, options);
@@ -789,6 +937,8 @@ const assert = {
   shouldNotArrayContaining: async (selector, elements, options) => {
     options = options ?? {};
 
+      elements = elements.map(element => resolveVariable(element))
+
     await expect(await elementInteractions.textContent(selector)).not.toEqual(
       expect.arrayContaining(elements),
       options,
@@ -797,6 +947,9 @@ const assert = {
   shouldNotCloseTo: async (selector, expected, precision, options) => {
     options = options ?? {};
 
+      expected = await resolveVariable(expected)
+      precision = await resolveVariable(precision)
+
     await expect(
       Number(await elementInteractions.textContent(selector)),
     ).not.toBeCloseTo(expected, precision, options);
@@ -804,6 +957,8 @@ const assert = {
   shouldNotObjectContaining: async (selector, properties, options) => {
     options = options ?? {};
 
+      properties = await resolveVariable(properties)
+
     await expect(await elementInteractions.textContent(selector)).not.toEqual(
       expect.objectContaining(properties),
       options,
@@ -812,6 +967,8 @@ const assert = {
   shouldNotStringContaining: async (selector, substring, options) => {
     options = options ?? {};
 
+      substring = await resolveVariable(substring)
+
     await expect(await elementInteractions.textContent(selector)).not.toEqual(
       expect.stringContaining(substring),
       options,
@@ -820,6 +977,8 @@ const assert = {
   shouldNotStringMatching: async (selector, regex, options) => {
     options = options ?? {};
 
+      regex = await resolveVariable(regex)
+
     await expect(await elementInteractions.textContent(selector)).not.toEqual(
       expect.stringMatching(regex),
       options,

package/src/helper/stepFunctions/elementInteractions.js

@@ -1,4 +1,4 @@
-const { element } = require("../imports/commons");
+const { element, resolveVariable } = require("../imports/commons");
 
 const elementInteractions = {
   isChecked: async (selector, options) => {
@@ -34,6 +34,8 @@ const elementInteractions = {
   getAttribute: async (selector, attribute, options) => {
     options = options ?? {};
 
+    attribute = await resolveVariable(attribute)
+
     return await element(selector).getAttribute(attribute, options);
   },
   innerHTML: async (selector, options) => {

package/src/helper/stepFunctions/keyboardActions.js

@@ -1,41 +1,46 @@
 const { element, resolveVariable } = require("../imports/commons");
-const { frame } = require("./frameActions");
 
 const keyboard = {
   press: async (selector, key, options) => {
     options = options ?? {};
 
     key = await resolveVariable(key);
+
     await element(selector).press(key, options);
   },
   pressSequentially: async (selector, keys, options) => {
     options = options ?? {};
 
     keys = await resolveVariable(keys);
+
     await element(selector).pressSequentially(keys, options);
   },
   fill: async (selector, value, options) => {
     options = options ?? {};
 
     value = await resolveVariable(value);
+
     value !== "" ? await element(selector).fill(value, options) : "";
   },
   keyDown: async (selector, key, options) => {
     options = options ?? {};
 
     key = await resolveVariable(key);
+
     await element(selector).down(key, options);
   },
   keyUp: async (selector, key, options) => {
     options = options ?? {};
 
     key = await resolveVariable(key);
+
     await element(selector).up(key, options);
   },
   insertText: async (selector, text, options) => {
     options = options ?? {};
 
     text = await resolveVariable(text);
+
     await element(selector).insertText(text, options);
   },
   clear: async (selector, options) => {

package/src/helper/stepFunctions/mouseActions.js

@@ -3,7 +3,7 @@ const {
   element,
   context,
   selector,
-  moduleConfig,
+  moduleConfig, resolveVariable
 } = require("../imports/commons");
 
 const mouse = {
@@ -37,11 +37,15 @@ const mouse = {
   selectByValue: async (selector, value, options) => {
     options = options ?? {};
 
+    value = await resolveVariable(value);
+
     value !== "" ? await element(selector).selectOption(value, options) : "";
   },
   selectByText: async (selector, text, options) => {
     options = options ?? {};
 
+    text = await resolveVariable(text);
+
     text !== "" ? await element(selector).selectOption(text, options) : "";
   },
   check: async (selector, options) => {
@@ -62,6 +66,7 @@ const mouse = {
   upload: async (filePath, fileInput, options) => {
     options = options ?? {};
 
+    filePath = await resolveVariable(filePath);
     const file = selector(filePath);
     const fileChooserPromise = context.page.waitForEvent("filechooser");
     await element(fileInput).click();

package/src/helper/stepFunctions/pageActions.js

@@ -1,10 +1,12 @@
-const { context, selector } = require("../imports/commons");
+const { context, selector, resolveVariable } = require("../imports/commons");
 
 const page = {
   navigateTo: async (url, options) => {
     options = options ?? {};
 
-    url = selector(url);
+    url = await resolveVariable(url);
+    url = await selector(url);
+
     return await context.page.goto(url, options);
   },
   getURL: async (options) => {
@@ -30,6 +32,8 @@ const page = {
   wait: async (time, options) => {
     options = options ?? {};
 
+    time = await resolveVariable(time);
+
     return await context.page.waitForTimeout(time, options);
   },
 };

package/src/stepDefinitions/API.steps.js

@@ -5,7 +5,7 @@ const {
   saveVar,
   time,
   random,
-  moduleConfig,
+  moduleConfig, resolveVariable
 } = require("../helper/imports/commons");
 const { api } = require("../helper/stepFunctions/exporter");
 const path = require("path");
@@ -239,37 +239,29 @@ When("User wants to see response body", async function () {
 });
 
 When(
-  "User sends {string} request to {string}",
-  async function (method, url, reqParams) {
+  "User sends {string} request to {string} with payload:",
+  async function (method, url, payload) {
     const httpMethod = method.toUpperCase();
 
-    let headers = {};
-    let body;
-
-    if (["POST", "PUT", "PATCH"].includes(httpMethod)) {
-      const payload = JSON.parse(reqParams);
-      headers = payload.headers || {};
-      body = payload.body || {};
-    }
 
     switch (httpMethod) {
       case "GET":
-        await api.get(url);
+        await api.get(url, payload);
         break;
       case "HEAD":
-        await api.head(url);
+        await api.head(url, payload);
         break;
       case "POST":
-        await api.post(url, headers, body);
+        await api.post(url, payload);
         break;
       case "PUT":
-        await api.put(url, headers, body);
+        await api.put(url, payload);
         break;
       case "PATCH":
-        await api.patch(url, headers, body);
+        await api.patch(url, payload);
         break;
       case "DELETE":
-        await api.delete(url);
+        await api.delete(url, payload);
         break;
       default:
         throw new Error(`Unsupported HTTP method: ${httpMethod}`);
@@ -308,6 +300,8 @@ When(
 When(
   "User convert {string} into base64 as {string}",
   async (file, variable) => {
+    file = await resolveVariable(file);
+    
     const filePath = await path.join(moduleConfig.projectPath, file);
     const fileData = await fs.readFileSync(filePath);
     const base64Data = await fileData.toString("base64");

package/src/stepDefinitions/assertions.steps.js

@@ -5,7 +5,7 @@ const {
   element,
   extractVarsFromResponse,
   context,
-  resolveVariable,
+  resolveVariable
 } = require("../helper/imports/commons");
 const { assert, frame } = require("../helper/stepFunctions/exporter");
 const Ajv = require("ajv");
@@ -837,6 +837,7 @@ Then(
 Then(
   "User expects that response body should match {string} schema",
   async function (expectedSchema) {
+    expectedSchema = await resolveVariable(expectedSchema);
     if (expectedSchema != "") {
       const schema = await selector(expectedSchema);
       const ajv = await new Ajv();
@@ -851,6 +852,7 @@ Then(
 Then(
   "User expects that request should have {int} status code",
   async function (expectedStatusCode) {
+    expectedStatusCode = await resolveVariable(expectedStatusCode);
     const actualStatusCode = await context.response.Response.status();
     expect(actualStatusCode).toBe(expectedStatusCode);
   },
@@ -859,6 +861,7 @@ Then(
 Then(
   "User expects that response should have {int} status code",
   async function (expectedStatusCode) {
+    expectedStatusCode = await resolveVariable(expectedStatusCode);
     const actualStatusCode = await context.response.Response.status();
     expect(actualStatusCode).toBe(expectedStatusCode);
   },

package/src/stepDefinitions/keyboardActions.steps.js

@@ -3,7 +3,7 @@ const {
   random,
   element,
   selector,
-  time,
+  time, resolveVariable
 } = require("../helper/imports/commons");
 const { keyboard, frame } = require("../helper/stepFunctions/exporter");
 
@@ -225,6 +225,9 @@ When("User types random middle name in {string}", async (input) => {
 When(
   "User types random date between {int} and {int} in {string}",
   async (fromYear, toYear, input) => {
+      fromYear = await resolveVariable(fromYear);
+      toYear = await resolveVariable(toYear);
+
     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;
@@ -237,6 +240,9 @@ When(
 When(
   "User types date {int} days after today in {string}",
   async (day, input) => {
+
+    day = await resolveVariable(day);
+
     const now = new time();
     const afterDate = now.add(day, "day").format("DD-MM-YYYY");
     await element(input).fill(afterDate);
@@ -246,6 +252,9 @@ When(
 When(
   "User types date {int} days before today in {string}",
   async (day, input) => {
+
+     day = await resolveVariable(day);
+
     const now = new time();
     const beforeDate = now.subtract(day, "day").format("DD-MM-YYYY");
     await element(input).fill(beforeDate);

package/src/stepDefinitions/random.steps.js

@@ -1,4 +1,4 @@
-const { Given, context, random, time } = require("../helper/imports/commons");
+const { Given, context, random, time, resolveVariable } = require("../helper/imports/commons");
 const { api } = require("../helper/stepFunctions/exporter");
 
 Given("User sets random word as {string}", async (key) => {
@@ -153,6 +153,10 @@ Given("User sets random middle name as {string}", async (key) => {
 Given(
   "User sets random date between {int} and {int} as {string}",
   async (fromYear, toYear, key) => {
+
+    fromYear = await resolveVariable(fromYear);
+    toYear = await resolveVariable(toYear);
+
     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;
@@ -163,6 +167,9 @@ Given(
 );
 
 Given("User sets date {int} days after today as {string}", async (day, key) => {
+
+  day = await resolveVariable(day);
+
   const now = new time();
   const afterDate = now.add(day, "day").format("DD-MM-YYYY");
   context.vars[key] = afterDate;
@@ -171,6 +178,9 @@ Given("User sets date {int} days after today as {string}", async (day, key) => {
 Given(
   "User sets date {int} days before today as {string}",
   async (day, key) => {
+
+    day = await resolveVariable(day);
+
     const now = new time();
     const beforeDate = now.subtract(day, "day").format("DD-MM-YYYY");
     context.vars[key] = beforeDate;