artes 1.0.41 → 1.0.43

package/cucumber.config.js

@@ -71,13 +71,20 @@ module.exports = {
     worldParameters: artesConfig.worldParameters || {}, // Custom world parameters
   },
 
+  api: {
+    baseURL: artesConfig?.baseURL ? artesConfig?.baseURL : "",
+  },
+
   browser: {
     browserType: artesConfig?.browser || "chrome",
     viewport: {
       width: artesConfig?.width || 1280,
       height: artesConfig?.height || 720,
     },
-    maximizeScreen: artesConfig?.maximizeScreen !== undefined ? artesConfig.maximizeScreen : true,
+    maximizeScreen:
+      artesConfig?.maximizeScreen !== undefined
+        ? artesConfig.maximizeScreen
+        : true,
     headless: artesConfig?.headless !== undefined ? artesConfig.headless : true,
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "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": {
@@ -35,6 +35,7 @@
     "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/contextManager/browserManager.js

@@ -20,7 +20,7 @@ const invokeBrowser = async () => {
       dir: "./test-results/visualReport/",
       size: cucumberConfig.browser.viewport,
     },
-    ignoreHTTPSErrors: true
+    ignoreHTTPSErrors: true,
   };
 
   switch (browserType) {

package/src/helper/contextManager/requestManager.js

@@ -1,10 +1,13 @@
 const { request } = require("playwright");
+const cucumberConfig = require("../../../cucumber.config.js");
 
-const requestContextOptions = {};
+const requestContextOptions = {
+  baseURL: cucumberConfig.api.baseURL,
+};
 
 async function invokeRequest() {
   const context = await request.newContext(requestContextOptions);
-  return await context;
+  return context;
 }
 
 module.exports = { invokeRequest };

package/src/helper/executers/projectCreator.js

@@ -39,6 +39,7 @@ function createProject(createYes) {
     headless: false, // Set to true for headless browser mode
 
     // Configuration options:
+    // baseURL: "",                     // string - Base URL for API tests
     // paths: [],                    // string[] - Paths to feature files
     // steps: "",                    // string - Step definitions files
     // pomPath: "",                  // string - Path to POM files

package/src/helper/imports/commons.js

@@ -3,6 +3,8 @@ const { Given, When, Then } = require("@cucumber/cucumber");
 const {
   getElement,
   getSelector,
+  saveVar,
+  resolveVariable,
 } = require("../pomController/elementController");
 const { context } = require("../../hooks/context");
 
@@ -35,6 +37,8 @@ module.exports = {
   Then,
   element,
   selector,
+  saveVar,
+  resolveVariable,
   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,23 +1,147 @@
-const { context } = require("../imports/commons");
+const { context, selector, resolveVariable } = require("../imports/commons");
 
 const api = {
-  get: async (url) => {
-    return 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();
+
+    const response = {
+      url: res.url(),
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
   head: async (url) => {
-    return 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 = {
+      url: res.url(),
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  post: async (url) => {
-    return await context.request.post(url);
+  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: payloadJSON.headers,
+      requestBody: payloadJSON.body,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
+  },
+  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: payloadJSON.headers,
+      requestBody: payloadJSON.body,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  put: async (url) => {
-    return await context.request.put(url);
+  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: payloadJSON.headers,
+      requestBody: payloadJSON.body,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  patch: async (url) => {
-    return await context.request.patch(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();
+
+    const response = {
+      url: res.url(),
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  delete: async (url) => {
-    return await context.request.head(url);
+  vars: () => {
+     context.vars
   },
 };
 

package/src/helper/stepFunctions/mouseActions.js

@@ -1,5 +1,10 @@
-const path = require('path');
-const { element, context, selector, moduleConfig } = require("../imports/commons");
+const path = require("path");
+const {
+  element,
+  context,
+  selector,
+  moduleConfig,
+} = require("../imports/commons");
 const { frame } = require("../stepFunctions/frameActions");
 
 const mouse = {
@@ -127,7 +132,7 @@ const mouse = {
     await element(selector).scrollIntoViewIfNeeded();
   },
   upload: async (filePath, fileInput) => {
-    const file = selector(filePath)
+    const file = selector(filePath);
     const fileChooserPromise = context.page.waitForEvent("filechooser");
     await element(fileInput).click();
     const fileChooser = await fileChooserPromise;

package/src/hooks/context.js

@@ -3,6 +3,8 @@ class Context {
     this.browser = undefined;
     this.page = undefined;
     this.request = undefined;
+    this.response = undefined;
+    this.vars = {};
   }
 }
 

package/src/hooks/hooks.js

@@ -30,6 +30,7 @@ Before(async function () {
   context.browser = await browser;
   context.page = await browser.newPage();
   await context.page.setDefaultTimeout(cucumberConfig.default.timeout * 1000);
+
   context.request = await request;
 
   await browser.tracing.start({
@@ -53,8 +54,17 @@ After(async function ({ pickle, result }) {
   await browser.tracing.stop({
     path: path.join(moduleConfig.projectPath, "./trace.zip"),
   });
+
+  if (context.response) {
+    await this.attach(
+      `Request Payload:\n${JSON.stringify(context.response, null, 2)}`,
+      "text/plain",
+    );
+  }
+
   await context.page.close();
   await browser.close();
+  await context.request.dispose();
 
   if (result?.status != Status.PASSED) {
     const videoPath = await context.page.video().path();

package/src/stepDefinitions/API.steps.js

@@ -1,26 +1,230 @@
-const { When, context } = require("../helper/imports/commons");
-const { api, assert } = require("../helper/stepFunctions/exporter");
+const {
+  When,
+  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, 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);
+  },
+);
+
 When("User sends HEAD request to {string}", async function (url) {
-  await api.get(url);
+  await api.head(url);
 });
 
-When("User sends POST request to {string}", async function (url) {
-  await api.get(url);
+When(
+  "User sends POST request to {string} with payload:",
+  async function (url, payload) {
+    await api.post(url, payload);
+  },
+);
+
+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, 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);
+  },
+);
+
+When("User sends DELETE request to {string}", async function (url) {
+  await api.delete(url);
 });
 
-When("User sends PUT request to {string}", async function (url) {
-  await api.get(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 sends PATCH request to {string}", async function (url) {
-  await api.get(url);
+When("User wants to see request body", async function () {
+  console.log("Request Body: ", context.response.requestBody);
 });
 
-When("User sends DELETE request to {string}", async function (url) {
-  await api.get(url);
+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) {
+    const httpMethod = method.toUpperCase();
+
+    let headers = {};
+    let body;
+
+    if (["POST", "PUT", "PATCH"].includes(httpMethod)) {
+      const payload = JSON.parse(reqParams);
+      headers = payload.headers || {};
+      body = payload.body || {};
+    }
+
+    switch (httpMethod) {
+      case "GET":
+        await api.get(url);
+        break;
+      case "HEAD":
+        await api.head(url);
+        break;
+      case "POST":
+        await api.post(url, headers, body);
+        break;
+      case "PUT":
+        await api.put(url, headers, body);
+        break;
+      case "PATCH":
+        await api.patch(url, headers, body);
+        break;
+      case "DELETE":
+        await api.delete(url);
+        break;
+      default:
+        throw new Error(`Unsupported HTTP method: ${httpMethod}`);
+    }
+  },
+);
+
+When(
+  "User expects that request should have {int} status code",
+  async function (expectedStatusCode) {
+    const actualStatusCode = await context.response.response.status();
+    expect(actualStatusCode).toBe(expectedStatusCode);
+  },
+);
+
+When(
+  "User expects that response body should match {string} schema",
+  async function (expectedSchema) {
+    const schema = selector(expectedSchema);
+
+    const ajv = new Ajv();
+
+    const validate = ajv.compile(schema);
+
+    const responseBody = context.response?.responseBody;
+
+    const valid = validate(responseBody);
+
+    expect(valid).toBe(true);
+  },
+);