artes 1.4.3 → 1.4.5

package/README.md

@@ -119,6 +119,7 @@ npx artes [options]
 | 📜 `--stepDef`            | Specify one or more step definition files' relative paths to use (comma-separated) | `artes --stepDef "tests/steps/login.js,tests/steps/home.js"`          |
 | 🔖 `--tags`               | Run tests with specified Cucumber tags                                             | `artes --tags "@smoke or @wip"`                                       |
 | 🌐 `--env`                | Set the environment for the test run                                               | `artes --env "dev"`                                                   |
+| `--saveVar`              |  Set the variables from CLI                                                         | `artes --saveVar '{"armud":20,"banana":200}'` |  
 | 🕶️ `--headless`           | Run browser in headless mode                                                       | `artes --headless`                                                    |
 | ⚡ `--parallel`           | Run tests in parallel mode                                                         | `artes --parallel 2`                                                  |
 | 🔁 `--retry`              | Retry failed tests                                                                 | `artes --retry 3`                                                     |
@@ -482,23 +483,34 @@ You can configure Artes by editing the `artes.config.js` file. Below are the def
 
 | **Option**        | **Default Value**                                                            | **Description**                                               |
 | ----------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| `headless`        | `false`                                                                      | Run browser in headless mode.                                 |
+| `env`             | `""`                                                                         | Environment name for tests.                                   |
+| `variables`       | `{}`                                                                         | Variables for tests.                                          |
+| `baseURL`         | `""`                                                                         | Base URL for API or web tests.                                |
 | `timeout`         | `30`                                                                         | Default timeout in seconds.                                   |
-| `slowMo`          | `0`                                                                          | Default slow motion in seconds                                |
+| `slowMo`          | `0`                                                                          | Default slow motion in seconds.                               |
 | `paths`           | `[moduleConfig.featuresPath]`                                                | Paths to feature files.                                       |
 | `require`         | `[moduleConfig.stepsPath, "src/stepDefinitions/*.js", "src/hooks/hooks.js"]` | Support code paths (CommonJS).                                |
 | `pomPath`         | `moduleConfig.pomPath`                                                       | Path to Page Object Models.                                   |
 | `import`          | `[]`                                                                         | Support code paths.                                           |
 | `testPercentage`  | `0`                                                                          | Define test coverage percentage                               |
 | `report`          | `false`                                                                      | Generate report                                               |
-| `reportSuccess`   | `false`                                                                      | Add screenshots and video records for also success test cases |
-| `trace`           | `false`                                                                      | Enable trace                                                  |
-| `reportWithTrace` | `false`                                                                      | Add trace to the report                                       |
+| `zip`             |  `false`                                                                     | Generate zip of report |
+| `reportSuccess`   | `false`                                                                      | Add screenshots and video records also for success test cases |
+| `trace`           | `false`                                                                      | Enable tracing                                                |
+| `reportWithTrace` | `false`                                                                      | Include trace in report                                       |
 | `format`          | `["rerun:@rerun.txt", "allure-cucumberjs/reporter"]`                         | Formatter names/paths.                                        |
 | `formatOptions`   | `{ "resultsDir": "allure-result" }`                                          | Formatter options.                                            |
 | `parallel`        | `1`                                                                          | Number of parallel workers.                                   |
+| `browser`         | `"chrome"`                                                                   | Browser to use: "chrome", "firefox", "webkit".                |
+| `offline`         | `false`                                                                      | Run browser in offline mode.                                  |
+| `device`          | `""`                                                                         | Emulate specific device (e.g., "iPhone 13").                  |
+| `width`           | `1280`                                                                       | Browser width in pixels.                                      |
+| `height`          | `720`                                                                        | Browser height in pixels.                                     |
+| `maximizeScreen`  | `true`                                                                       | Maximize browser window on start.                             |
 | `dryRun`          | `false`                                                                      | Prepare test run without execution.                           |
 | `failFast`        | `false`                                                                      | Stop on first test failure.                                   |
-| `forceExit`       | `false`                                                                      | Force `process.exit()` after tests.                           |
+| `forceExit`       | `false`                                                                      | Force `process.exit()` after tests                            |
 | `strict`          | `true`                                                                       | Fail on pending steps.                                        |
 | `backtrace`       | `false`                                                                      | Show full backtrace for errors.                               |
 | `tags`            | `""`                                                                         | Tag expression to filter scenarios.                           |

package/cucumber.config.js

@@ -51,6 +51,25 @@ function resolveEnv(artesConfig) {
 }
 const env = resolveEnv(artesConfig);
 
+function loadVariables(cliVariables, artesConfigVariables) {
+
+  if (cliVariables) {
+    try {
+      cliVariables = JSON.parse(process.env.VARS);
+    } catch (err) {
+      console.error("Invalid JSON in process.env.VARS:", process.env.VARS);
+      envVars = {};
+    }
+  }
+
+  const mergedVars = {
+    ...(artesConfigVariables || {}),
+    ...cliVariables,
+  };
+
+  return mergedVars;
+}
+
 const resolveFeaturePaths = (basePath, value) => {
   return value
     .split(',')
@@ -162,6 +181,7 @@ module.exports = {
     zip: process.env.ZIP == "true" ? true : artesConfig.zip ? true : false,
   },
   env: env,
+  variables: loadVariables(process.env.VARS, artesConfig.variables),
   baseURL: process.env.BASE_URL
     ? JSON.parse(process.env.BASE_URL)
     : artesConfig?.baseURL

package/executer.js

@@ -10,13 +10,14 @@ const {
 const { logPomWarnings } = require("./src/helper/controller/pomCollector");
 const fs = require("fs");
 const path = require("path");
+const { spawnSync } = require("child_process");
 
-const configPath = path.resolve(process.cwd(), "artes.config.js");
+const artesConfigPath = path.resolve(process.cwd(), "artes.config.js");
 
 let artesConfig = {};
 
-if (fs.existsSync(configPath)) {
-  artesConfig = require(configPath);
+if (fs.existsSync(artesConfigPath)) {
+  artesConfig = require(artesConfigPath);
 }
 
 const args = process.argv.slice(2);
@@ -37,6 +38,7 @@ const flags = {
   stepDef: args.includes("--stepDef"),
   tags: args.includes("--tags"),
   env: args.includes("--env"),
+  saveVar: args.includes("--saveVar"),
   headless: args.includes("--headless"),
   parallel: args.includes("--parallel"),
   retry: args.includes("--retry"),
@@ -55,6 +57,7 @@ const flags = {
 };
 
 const env = args[args.indexOf("--env") + 1];
+const vars = args[args.indexOf("--saveVar") + 1]
 const featureFiles = args[args.indexOf("--features") + 1];
 const features = flags.features && featureFiles;
 const stepDef = args[args.indexOf("--stepDef") + 1];
@@ -73,6 +76,8 @@ const slowMo = args[args.indexOf("--slowMo") + 1];
 
 flags.env ? (process.env.ENV = env) : "";
 
+vars ? (process.env.VARS = vars) : "";
+
 flags.reportWithTrace ||
 artesConfig.reportWithTrace ||
 flags.report ||
@@ -146,6 +151,83 @@ flags.timeout ? (process.env.TIMEOUT = timeout) : "";
 
 flags.slowMo ? (process.env.SLOWMO = slowMo) : "";
 
+
+function testCoverageCalculation(testStatusDir){
+  if(fs.existsSync(testStatusDir)){
+    const files = fs.readdirSync(testStatusDir);
+
+    const map = {};
+    const retriedTests = [];
+    const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  
+    files.forEach(file => {
+     const match = file.match(uuidRegex);
+     if (!match) return;
+ 
+     const id = match[0];
+ 
+     const beforeId = file.substring(0, file.indexOf(id) - 1);
+     const afterId = file.substring(file.indexOf(id) + id.length + 1);
+ 
+     const status = beforeId.split('-')[0];
+     const scenario = beforeId.substring(status.length + 1);
+     const timestamp = afterId;
+ 
+     if (!map[id]) {
+       map[id] = {
+         count: 1,
+         latest: { status, scenario, timestamp }
+       };
+     } else {
+       map[id].count++;
+       if (timestamp > map[id].latest.timestamp) {
+         map[id].latest = { status, scenario, timestamp };
+       }
+     }
+   });
+ 
+   let total = 0;
+   let notPassed = 0;
+ 
+   Object.entries(map).forEach(([id, data]) => {
+     total++;
+ 
+     if (data.count > 1) {
+       retriedTests.push({
+         scenario: data.latest.scenario,
+         id,
+         count: data.count
+       });
+     }
+ 
+     if (data.latest.status !== 'PASSED') {
+      notPassed++;
+     }
+   });
+ 
+   if (retriedTests.length > 0) {
+     console.warn('\n\x1b[33mRetried test cases:');
+     retriedTests.forEach(t => {
+       console.warn(`- "${t.scenario}" ran ${t.count} times`);
+     });
+     console.log("\x1b[0m");
+   }
+ 
+   return {
+     percentage : (total - notPassed)/total*100,
+     totalTests: total,
+     notPassed,
+     passed: total - notPassed,
+     latestStatuses: Object.fromEntries(
+       Object.entries(map).map(([id, data]) => [
+         id,
+         data.latest.status
+       ])
+     )
+   };
+  }
+}
+
 function main() {
   if (flags.help) return showHelp();
   if (flags.version) return showVersion();
@@ -155,6 +237,35 @@ function main() {
 
   logPomWarnings();
 
+  const testCoverage = testCoverageCalculation(path.join(process.cwd(), "node_modules", "artes" , "testsStatus"))
+
+  const testPercentage = (process.env.PERCENTAGE  ? Number(process.env.PERCENTAGE)  : artesConfig.testPercentage || 0)
+
+  if (testPercentage > 0) {
+
+    const meetsThreshold = testCoverage.percentage >= testPercentage
+
+    if (meetsThreshold) {
+      console.log(
+        `✅ Tests passed required ${testPercentage}% success rate with ${testCoverage.percentage.toFixed(2)}%!`,
+      );
+      process.env.EXIT_CODE = parseInt(0, 10);
+    } else {
+      console.log(
+        `❌ Tests failed required ${testPercentage}% success rate with ${testCoverage.percentage.toFixed(2)}%!`,
+      );
+      process.env.EXIT_CODE = parseInt(1, 10);
+    }
+  }
+
+if (fs.existsSync(path.join(process.cwd(), "node_modules", "artes" , "@rerun.txt"))) {
+  spawnSync("mv", ["@rerun.txt", process.cwd()], {
+    cwd: path.join(process.cwd(), "node_modules", "artes"),
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
   if (
     flags.reportWithTrace ||
     artesConfig.reportWithTrace ||
@@ -163,18 +274,25 @@ function main() {
   )
     generateReport();
 
-  if (
-    fs.existsSync(
-      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
-    )
-  ) {
-    const data = fs.readFileSync(
-      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
-      "utf8",
-    );
-    process.env.EXIT_CODE = parseInt(data, 10);
-  }
 
+    if (!( process.env.TRACE === "true"
+      ? process.env.TRACE
+      : artesConfig.trace || false)) {
+      spawnSync(
+        "npx",
+        [
+          "rimraf",
+          "--no-glob",
+          path.join(process.cwd(), "traces"),
+        ],
+        {
+          cwd: process.cwd(),
+          stdio: "inherit",
+          shell: false,
+        },
+      );
+    }
+    
   cleanUp();
   process.exit(process.env.EXIT_CODE);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {
@@ -30,6 +30,7 @@
     "dayjs": "1.11.13",
     "deasync": "^0.1.31",
     "playwright": "^1.58.2",
+    "proper-lockfile": "^4.1.2",
     "rimraf": "6.0.1"
   },
   "repository": {

package/src/helper/executers/helper.js

@@ -54,6 +54,9 @@ function showHelp() {
       
             🌐 --env           Set environment for the test run
                 Usage:   artes --env "dev"
+
+            --saveVar         Set variables from cli
+                        artes --saveVar '{"armud":20,"banana":200}'
       
             🕶️ --headless      Run browser in headless mode
                 Usage:   artes --headless

package/src/helper/executers/projectCreator.js

@@ -47,6 +47,7 @@ function createProject(createYes, noDeps) {
 
     // Configuration options:
     // env: "",                      // string - Environment name for tests
+    // variables: {}                 // object - Variables for tests
     // testPercentage: 0,            // number - Minimum success rate percentage(Default: 0)
     // baseURL: "",                  // string - Base URL for API tests
     // paths: [],                    // string[] - Paths to feature files
@@ -56,6 +57,7 @@ function createProject(createYes, noDeps) {
     // slowMo: 0,                    // number - Slow down test execution (Default: 0 seconds)
     // parallel: 0,                  // number - Number of parallel workers
     // report: true                  // boolean - Generate report
+    // zip: false                    // boolean - Generate zip of report
     // reportSuccess: false,         // boolean - Add screenshots and video records to report also for success test cases
     // trace: false,                 // boolean - Enable tracing
     // reportWithTrace: false,       // boolean - Include trace in report

package/src/helper/executers/reportGenerator.js

@@ -58,7 +58,7 @@ function generateReport() {
 
       require("deasync").loopWhile(() => !done);
 
-      console.log(`🗜️ Zipped in ${moduleConfig.projectPath}/report.zip!`);
+      console.log(`🗜️ Zipped in ${path.join( path.dirname(moduleConfig.reportPath),  "report.zip" )}!`);
       if (error) throw error;
     }
   } catch (err) {

package/src/helper/imports/commons.js

@@ -35,7 +35,7 @@ const moduleConfig = {
   stepsPath: path.join(projectPath, "/tests/steps/*.js"),
   pomPath: path.join(projectPath, "/tests/POMs"),
   cleanUpPaths:
-    "allure-result allure-results test-results @rerun.txt testsStatus EXIT_CODE.txt pomDuplicateWarnings.json",
+    "allure-result allure-results test-results @rerun.txt testsStatus pomDuplicateWarnings.json",
 };
 
 module.exports = {

package/src/hooks/hooks.js

@@ -8,18 +8,16 @@ const {
   BeforeStep,
   AfterAll,
 } = require("@cucumber/cucumber");
-const { spawnSync } = require("child_process");
 const { invokeBrowser } = require("../helper/contextManager/browserManager");
 const { invokeRequest } = require("../helper/contextManager/requestManager");
 const {
-  pomCollector,
-  logPomWarnings,
+  pomCollector
 } = require("../helper/controller/pomCollector");
 const cucumberConfig = require("../../cucumber.config");
 const { context } = require("./context");
 const fs = require("fs");
 const path = require("path");
-const { moduleConfig } = require("artes/src/helper/imports/commons");
+const { moduleConfig, saveVar } = require("artes/src/helper/imports/commons");
 require("allure-cucumberjs");
 const allure = require("allure-js-commons");
 
@@ -44,11 +42,26 @@ async function attachResponse(attachFn) {
 }
 
 function saveTestStatus(result, pickle) {
+
   fs.mkdirSync(statusDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(statusDir, `${result.status}-${pickle.id}.txt`),
-    "",
-  );
+  
+   const now = new Date();
+   const YYYY = now.getFullYear();
+   const MM = String(now.getMonth() + 1).padStart(2, '0');
+   const DD = String(now.getDate()).padStart(2, '0');
+   const hh = String(now.getHours()).padStart(2, '0');
+   const mm = String(now.getMinutes()).padStart(2, '0');
+   const ss = String(now.getSeconds()).padStart(2, '0');
+   const ms = String(now.getMilliseconds()).padStart(3, '0');
+
+   const timestamp = `${YYYY}${MM}${DD}-${hh}${mm}${ss}-${ms}`;
+
+   const fileName = `${result.status}-${pickle.name}-${pickle.id}-${timestamp}.txt`;
+
+   const filePath = path.join(statusDir, fileName);
+
+  fs.writeFileSync(filePath, "");
+
 }
 
 const projectHooksPath = path.resolve(
@@ -78,9 +91,18 @@ BeforeAll(async () => {
   pomCollector();
 });
 
-Before(async function () {
+Before(async function ({pickle}) {
   context.vars = {};
 
+  const vars = await cucumberConfig.variables
+
+  if (vars && typeof vars === "object") {
+    for (let [key, value] of Object.entries(vars)) {
+
+       saveVar(value, key);
+    }
+  }
+
   const envFilePath = path.join(
     moduleConfig.projectPath,
     "tests",
@@ -110,6 +132,7 @@ Before(async function () {
 
   if (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) {
     await browserContext.tracing.start({
+      title: pickle.name,
       sources: true,
       screenshots: true,
       snapshots: true,
@@ -141,7 +164,7 @@ AfterStep(async function ({ pickleStep }) {
   }
 });
 
-After(async function ({ pickle, result }) {
+After(async function ({result, pickle}) {
   if (typeof projectHooks.After === "function") {
     await projectHooks.After();
   }
@@ -155,12 +178,12 @@ After(async function ({ pickle, result }) {
     await allure.attachment("Screenshot", screenshotBuffer, "image/png");
   }
 
-  saveTestStatus(result, pickle);
+  if(cucumberConfig.default.testPercentage>0) saveTestStatus(result, pickle);
 
   if (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) {
     var tracePath = path.join(
       moduleConfig.projectPath,
-      `./traces/${pickle.name.replaceAll(" ", "_")}.zip`,
+      `./traces/${pickle.name.replaceAll(" ", "_")}-${pickle.id}.zip`,
     );
   }
 
@@ -211,55 +234,4 @@ AfterAll(async () => {
     await projectHooks.AfterAll();
   }
 
-  logPomWarnings();
-
-  if (!cucumberConfig.default.trace) {
-    spawnSync(
-      "npx",
-      [
-        "rimraf",
-        "--no-glob",
-        path.join(moduleConfig.projectPath, "./traces"),
-      ],
-      {
-        cwd: moduleConfig.projectPath,
-        stdio: "inherit",
-        shell: false,
-      },
-    );
-  }
-
-  if (!fs.existsSync(statusDir)) return;
-
-  const files = fs.readdirSync(statusDir);
-  const passedCount = files.filter((f) => f.split("-")[0] === "PASSED").length;
-  const totalTests = files.length;
-  const successPercentage = (passedCount / totalTests) * 100;
-
-  const failed = files.filter((f) => f.split("-")[0] === "FAILED").length;
-
-  if (failed > 0) {
-    spawnSync("mv", ["@rerun.txt", moduleConfig.projectPath], {
-      cwd: path.join(moduleConfig.projectPath, "node_modules", "artes"),
-      stdio: "ignore",
-      shell: true,
-    });
-  }
-
-  if (cucumberConfig.default.testPercentage > 0) {
-    const meetsThreshold =
-      successPercentage >= cucumberConfig.default.testPercentage;
-
-    if (meetsThreshold) {
-      console.log(
-        `✅ Tests passed required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}%!`,
-      );
-      fs.writeFileSync(path.join(process.cwd(), "EXIT_CODE.txt"), "0");
-    } else {
-      console.log(
-        `❌ Tests failed required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}%!`,
-      );
-      fs.writeFileSync(path.join(process.cwd(), "EXIT_CODE.txt"), "1");
-    }
-  }
 });

package/src/stepDefinitions/assertions.steps.js

@@ -15,41 +15,81 @@ Then("User expects {string} should be attached", async function (selector) {
   await assert.shouldBeAttached(selector);
 });
 
+Then("User expects {int} th of {string} should be attached", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeAttached(nthElement);
+});
+
 // Check if a selector should be checked
 Then("User expects {string} should be checked", async function (selector) {
   await assert.shouldBeChecked(selector);
 });
 
+Then("User expects {int} th of {string} should be checked", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeChecked(nthElement);
+});
+
 // Check if a selector should be disabled
 Then("User expects {string} should be disabled", async function (selector) {
   await assert.shouldBeDisabled(selector);
 });
 
+Then("User expects {int} th of {string} should be disabled", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeDisabled(nthElement);
+});
+
 // Check if a selector should be editable
 Then("User expects {string} should be editable", async function (selector) {
   await assert.shouldBeEditable(selector);
 });
 
+Then("User expects {int} th of {string} should be editable", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeEditable(nthElement);
+});
+
 // Check if a selector should be empty
 Then("User expects {string} should be empty", async function (selector) {
   await assert.shouldBeEmpty(selector);
 });
 
+Then("User expects {int} th of {string} should be empty", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeEmpty(nthElement);
+});
+
 // Check if a selector should be enabled
 Then("User expects {string} should be enabled", async function (selector) {
   await assert.shouldBeEnabled(selector);
 });
 
+Then("User expects {int} th of {string} should be enabled", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeEnabled(nthElement);
+});
+
 // Check if a selector should be focused
 Then("User expects {string} should be focused", async function (selector) {
   await assert.shouldBeFocused(selector);
 });
 
+Then("User expects {int} th of {string} should be focused", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeFocused(nthElement);
+});
+
 // Check if a selector should be hidden
 Then("User expects {string} should be hidden", async function (selector) {
   await assert.shouldBeHidden(selector);
 });
 
+Then("User expects {int} th of {string} should be hidden", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeHidden(nthElement);
+});
+
 // Check if a selector should be in the viewport
 Then(
   "User expects {string} should be on the screen",
@@ -58,11 +98,29 @@ Then(
   },
 );
 
+Then(
+  "User expects {int} th of {string} should be on the screen",
+  async function (order, elements) {
+    const nthElement = await frame.nth(elements, order);
+    await assert.shouldBeInViewport(nthElement);
+  },
+);
+
+Then("User expects {int} th of {string} should be screen", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeInViewport(nthElement);
+});
+
 // Check if a selector should be visible
 Then("User expects {string} should be visible", async function (selector) {
   await assert.shouldBeVisible(selector);
 });
 
+Then("User expects {int} th of {string} should be visible", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldBeVisible(nthElement);
+});
+
 // Check if a selector should contain specific text
 Then(
   "User expects {string} should have {string} text",
@@ -71,6 +129,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} text", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldContainText(nthElement, text);
+});
+
 Then(
   "User expects default value of {string} should have {string} text",
   async (selector, text) => {
@@ -79,6 +142,11 @@ Then(
   },
 );
 
+Then("User expects default value of {int} th of {string} should have {string} text", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.toContain(nthElement, text);
+});
+
 Then(
   "User expects multiple {string} should have {string} text",
   async (elements, expectedText) => {
@@ -94,6 +162,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} description", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveAccessibleDescription(nthElement, text);
+});
+
 // Check if a selector should have an accessible name
 Then(
   "User expects {string} should have {string} name",
@@ -102,6 +175,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} name", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveAccessibleName(nthElement, text);
+});
+
 // Check if a selector should have a specific attribute with a given value
 Then(
   "User expects {string} should have {string} attribute with {string} value",
@@ -110,6 +188,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} attribute with {string} value", async function (order, elements, attribute, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveAttribute(nthElement, attribute, value);
+});
+
 // Check if a selector should have a specific class
 Then(
   "User expects {string} should have {string} class",
@@ -118,6 +201,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} class", async function (order, elements, className) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveClass(nthElement, className);
+});
+
 // Check if a selector should have a specific count
 Then(
   "User expects count of {string} should be {int}",
@@ -134,6 +222,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} CSS property with {string} value", async function (order, elements, property, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveCSS(nthElement, property, value);
+});
+
 // Check if a selector should have a specific id
 Then(
   "User expects {string} should have {string} id",
@@ -142,6 +235,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} id", async function (order, elements, id) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveId(nthElement, id);
+});
+
 // Check if a selector should have a specific JavaScript property with a given value
 Then(
   "User expects {string} should have {string} JavaScript property with {string} value",
@@ -150,6 +248,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} JavaScript property with {string} value", async function (order, elements, property, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveJSProperty(nthElement, property, value);
+});
+
 // Check if a selector should have a specific role
 Then(
   "User expects {string} should have {string} role",
@@ -158,6 +261,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} role", async function (order, elements, role) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveId(nthElement, role);
+});
+
 // Check if a selector should have a screenshot
 Then(
   "User expects {string} should have a screenshot",
@@ -174,6 +282,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should match {string} text", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveText(nthElement, text);
+});
+
 // Check if a selector should have a specific value
 Then(
   "User expects {string} should have {string} value",
@@ -182,6 +295,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} value", async function (order, elements, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldHaveValue(nthElement, value);
+});
+
 // Check if a selector should have specific values
 Then(
   "User expects {string} should have {string} values",
@@ -209,64 +327,115 @@ Then("User expects to be in {string} page", async function (url) {
   await assert.shouldPageHaveURL(URL);
 });
 
-// Check if the response should be OK
-Then("The response should be OK", async function (response) {
-  await assert.shouldResponseBeOK(response);
-});
-
 // Check if a selector should not be attached
 Then("User expects {string} should not be attached", async function (selector) {
   await assert.shouldNotBeAttached(selector);
 });
 
+Then("User expects {int} th of {string} should be not be attached", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeAttached(nthElement);
+});
+
 // Check if a selector should not be checked
 Then("User expects {string} should not be checked", async function (selector) {
   await assert.shouldNotBeChecked(selector);
 });
 
+Then("User expects {int} th of {string} should be not be checked", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeChecked(nthElement);
+});
+
 // Check if a selector should not be disabled
 Then("User expects {string} should not be disabled", async function (selector) {
   await assert.shouldNotBeDisabled(selector);
 });
 
+Then("User expects {int} th of {string} should be not be disabled", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeDisabled(nthElement);
+});
+
 // Check if a selector should not be editable
 Then("User expects {string} should not be editable", async function (selector) {
   await assert.shouldNotBeEditable(selector);
 });
 
+Then("User expects {int} th of {string} should be not be editable", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeEditable(nthElement);
+});
+
 // Check if a selector should not be empty
 Then("User expects {string} should not be empty", async function (selector) {
   await assert.shouldNotBeEmpty(selector);
 });
 
+Then("User expects {int} th of {string} should be not be empty", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeEmpty(nthElement);
+});
+
 // Check if a selector should not be enabled
 Then("User expects {string} should not be enabled", async function (selector) {
   await assert.shouldNotBeEnabled(selector);
 });
 
+Then("User expects {int} th of {string} should be not be enabled", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeEnabled(nthElement);
+});
+
 // Check if a selector should not be focused
 Then("User expects {string} should not be focused", async function (selector) {
   await assert.shouldNotBeFocused(selector);
 });
 
+Then("User expects {int} th of {string} should be not be focused", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeFocused(nthElement);
+});
+
 // Check if a selector should not be hidden
 Then("User expects {string} should not be hidden", async function (selector) {
   await assert.shouldNotBeHidden(selector);
 });
 
+Then("User expects {int} th of {string} should be not be hidden", async function (order, elements) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotBeHidden(nthElement);
+});
+
 // Check if a selector should not be in the viewport
 Then(
-  "User expects {string} should not be on screen",
+  "User expects {string} should not be on the screen",
   async function (selector) {
     await assert.shouldNotBeInViewport(selector);
   },
 );
 
+Then(
+  "User expects {int} th of {string} should not be on the screen",
+  async function (order, elements) {
+    const nthElement = await frame.nth(elements, order);
+    await assert.shouldNotBeInViewport(nthElement);
+  },
+);
+
 // Check if a selector should not be visible
 Then("User expects {string} should not be visible", async function (selector) {
   await assert.shouldNotBeVisible(selector);
 });
 
+Then(
+  "User expects {int} th of {string} should not be visible",
+  async function (order, elements) {
+    const nthElement = await frame.nth(elements, order);
+    await assert.shouldNotBeVisible(nthElement);
+  },
+);
+
 // Check if a selector should not contain specific text
 Then(
   "User expects {string} should not have {string} text",
@@ -275,6 +444,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} text", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotContainText(nthElement, text);
+});
+
 // Check if a selector should not have an accessible description
 Then(
   "User expects {string} should not have {string} description",
@@ -283,6 +457,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} description", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveAccessibleDescription(nthElement, text);
+});
+
 // Check if a selector should not have an accessible name
 Then(
   "User expects {string} should not have {string} name",
@@ -291,6 +470,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} name", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveAccessibleName(nthElement, text);
+});
+
 // Check if a selector should not have a specific attribute with a given value
 Then(
   "User expects {string} should not have {string} attribute with {string} value",
@@ -299,6 +483,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should have {string} attribute with {string} value", async function (order, elements, attribute, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveAttribute(nthElement, attribute, value);
+});
+
 // Check if a selector should not have a specific class
 Then(
   "User expects {string} should not have {string} class",
@@ -307,6 +496,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} class", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveClass(nthElement, text);
+});
+
 // Check if a selector should not have a specific count
 Then(
   "User expects count of {string} should not be {int}",
@@ -323,6 +517,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} CSS property with {string} value", async function (order, elements, property, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveCSS(nthElement, property, value);
+});
+
 // Check if a selector should not have a specific ID
 Then(
   "User expects {string} should not have {string} id",
@@ -331,6 +530,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} id", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveId(nthElement, text);
+});
+
 // Check if a selector should not have a specific JavaScript property with a given value
 Then(
   "User expects {string} should not have {string} JavaScript property with {string} value",
@@ -339,6 +543,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} JavaScript property with {string} value", async function (order, elements, property, value) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveJSProperty(nthElement, property, value);
+});
+
 // Check if a selector should not have a specific role
 Then(
   "User expects {string} should not have {string} role",
@@ -347,6 +556,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} role", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveRole(nthElement, text);
+});
+
 // Check if a selector should not have specific text
 Then(
   "User expects {string} should not match {string} text",
@@ -355,6 +569,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} text", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveText(nthElement, text);
+});
+
 // Check if a selector should not have a specific value
 Then(
   "User expects {string} should not have {string} value",
@@ -363,6 +582,11 @@ Then(
   },
 );
 
+Then("User expects {int} th of {string} should not have {string} value", async function (order, elements, text) {
+  const nthElement = await frame.nth(elements, order);
+  await assert.shouldNotHaveValue(nthElement, text);
+});
+
 // Check if a selector should not have specific values
 Then(
   "User expects {string} should not have {string} values",

package/src/stepDefinitions/mouseActions.steps.js

@@ -3,6 +3,7 @@ const {
   element,
   selector,
   context,
+ resolveVariable
 } = require("../helper/imports/commons");
 const { mouse, frame, page } = require("../helper/stepFunctions/exporter");
 
@@ -39,6 +40,8 @@ When("User clicks {string} with force", async function (selector) {
 When(
   "User clicks {string} at {int}, {int} position",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.click(selector, { position: { x: x, y: y } });
   },
 );
@@ -47,12 +50,16 @@ When(
 When(
   "User clicks {string} at {int}, {int} position with force",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.click(selector, { force: true, position: { x: x, y: y } });
   },
 );
 
 // User clicks at specific coordinates
 When("User clicks at {int}, {int} coordinates", async function (x, y) {
+  x = await resolveVariable(x)
+  y = await resolveVariable(y)
   await context.page.click({ position: { x: x, y: y } });
 });
 
@@ -60,6 +67,8 @@ When("User clicks at {int}, {int} coordinates", async function (x, y) {
 When(
   "User clicks at {int}, {int} coordinates with click count {int} and delay {int}",
   async function (x, y, clickCount, delay) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await context.page.click({
       position: { x: x, y: y },
       clickCount: clickCount,
@@ -72,6 +81,8 @@ When(
 When(
   "User clicks at {int}, {int} coordinates with force",
   async function (x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     context.page.click({ position: { x: x, y: y }, force: true });
   },
 );
@@ -139,6 +150,8 @@ When("User double clicks {string} with force", async function (selector) {
 When(
   "User double clicks {string} at {int}, {int} position",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.doubleClick(selector, { position: { x: x, y: y } });
   },
 );
@@ -147,6 +160,8 @@ When(
 When(
   "User double clicks {string} at {int}, {int} position with force",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.doubleClick(selector, {
       position: { x: x, y: y },
       force: true,
@@ -156,6 +171,8 @@ When(
 
 // User double clicks at specific coordinates
 When("User double clicks at {int}, {int} coordinates", async function (x, y) {
+  x = await resolveVariable(x)
+  y = await resolveVariable(y)
   await context.page.doubleClick({ position: { x: x, y: y } });
 });
 
@@ -163,6 +180,8 @@ When("User double clicks at {int}, {int} coordinates", async function (x, y) {
 When(
   "User double clicks at {int}, {int}  coordinates with click count {int} and delay {int}",
   async function (x, y, clickCount, delay) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await context.page.doubleClick({
       position: { x: x, y: y },
       clickCount: clickCount,
@@ -175,12 +194,16 @@ When(
 When(
   "User double clicks at {int}, {int} coordinates  with force",
   async function (x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await context.page.doubleClick({ position: { x: x, y: y }, force: true });
   },
 );
 
 // User moves the mouse to specific coordinates
 When("User moves to {int}, {int} coordinates", async function (x, y) {
+  x = await resolveVariable(x)
+  y = await resolveVariable(y)
   await context.page.move({ position: { x: x, y: y } });
 });
 
@@ -188,6 +211,8 @@ When("User moves to {int}, {int} coordinates", async function (x, y) {
 When(
   "User scrolls the mouse wheel at {int}, {int} coordinates",
   async function (x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await context.page.wheel({ position: { x: x, y: y } });
   },
 );
@@ -206,6 +231,8 @@ When("User hovers over {string} with force", async function (selector) {
 When(
   "User hovers over {string} at {int}, {int} position",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.hover(selector, { position: { x: x, y: y } });
   },
 );
@@ -214,6 +241,8 @@ When(
 When(
   "User hovers over {string} at {int}, {int} position with force",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.hover(selector, { position: { x: x, y: y }, force: true });
   },
 );
@@ -232,6 +261,8 @@ When("User focuses on {string} with force", async function (selector) {
 When(
   "User focuses on {string} at {int}, {int} position",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.focus(selector, { position: { x: x, y: y } });
   },
 );
@@ -240,6 +271,8 @@ When(
 When(
   "User focuses on {string} at {int}, {int} position with force",
   async function (selector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.focus(selector, { position: { x: x, y: y }, force: true });
   },
 );
@@ -256,6 +289,8 @@ When(
 When(
   "User drags {string} to {int}, {int} position",
   async function (sourceSelector, x, y) {
+    x = await resolveVariable(x)
+    y = await resolveVariable(y)
     await mouse.dragAndDrop(sourceSelector, { position: { x: x, y: y } });
   },
 );