artes 1.0.0

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

@@ -0,0 +1,76 @@
+const { When } = require("../../helper/imports/commons");
+const { frame } = require("../../helper/stepFunctions/actionCommons");
+
+// User takes a screenshot of a specific selector
+When("User takes a screenshot of {string}", async function (selector) {
+  await frame.screenshot(selector);
+});
+
+// User gets the content frame of a specific selector
+When("User gets the content frame of {string}", async function (selector) {
+  await frame.contentFrame(selector);
+});
+
+// User gets the frame locator of a specific selector
+When("User gets the frame locator of {string}", async function (selector) {
+  await frame.frameLocator(selector);
+});
+
+// User gets the nth element of a specific selector
+When(
+  "User gets the {int}th element of {string}",
+  async function (index, selector) {
+    await frame.nth(selector, index);
+  },
+);
+
+// User gets the first element of a specific selector
+When("User gets the first element of {string}", async function (selector) {
+  await frame.first(selector);
+});
+
+// User gets the last element of a specific selector
+When("User gets the last element of {string}", async function (selector) {
+  await frame.last(selector);
+});
+
+// User filters elements of a specific selector
+When(
+  "User filters elements of {string} with filter {string}",
+  async function (selector, filter) {
+    await frame.filter(selector, filter);
+  },
+);
+
+// User counts the number of elements of a specific selector
+When("User counts the elements of {string}", async function (selector) {
+  await frame.count(selector);
+});
+
+// User gets an element by its alt text
+When("User gets the element with alt text {string}", async function (text) {
+  await frame.getByAltText(text);
+});
+
+// User gets an element by its label
+When("User gets the element with label {string}", async function (label) {
+  await frame.getByLabel(label);
+});
+
+// User gets an element by its placeholder
+When(
+  "User gets the element with placeholder {string}",
+  async function (placeholder) {
+    await frame.getByPlaceholder(placeholder);
+  },
+);
+
+// User gets an element by its role
+When("User gets the element with role {string}", async function (role) {
+  await frame.getByRole(role);
+});
+
+// User gets an element by its testId
+When("User gets the element with testId {string}", async function (testId) {
+  await frame.getByTestId(testId);
+});

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

@@ -0,0 +1,72 @@
+const { When } = require("../../helper/imports/commons");
+const { keyboard } = require("../../helper/stepFunctions/actionCommons");
+
+// User presses a key on a specific selector
+When("User presses {string} on {string}", async function (key, selector) {
+  await keyboard.press(selector, key);
+});
+
+// User presses keys sequentially on a specific selector
+When(
+  "User presses keys {string} sequentially on {string}",
+  async function (keys, selector) {
+    await keyboard.pressSequentially(selector, keys);
+  },
+);
+
+// User presses keys sequentially with a delay on a specific selector
+When(
+  "User presses keys {string} sequentially with delay {int} on {string}",
+  async function (keys, delay, selector) {
+    await keyboard.pressSequentiallyDelay(selector, keys, delay);
+  },
+);
+
+// User fills a value into a specific selector
+When("User types {string} in {string}", async function (value, selector) {
+  await keyboard.fill(selector, value);
+});
+
+// User clears the input of a specific selector
+When("User clears {string}", async function (selector) {
+  await keyboard.clear(selector);
+});
+
+// User selects text in a specific selector
+When("User selects text in {string}", async function (selector) {
+  await keyboard.selectText(selector);
+});
+
+// User sets input files for a specific selector
+When(
+  "User sets input files {string} for {string}",
+  async function (files, selector) {
+    const fileArray = files.split(","); // Assuming files are comma-separated
+    await keyboard.setInputFiles(selector, fileArray);
+  },
+);
+
+// User presses a key down
+When("User holds down {string}", async function (key) {
+  await keyboard.keyDown(key);
+});
+
+// User releases a key
+When("User releases {string}", async function (key) {
+  await keyboard.keyUp(key);
+});
+
+// User inserts text
+When("User inserts text {string}", async function (text) {
+  await keyboard.insertText(text);
+});
+
+// User presses a key
+When("User presses {string}", async function (key) {
+  await keyboard.keyboardPress(key);
+});
+
+// User types a key with a delay
+When("User types {string} with delay {int}", async function (key, delay) {
+  await keyboard.keyboardType(key, delay);
+});

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

@@ -0,0 +1,224 @@
+const { When } = require("../../helper/imports/commons");
+const { mouse } = require("../../helper/stepFunctions/actionCommons");
+
+// User clicks on a selector
+When("User clicks {string}", async function (selector) {
+  await mouse.click(selector);
+});
+
+// User clicks on a selector with force
+When("User clicks {string} with force", async function (selector) {
+  await mouse.click(selector, true);
+});
+
+// User clicks on a selector at a specific position
+When(
+  "User clicks {string} at {int}, {int} position",
+  async function (selector, x, y) {
+    await mouse.clickPosition(selector, x, y);
+  },
+);
+
+// User clicks on a selector at a specific position with force
+When(
+  "User clicks {string} at {int}, {int} position with force",
+  async function (selector, x, y) {
+    await mouse.clickPosition(selector, x, y, true);
+  },
+);
+
+// User clicks at specific coordinates
+When("User clicks at {int}, {int} coordinates", async function (x, y) {
+  await mouse.mouseClickPosition(x, y);
+});
+
+// User clicks at specific coordinates with click count and delay
+When(
+  "User clicks at {int}, {int} coordinates with click count {int} and delay {int}",
+  async function (x, y, clickCount, delay) {
+    await mouse.mouseClickPosition(x, y, clickCount, delay);
+  },
+);
+
+// User clicks at specific coordinates with force
+When(
+  "User clicks at {int}, {int} coordinates with force",
+  async function (x, y) {
+    await mouse.mouseClickPosition(x, y, 1, 0, true); // Defaulting clickCount and delay
+  },
+);
+
+// User clicks on a selector with a specific mouse button
+When(
+  "User clicks {string} with button {string}",
+  async function (selector, button) {
+    await mouse.clickByBtn(selector, button);
+  },
+);
+
+// User clicks on a selector with a specific mouse button and force
+When(
+  "User clicks {string} with button {string} and force",
+  async function (selector, button) {
+    await mouse.clickByBtn(selector, button, true);
+  },
+);
+
+// User double clicks on a selector
+When("User double clicks {string}", async function (selector) {
+  await mouse.doubleClick(selector);
+});
+
+// User double clicks on a selector with force
+When("User double clicks {string} with force", async function (selector) {
+  await mouse.doubleClick(selector, true);
+});
+
+// User double clicks on a selector at a specific position
+When(
+  "User double clicks {string} at {int}, {int} position",
+  async function (selector, x, y) {
+    await mouse.doubleClickPosition(selector, x, y);
+  },
+);
+
+// User double clicks on a selector at a specific position with force
+When(
+  "User double clicks {string} at {int}, {int} position with force",
+  async function (selector, x, y) {
+    await mouse.doubleClickPosition(selector, x, y, true);
+  },
+);
+
+// User double clicks at specific coordinates
+When("User double clicks at {int}, {int} coordinates", async function (x, y) {
+  await mouse.mouseDoubleClickPosition(x, y);
+});
+
+// User double clicks at specific coordinates with click count and delay
+When(
+  "User double clicks at {int}, {int}  coordinates with click count {int} and delay {int}",
+  async function (x, y, clickCount, delay) {
+    await mouse.mouseDoubleClickPosition(x, y, clickCount, delay);
+  },
+);
+
+// User double clicks at specific coordinates with force
+When(
+  "User double clicks at {int}, {int} coordinates  with force",
+  async function (x, y) {
+    await mouse.mouseDoubleClickPosition(x, y, 1, 0, true); // Defaulting clickCount and delay
+  },
+);
+
+// User moves the mouse to specific coordinates
+When("User moves to {int}, {int} coordinates", async function (x, y) {
+  await mouse.move(x, y);
+});
+
+// User scrolls the mouse wheel at specific coordinates
+When(
+  "User scrolls the mouse wheel at {int}, {int} coordinates",
+  async function (x, y) {
+    await mouse.wheel(x, y);
+  },
+);
+
+// User hovers over a selector
+When("User hovers over {string}", async function (selector) {
+  await mouse.hover(selector);
+});
+
+// User hovers over a selector with force
+When("User hovers over {string} with force", async function (selector) {
+  await mouse.hover(selector, true);
+});
+
+// User hovers over a selector at a specific position
+When(
+  "User hovers over {string} at {int}, {int} position",
+  async function (selector, x, y) {
+    await mouse.hoverPosition(selector, x, y);
+  },
+);
+
+// User hovers over a selector at a specific position with force
+When(
+  "User hovers over {string} at {int}, {int} position with force",
+  async function (selector, x, y) {
+    await mouse.hoverPosition(selector, x, y, true);
+  },
+);
+
+// User focuses on a selector
+When("User focuses on {string}", async function (selector) {
+  await mouse.focus(selector);
+});
+
+// User focuses on a selector with force
+When("User focuses on {string} with force", async function (selector) {
+  await mouse.focus(selector, true);
+});
+
+// User focuses on a selector at a specific position
+When(
+  "User focuses on {string} at {int}, {int} position",
+  async function (selector, x, y) {
+    await mouse.focusPosition(selector, x, y);
+  },
+);
+
+// User focuses on a selector at a specific position with force
+When(
+  "User focuses on {string} at {int}, {int} position with force",
+  async function (selector, x, y) {
+    await mouse.focusPosition(selector, x, y, true);
+  },
+);
+
+// User drags an element from one selector to another
+When(
+  "User drags {string} to {string}",
+  async function (sourceSelector, targetSelector) {
+    await mouse.dragAndDrop(sourceSelector, targetSelector);
+  },
+);
+
+// User drags an element to a specific position
+When(
+  "User drags {string} to {int}, {int} position",
+  async function (sourceSelector, x, y) {
+    await mouse.dragAndDropPosition(sourceSelector, x, y);
+  },
+);
+
+// User selects options by value
+When(
+  "User selects by value {string} from {string}",
+  async function (value, selector) {
+    await mouse.selectByValue(selector, value);
+  },
+);
+
+// User selects an option by text
+When(
+  "User selects by text {string} from {string}",
+  async function (text, selector) {
+    await mouse.selectByText(selector, text);
+  },
+);
+
+// User checks a checkbox or radio button
+When("User checks {string}", async function (selector) {
+  await mouse.check(selector);
+});
+
+// User unchecks a checkbox or radio button
+When("User unchecks {string}", async function (selector) {
+  await mouse.uncheck(selector);
+});
+
+// User scrolls into view if needed for a selector
+When("User scrolls {string} into view", async function (selector) {
+  await mouse.scrollIntoViewIfNeeded(selector);
+});

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

@@ -0,0 +1,30 @@
+const { When, context } = require("../../helper/imports/commons");
+const { page } = require("../../helper/stepFunctions/actionCommons");
+
+When("User navigates to {string} page", async function (url) {
+  await page.navigateTo(url);
+});
+
+// When("User is on {string} page", async function (url) {
+//   await page.navigateTo(url);
+// });
+
+When("User gets URL of page", async function () {
+  await page.getURL();
+});
+
+When("User gets URL of page", async function () {
+  await page.getURL();
+});
+
+When(`User waits {int} seconds`, async (sec) => {
+  await context.page.waitForTimeout(sec * 1000);
+});
+
+When(`User waits {int} milliseconds`, async (sec) => {
+  await context.page.waitForTimeout(sec);
+});
+
+When(`User waits {int} minutes`, async (sec) => {
+  await context.page.waitForTimeout(sec * 1000 * 60);
+});

package/stepDefinitions.md

@@ -0,0 +1,267 @@
+# Step Definitions
+
+## Table of Contents
+
+- [Mouse Actions](#mouse-actions)
+- [Keyboard Actions](#keyboard-actions)
+- [Page Actions](#page-actions)
+- [Frame Actions](#frame-actions)
+- [Assertions](#assertions)
+
+---
+
+## Mouse Actions
+
+### Click Actions
+
+- User clicks `{string}`
+- User clicks `{string}` with force
+- User clicks `{string}` at `{int}, {int}` position
+- User clicks `{string}` at `{int}, {int}` position with force
+- User clicks at `{int}, {int}` coordinates
+- User clicks at `{int}, {int}` coordinates with click count `{int}` and delay `{int}`
+- User clicks at `{int}, {int}` coordinates with force
+- User clicks `{string}` with button `{string}`
+- User clicks `{string}` with button `{string}` and force
+
+### Double Click Actions
+
+- User double clicks `{string}`
+- User double clicks `{string}` with force
+- User double clicks `{string}` at `{int}, {int}` position
+- User double clicks `{string}` at `{int}, {int}` position with force
+- User double clicks at `{int}, {int}` coordinates
+- User double clicks at `{int}, {int}` coordinates with click count `{int}` and delay `{int}`
+- User double clicks at `{int}, {int}` coordinates with force
+
+### Mouse Movement Actions
+
+- User moves to `{int}, {int}` coordinates
+- User scrolls the mouse wheel at `{int}, {int}` coordinates
+
+### Hover Actions
+
+- User hovers over `{string}`
+- User hovers over `{string}` with force
+- User hovers over `{string}` at `{int}, {int}` position
+- User hovers over `{string}` at `{int}, {int}` position with force
+
+### Focus Actions
+
+- User focuses on `{string}`
+- User focuses on `{string}` with force
+- User focuses on `{string}` at `{int}, {int}` position
+- User focuses on `{string}` at `{int}, {int}` position with force
+
+### Drag Actions
+
+- User drags `{string}` to `{string}`
+- User drags `{string}` to `{int}, {int}` position
+
+### Selection Actions
+
+- User selects by value `{string}` from `{string}`
+- User selects by text `{string}` from `{string}`
+
+### Checkbox Actions
+
+- User checks `{string}`
+- User unchecks `{string}`
+
+### Scroll Actions
+
+- User scrolls into view for `{string}`
+
+---
+
+## Keyboard Actions
+
+### Press Actions
+
+- User presses `{string} on {string}`
+- User presses keys `{string}` sequentially on `{string}`
+- User presses keys `{string}` sequentially with delay `{int} on {string}`
+
+### Input Actions
+
+- User types `{string}` in `{string}`
+- User types `{string}` with delay `{int}`
+- User inserts text `{string}`
+- User clears `{string}`
+
+### Selection Actions
+
+- User selects text in `{string}`
+
+### File Input Actions
+
+- User sets input files `{string}` for `{string}`
+
+### Key State Actions
+
+- User holds down `{string}`
+- User releases `{string}`
+- User presses `{string}`
+
+---
+
+## Page Actions
+
+### Navigation Actions
+
+- User navigates to `{string}` page
+
+### URL Actions
+
+- User gets URL of page
+
+### Wait Actions
+
+- User waits `{int}` seconds
+- User waits `{int}` milliseconds
+- User waits `{int}` minutes
+
+---
+
+## Frame Actions
+
+### Screenshot Actions
+
+- User takes a screenshot of `{string}`
+
+### Content and Locator Actions
+
+- User gets the content frame of `{string}`
+- User gets the frame locator of `{string}`
+
+### Element Retrieval Actions
+
+- User gets the `{int}th` element of `{string}`
+- User gets the first element of `{string}`
+- User gets the last element of `{string}`
+- User filters elements of `{string}` with filter `{string}`
+
+### Counting Actions
+
+- User counts the elements of `{string}`
+
+### Accessibility-Based Retrieval Actions
+
+- User gets the element with alt text `{string}`
+- User gets the element with label `{string}`
+- User gets the element with placeholder `{string}`
+- User gets the element with role `{string}`
+- User gets the element with testI `{string}`
+- User gets the element with testII `{string}`
+
+## Assertions
+
+- User expects `{string}` should be attached
+- User expects `{string}` should be checked
+- User expects `{string}` should be disabled
+- User expects `{string}` should be editable
+- User expects `{string}` should be empty
+- User expects `{string}` should be enabled
+- User expects `{string}` should be focused
+- User expects `{string}` should be hidden
+- User expects `{string}` should be on the screen
+- User expects `{string}` should be visible
+- User expects `{string}` should have `{string}` text
+- User expects `{string}` should have `{string}` description
+- User expects `{string}` should have `{string}` name
+- User expects `{string}` should have `{string}` attribute with `{string}` value
+- User expects `{string}` should have `{string}` class
+- User expects `{string}` should have `{int}` count
+- User expects `{string}` should have `{string}` CSS property with `{string}` value
+- User expects `{string}` should have `{string}` id
+- User expects `{string}` should have `{string}` JavaScript property with `{string}` value
+- User expects `{string}` should have `{string}` role
+- User expects `{string}` should have a screenshot
+- User expects `{string}` should match `{string}` text
+- User expects `{string}` should have `{string}` value
+- User expects `{string}` should have `{string}` values
+- User expects `{string}` should not be attached
+- User expects `{string}` should not be checked
+- User expects `{string}` should not be disabled
+- User expects `{string}` should not be editable
+- User expects `{string}` should not be empty
+- User expects `{string}` should not be enabled
+- User expects `{string}` should not be focused
+- User expects `{string}` should not be hidden
+- User expects `{string}` should not be on screen
+- User expects `{string}` should not be visible
+- User expects `{string}` should not have `{string}` text
+- User expects `{string}` should not have `{string}` description
+- User expects `{string}` should not have `{string}` name
+- User expects `{string}` should not have `{string}` attribute with `{string}` value
+- User expects `{string}` should not have `{string}` class
+- User expects count of `{string}` should not be `{int}`
+- User expects `{string}` should not have `{string}` CSS property with `{string}` value
+- User expects `{string}` should not have `{string}` id
+- User expects `{string}` should not have `{string}` JavaScript property with `{string}` value
+- User expects `{string}` should not have `{string}` role
+- User expects `{string}` should not match `{string}` text
+- User expects `{string}` should not have `{string}` value
+- User expects `{string}` should not have `{string}` values
+- User expects the page should not have a screenshot
+- User expects the page should not have `{string}` title
+- User expects the page url should not be `{string}`
+- User is not on `{string}` page
+- The response should not be OK
+- User expects `{string}` should be `{string}` text
+- User expects `{string}` should be close to `{float}` with precision `{int}`
+- User expects `{string}` should be defined
+- User expects `{string}` should be falsy
+- User expects `{string}` should be greater than `{float}`
+- User expects `{string}` should be greater than or equal to `{float}`
+- User expects `{string}` should be an instance of `{string}`
+- User expects `{string}` should be less than `{float}`
+- User expects `{string}` should be less than or equal to `{float}`
+- User expects `{string}` should be NaN
+- User expects `{string}` should be null
+- User expects `{string}` should be truthy
+- User expects `{string}` should be undefined
+- User expects `{string}` should have `{string}` substring
+- User expects `{string}` should contain equal `{string}`
+- User expects `{string}` should equal `{int}`
+- User expects length of `{string}` should be `{int}`
+- User expects `{string}` should have `{string}` property
+- User expects `{string}` should match `{string}` regex
+- User expects `{string}` should match `{string}` object
+- User expects `{string}` should strictly equal `{string}`
+- The function should throw
+- User expects `{string}` should be any instance of `{string}`
+- User expects `{string}` may be anything
+- User expects `{string}` should contain `{string}` array elements
+- User expects `{string}` should be close to `{float}` with precision `{int}`
+- User expects `{string}` should contain `{string}` object properties
+- User expects `{string}` should have `{string}` substring
+- User expects `{string}` should match `{string}` regex
+- User expects `{string}` should not have `{string}` text
+- User expects `{string}` should not be close to `{float}` with precision `{int}`
+- User expects `{string}` should not be defined
+- User expects `{string}` should not be falsy
+- User expects `{string}` should not be greater than `{float}`
+- User expects `{string}` should not be greater than or equal to `{float}`
+- User expects `{string}` should not be instance of `{string}`
+- User expects `{string}` should not be less than `{float}`
+- User expects `{string}` should not be less than or equal to `{float}`
+- User expects `{string}` should not be NaN
+- User expects `{string}` should not be null
+- User expects `{string}` should not be truthy
+- User expects `{string}` should not be undefined
+- User expects `{string}` should not have `{string}` substring
+- User expects `{string}` should not contain equal `{string}`
+- User expects `{string}` should not equal `{string}`
+- User expects length of `{string}` should not be `{int}`
+- User expects `{string}` should not have `{string}` property
+- User expects `{string}` should not match `{string}` regex
+- User expects `{string}` should not match `{string}` object
+- The function should not throw
+- User expects `{string}` should not be any instance of `{string}`
+- User expects `{string}` may not be anything
+- User expects `{string}` should not contain `{string}` array elements
+- User expects `{string}` should not be close to `{float}` with precision `{int}`
+- User expects `{string}` should not contain `{string}` object properties
+- User expects `{string}` should not contain `{string}` substring
+- User expects `{string}` should not match `{string}` regex