artes 1.0.59 → 1.0.61

package/package.json

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

package/src/helper/executers/testRunner.js

@@ -7,9 +7,8 @@ function runTests(args, flags) {
 
   const featureFiles = args[args.indexOf("--features") + 1];
   const features = flags.features && featureFiles;
-  
-  const tags = args[args.indexOf("--tags") + 1];
 
+  const tags = args[args.indexOf("--tags") + 1];
 
   flags.env && console.log("Running env:", env);
   flags.env ? (process.env.ENV = JSON.stringify(env)) : "";

package/src/helper/pomController/pomCollector.js

@@ -2,17 +2,19 @@ const { addElements } = require("./elementController");
 const cucumberConfig = require("../../../cucumber.config");
 const fs = require("fs");
 function pomCollector() {
-  fs.readdir(`${cucumberConfig.default.pomPath}`, (err, files) => {
-    files.forEach((file) => {
-      fs.readFile(
-        `${cucumberConfig.default.pomPath}/${file}`,
-        "utf-8",
-        (err, content) => {
-          addElements(JSON.parse(content));
-        },
-      );
+  if (fs.existsSync(cucumberConfig.default.pomPath)) {
+    fs.readdir(`${cucumberConfig.default.pomPath}`, (err, files) => {
+      files.forEach((file) => {
+        fs.readFile(
+          `${cucumberConfig.default.pomPath}/${file}`,
+          "utf-8",
+          (err, content) => {
+            addElements(JSON.parse(content));
+          },
+        );
+      });
     });
-  });
+  }
 }
 
 module.exports = { pomCollector };

package/src/helper/stepFunctions/APIActions.js

@@ -51,7 +51,6 @@ function processForm(key, value) {
       value.endsWith(".docx") ||
       value.includes("/"))
   ) {
-    // If it looks like a file path, treat it as a file
     try {
       if (fs.existsSync(value)) {
         formData[key] = {
@@ -61,41 +60,72 @@ function processForm(key, value) {
         };
         return;
       }
-    } catch (error) {
-      // If file doesn't exist, treat as regular string
-    }
+    } catch (error) {}
   }
 
   return formData;
 }
 
+async function requestMaker(headers, data, requestDataType) {
+  let request = {};
+
+  Object.assign(request, { headers: headers });
+
+  switch (requestDataType) {
+    case "multipart":
+      Object.assign(request, { multipart: data });
+      break;
+    default:
+      Object.assign(request, { data: data });
+  }
+
+  return request;
+}
+
+async function responseMaker(request, response) {
+  const responseObject = {};
+
+  response && Object.assign(responseObject, { URL: response.url() });
+
+  request.headers &&
+    Object.assign(responseObject, { "Request Headers": await request.headers });
+
+  request.body &&
+    Object.assign(responseObject, { "Request Body": await request.body });
+
+  response && Object.assign(responseObject, { Response: await response });
+
+  response &&
+    Object.assign(responseObject, {
+      "Response Headers": await response.headers(),
+    });
+
+  if (response) {
+    try {
+      Object.assign(responseObject, { "Response Body": await response.json() });
+    } catch (e) {
+      Object.assign(responseObject, { "Response Body": await response.text() });
+    }
+  }
+
+  return responseObject;
+}
+
 const api = {
   get: async (url, payload) => {
     const URL = await selector(url);
     const resolvedURL = await resolveVariable(URL);
 
-    const resolvedPayload = resolveVariable(payload);
+    const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    const res = await context.request.get(resolvedURL, {
-      headers: payloadJSON ? payloadJSON.headers : {},
-    });
+    const req = await requestMaker(payloadJSON?.headers || {});
 
-    try {
-      const header = await res.headers();
-      const body = await res.json();
-
-      const response = {
-        url: res.url(),
-        response: res,
-        responseHeaders: header,
-        responseBody: body,
-      };
+    const res = await context.request.get(resolvedURL, req);
 
-      context.response = response;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    const response = responseMaker(payloadJSON, res);
+
+    context.response = await response;
   },
   head: async (url) => {
     const URL = await selector(url);
@@ -103,188 +133,135 @@ const api = {
 
     const res = await context.request.head(resolvedURL);
 
-    try {
-      const header = await res.headers();
+    const response = responseMaker(payloadJSON, res);
 
-      const response = {
-        url: res.url(),
-        response: res,
-        responseHeaders: header,
-        responseBody: body,
-      };
-
-      context.response = response;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    context.response = await response;
   },
-  post: async (url, payload, bodyType) => {
+  post: async (url, payload, requestDataType) => {
     const URL = await selector(url);
     const resolvedURL = await resolveVariable(URL);
 
-    const resolvedPayload = await resolveVariable(payload);
+    const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    let requestBody = {};
+    let req;
 
-    switch (bodyType) {
+    switch (requestDataType) {
       case "multipart":
         let combinedFormData = {};
+
         for (const [key, value] of Object.entries(payloadJSON.body)) {
           const formData = processForm(key, value);
           Object.assign(combinedFormData, formData);
         }
-        requestBody = {
-          headers: payloadJSON.headers,
-          multipart: combinedFormData,
-        };
+
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          combinedFormData || {},
+          requestDataType,
+        );
         break;
       default:
-        requestBody = {
-          headers: payloadJSON ? payloadJSON.headers : {},
-          data: payloadJSON ? payloadJSON.body : {},
-        };
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          payloadJSON.body || {},
+        );
     }
 
-    const res = await context.request.post(resolvedURL, requestBody);
+    const res = await context.request.post(resolvedURL, req);
 
-    try {
-      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;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    const response = await responseMaker(payloadJSON, res);
+
+    context.response = await response;
   },
-  put: async (url, payload, bodyType) => {
+  put: async (url, payload, requestDataType) => {
     const URL = await selector(url);
     const resolvedURL = await resolveVariable(URL);
 
-    const resolvedPayload = await resolveVariable(payload);
+    const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    let requestBody = {};
+    let req;
 
-    switch (bodyType) {
+    switch (requestDataType) {
       case "multipart":
         let combinedFormData = {};
         for (const [key, value] of Object.entries(payloadJSON.body)) {
           const formData = processForm(key, value);
           Object.assign(combinedFormData, formData);
         }
-        requestBody = {
-          headers: payloadJSON.headers,
-          multipart: combinedFormData,
-        };
+
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          combinedFormData || {},
+          requestDataType,
+        );
+
         break;
       default:
-        requestBody = {
-          headers: payloadJSON ? payloadJSON.headers : {},
-          data: payloadJSON ? payloadJSON.body : {},
-        };
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          payloadJSON.body || {},
+        );
     }
 
-    const res = await context.request.put(resolvedURL, requestBody);
+    const res = await context.request.put(resolvedURL, req);
 
-    try {
-      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;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    const response = await responseMaker(payloadJSON, res);
+
+    context.response = await response;
   },
-  patch: async (url, payload, bodyType) => {
+  patch: async (url, payload, requestDataType) => {
     const URL = await selector(url);
     const resolvedURL = await resolveVariable(URL);
 
-    const resolvedPayload = await resolveVariable(payload);
+    const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    let requestBody = {};
+    let req;
 
-    switch (bodyType) {
+    switch (requestDataType) {
       case "multipart":
         let combinedFormData = {};
         for (const [key, value] of Object.entries(payloadJSON.body)) {
           const formData = processForm(key, value);
           Object.assign(combinedFormData, formData);
         }
-        requestBody = {
-          headers: payloadJSON.headers,
-          multipart: combinedFormData,
-        };
+
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          combinedFormData || {},
+          requestDataType,
+        );
+
         break;
       default:
-        requestBody = {
-          headers: payloadJSON ? payloadJSON.headers : {},
-          data: payloadJSON ? payloadJSON.body : {},
-        };
+        req = await requestMaker(
+          payloadJSON.headers || {},
+          payloadJSON.body || {},
+        );
     }
 
-    const res = await context.request.patch(resolvedURL, requestBody);
+    const res = await context.request.patch(resolvedURL, req);
 
-    try {
-      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;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    const response = responseMaker(payloadJSON, res);
+
+    context.response = await response;
   },
   delete: async (url, payload) => {
     const URL = await selector(url);
     const resolvedURL = await resolveVariable(URL);
 
-    const resolvedPayload = await resolveVariable(payload);
+    const resolvedPayload = (await payload) && resolveVariable(payload);
     const payloadJSON = (await resolvedPayload) && JSON.parse(resolvedPayload);
 
-    const res = await context.request.delete(resolvedURL, {
-      headers: payloadJSON.headers,
-    });
+    const req = await requestMaker(payloadJSON.headers || {});
 
-    try {
-      const header = await res.headers();
-      const body = await res.json();
-
-      const response = {
-        url: res.url(),
-        response: res,
-        responseHeaders: header,
-        responseBody: body,
-      };
+    const res = await context.request.delete(resolvedURL, req);
 
-      context.response = response;
-    } catch (error) {
-      throw new Error(`Error processing response: ${error.message}`);
-    }
+    const response = responseMaker(payloadJSON, res);
+
+    context.response = await response;
   },
   vars: () => {
     return context.vars;

package/src/hooks/hooks.js

@@ -56,10 +56,12 @@ After(async function ({ pickle, result }) {
   });
 
   if (context.response) {
-    await this.attach(
-      `Request Payload:\n${JSON.stringify(context.response, null, 2)}`,
-      "text/plain",
-    );
+    Object.entries(context.response).forEach(async ([key, value]) => {
+      await this.attach(
+        `${key}:\n${JSON.stringify(value, null, 2)}`,
+        "text/plain",
+      );
+    });
   }
 
   await context.page.close();