artes 1.0.10 → 1.0.12

package/README.md

@@ -265,26 +265,26 @@ Then("User should see the login form", async () => {
 
 You can configure Artes by editing the `artes.config.js` file. Below are the default configuration options with explanations:
 
-| **Option**       | **Default Value**                                    | **Description**                         |
-| ---------------- | ---------------------------------------------------- | --------------------------------------- |
-| `headless`       | `true`                                               | Run in headless browser mode.           |
-| `paths`          | `["tests/features/"]`                                | Array of paths to feature files.        |
-| `pomPath`        | `"tests/POMs/*.json"`                                | Path to Page Object Models.             |
-| `require`        | `"tests/steps/*.js"`                                 | Array of support code paths (CommonJS). |
-| `parallel`       | `1`                                                  | Number of parallel workers.             |
-| `tags`           | `""`                                                 | Tag expression to filter scenarios.     |
-| `language`       | `"en"`                                               | Default language for feature files.     |
-| `order`          | `"defined"`                                          | Run order (defined or random).          |
-| `dryRun`         | `false`                                              | Prepare test run without execution.     |
-| `failFast`       | `false`                                              | Stop on first failure.                  |
-| `forceExit`      | `false`                                              | Force `process.exit()` after tests.     |
-| `retry`          | `0`                                                  | Retry attempts for failing tests.       |
-| `retryTagFilter` | `""`                                                 | Tag expression for retries.             |
-| `strict`         | `true`                                               | Fail on pending steps.                  |
-| `backtrace`      | `false`                                              | Show full backtrace for errors.         |
-| `format`         | `["rerun:@rerun.txt", "allure-cucumberjs/reporter"]` | Array of formatter names/paths.         |
-| `formatOptions`  | `{ "resultsDir": "allure-result" }`                  | Formatter options.                      |
-| `publish`        | `false`                                              | Publish results to `cucumber.io`.       |
+| **Option**       | **Default Value**                                    | **Description**                     |
+| ---------------- | ---------------------------------------------------- | ----------------------------------- |
+| `headless`       | `true`                                               | Run in headless browser mode.       |
+| `paths`          | `["tests/features/"]`                                | Array of paths to feature files.    |
+| `pomPath`        | `"tests/POMs/*.json"`                                | Path to Page Object Models.         |
+| `steps`          | `"tests/steps/*.js"`                                 | string - Step definitions files.    |
+| `format`         | `["rerun:@rerun.txt", "allure-cucumberjs/reporter"]` | Array of formatter names/paths.     |
+| `formatOptions`  | `{ "resultsDir": "allure-result" }`                  | Formatter options.                  |
+| `parallel`       | `1`                                                  | Number of parallel workers.         |
+| `tags`           | `""`                                                 | Tag expression to filter scenarios. |
+| `language`       | `"en"`                                               | Default language for feature files. |
+| `order`          | `"defined"`                                          | Run order (defined or random).      |
+| `dryRun`         | `false`                                              | Prepare test run without execution. |
+| `failFast`       | `false`                                              | Stop on first failure.              |
+| `forceExit`      | `false`                                              | Force `process.exit()` after tests. |
+| `retry`          | `0`                                                  | Retry attempts for failing tests.   |
+| `retryTagFilter` | `""`                                                 | Tag expression for retries.         |
+| `strict`         | `true`                                               | Fail on pending steps.              |
+| `backtrace`      | `false`                                              | Show full backtrace for errors.     |
+| `publish`        | `false`                                              | Publish results to `cucumber.io`.   |
 
 ---
 

package/cucumber.config.js

@@ -17,7 +17,7 @@ try {
 module.exports = {
   default: {
     // File paths and patterns
-    cucumberTimeout: artesConfig.cucumberTimeout || 30, // Default timeout in milliseconds
+    cucumberTimeout: artesConfig.timeout || 30, // Default timeout in milliseconds
     paths: artesConfig.features
       ? path.join(moduleConfig.projectPath, artesConfig.features)
       : [moduleConfig.featuresPath], // Paths to feature files
@@ -43,7 +43,7 @@ module.exports = {
     }, // Formatter options
 
     // Execution options
-    parallel: artesConfig.parallel || 0, // Number of parallel workers
+    parallel: artesConfig.parallel || 1, // Number of parallel workers
     dryRun: artesConfig.dryRun || false, // Prepare test run without execution
     failFast: artesConfig.failFast || false, // Stop on first test failure
     forceExit: artesConfig.forceExit || false, // Force process.exit() after tests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "The package provide step definitions and user writes feature files, and the package handles automation, with optional POM files and custom step definitions.",
   "main": "index.js",
   "scripts": {

package/src/hooks/hooks.js

@@ -19,9 +19,6 @@ let request;
 setDefaultTimeout(cucumberConfig.default.cucumberTimeout * 1000);
 
 BeforeAll(async function () {
-  browser = await invokeBrowser();
-  request = await invokeRequest();
-
   pomCollector();
 
   //  browser.tracing.start({
@@ -32,6 +29,8 @@ BeforeAll(async function () {
 });
 
 Before(async function () {
+  browser = await invokeBrowser();
+  request = await invokeRequest();
   context.page = await browser.newPage();
   context.request = await request;
 });
@@ -48,6 +47,8 @@ After(async function ({ pickle, result }) {
   }
 
   await context.page.close();
+  await browser.close();
+
   // await browser.tracing.stop({ path: 'trace.zip' });
   if (result?.status != Status.PASSED) {
     const videoPath = await context.page.video().path();
@@ -56,6 +57,4 @@ After(async function ({ pickle, result }) {
   }
 });
 
-AfterAll(function () {
-  browser.close();
-});
+AfterAll(function () {});

package/src/tests/stepDefinitions/assertions.steps.js

@@ -2,768 +2,792 @@ const { Then } = require("../../helper/imports/commons");
 const { assert } = require("../../helper/stepFunctions/exporter");
 
 // Check if a selector should be attached
-Then("User expects {string} should be attached", function (selector) {
-  assert.shouldBeAttached(selector);
+Then("User expects {string} should be attached", async function (selector) {
+  await assert.shouldBeAttached(selector);
 });
 
 // Check if a selector should be checked
-Then("User expects {string} should be checked", function (selector) {
-  assert.shouldBeChecked(selector);
+Then("User expects {string} should be checked", async function (selector) {
+  await assert.shouldBeChecked(selector);
 });
 
 // Check if a selector should be disabled
-Then("User expects {string} should be disabled", function (selector) {
-  assert.shouldBeDisabled(selector);
+Then("User expects {string} should be disabled", async function (selector) {
+  await assert.shouldBeDisabled(selector);
 });
 
 // Check if a selector should be editable
-Then("User expects {string} should be editable", function (selector) {
-  assert.shouldBeEditable(selector);
+Then("User expects {string} should be editable", async function (selector) {
+  await assert.shouldBeEditable(selector);
 });
 
 // Check if a selector should be empty
-Then("User expects {string} should be empty", function (selector) {
-  assert.shouldBeEmpty(selector);
+Then("User expects {string} should be empty", async function (selector) {
+  await assert.shouldBeEmpty(selector);
 });
 
 // Check if a selector should be enabled
-Then("User expects {string} should be enabled", function (selector) {
-  assert.shouldBeEnabled(selector);
+Then("User expects {string} should be enabled", async function (selector) {
+  await assert.shouldBeEnabled(selector);
 });
 
 // Check if a selector should be focused
-Then("User expects {string} should be focused", function (selector) {
-  assert.shouldBeFocused(selector);
+Then("User expects {string} should be focused", async function (selector) {
+  await assert.shouldBeFocused(selector);
 });
 
 // Check if a selector should be hidden
-Then("User expects {string} should be hidden", function (selector) {
-  assert.shouldBeHidden(selector);
+Then("User expects {string} should be hidden", async function (selector) {
+  await assert.shouldBeHidden(selector);
 });
 
 // Check if a selector should be in the viewport
-Then("User expects {string} should be on the screen", function (selector) {
-  assert.shouldBeInViewport(selector);
-});
+Then(
+  "User expects {string} should be on the screen",
+  async function (selector) {
+    await assert.shouldBeInViewport(selector);
+  },
+);
 
 // Check if a selector should be visible
-Then("User expects {string} should be visible", function (selector) {
-  assert.shouldBeVisible(selector);
+Then("User expects {string} should be visible", async function (selector) {
+  await assert.shouldBeVisible(selector);
 });
 
 // Check if a selector should contain specific text
 Then(
   "User expects {string} should have {string} text",
-  function (selector, text) {
-    assert.shouldContainText(selector, text);
+  async function (selector, text) {
+    await assert.shouldContainText(selector, text);
   },
 );
 
 // Check if a selector should have an accessible description
 Then(
   "User expects {string} should have {string} description",
-  function (selector, description) {
-    assert.shouldHaveAccessibleDescription(selector, description);
+  async function (selector, description) {
+    await assert.shouldHaveAccessibleDescription(selector, description);
   },
 );
 
 // Check if a selector should have an accessible name
 Then(
   "User expects {string} should have {string} name",
-  function (selector, name) {
-    assert.shouldHaveAccessibleName(selector, name);
+  async function (selector, name) {
+    await assert.shouldHaveAccessibleName(selector, name);
   },
 );
 
 // Check if a selector should have a specific attribute with a given value
 Then(
   "User expects {string} should have {string} attribute with {string} value",
-  function (selector, attribute, value) {
-    assert.shouldHaveAttribute(selector, attribute, value);
+  async function (selector, attribute, value) {
+    await assert.shouldHaveAttribute(selector, attribute, value);
   },
 );
 
 // Check if a selector should have a specific class
 Then(
   "User expects {string} should have {string} class",
-  function (selector, className) {
-    assert.shouldHaveClass(selector, className);
+  async function (selector, className) {
+    await assert.shouldHaveClass(selector, className);
   },
 );
 
 // Check if a selector should have a specific count
 Then(
   "User expects count of {string} should be {int}",
-  function (selector, count) {
-    assert.shouldHaveCount(selector, count);
+  async function (selector, count) {
+    await assert.shouldHaveCount(selector, count);
   },
 );
 
 // Check if a selector should have a specific CSS property with a given value
 Then(
   "User expects {string} should have {string} CSS property with {string} value",
-  function (selector, property, value) {
-    assert.shouldHaveCSS(selector, property, value);
+  async function (selector, property, value) {
+    await assert.shouldHaveCSS(selector, property, value);
   },
 );
 
 // Check if a selector should have a specific id
-Then("User expects {string} should have {string} id", function (selector, id) {
-  assert.shouldHaveId(selector, id);
-});
+Then(
+  "User expects {string} should have {string} id",
+  async function (selector, id) {
+    await assert.shouldHaveId(selector, 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",
-  function (selector, property, value) {
-    assert.shouldHaveJSProperty(selector, property, value);
+  async function (selector, property, value) {
+    await assert.shouldHaveJSProperty(selector, property, value);
   },
 );
 
 // Check if a selector should have a specific role
 Then(
   "User expects {string} should have {string} role",
-  function (selector, role) {
-    assert.shouldHaveRole(selector, role);
+  async function (selector, role) {
+    await assert.shouldHaveRole(selector, role);
   },
 );
 
 // Check if a selector should have a screenshot
-Then("User expects {string} should have a screenshot", function (selector) {
-  assert.shouldHaveScreenshot(selector);
-});
+Then(
+  "User expects {string} should have a screenshot",
+  async function (selector) {
+    await assert.shouldHaveScreenshot(selector);
+  },
+);
 
 // Check if a selector should have specific text
 Then(
   "User expects {string} should match {string} text",
-  function (selector, text) {
-    assert.shouldHaveText(selector, text);
+  async function (selector, text) {
+    await assert.shouldHaveText(selector, text);
   },
 );
 
 // Check if a selector should have a specific value
 Then(
   "User expects {string} should have {string} value",
-  function (selector, value) {
-    assert.shouldHaveValue(selector, value);
+  async function (selector, value) {
+    await assert.shouldHaveValue(selector, value);
   },
 );
 
 // Check if a selector should have specific values
 Then(
   "User expects {string} should have {string} values",
-  function (selector, values) {
-    assert.shouldHaveValues(selector, values.split(","));
+  async function (selector, values) {
+    await assert.shouldHaveValues(selector, values.split(","));
   },
 );
 
 // Check if the page should have a screenshot
-Then("User expects the page should have a screenshot", function () {
-  assert.shouldPageHaveScreenshot();
+Then("User expects the page should have a screenshot", async function () {
+  await assert.shouldPageHaveScreenshot();
 });
 
 // Check if the page should have a specific title
-Then("User expects the page should have {string} title", function (title) {
-  assert.shouldPageHaveTitle(title);
-});
+Then(
+  "User expects the page should have {string} title",
+  async function (title) {
+    await assert.shouldPageHaveTitle(title);
+  },
+);
 
 // Check if the page should have a specific URL
-Then("User expects the page url should be {string}", function (url) {
-  assert.shouldPageHaveURL(url);
+Then("User expects the page url should be {string}", async function (url) {
+  await assert.shouldPageHaveURL(url);
 });
 
-Then("User is on {string} page", function (url) {
-  assert.shouldPageHaveURL(url);
+Then("User is on {string} page", async function (url) {
+  await assert.shouldPageHaveURL(url);
 });
 
 // Check if the response should be OK
-Then("The response should be OK", function (response) {
-  assert.shouldResponseBeOK(response);
+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", function (selector) {
-  assert.shouldNotBeAttached(selector);
+Then("User expects {string} should not be attached", async function (selector) {
+  await assert.shouldNotBeAttached(selector);
 });
 
 // Check if a selector should not be checked
-Then("User expects {string} should not be checked", function (selector) {
-  assert.shouldNotBeChecked(selector);
+Then("User expects {string} should not be checked", async function (selector) {
+  await assert.shouldNotBeChecked(selector);
 });
 
 // Check if a selector should not be disabled
-Then("User expects {string} should not be disabled", function (selector) {
-  assert.shouldNotBeDisabled(selector);
+Then("User expects {string} should not be disabled", async function (selector) {
+  await assert.shouldNotBeDisabled(selector);
 });
 
 // Check if a selector should not be editable
-Then("User expects {string} should not be editable", function (selector) {
-  assert.shouldNotBeEditable(selector);
+Then("User expects {string} should not be editable", async function (selector) {
+  await assert.shouldNotBeEditable(selector);
 });
 
 // Check if a selector should not be empty
-Then("User expects {string} should not be empty", function (selector) {
-  assert.shouldNotBeEmpty(selector);
+Then("User expects {string} should not be empty", async function (selector) {
+  await assert.shouldNotBeEmpty(selector);
 });
 
 // Check if a selector should not be enabled
-Then("User expects {string} should not be enabled", function (selector) {
-  assert.shouldNotBeEnabled(selector);
+Then("User expects {string} should not be enabled", async function (selector) {
+  await assert.shouldNotBeEnabled(selector);
 });
 
 // Check if a selector should not be focused
-Then("User expects {string} should not be focused", function (selector) {
-  assert.shouldNotBeFocused(selector);
+Then("User expects {string} should not be focused", async function (selector) {
+  await assert.shouldNotBeFocused(selector);
 });
 
 // Check if a selector should not be hidden
-Then("User expects {string} should not be hidden", function (selector) {
-  assert.shouldNotBeHidden(selector);
+Then("User expects {string} should not be hidden", async function (selector) {
+  await assert.shouldNotBeHidden(selector);
 });
 
 // Check if a selector should not be in the viewport
-Then("User expects {string} should not be on screen", function (selector) {
-  assert.shouldNotBeInViewport(selector);
-});
+Then(
+  "User expects {string} should not be on screen",
+  async function (selector) {
+    await assert.shouldNotBeInViewport(selector);
+  },
+);
 
 // Check if a selector should not be visible
-Then("User expects {string} should not be visible", function (selector) {
-  assert.shouldNotBeVisible(selector);
+Then("User expects {string} should not be visible", async function (selector) {
+  await assert.shouldNotBeVisible(selector);
 });
 
 // Check if a selector should not contain specific text
 Then(
   "User expects {string} should not have {string} text",
-  function (selector, text) {
-    assert.shouldNotContainText(selector, text);
+  async function (selector, text) {
+    await assert.shouldNotContainText(selector, text);
   },
 );
 
 // Check if a selector should not have an accessible description
 Then(
   "User expects {string} should not have {string} description",
-  function (selector, description) {
-    assert.shouldNotHaveAccessibleDescription(selector, description);
+  async function (selector, description) {
+    await assert.shouldNotHaveAccessibleDescription(selector, description);
   },
 );
 
 // Check if a selector should not have an accessible name
 Then(
   "User expects {string} should not have {string} name",
-  function (selector, name) {
-    assert.shouldNotHaveAccessibleName(selector, name);
+  async function (selector, name) {
+    await assert.shouldNotHaveAccessibleName(selector, name);
   },
 );
 
 // 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",
-  function (selector, attribute, value) {
-    assert.shouldNotHaveAttribute(selector, attribute, value);
+  async function (selector, attribute, value) {
+    await assert.shouldNotHaveAttribute(selector, attribute, value);
   },
 );
 
 // Check if a selector should not have a specific class
 Then(
   "User expects {string} should not have {string} class",
-  function (selector, className) {
-    assert.shouldNotHaveClass(selector, className);
+  async function (selector, className) {
+    await assert.shouldNotHaveClass(selector, className);
   },
 );
 
 // Check if a selector should not have a specific count
 Then(
   "User expects count of {string} should not be {int}",
-  function (selector, count) {
-    assert.shouldNotHaveCount(selector, count);
+  async function (selector, count) {
+    await assert.shouldNotHaveCount(selector, count);
   },
 );
 
 // Check if a selector should not have a specific CSS property with a given value
 Then(
   "User expects {string} should not have {string} CSS property with {string} value",
-  function (selector, property, value) {
-    assert.shouldNotHaveCSS(selector, property, value);
+  async function (selector, property, value) {
+    await assert.shouldNotHaveCSS(selector, property, value);
   },
 );
 
 // Check if a selector should not have a specific ID
 Then(
   "User expects {string} should not have {string} id",
-  function (selector, id) {
-    assert.shouldNotHaveId(selector, id);
+  async function (selector, id) {
+    await assert.shouldNotHaveId(selector, id);
   },
 );
 
 // 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",
-  function (selector, property, value) {
-    assert.shouldNotHaveJSProperty(selector, property, value);
+  async function (selector, property, value) {
+    await assert.shouldNotHaveJSProperty(selector, property, value);
   },
 );
 
 // Check if a selector should not have a specific role
 Then(
   "User expects {string} should not have {string} role",
-  function (selector, role) {
-    assert.shouldNotHaveRole(selector, role);
+  async function (selector, role) {
+    await assert.shouldNotHaveRole(selector, role);
   },
 );
 
 // Check if a selector should not have specific text
 Then(
   "User expects {string} should not match {string} text",
-  function (selector, text) {
-    assert.shouldNotHaveText(selector, text);
+  async function (selector, text) {
+    await assert.shouldNotHaveText(selector, text);
   },
 );
 
 // Check if a selector should not have a specific value
 Then(
   "User expects {string} should not have {string} value",
-  function (selector, value) {
-    assert.shouldNotHaveValue(selector, value);
+  async function (selector, value) {
+    await assert.shouldNotHaveValue(selector, value);
   },
 );
 
 // Check if a selector should not have specific values
 Then(
   "User expects {string} should not have {string} values",
-  function (selector, values) {
-    assert.shouldNotHaveValues(selector, values.split(","));
+  async function (selector, values) {
+    await assert.shouldNotHaveValues(selector, values.split(","));
   },
 );
 
 // Check if the page should not have a screenshot
-Then("User expects the page should not have a screenshot", function () {
-  assert.shouldNotPageHaveScreenshot();
+Then("User expects the page should not have a screenshot", async function () {
+  await assert.shouldNotPageHaveScreenshot();
 });
 
 // Check if the page should not have a specific title
-Then("User expects the page should not have {string} title", function (title) {
-  assert.shouldNotPageHaveTitle(title);
-});
+Then(
+  "User expects the page should not have {string} title",
+  async function (title) {
+    await assert.shouldNotPageHaveTitle(title);
+  },
+);
 
 // Check if the page should not have a specific URL
-Then("User expects the page url should not be {string}", function (url) {
-  assert.shouldNotPageHaveURL(url);
+Then("User expects the page url should not be {string}", async function (url) {
+  await assert.shouldNotPageHaveURL(url);
 });
 
-Then("User is not on {string} page", function (url) {
-  assert.shouldNotPageHaveURL(url);
+Then("User is not on {string} page", async function (url) {
+  await assert.shouldNotPageHaveURL(url);
 });
 
 // Check if a response should not be OK
-Then("The response should not be OK", function (response) {
-  assert.shouldNotResponseBeOK(response);
+Then("The response should not be OK", async function (response) {
+  await assert.shouldNotResponseBeOK(response);
 });
 
 // Check if a selector's value should be equal to the expected value
 Then(
   "User expects {string} should be {string} text",
-  function (selector, expected) {
-    assert.shouldBe(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldBe(selector, expected);
   },
 );
 
 // Check if a selector's value should be close to the expected value within a precision
 Then(
   "User expects {string} should be close to {float} with precision {int}",
-  function (selector, expected, precision) {
-    assert.shouldBeCloseTo(selector, expected, precision);
+  async function (selector, expected, precision) {
+    await assert.shouldBeCloseTo(selector, expected, precision);
   },
 );
 
 // Check if a selector's value should be defined
-Then("User expects {string} should be defined", function (selector) {
-  assert.shouldBeDefined(selector);
+Then("User expects {string} should be defined", async function (selector) {
+  await assert.shouldBeDefined(selector);
 });
 
 // Check if a selector's text content should be falsy
-Then("User expects {string} should be falsy", function (selector) {
-  assert.shouldBeFalsy(selector);
+Then("User expects {string} should be falsy", async function (selector) {
+  await assert.shouldBeFalsy(selector);
 });
 
 // Check if a selector's value should be greater than the expected value
 Then(
   "User expects {string} should be greater than {float}",
-  function (selector, expected) {
-    assert.shouldBeGreaterThan(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldBeGreaterThan(selector, expected);
   },
 );
 
 // Check if a selector's value should be greater than or equal to the expected value
 Then(
   "User expects {string} should be greater than or equal to {float}",
-  function (selector, expected) {
-    assert.shouldBeGreaterThanOrEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldBeGreaterThanOrEqual(selector, expected);
   },
 );
 
 // Check if a selector's value should be an instance of a specific constructor
 Then(
   "User expects {string} should be an instance of {string}",
-  function (selector, constructor) {
-    assert.shouldBeInstanceOf(selector, constructor);
+  async function (selector, constructor) {
+    await assert.shouldBeInstanceOf(selector, constructor);
   },
 );
 
 // Check if a selector's value should be less than the expected value
 Then(
   "User expects {string} should be less than {float}",
-  function (selector, expected) {
-    assert.shouldBeLessThan(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldBeLessThan(selector, expected);
   },
 );
 
 // Check if a selector's value should be less than or equal to the expected value
 Then(
   "User expects {string} should be less than or equal to {float}",
-  function (selector, expected) {
-    assert.shouldBeLessThanOrEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldBeLessThanOrEqual(selector, expected);
   },
 );
 
 // Check if a selector's value should be NaN
-Then("User expects {string} should be NaN", function (selector) {
-  assert.shouldBeNaN(selector);
+Then("User expects {string} should be NaN", async function (selector) {
+  await assert.shouldBeNaN(selector);
 });
 
 // Check if a selector's value should be null
-Then("User expects {string} should be null", function (selector) {
-  assert.shouldBeNull(selector);
+Then("User expects {string} should be null", async function (selector) {
+  await assert.shouldBeNull(selector);
 });
 
 // Check if a selector's value should be truthy
-Then("User expects {string} should be truthy", function (selector) {
-  assert.shouldBeTruthy(selector);
+Then("User expects {string} should be truthy", async function (selector) {
+  await assert.shouldBeTruthy(selector);
 });
 
 // Check if a selector's value should be undefined
-Then("User expects {string} should be undefined", function (selector) {
-  assert.shouldBeUndefined(selector);
+Then("User expects {string} should be undefined", async function (selector) {
+  await assert.shouldBeUndefined(selector);
 });
 
 // Check if a selector's value should contain a specific substring
 Then(
   "User expects {string} should have {string} substring",
-  function (selector, substring) {
-    assert.shouldContain(selector, substring);
+  async function (selector, substring) {
+    await assert.shouldContain(selector, substring);
   },
 );
 
 // Check if a selector's value should contain an equal value
 Then(
   "User expects {string} should contain equal {string}",
-  function (selector, expected) {
-    assert.shouldContainEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldContainEqual(selector, expected);
   },
 );
 
 // Check if a selector's value should equal the expected value
-Then("User expects {string} should equal {int}", function (selector, expected) {
-  assert.shouldEqual(selector, expected);
-});
+Then(
+  "User expects {string} should equal {int}",
+  async function (selector, expected) {
+    await assert.shouldEqual(selector, expected);
+  },
+);
 
 // Check if a selector's text content should have a specific length
 Then(
   "User expects length of {string} should be {int}",
-  function (selector, length) {
-    assert.shouldHaveLength(selector, length);
+  async function (selector, length) {
+    await assert.shouldHaveLength(selector, length);
   },
 );
 
 // Check if a selector's text content should have a specific property
 Then(
   "User expects {string} should have {string} property",
-  function (selector, property) {
-    assert.shouldHaveProperty(selector, property);
+  async function (selector, property) {
+    await assert.shouldHaveProperty(selector, property);
   },
 );
 
 // Check if a selector's text content should match a specific regex
 Then(
   "User expects {string} should match {string} regex",
-  function (selector, regex) {
-    assert.shouldMatch(selector, new RegExp(regex));
+  async function (selector, regex) {
+    await assert.shouldMatch(selector, new RegExp(regex));
   },
 );
 
 // Check if a selector's text content should match a specific object
 Then(
   "User expects {string} should match {string} object",
-  function (selector, object) {
-    assert.shouldMatchObject(selector, JSON.parse(object));
+  async function (selector, object) {
+    await assert.shouldMatchObject(selector, JSON.parse(object));
   },
 );
 
 // Check if a selector's text content should strictly equal the expected value
 Then(
   "User expects {string} should strictly equal {string}",
-  function (selector, expected) {
-    assert.shouldStrictEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldStrictEqual(selector, expected);
   },
 );
 
-// Check if a function should throw an error
-Then("The function should throw", function (fn) {
-  assert.shouldThrow(fn);
+// Check if a async function should throw an error
+Then("The async function should throw", async function (fn) {
+  await assert.shouldThrow(fn);
 });
 
 // Check if the text content of a selector should be an instance of a specific constructor
 Then(
   "User expects {string} should be any instance of {string}",
-  function (selector, constructor) {
-    assert.shouldAny(selector, constructor);
+  async function (selector, constructor) {
+    await assert.shouldAny(selector, constructor);
   },
 );
 
 // Check if the text content of a selector may be anything (truthy)
-Then("User expects {string} may be anything", function (selector) {
-  assert.shouldAnything(selector);
+Then("User expects {string} may be anything", async function (selector) {
+  await assert.shouldAnything(selector);
 });
 
 // Check if the text content of a selector should contain any of the specified elements in an array
 Then(
   "User expects {string} should contain {string} array elements",
-  function (selector, elements) {
+  async function (selector, elements) {
     const parsedElements = elements.split(",");
-    assert.shouldArrayContaining(selector, parsedElements);
+    await assert.shouldArrayContaining(selector, parsedElements);
   },
 );
 
 // Check if the text content of a selector should be close to the expected value within a precision
 Then(
   "User expects {string} should be close to {float} with precision {int}",
-  function (selector, expected, precision) {
-    assert.shouldCloseTo(selector, expected, precision);
+  async function (selector, expected, precision) {
+    await assert.shouldCloseTo(selector, expected, precision);
   },
 );
 
 // Check if the text content of a selector should contain the specified properties in an object
 Then(
   "User expects {string} should contain {string} object properties",
-  function (selector, properties) {
+  async function (selector, properties) {
     const parsedProperties = properties.split(",");
-    assert.shouldObjectContaining(selector, parsedProperties);
+    await assert.shouldObjectContaining(selector, parsedProperties);
   },
 );
 
 // Check if the text content of a selector should contain a specific substring
 Then(
   "User expects {string} should have {string} substring",
-  function (selector, substring) {
-    assert.shouldStringContaining(selector, substring);
+  async function (selector, substring) {
+    await assert.shouldStringContaining(selector, substring);
   },
 );
 
 // Check if the text content of a selector should match a specific regex
 Then(
   "User expects {string} should match {string} regex",
-  function (selector, regex) {
-    assert.shouldStringMatching(selector, new RegExp(regex));
+  async function (selector, regex) {
+    await assert.shouldStringMatching(selector, new RegExp(regex));
   },
 );
 
 // Check if a selector's text content should not be equal to the expected value
 Then(
-  "User expects {string} should not have {string} text",
-  function (selector, expected) {
-    assert.shouldNotBe(selector, expected);
+  "User expects {string} should not be {string} text",
+  async function (selector, expected) {
+    await assert.shouldNotBe(selector, expected);
   },
 );
 
 // Check if a selector's text content should not be close to the expected value within a precision
 Then(
   "User expects {string} should not be close to {float} with precision {int}",
-  function (selector, expected, precision) {
-    assert.shouldNotBeCloseTo(selector, expected, precision);
+  async function (selector, expected, precision) {
+    await assert.shouldNotBeCloseTo(selector, expected, precision);
   },
 );
 
 // Check if a selector's text content should not be defined
-Then("User expects {string} should not be defined", function (selector) {
-  assert.shouldNotBeDefined(selector);
+Then("User expects {string} should not be defined", async function (selector) {
+  await assert.shouldNotBeDefined(selector);
 });
 
 // Check if a selector's text content should not be falsy
-Then("User expects {string} should not be falsy", function (selector) {
-  assert.shouldNotBeFalsy(selector);
+Then("User expects {string} should not be falsy", async function (selector) {
+  await assert.shouldNotBeFalsy(selector);
 });
 
 // Check if a selector's text content should not be greater than the expected value
 Then(
   "User expects {string} should not be greater than {float}",
-  function (selector, expected) {
-    assert.shouldNotBeGreaterThan(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotBeGreaterThan(selector, expected);
   },
 );
 
 // Check if a selector's text content should not be greater than or equal to the expected value
 Then(
   "User expects {string} should not be greater than or equal to {float}",
-  function (selector, expected) {
-    assert.shouldNotBeGreaterThanOrEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotBeGreaterThanOrEqual(selector, expected);
   },
 );
 
 // Check if a selector's text content should not be an instance of a specific constructor
 Then(
   "User expects {string} should not be an instance of {string}",
-  function (selector, constructor) {
-    assert.shouldNotBeInstanceOf(selector, constructor);
+  async function (selector, constructor) {
+    await assert.shouldNotBeInstanceOf(selector, constructor);
   },
 );
 
 // Check if a selector's text content should not be less than the expected value
 Then(
   "User expects {string} should not be less than {float}",
-  function (selector, expected) {
-    assert.shouldNotBeLessThan(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotBeLessThan(selector, expected);
   },
 );
 
 // Check if a selector's text content should not be less than or equal to the expected value
 Then(
   "User expects {string} should not be less than or equal to {float}",
-  function (selector, expected) {
-    assert.shouldNotBeLessThanOrEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotBeLessThanOrEqual(selector, expected);
   },
 );
 
 // Check if a selector's text content should not be NaN
-Then("User expects {string} should not be NaN", function (selector) {
-  assert.shouldNotBeNaN(selector);
+Then("User expects {string} should not be NaN", async function (selector) {
+  await assert.shouldNotBeNaN(selector);
 });
 
 // Check if a selector's text content should not be null
-Then("User expects {string} should not be null", function (selector) {
-  assert.shouldNotBeNull(selector);
+Then("User expects {string} should not be null", async function (selector) {
+  await assert.shouldNotBeNull(selector);
 });
 
 // Check if a selector's text content should not be truthy
-Then("User expects {string} should not be truthy", function (selector) {
-  assert.shouldNotBeTruthy(selector);
+Then("User expects {string} should not be truthy", async function (selector) {
+  await assert.shouldNotBeTruthy(selector);
 });
 
 // Check if a selector's text content should not be undefined
-Then("User expects {string} should not be undefined", function (selector) {
-  assert.shouldNotBeUndefined(selector);
-});
+Then(
+  "User expects {string} should not be undefined",
+  async function (selector) {
+    await assert.shouldNotBeUndefined(selector);
+  },
+);
 
 // Check if a selector's text content should not contain a specific substring
 Then(
   "User expects {string} should not have {string} substring",
-  function (selector, substring) {
-    assert.shouldNotContain(selector, substring);
+  async function (selector, substring) {
+    await assert.shouldNotContain(selector, substring);
   },
 );
 
 // Check if a selector's text content should not contain an equal value
 Then(
   "User expects {string} should not contain equal {string}",
-  function (selector, expected) {
-    assert.shouldNotContainEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotContainEqual(selector, expected);
   },
 );
 
 // Check if a selector's text content should not equal the expected value
 Then(
   "User expects {string} should not equal {string}",
-  function (selector, expected) {
-    assert.shouldNotEqual(selector, expected);
+  async function (selector, expected) {
+    await assert.shouldNotEqual(selector, expected);
   },
 );
 
 // Check if a selector's text content should not have a specific length
 Then(
   "User expects length of {string} should not be {int} ",
-  function (selector, length) {
-    assert.shouldNotHaveLength(selector, length);
+  async function (selector, length) {
+    await assert.shouldNotHaveLength(selector, length);
   },
 );
 
 // Check if a selector's text content should not have a specific property
 Then(
   "User expects {string} should not have {string} property",
-  function (selector, property) {
-    assert.shouldNotHaveProperty(selector, property);
+  async function (selector, property) {
+    await assert.shouldNotHaveProperty(selector, property);
   },
 );
 
 // Check if a selector's text content should not match a specific regex
 Then(
   "User expects {string} should not match {string} regex",
-  function (selector, regex) {
-    assert.shouldNotMatch(selector, new RegExp(regex));
+  async function (selector, regex) {
+    await assert.shouldNotMatch(selector, new RegExp(regex));
   },
 );
 
 // Check if a selector's text content should not match a specific object
 Then(
   "User expects {string} should not match {string} object",
-  function (selector, object) {
-    assert.shouldNotMatchObject(selector, JSON.parse(object));
+  async function (selector, object) {
+    await assert.shouldNotMatchObject(selector, JSON.parse(object));
   },
 );
 
-// Check if a function should not throw an error
-Then("The function should not throw", function (fn) {
-  assert.shouldNotThrow(fn);
+// Check if a async function should not throw an error
+Then("The async function should not throw", async function (fn) {
+  await assert.shouldNotThrow(fn);
 });
 
 // Check if a selector's text content should not be any instance of a specific constructor
 Then(
   "User expects {string} should not be any instance of {string}",
-  function (selector, constructor) {
-    assert.shouldNotAny(selector, constructor);
+  async function (selector, constructor) {
+    await assert.shouldNotAny(selector, constructor);
   },
 );
 
 // Check if a selector's text content may not be anything (falsy)
-Then("User expects {string} may not be anything", function (selector) {
-  assert.shouldNotAnything(selector);
+Then("User expects {string} may not be anything", async function (selector) {
+  await assert.shouldNotAnything(selector);
 });
 
 // Check if a selector's text content should not contain any of the specified elements in an array
 Then(
   "User expects {string} should not contain {string} array elements",
-  function (selector, elements) {
+  async function (selector, elements) {
     const parsedElements = elements.split(",");
-    assert.shouldNotArrayContaining(selector, parsedElements);
+    await assert.shouldNotArrayContaining(selector, parsedElements);
   },
 );
 
 // Check if a selector's text content should not be close to the expected value within a precision
 Then(
   "User expects {string} should not be close to {float} with precision {int}",
-  function (selector, expected, precision) {
-    assert.shouldNotCloseTo(selector, expected, precision);
+  async function (selector, expected, precision) {
+    await assert.shouldNotCloseTo(selector, expected, precision);
   },
 );
 
 // Check if a selector's text content should not contain the specified properties in an object
 Then(
   "User expects {string} should not contain {string} object properties",
-  function (selector, properties) {
+  async function (selector, properties) {
     const parsedProperties = JSON.parse(properties);
-    assert.shouldNotObjectContaining(selector, parsedProperties);
+    await assert.shouldNotObjectContaining(selector, parsedProperties);
   },
 );
 
 // Check if a selector's text content should not contain a specific substring
 Then(
   "User expects {string} should not contain {string} substring",
-  function (selector, substring) {
-    assert.shouldNotStringContaining(selector, substring);
+  async function (selector, substring) {
+    await assert.shouldNotStringContaining(selector, substring);
   },
 );
 
 // Check if a selector's text content should not match a specific regex
 Then(
   "User expects {string} should not match {string} regex",
-  function (selector, regex) {
-    assert.shouldNotStringMatching(selector, new RegExp(regex));
+  async function (selector, regex) {
+    await assert.shouldNotStringMatching(selector, new RegExp(regex));
   },
 );

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "cSpell.words": ["artes"]
-}