artes 1.4.3 → 1.4.4

package/package.json

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

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/hooks/hooks.js

@@ -78,7 +78,7 @@ BeforeAll(async () => {
   pomCollector();
 });
 
-Before(async function () {
+Before(async function ({pickle}) {
   context.vars = {};
 
   const envFilePath = path.join(
@@ -110,6 +110,7 @@ Before(async function () {
 
   if (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) {
     await browserContext.tracing.start({
+      title: pickle.name,
       sources: true,
       screenshots: true,
       snapshots: true,

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 } });
   },
 );