artes 1.2.18 → 1.2.20

package/src/stepDefinitions/API.steps.js

@@ -3,7 +3,8 @@ const {
   context,
   extractVarsFromResponse,
   saveVar,
-  time,random
+  time,
+  random,
 } = require("../helper/imports/commons");
 const { api } = require("../helper/stepFunctions/exporter");
 const Ajv = require("ajv");
@@ -16,7 +17,7 @@ When(
   "User sends GET request to {string} with payload:",
   async function (url, payload) {
     await api.get(url, payload);
-  }
+  },
 );
 
 When(
@@ -24,7 +25,7 @@ When(
   async function (url, vars) {
     await api.get(url);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
@@ -32,7 +33,7 @@ When(
   async function (url, vars, payload) {
     await api.get(url, payload);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When("User sends HEAD request to {string}", async function (url) {
@@ -43,7 +44,7 @@ When(
   "User sends POST request to {string} with payload:",
   async function (url, payload) {
     await api.post(url, payload);
-  }
+  },
 );
 
 When(
@@ -51,14 +52,14 @@ When(
   async function (url, vars, payload) {
     await api.post(url, payload);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends multipart POST request to {string} with payload:",
   async (url, payload) => {
     await api.post(url, payload, "multipart");
-  }
+  },
 );
 
 When(
@@ -66,14 +67,14 @@ When(
   async (url, vars, payload) => {
     await api.post(url, payload, "multipart");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends x-www-form-urlencoded POST request to {string} with payload:",
   async (url, payload) => {
     await api.post(url, payload, "application/x-www-form-urlencoded");
-  }
+  },
 );
 
 When(
@@ -81,14 +82,14 @@ When(
   async (url, vars, payload) => {
     await api.post(url, payload, "application/x-www-form-urlencoded");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends PUT request to {string} with payload:",
   async function (url, payload) {
     await api.put(url, payload);
-  }
+  },
 );
 
 When(
@@ -96,14 +97,14 @@ When(
   async function (url, vars, payload) {
     await api.put(url, payload);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends multipart PUT request to {string} with payload:",
   async function (url, payload) {
     await api.put(url, payload, "multipart");
-  }
+  },
 );
 
 When(
@@ -111,14 +112,14 @@ When(
   async function (url, vars, payload) {
     await api.put(url, payload, "multipart");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends x-www-form-urlencoded PUT request to {string} with payload:",
   async (url, payload) => {
     await api.put(url, payload, "application/x-www-form-urlencoded");
-  }
+  },
 );
 
 When(
@@ -126,14 +127,14 @@ When(
   async (url, vars, payload) => {
     await api.put(url, payload, "application/x-www-form-urlencoded");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends PATCH request to {string} with payload:",
   async function (url, payload) {
     await api.patch(url, payload);
-  }
+  },
 );
 
 When(
@@ -141,14 +142,14 @@ When(
   async function (url, vars, payload) {
     await api.patch(url, payload);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends multipart PATCH request to {string} with payload:",
   async function (url, payload) {
     await api.patch(url, payload, "multipart");
-  }
+  },
 );
 
 When(
@@ -156,14 +157,14 @@ When(
   async function (url, vars, payload) {
     await api.patch(url, payload, "multipart");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends x-www-form-urlencoded PATCH request to {string} with payload:",
-  async (url,  payload) => {
+  async (url, payload) => {
     await api.patch(url, payload, "application/x-www-form-urlencoded");
-  }
+  },
 );
 
 When(
@@ -171,7 +172,7 @@ When(
   async (url, vars, payload) => {
     await api.patch(url, payload, "application/x-www-form-urlencoded");
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When("User sends DELETE request to {string}", async function (url) {
@@ -183,14 +184,14 @@ When(
   async function (url, vars) {
     await api.delete(url);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
   "User sends DELETE request to {string} with payload:",
   async function (url, payload) {
     await api.delete(url, payload);
-  }
+  },
 );
 
 When(
@@ -198,7 +199,7 @@ When(
   async function (url, vars, payload) {
     await api.delete(url, payload);
     await extractVarsFromResponse(context.response["Response Body"], vars);
-  }
+  },
 );
 
 When(
@@ -209,14 +210,14 @@ When(
       vars,
       customVarName,
     );
-  }
+  },
 );
 
 When(
   "User saves {string} variable as {string}",
   async function (value, customVarName) {
     saveVar(value, customVarName);
-  }
+  },
 );
 
 When("User wants to see saved variables", async function () {
@@ -267,7 +268,7 @@ When(
       default:
         throw new Error(`Unsupported HTTP method: ${httpMethod}`);
     }
-  }
+  },
 );
 
 When(
@@ -286,7 +287,6 @@ When(
   },
 );
 
-
 When(
   "User sets {string} date {int} days from today",
   async function (dateName, days) {
@@ -297,4 +297,4 @@ When(
 
     context.vars[dateName] = expiresAt;
   },
-);
+);

package/src/stepDefinitions/assertions.steps.js

@@ -826,31 +826,33 @@ Then(
   },
 );
 
-Then('User expects that {string} should match {string}', async (value1, value2) => {
-  await expect(resolveVariable(value1)).toBe(value2)
-})
+Then(
+  "User expects that {string} should match {string}",
+  async (value1, value2) => {
+    await expect(resolveVariable(value1)).toBe(value2);
+  },
+);
 
 Then(
   "User expects that response body should match {string} schema",
   async function (expectedSchema) {
-    if(expectedSchema !="" ){
-    const schema = await selector(expectedSchema);
-    const ajv = await new Ajv();
-    const validate = await ajv.compile(schema);
-    const responseBody = await context.response["Response Body"];
-    const valid = await validate(responseBody);
-    await expect(valid).toBe(true);
+    if (expectedSchema != "") {
+      const schema = await selector(expectedSchema);
+      const ajv = await new Ajv();
+      const validate = await ajv.compile(schema);
+      const responseBody = await context.response["Response Body"];
+      const valid = await validate(responseBody);
+      await expect(valid).toBe(true);
     }
-  }
+  },
 );
 
-
 Then(
   "User expects that request should have {int} status code",
   async function (expectedStatusCode) {
     const actualStatusCode = await context.response.Response.status();
     expect(actualStatusCode).toBe(expectedStatusCode);
-  }
+  },
 );
 
 Then(
@@ -858,5 +860,5 @@ Then(
   async function (expectedStatusCode) {
     const actualStatusCode = await context.response.Response.status();
     expect(actualStatusCode).toBe(expectedStatusCode);
-  }
-);
+  },
+);

package/src/stepDefinitions/keyboardActions.steps.js

@@ -1,4 +1,10 @@
-const { When, random, element, selector, time } = require("../helper/imports/commons");
+const {
+  When,
+  random,
+  element,
+  selector,
+  time,
+} = require("../helper/imports/commons");
 const { keyboard, frame } = require("../helper/stepFunctions/exporter");
 
 // User presses a key on a specific selector
@@ -94,134 +100,162 @@ When("User types {string} with delay {int}", async function (key, delay) {
   await keyboard.keyboardType(key, delay);
 });
 
-
-
-When('User types random word in {string}', async (input) => {
+When("User types random word in {string}", async (input) => {
   const randomWord = random.lorem.word();
   await keyboard.fill(input, randomWord);
 });
 
-When('User types random word that has character between {int} and {int} in {string}', async (from,to, input) => {
-const randomWord = random.lorem.word({min:from, max:to});
-await keyboard.fill(input, randomWord);
-});
+When(
+  "User types random word that has character between {int} and {int} in {string}",
+  async (from, to, input) => {
+    const randomWord = random.lorem.word({ min: from, max: to });
+    await keyboard.fill(input, randomWord);
+  },
+);
 
-When('User types random words in {string}', async (input) => {
-const randomWord = random.lorem.words();
-await keyboard.fill(input, randomWord);
+When("User types random words in {string}", async (input) => {
+  const randomWord = random.lorem.words();
+  await keyboard.fill(input, randomWord);
 });
 
 When(
-"User types random words that range between {int} and {int} in {string}",
-async (from, to, input) => {
-  const words = random.lorem.words({ min: from, max: to });
-  await keyboard.fill(input, words);
-},
+  "User types random words that range between {int} and {int} in {string}",
+  async (from, to, input) => {
+    const words = random.lorem.words({ min: from, max: to });
+    await keyboard.fill(input, words);
+  },
 );
 
-When('User types random paragraph in {string}', async (input) => {
+When("User types random paragraph in {string}", async (input) => {
   const randomParagraph = random.lorem.paragraph();
   await keyboard.fill(input, randomParagraph);
 });
 
 When(
-"User types random paragraph that range between {int} and {int} in {string}",
-async (from, to, input) => {
-  const words = random.lorem.paragraph({ min: from, max: to });
-  await keyboard.fill(input, words);
-},
+  "User types random paragraph that range between {int} and {int} in {string}",
+  async (from, to, input) => {
+    const words = random.lorem.paragraph({ min: from, max: to });
+    await keyboard.fill(input, words);
+  },
 );
 
-When('User types random url in {string}', async (input) => {
+When("User types random url in {string}", async (input) => {
   const randomURL = random.internet.url();
   await keyboard.fill(input, randomURL);
 });
 
-When('User types random number in {string}', async (input) => {
-    const randomNumber = random.number.int();
+When("User types random number in {string}", async (input) => {
+  const randomNumber = random.number.int();
   await keyboard.fill(input, randomNumber.toString());
 });
 
-When('User types random number that range between {int} and {int} in {string}', async (from, to, input) => {
-const randomNumber = random.number.int({ min: from, max: to });
-await keyboard.fill(input, randomNumber.toString());
-});
+When(
+  "User types random number that range between {int} and {int} in {string}",
+  async (from, to, input) => {
+    const randomNumber = random.number.int({ min: from, max: to });
+    await keyboard.fill(input, randomNumber.toString());
+  },
+);
 
-When('User types random email in {string}', async (key) => {
-const email = random.internet.email()
-await keyboard.fill(key, email);
+When("User types random email in {string}", async (key) => {
+  const email = random.internet.email();
+  await keyboard.fill(key, email);
 });
 
-When(
-"User types random word in {int} th of {string}",
-async (th, inputs) => {
+When("User types random word in {int} th of {string}", async (th, inputs) => {
   const nthElement = await frame.nth(th, inputs);
   const randomWord = random.lorem.word();
   await nthElement.fill(randomWord);
-},
-);
-
-When('User types random word that has character between {int} and {int} in {int} th of {string}', async (from,to,th, inputs) => {
-const nthElement = await frame.nth(th, inputs);
-const randomWord = random.lorem.word({min:from, max:to});
-await nthElement.fill(randomWord);
-});
-
-When('User types random characters from {string}  in {string}', async (chars, input) => {
-      const randomCharacters = random.string.fromCharacters(chars,10);
-      input = await element(selector(input))
-      await input.fill(randomCharacters)
-})
-
-When('User types random number by hand in range from {int} to {int} in {string} with {int} ms delay', async (from,to, input, delay) => {
-const randomNumber = Math.floor(Math.random() * (to - from + 1)) + from;
-await keyboard.pressSequentiallyDelay(input, randomNumber.toString(), delay);
-})
-
-When('User types random alphanumeric in range from {int} to {int} in {string}', async (from,to, input) => {
-  const randomWords = await random.string.alphanumeric({length: { min: from, max: to }})
-   await element(input).fill(randomWords)
-})
-
-When('User types random fullname in {string}', async (input) => {
-  const randomFirstName = await random.person.firstName()
-  const randomLastName = await random.person.lastName()
-
-  await element(input).fill(`${randomFirstName} ${randomLastName}`)
-})
-
-When('User types random first name in {string}', async (input) => {
-  const randomFirstName = await random.person.firstName()
-  await element(input).fill(randomFirstName)
-})
-
-When('User types random last name in {string}', async (input) => {
-  const randomLastName = await random.person.lastName()
-  await element(input).fill(randomLastName)
-})
-
-When('User types random middle name in {string}', async (input) => {
-  const randomMiddleName = await random.person.middleName()
-  await element(input).fill(randomMiddleName)
-})
-
-When('User types random date between {int} and {int} in {string}', async (fromYear, toYear, input) => {
-  const year = Math.floor(Math.random() * (toYear - fromYear + 1)) + fromYear
-  const month = Math.floor(Math.random() * 12) + 1
-  const day = Math.floor(Math.random() * 28) + 1
-  const pad = (num) => num.toString().padStart(2, '0')
-  const dateStr = `${pad(day)}.${pad(month)}.${year}`
-  await element(input).fill(dateStr)
-})
-
-When('User types date {int} days after today in {string}', async (day, input) => {
-  const now = new time();
-  const afterDate = now.add(day, 'day').format("DD-MM-YYYY");
-  await element(input).fill(afterDate)
-})
-
-When('User types date {int} days before today in {string}', async (day, input) => {
-  const now = new time();
-  const beforeDate = now.subtract(day, 'day').format("DD-MM-YYYY");
-  await element(input).fill(beforeDate)
-})
+});
+
+When(
+  "User types random word that has character between {int} and {int} in {int} th of {string}",
+  async (from, to, th, inputs) => {
+    const nthElement = await frame.nth(th, inputs);
+    const randomWord = random.lorem.word({ min: from, max: to });
+    await nthElement.fill(randomWord);
+  },
+);
+
+When(
+  "User types random characters from {string}  in {string}",
+  async (chars, input) => {
+    const randomCharacters = random.string.fromCharacters(chars, 10);
+    input = await element(selector(input));
+    await input.fill(randomCharacters);
+  },
+);
+
+When(
+  "User types random number by hand in range from {int} to {int} in {string} with {int} ms delay",
+  async (from, to, input, delay) => {
+    const randomNumber = Math.floor(Math.random() * (to - from + 1)) + from;
+    await keyboard.pressSequentiallyDelay(
+      input,
+      randomNumber.toString(),
+      delay,
+    );
+  },
+);
+
+When(
+  "User types random alphanumeric in range from {int} to {int} in {string}",
+  async (from, to, input) => {
+    const randomWords = await random.string.alphanumeric({
+      length: { min: from, max: to },
+    });
+    await element(input).fill(randomWords);
+  },
+);
+
+When("User types random fullname in {string}", async (input) => {
+  const randomFirstName = await random.person.firstName();
+  const randomLastName = await random.person.lastName();
+
+  await element(input).fill(`${randomFirstName} ${randomLastName}`);
+});
+
+When("User types random first name in {string}", async (input) => {
+  const randomFirstName = await random.person.firstName();
+  await element(input).fill(randomFirstName);
+});
+
+When("User types random last name in {string}", async (input) => {
+  const randomLastName = await random.person.lastName();
+  await element(input).fill(randomLastName);
+});
+
+When("User types random middle name in {string}", async (input) => {
+  const randomMiddleName = await random.person.middleName();
+  await element(input).fill(randomMiddleName);
+});
+
+When(
+  "User types random date between {int} and {int} in {string}",
+  async (fromYear, toYear, input) => {
+    const year = Math.floor(Math.random() * (toYear - fromYear + 1)) + fromYear;
+    const month = Math.floor(Math.random() * 12) + 1;
+    const day = Math.floor(Math.random() * 28) + 1;
+    const pad = (num) => num.toString().padStart(2, "0");
+    const dateStr = `${pad(day)}.${pad(month)}.${year}`;
+    await element(input).fill(dateStr);
+  },
+);
+
+When(
+  "User types date {int} days after today in {string}",
+  async (day, input) => {
+    const now = new time();
+    const afterDate = now.add(day, "day").format("DD-MM-YYYY");
+    await element(input).fill(afterDate);
+  },
+);
+
+When(
+  "User types date {int} days before today in {string}",
+  async (day, input) => {
+    const now = new time();
+    const beforeDate = now.subtract(day, "day").format("DD-MM-YYYY");
+    await element(input).fill(beforeDate);
+  },
+);

package/src/stepDefinitions/mouseActions.steps.js

@@ -1,7 +1,6 @@
 const { When, element, selector } = require("../helper/imports/commons");
 const { mouse, frame } = require("../helper/stepFunctions/exporter");
 
-
 // User clicks on a selector
 When("User clicks {string}", async function (selector) {
   await mouse.click(selector);
@@ -256,21 +255,22 @@ When("User uploads {string} file to {string}", async (filePath, fileInput) => {
   await mouse.upload(filePath, fileInput);
 });
 
-
-When('User selects by text from {string} randomly', async ( select) => {
+When("User selects by text from {string} randomly", async (select) => {
   const optionsArray = await element(`${selector(select)} option`).evaluateAll(
-      options => options.map(option => option.text)
-    );
-  const randomOption = await optionsArray[Math.floor(Math.random() * optionsArray.length)];
+    (options) => options.map((option) => option.text),
+  );
+  const randomOption =
+    await optionsArray[Math.floor(Math.random() * optionsArray.length)];
 
   await mouse.selectByText(select, randomOption);
-})
+});
 
-When('User selects by value from {string} randomly', async ( select) => {
+When("User selects by value from {string} randomly", async (select) => {
   const optionsArray = await element(`${selector(select)} option`).evaluateAll(
-      options => options.map(option => option.value)
-    );
-  const randomOption = await optionsArray[Math.floor(Math.random() * optionsArray.length)];
+    (options) => options.map((option) => option.value),
+  );
+  const randomOption =
+    await optionsArray[Math.floor(Math.random() * optionsArray.length)];
 
   await mouse.selectByValue(select, randomOption);
-})
+});