artes 1.0.40 → 1.0.42

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.40",
+  "version": "1.0.42",
   "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,6 +20,7 @@ const invokeBrowser = async () => {
       dir: "./test-results/visualReport/",
       size: cucumberConfig.browser.viewport,
     },
+    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/stepFunctions/APIActions.js

@@ -2,22 +2,100 @@ const { context } = require("../imports/commons");
 
 const api = {
   get: async (url) => {
-    return await context.request.get(url);
+    const res = await context.request.get(url);
+    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 res = await context.request.head(url);
+    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, reqHeader, reqBody) => {
+    const res = await context.request.post(url, {
+      headers: reqHeader,
+      body: reqBody,
+    });
+    const header = await res.headers();
+    const body = await res.json();
+
+    const response = {
+      url: res.url(),
+      requestHeaders: reqHeader,
+      requestBody: reqBody,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  put: async (url) => {
-    return await context.request.put(url);
+  put: async (url, reqHeader, reqBody) => {
+    const res = await context.request.put(url, {
+      body: JSON.stringify(reqBody),
+    });
+    const header = await res.headers();
+    const body = await res.json();
+
+    const response = {
+      url: res.url(),
+      requestHeaders: reqHeader,
+      requestBody: reqBody,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
-  patch: async (url) => {
-    return await context.request.patch(url);
+  patch: async (url, reqHeader, reqBody) => {
+    const res = await context.request.patch(url, {
+      body: JSON.stringify(reqBody),
+    });
+    const header = await res.headers();
+    const body = await res.json();
+
+    const response = {
+      url: res.url(),
+      requestHeaders: reqHeader,
+      requestBody: reqBody,
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
   delete: async (url) => {
-    return await context.request.head(url);
+    const res = await context.request.delete(url);
+    const header = await res.headers();
+    const body = await res.json();
+
+    const response = {
+      url: res.url(),
+      response: res,
+      responseHeaders: header,
+      responseBody: body,
+    };
+
+    context.response = response;
   },
 };
 

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,114 @@
-const { When, context } = require("../helper/imports/commons");
-const { api, assert } = require("../helper/stepFunctions/exporter");
+const {
+  When,
+  context,
+  expect,
+  selector,
+} = require("../helper/imports/commons");
+const { api } = require("../helper/stepFunctions/exporter");
+const Ajv = require("ajv");
 
 When("User sends GET request to {string}", async function (url) {
   await api.get(url);
 });
 
+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);
+  },
+);
+
 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, reqParams) {
+    const payload = JSON.parse(reqParams);
+    await api.post(url, payload.headers, payload.body);
+  },
+);
 
-When("User sends PUT request to {string}", async function (url) {
-  await api.get(url);
+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 PATCH request to {string}", async function (url) {
-  await api.get(url);
-});
+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);
+  },
+);
 
 When("User sends DELETE request to {string}", async function (url) {
-  await api.get(url);
+  await api.delete(url);
 });
+
+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);
+  },
+);