artes 1.7.11 → 1.7.14

package/index.js

@@ -13,6 +13,7 @@ const {
   random,
   time,
   resolveVariable,
+  pathToCamelCase
 } = require("./src/helper/imports/commons");
 
 const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.7.11",
+  "version": "1.7.14",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {

package/src/helper/controller/getEnvInfo.js

@@ -27,6 +27,9 @@ async function getEnvInfo() {
   }
 
   const environment = {
+    // ── ARTES Version ───────────────────────
+    ARTES_Version: require(moduleConfig.modulePackageJsonPath).version,
+    
     // ── System ──────────────────────────────
     OS_Name: os.type(),
     OS_Version: os.release(),

package/src/helper/stepFunctions/APIActions.js

@@ -48,6 +48,10 @@ function curlExtractor(url, method, headers, body, requestDataType) {
           }
         }
         break;
+      case "xml":
+        curlCommand += ` \\\n  -H 'Content-Type: application/xml'`;
+        curlCommand += ` \\\n  --data-raw '${data}'`;
+        break;
 
       case "urlencoded":
       case "application/x-www-form-urlencoded":
@@ -106,28 +110,37 @@ function processForm(requestBody) {
       }
     }
 
-    if (
-      typeof value === "string" &&
-      (value.endsWith(".pdf") ||
-        value.endsWith(".jpg") ||
-        value.endsWith(".png") ||
-        value.endsWith(".txt") ||
-        value.endsWith(".doc") ||
-        value.endsWith(".docx") ||
-        value.includes("/"))
-    ) {
-      try {
-        const filePath = path.join(moduleConfig.projectPath, value);
-        if (fs.existsSync(filePath)) {
-          formData[key] = {
-            name: path.basename(filePath),
-            mimeType: getMimeType(filePath),
-            buffer: fs.readFileSync(filePath),
-          };
-          continue;
+    if (typeof value === "string") {
+
+      const normalizedValue = path.normalize(value);
+
+      const looksLikeFilePath =
+        normalizedValue.endsWith(".pdf") ||
+        normalizedValue.endsWith(".jpg") ||
+        normalizedValue.endsWith(".jpeg") ||
+        normalizedValue.endsWith(".png") ||
+        normalizedValue.endsWith(".txt") ||
+        normalizedValue.endsWith(".doc") ||
+        normalizedValue.endsWith(".docx") ||
+        normalizedValue.includes(path.sep);
+
+      if (looksLikeFilePath) {
+        try {
+          const filePath = path.isAbsolute(normalizedValue)
+            ? normalizedValue
+            : path.join(moduleConfig.projectPath, normalizedValue);
+
+          if (fs.existsSync(filePath)) {
+            formData[key] = {
+              name: path.basename(filePath),
+              mimeType: getMimeType(filePath),
+              buffer: fs.readFileSync(filePath),
+            };
+            continue;
+          }
+        } catch (error) {
+          console.log(error);
         }
-      } catch (error) {
-        console.log(error);
       }
     }
 
@@ -145,6 +158,12 @@ async function requestMaker(headers, data, requestDataType) {
     case "multipart":
       Object.assign(request, { multipart: data });
       break;
+    case "xml":
+      Object.assign(request, {
+        headers: { ...headers, "Content-Type": "application/xml" },
+        data: data,
+      });
+      break;
     case "urlencoded":
     case "application/x-www-form-urlencoded":
       const urlEncodedData = new URLSearchParams(data).toString();
@@ -264,6 +283,14 @@ const api = {
         );
         bodyForCurl = formRequest;
         break;
+      case "xml":
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        bodyForCurl = payloadJSON?.body || {};
+        break;
       case "urlencoded":
       case "application/x-www-form-urlencoded":
         req = await requestMaker(
@@ -334,6 +361,14 @@ const api = {
         );
         bodyForCurl = formRequest;
         break;
+      case "xml":
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        bodyForCurl = payloadJSON?.body || {};
+        break;
       case "urlencoded":
       case "application/x-www-form-urlencoded":
         req = await requestMaker(
@@ -404,6 +439,14 @@ const api = {
         );
         bodyForCurl = formRequest;
         break;
+      case "xml":
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        bodyForCurl = payloadJSON?.body || {};
+        break;
       case "urlencoded":
       case "application/x-www-form-urlencoded":
         req = await requestMaker(
@@ -452,7 +495,7 @@ const api = {
 
     context.response = response;
   },
-  delete: async (url, payload, options) => {
+delete: async (url, payload, requestDataType, options) => {
     const URL = await selector(url);
 
     options = options ?? {};
@@ -460,10 +503,53 @@ const api = {
     const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    const req = await requestMaker(
-      payloadJSON?.headers || {},
-      payloadJSON?.body || {},
-    );
+    let req;
+    let bodyForCurl = payloadJSON?.body || {};
+
+    switch (requestDataType) {
+      case "multipart":
+        const formRequest = processForm(payloadJSON?.body || {});
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          formRequest || {},
+          requestDataType,
+        );
+        bodyForCurl = formRequest;
+        break;
+      case "urlencoded":
+      case "application/x-www-form-urlencoded":
+        req = await requestMaker(
+          {
+            ...payloadJSON?.headers,
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        break;
+      case "form":
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        break;
+      case "xml":
+        req = await requestMaker(
+          {
+            ...payloadJSON?.headers,
+            "Content-Type": "application/xml",
+          },
+          payloadJSON?.body || {},
+          requestDataType,
+        );
+        break;
+      default:
+        req = await requestMaker(
+          payloadJSON?.headers || {},
+          payloadJSON?.body || {},
+        );
+    }
 
     const requestStarts = performance.now();
 
@@ -474,9 +560,9 @@ const api = {
     const curlCommand = curlExtractor(
       res.url(),
       "DELETE",
-      payloadJSON?.headers || {},
-      payloadJSON?.body || {},
-      null,
+      req.headers,
+      bodyForCurl,
+      requestDataType,
     );
 
     const response = responseMaker(payloadJSON, res, duration, curlCommand);

package/src/stepDefinitions/API.steps.js

@@ -88,6 +88,21 @@ When(
   },
 );
 
+When(
+  "User sends xml POST request to {string} with payload:",
+  async (url, payload) => {
+    await api.post(url, payload, "xml");
+  },
+);
+
+When(
+  "User sends xml POST request to {string} with payload and saves {string} variables",
+  async (url, vars, payload) => {
+    await api.post(url, payload, "xml");
+    await extractVarsFromResponse(context.response["Response Body"], vars);
+  },
+);
+
 When(
   "User sends PUT request to {string} with payload:",
   async function (url, payload) {
@@ -133,6 +148,21 @@ When(
   },
 );
 
+When(
+  "User sends xml PUT request to {string} with payload:",
+  async (url, payload) => {
+    await api.put(url, payload, "xml");
+  },
+);
+
+When(
+  "User sends xml PUT request to {string} with payload and saves {string} variables",
+  async (url, vars, payload) => {
+    await api.put(url, payload, "xml");
+    await extractVarsFromResponse(context.response["Response Body"], vars);
+  },
+);
+
 When(
   "User sends PATCH request to {string} with payload:",
   async function (url, payload) {
@@ -178,6 +208,21 @@ When(
   },
 );
 
+When(
+  "User sends xml PATCH request to {string} with payload:",
+  async (url, payload) => {
+    await api.patch(url, payload, "xml");
+  },
+);
+
+When(
+  "User sends xml PATCH request to {string} with payload and saves {string} variables",
+  async (url, vars, payload) => {
+    await api.patch(url, payload, "xml");
+    await extractVarsFromResponse(context.response["Response Body"], vars);
+  },
+);
+
 When("User sends DELETE request to {string}", async function (url) {
   await api.delete(url);
 });
@@ -205,6 +250,21 @@ When(
   },
 );
 
+When(
+  "User sends xml DELETE request to {string} with payload:",
+  async (url, payload) => {
+    await api.delete(url, payload, "xml");
+  },
+);
+
+When(
+  "User sends xml DELETE request to {string} with payload and saves {string} variables",
+  async (url, vars, payload) => {
+    await api.delete(url, payload, "xml");
+    await extractVarsFromResponse(context.response["Response Body"], vars);
+  },
+);
+
 When(
   "User saves {string} variable from response as {string}",
   async function (vars, customVarName) {
@@ -223,6 +283,33 @@ When(
   },
 );
 
+  When(
+  'User sets {int} year from current year as {string}',
+  async function (year, yearName) {
+    const targetYear = time().add(year, 'year').year();
+    context.vars[yearName] = targetYear.toString();
+  }
+);
+
+When(
+  'User sets {int} month from current month as {string}',
+  async function (month, monthName) {
+    const targetMonth = time().add(month, 'month').month() + 1;
+
+    context.vars[monthName] = targetMonth.toString().padStart(2, '0');
+  }
+);
+
+When(
+  "User saves request time in ISO format as {string}",
+  async (request_time) => {
+    context.vars[request_time] = new Date(
+      context.response["Response Headers"].date,
+    ).toISOString();
+    allure.attachment("Request Time", context.vars[request_time], "text/plain");
+  },
+);
+
 When("User wants to see saved variables", async function () {
   console.log("\nVariables:", api.vars(null), "\n");
 });
@@ -302,9 +389,14 @@ When(
   async (file, variable) => {
     file = await resolveVariable(file);
 
-    const filePath = await path.join(moduleConfig.projectPath, file);
-    const fileData = await fs.readFileSync(filePath);
-    const base64Data = await fileData.toString("base64");
-    context.vars[variable] = await base64Data;
+    const normalizedFile = path.normalize(file);
+
+    const filePath = path.isAbsolute(normalizedFile)
+      ? normalizedFile
+      : path.join(moduleConfig.projectPath, normalizedFile);
+
+    const fileData = fs.readFileSync(filePath);
+    const base64Data = fileData.toString("base64");
+    context.vars[variable] = base64Data;
   },
-);
+);

package/src/stepDefinitions/assertions.steps.js

@@ -1264,6 +1264,15 @@ Then(
   },
 );
 
+Then(
+  "User expects that {string} array has {int} items",
+  async (field, count) => {
+      extractVarsFromResponse(context.response["Response Body"], field);
+      const key = pathToCamelCase(field);
+      expect(context.vars[key].length).toEqual(count);
+  },
+);
+
 Then(
   "User expects that {string} should match {string}",
   async (value1, value2) => {
@@ -1303,3 +1312,41 @@ Then(
     expect(actualStatusCode).toBe(expectedStatusCode);
   },
 );
+
+
+Then("User expects that response should have {string} field", async (field) => {
+  extractVarsFromResponse(context.response["Response Body"], field);
+  const key = pathToCamelCase(field);
+  const varToString = JSON.stringify(context.vars[field]);
+  expect(varToString).toBeDefined();
+});
+
+Then(
+  "User expects that response should not have {string} field",
+  async (field) => {
+    extractVarsFromResponse(context.response["Response Body"], field);
+    const key = pathToCamelCase(field);
+    const varToString = JSON.stringify(context.vars[field]);
+    expect(varToString).not.toBeDefined();
+  },
+);
+
+Then(
+  "User expects that {string} array has items more than {int}",
+  (field, count) => {
+    extractVarsFromResponse(context.response["Response Body"], field);
+    const key = pathToCamelCase(field);
+    const resolvedCount = resolveVariable(count)
+    expect(context.vars[key].length).toBeLessThan(resolvedCount);
+  },
+);
+
+Then(
+  "User expects that {string} array has items less than {int}",
+  (field, count) => {
+    extractVarsFromResponse(context.response["Response Body"], field);
+    const key = pathToCamelCase(field);
+    const resolvedCount = resolveVariable(count)
+    expect(context.vars[key].length).toBeLessThan(resolvedCount);
+  },
+);

package/src/stepDefinitions/mouseActions.steps.js

@@ -60,7 +60,7 @@ When(
 When("User clicks at {int}, {int} coordinates", async function (x, y) {
   x = await resolveVariable(x);
   y = await resolveVariable(y);
-  await context.page.click({ position: { x: x, y: y } });
+  await context.page.mouse.click(x, y);
 });
 
 // User clicks at specific coordinates with click count and delay
@@ -69,11 +69,7 @@ When(
   async function (x, y, clickCount, delay) {
     x = await resolveVariable(x);
     y = await resolveVariable(y);
-    await context.page.click({
-      position: { x: x, y: y },
-      clickCount: clickCount,
-      delay: delay,
-    });
+    await context.page.mouse.click(x, y, { clickCount: clickCount, delay: delay });
   },
 );
 
@@ -83,7 +79,7 @@ When(
   async function (x, y) {
     x = await resolveVariable(x);
     y = await resolveVariable(y);
-    context.page.click({ position: { x: x, y: y }, force: true });
+    await context.page.mouse.click(x, y, { force: true });
   },
 );
 

package/src/stepDefinitions/report.steps.js

@@ -0,0 +1,5 @@
+const { Given } = require("../helper/imports/commons");
+
+Given('{string}', (s) => {
+// This step is for adding description between the steps to the report
+})