artes 1.0.42 → 1.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "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": {
@@ -27,15 +27,16 @@
   "dependencies": {
     "@cucumber/cucumber": "^11.0.1",
     "@cucumber/messages": "^26.0.1",
-    "@gatling.io/core": "3.12.0",
+    "@faker-js/faker": "^9.8.0",
     "@gatling.io/cli": "3.12.0",
+    "@gatling.io/core": "3.12.0",
     "@gatling.io/http": "3.12.0",
     "@types/node": "^22.9.0",
+    "ajv": "^8.17.1",
     "allure-commandline": "^2.30.0",
     "allure-cucumberjs": "^3.0.5",
     "allure-js-commons": "^3.0.5",
     "playwright": "^1.48.2",
-    "ajv": "^8.17.1",
     "rimraf": "^6.0.1"
   },
   "repository": {

package/src/helper/imports/commons.js

@@ -3,13 +3,17 @@ const { Given, When, Then } = require("@cucumber/cucumber");
 const {
   getElement,
   getSelector,
+  saveVar,
+  resolveVariable,
 } = require("../pomController/elementController");
+const { faker } = require('@faker-js/faker');
 const { context } = require("../../hooks/context");
 
 const element = getElement;
 const selector = getSelector;
 const page = context.page;
 const request = context.request;
+const random = faker;
 
 const path = require("path");
 const modulePath = process.cwd();
@@ -35,6 +39,9 @@ module.exports = {
   Then,
   element,
   selector,
+  saveVar,
+  resolveVariable,
+  random,
   page,
   request,
   context,

package/src/helper/pomController/elementController.js

@@ -84,10 +84,35 @@ class Elements {
       this.elements?.[element]?.selector || this.elements?.[element] || element;
     return selector;
   }
+
+  static saveVar(value, customName, path) {
+    if (!customName) {
+      const flatKey = path
+        .split(".")
+        .map((part, i) =>
+          i === 0 ? part : part[0].toUpperCase() + part.slice(1),
+        )
+        .join("");
+
+      context.vars[flatKey] = value;
+    } else {
+      context.vars[customName] = value;
+    }
+  }
+
+  static resolveVariable(template) {
+    if (typeof template !== "string") return template;
+    return template.replace(/{{\s*(\w+)\s*}}/g, (_, varName) => {
+      const value = context.vars[varName];
+      return value !== undefined ? value : `{{${varName}}}`;
+    });
+  }
 }
 
 module.exports = {
   getElement: Elements.getElement.bind(Elements),
   addElements: Elements.addElements.bind(Elements),
   getSelector: Elements.getSelector.bind(Elements),
+  saveVar: Elements.saveVar.bind(Elements),
+  resolveVariable: Elements.resolveVariable.bind(Elements),
 };

package/src/helper/stepFunctions/APIActions.js

@@ -1,8 +1,16 @@
-const { context } = require("../imports/commons");
+const { context, selector, resolveVariable } = require("../imports/commons");
 
 const api = {
-  get: async (url) => {
-    const res = await context.request.get(url);
+  get: async (url, payload) => {
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const resolvedPayload = resolveVariable(payload);
+    const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
+
+    const res = await context.request.get(resolvedURL, {
+      headers: payloadJSON ? payloadJSON.headers : {},
+    });
     const header = await res.headers();
     const body = await res.json();
 
@@ -16,7 +24,10 @@ const api = {
     context.response = response;
   },
   head: async (url) => {
-    const res = await context.request.head(url);
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const res = await context.request.head(resolvedURL);
     const header = await res.headers();
 
     const response = {
@@ -28,18 +39,25 @@ const api = {
 
     context.response = response;
   },
-  post: async (url, reqHeader, reqBody) => {
-    const res = await context.request.post(url, {
-      headers: reqHeader,
-      body: reqBody,
+  post: async (url, payload) => {
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const resolvedPayload = await resolveVariable(payload);
+    const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
+
+    const res = await context.request.post(resolvedURL, {
+      headers: payloadJSON ? payloadJSON.headers : {},
+      data: payloadJSON ? payloadJSON.body : {},
     });
+
     const header = await res.headers();
     const body = await res.json();
 
     const response = {
       url: res.url(),
-      requestHeaders: reqHeader,
-      requestBody: reqBody,
+      requestHeaders: payloadJSON.headers,
+      requestBody: payloadJSON.body,
       response: res,
       responseHeaders: header,
       responseBody: body,
@@ -47,17 +65,25 @@ const api = {
 
     context.response = response;
   },
-  put: async (url, reqHeader, reqBody) => {
-    const res = await context.request.put(url, {
-      body: JSON.stringify(reqBody),
+  put: async (url, payload) => {
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const resolvedPayload = await resolveVariable(payload);
+    const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
+
+    const res = await context.request.put(resolvedURL, {
+      headers: payloadJSON ? payloadJSON.headers : {},
+      data: payloadJSON ? payloadJSON.body : {},
     });
+
     const header = await res.headers();
     const body = await res.json();
 
     const response = {
       url: res.url(),
-      requestHeaders: reqHeader,
-      requestBody: reqBody,
+      requestHeaders: payloadJSON.headers,
+      requestBody: payloadJSON.body,
       response: res,
       responseHeaders: header,
       responseBody: body,
@@ -65,17 +91,25 @@ const api = {
 
     context.response = response;
   },
-  patch: async (url, reqHeader, reqBody) => {
-    const res = await context.request.patch(url, {
-      body: JSON.stringify(reqBody),
+  patch: async (url, payload) => {
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const resolvedPayload = await resolveVariable(payload);
+    const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
+
+    const res = await context.request.patch(resolvedURL, {
+      headers: payloadJSON ? payloadJSON.headers : {},
+      data: payloadJSON ? payloadJSON.body : {},
     });
+
     const header = await res.headers();
     const body = await res.json();
 
     const response = {
       url: res.url(),
-      requestHeaders: reqHeader,
-      requestBody: reqBody,
+      requestHeaders: payloadJSON.headers,
+      requestBody: payloadJSON.body,
       response: res,
       responseHeaders: header,
       responseBody: body,
@@ -83,8 +117,17 @@ const api = {
 
     context.response = response;
   },
-  delete: async (url) => {
-    const res = await context.request.delete(url);
+  delete: async (url, payload) => {
+    const URL = await selector(url);
+    const resolvedURL = await resolveVariable(URL);
+
+    const resolvedPayload = await resolveVariable(payload);
+    const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
+
+    const res = await context.request.delete(resolvedURL, {
+      headers: payloadJSON.headers,
+    });
+
     const header = await res.headers();
     const body = await res.json();
 
@@ -97,6 +140,9 @@ const api = {
 
     context.response = response;
   },
+  vars: () => {
+     context.vars
+  },
 };
 
 module.exports = { api };

package/src/stepDefinitions/API.steps.js

@@ -3,20 +3,62 @@ const {
   context,
   expect,
   selector,
+  saveVar
 } = require("../helper/imports/commons");
 const { api } = require("../helper/stepFunctions/exporter");
 const Ajv = require("ajv");
 
+function extractVarsFromResponse(vars, customVarName) {
+  const responseBody = context.response.responseBody;
+
+  function getValueByPath(obj, path) {
+    const keys = path.split(".");
+    let current = obj;
+
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return undefined;
+      }
+    }
+
+    return current;
+  }
+
+  vars.split(",").forEach((v) => {
+    const path = v.trim();
+    const value = getValueByPath(responseBody, path);
+    if (value !== undefined) {
+      saveVar(value, customVarName, path);
+    }
+  });
+}
+
 When("User sends GET request to {string}", async function (url) {
   await api.get(url);
 });
 
+When(
+  "User sends GET request to {string} with payload:",
+  async function (url, reqParams) {
+    await api.get(url, payload);
+  },
+);
+
 When(
   "User sends GET request to {string} and saves {string} variables",
   async function (url, vars) {
-    await api.get(url);
-    vars = vars.split(",").map((v) => v.trim());
-    console.log(vars);
+    await api.get(url, payload);
+    extractVarsFromResponse(vars);
+  },
+);
+
+When(
+  "User sends GET request to {string} with payload and saves {string} variables",
+  async function (url, vars, payload) {
+    await api.get(url, payload);
+    extractVarsFromResponse(vars);
   },
 );
 
@@ -26,22 +68,46 @@ When("User sends HEAD request to {string}", async function (url) {
 
 When(
   "User sends POST request to {string} with payload:",
-  async function (url, reqParams) {
-    const payload = JSON.parse(reqParams);
-    await api.post(url, payload.headers, payload.body);
+  async function (url, payload) {
+    await api.post(url, payload);
   },
 );
 
-When("User sends PUT request to {string} with payload:", async function (url) {
-  const payload = JSON.parse(reqParams);
-  await api.put(url, payload.headers, payload.body);
-});
+When(
+  "User sends POST request to {string} with payload and saves {string} variables",
+  async function (url, payload) {
+    await api.post(url, payload);
+    extractVarsFromResponse(vars);
+  },
+);
+
+When(
+  "User sends PUT request to {string} with payload:",
+  async function (url, payload) {
+    await api.put(url, payload);
+  },
+);
+
+When(
+  "User sends PUT request to {string} with payload and saves {string} variables",
+  async function (url, payload) {
+    await api.put(url, payload);
+    extractVarsFromResponse(vars);
+  },
+);
 
 When(
   "User sends PATCH request to {string} with payload:",
-  async function (url) {
-    const payload = JSON.parse(reqParams);
-    await api.patch(url, payload.headers, payload.body);
+  async function (url, payload) {
+    await api.patch(url, payload);
+  },
+);
+
+When(
+  "User sends PATCH request to {string} with payload and saves {string} variables",
+  async function (url, payload) {
+    await api.patch(url, payload);
+    extractVarsFromResponse(vars);
   },
 );
 
@@ -49,6 +115,56 @@ When("User sends DELETE request to {string}", async function (url) {
   await api.delete(url);
 });
 
+When(
+  "User sends DELETE request to {string} and saves {string} variables",
+  async function (url, vars) {
+    await api.delete(url);
+    extractVarsFromResponse(vars);
+  },
+);
+
+When(
+  "User sends DELETE request to {string} with payload:",
+  async function (url, payload) {
+    await api.delete(url, payload);
+  },
+);
+
+When(
+  "User sends DELETE request to {string} with payload and saves {string} variables",
+  async function (url, vars, payload) {
+    await api.delete(url, payload);
+    extractVarsFromResponse(vars);
+  },
+);
+
+When(
+  "User saves {string} variable from response as {string}",
+  async function (vars, customVarName) {
+    extractVarsFromResponse(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 () {
+  console.log("\nVariables:", api.vars(), "\n");
+
+});
+
+When("User wants to see request body", async function () {
+  console.log("Request Body: ", context.response.requestBody);
+});
+
+When("User wants to see response body", async function () {
+  console.log("Request Body: ", context.response.responseBody);
+});
+
 When(
   "User sends {string} request to {string}",
   async function (method, url, reqParams) {