froth-webdriverio-framework 7.0.0 → 7.0.1

package/froth_api_calls/browsersatckSessionInfo.js

@@ -88,6 +88,38 @@ async function amend2Browserstack(annotationMessage, level) {
         throw error;
     }
 }
+async function amend2Browserstack(annotationMessage, level) {
+    try {
+        const MAX_CHUNK_SIZE = 800 * 1024; // 800 KB
+
+        // Convert message to string in case it's not
+        let messageStr = typeof annotationMessage === "string" ? annotationMessage : JSON.stringify(annotationMessage);
+
+        // Split into chunks if needed
+        const chunks = [];
+        for (let i = 0; i < messageStr.length; i += MAX_CHUNK_SIZE) {
+            chunks.push(messageStr.slice(i, i + MAX_CHUNK_SIZE));
+        }
+
+        // Send each chunk to BrowserStack sequentially
+        for (let i = 0; i < chunks.length; i++) {
+            const chunkMessage = chunks.length > 1
+                ? `PART ${i + 1}/${chunks.length}\n${chunks[i]}`
+                : chunks[i];
+
+            console.log(`Annotation message: ${chunkMessage}`);
+
+            if (process.env.PLATFORM === 'browserstack' || process.env.PLATFORM === 'browserstacklocal') {
+                await driver.execute(`browserstack_executor: {"action": "annotate", "arguments": {"data":"${chunkMessage}","level": "${level}"}}`);
+            }
+        }
+
+    } catch (error) {
+        console.error('Error annotating BrowserStack session:', error);
+        throw error;
+    }
+}
+
 
 module.exports = {
     getBSSessionDetails,

package/froth_common_actions/apicall.js

@@ -1,179 +1,245 @@
-const axios = require('axios');
+const axios = require("axios");
+const FormData = require("form-data");
 
-const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
+const { mend2Browserstack: amendToBrowserstack } = require("../froth_api_calls/browsersatckSessionInfo");
 
-async function callapi(methodtype, api_url, queryParams, payloaddetails, body_type, authentication, headersdetails, attachments) {
-    let response;
-    // if (queryParams && Object.keys(queryParams).length > 0) {
-    //     const queryString = new URLSearchParams(queryParams).toString();
-    //     api_url += `?${queryString}`;
-    // }
-    console.log("Final API URL:", api_url);
+/**
+ * ===============================
+ * UTILS
+ * ===============================
+ */
+function safeStringify(data) {
+    try {
+        return JSON.stringify(data, null, 2);
+    } catch {
+        return String(data);
+    }
+}
 
+/**
+ * ===============================
+ * MAIN API CALL
+ * ===============================
+ */
+async function callapi(
+    methodType,
+    apiUrl,
+    queryParams,
+    payloadDetails,
+    bodyType,
+    authentication,
+    headersDetails
+) {
+    let response;
+    const startTime = Date.now();
 
     try {
+        const method = methodType.toUpperCase();
+        const headers = await formHeaders(authentication, headersDetails, bodyType);
 
-        let method = methodtype.toUpperCase();
-        let headers = await formheaders(authentication, headersdetails, body_type);
-        let body = null;
-        console.log("Body Type:", body_type);
-        console.log("method:", method);
-        console.log("headers:", headers);
-
-        if (body_type === "raw" && payloaddetails && Object.keys(payloaddetails).length > 0) {
-            console.log("Payload (JSON):", JSON.stringify(payloaddetails));
-            body = JSON.stringify(payloaddetails);
-            console.log("Payload (raw):", body);
-        } else if (body_type === "form-data" && payloaddetails) {
-            body = await jsonToFormData(payloaddetails);
-            console.log("Payload (FormData):", body);
-            for (let [key, value] of body.entries()) {
-                console.log(`FormData Key: ${key}, Value: ${value}`);
-            }
-        } else {
-            console.log("No body sent (body_type not provided or empty payload).");
+        let body;
+        if (bodyType === "raw" && payloadDetails) {
+            body = payloadDetails;
         }
 
-
-        console.warn("Warning: GET request with a body is non-standard and may not work with all APIs.");
-        const config = {
-            method: method,
-            url: api_url,
-            headers: headers
-        };
-        const isBodyEmpty =
-            body === null ||
-            body === undefined ||
-            body === ''
-          
-
-        if (!isBodyEmpty) {
-            config.data = body;
+        if (bodyType === "form-data" && payloadDetails) {
+            body = jsonToFormData(payloadDetails);
+            Object.assign(headers, body.getHeaders());
         }
-        console.log("body:", body);
-        console.log("Config for API call:", config);
-        response = await axios(config);
-
-        // response = await axios({
-        //     method: method,
-        //     url: api_url,
-        //     headers: headers,
-        //     data: body === null ? undefined : body // Axios allows body with GET in some cases
-        // });
 
-
-        console.log("Response Data:", response.data);
+        /**
+        * -------- ANNOTATE REQUEST --------
+        * Full request annotated with chunking handled in amend2Browserstack
+        */
+        await amendToBrowserstack(
+            safeStringify({
+                method,
+                url: apiUrl,
+                bodyType,
+                body: payloadDetails
+            }),
+            "info"
+        );
+        /**
+         * -------- API CALL --------
+         */
+        response = await axios({
+            method,
+            url: apiUrl,
+            headers,
+            ...(body && { data: body })
+        });
+
+        const duration = Date.now() - startTime;
+
+        // Always store full response
+        BUFFER.setItem("LAST_API_RESPONSE", response.data);
+
+        /**
+         * -------- ANNOTATE FULL RESPONSE --------
+         * Now chunking is handled in amend2Browserstack
+         */
+        await amendToBrowserstack(
+            safeStringify({
+                status: response.status,
+                durationMs: duration,
+                data: response.data
+            }),
+            "info"
+        );
 
     } catch (error) {
-        console.error('Error during API call in call api menthod:', error);
-        let annotationMessage = 'Error during API call:' + error.response ? error.response.data : error.message;
-        await amendToBrowserstack(annotationMessage, "error");
+        await amendToBrowserstack(
+            safeStringify({
+                message: error.message,
+                status: error.response?.status,
+                data: error.response?.data
+            }),
+            "error"
+        );
+
         throw error;
     }
+
     return response;
 }
-async function jsonToFormData(json) {
+
+/**
+ * ===============================
+ * JSON → FORM DATA
+ * ===============================
+ */
+function jsonToFormData(json) {
     const formData = new FormData();
 
-    function appendFormData(data, parentKey = '') {
-        if (data && typeof data === 'object' && !Array.isArray(data)) {
-            for (const key in data) {
-                if (data.hasOwnProperty(key)) {
-                    appendFormData(data[key], parentKey ? `${parentKey}[${key}]` : key);
-                }
-            }
+    function append(data, parentKey) {
+        if (data && typeof data === "object" && !Array.isArray(data)) {
+            Object.keys(data).forEach(key =>
+                append(data[key], parentKey ? `${parentKey}[${key}]` : key)
+            );
         } else {
             formData.append(parentKey, data);
         }
     }
 
-    appendFormData(json);
-    console.log("FormData in json to formdata:", formData);
+    append(json);
     return formData;
 }
 
-// Function to form headers
-async function formheaders(authentication, headers, body_type) {
-    try {
-        if (!headers || typeof headers !== "object") {
-            headers = {};
-        }
-        if (body_type === "raw") {
-            headers['Content-Type'] = 'application/json';
-        }
-        // Add authentication headers based on the type
-        if (authentication && authentication.auth_type) {
-            if (authentication.auth_type?.toLowerCase() === 'bearer') {
-                console.log('Bearer token:', authentication.token);
-                headers.Authorization = `Bearer ` + authentication.token;
-            } else if (authentication.auth_type?.toLowerCase() === 'basic') {
-                headers.Authorization = `Basic ` + btoa(authentication.username + `:` + authentication.password);
-            }
+/**
+ * ===============================
+ * HEADERS
+ * ===============================
+ */
+async function formHeaders(authentication, headers = {}, bodyType) {
+    if (bodyType === "raw") {
+        headers["Content-Type"] = "application/json";
+    }
+
+    if (authentication?.auth_type) {
+        const type = authentication.auth_type.toLowerCase();
+
+        if (type === "bearer") {
+            headers.Authorization = `Bearer ${authentication.token}`;
         }
-        console.log('Headers:', headers);
-    } catch (e) {
 
-        console.error('Error in formheaders:', e);
-        let annotationMessage = `Error during API call: ${error.response?.data || error.message}`;
-        await amendToBrowserstack(annotationMessage, "error");
+        if (type === "basic") {
+            headers.Authorization = `Basic ${Buffer.from(
+                `${authentication.username}:${authentication.password}`
+            ).toString("base64")}`;
+        }
     }
-    return headers;
 
+    return headers;
 }
-async function validate(attribute_name, attribute, actionname, buffer, buffername_value, datatype) {
-
-    if (actionname.toLowerCase() == "verify") {
-        await validateAttributeData(attribute_name, attribute, buffer, buffername_value, datatype);
-    } else if (actionname.toLowerCase() == "setbuffer") {
-        BUFFER.setItem(buffername_value, attribute);
-        let annotationMessage = `The vlaue has been stored in the buffer : ${buffername_value}.`;
-        await amendToBrowserstack(annotationMessage, "info");
-
-    } else if (actionname.toLowerCase() == "getbuffer") {
-        let annotationMessage = `The vlaue has been retrived from the buffer : ${buffername_value}.`;
-        await amendToBrowserstack(annotationMessage, "info");
-        return await BUFFER.getItem(buffername_value);
 
+/**
+ * ===============================
+ * VALIDATION
+ * ===============================
+ */
+async function validate(
+    attributeName,
+    actualValue,
+    actionName,
+    useBuffer,
+    bufferKey,
+    datatype
+) {
+    switch (actionName.toLowerCase()) {
+        case "verify":
+            return validateAttributeData(
+                attributeName,
+                actualValue,
+                useBuffer,
+                bufferKey,
+                datatype
+            );
+
+        case "setbuffer":
+            BUFFER.setItem(bufferKey, actualValue);
+            await amendToBrowserstack(
+                `Stored value in BUFFER: ${bufferKey}`,
+                "info"
+            );
+            break;
+
+        case "getbuffer":
+            await amendToBrowserstack(
+                `Retrieved value from BUFFER: ${bufferKey}`,
+                "info"
+            );
+            return BUFFER.getItem(bufferKey);
     }
-    // } catch (e) {
-    //     console.error('Error in validate method:', e);
-    //     throw e;
-    // }
 }
 
-async function validateAttributeData(attribute_name, attribute, buffer, buffername_value, datatype) {
-    let assertionStatus = false; // Initialize status
-    let valueToVerify;
+async function validateAttributeData(
+    attributeName,
+    actualValue,
+    useBuffer,
+    bufferKey,
+    datatype
+) {
+    let expectedValue = useBuffer
+        ? BUFFER.getItem(bufferKey)
+        : bufferKey;
+
+    switch (datatype.toLowerCase()) {
+        case "integer":
+            expectedValue = Number(expectedValue);
+            break;
+        case "boolean":
+            expectedValue = Boolean(expectedValue);
+            break;
+        case "decimal":
+            expectedValue = parseFloat(expectedValue);
+            break;
+        case "string":
+            expectedValue = String(expectedValue);
+            break;
+    }
 
     try {
-        //if buffer is true, get the value from buffer
-        buffer ? valueToVerify = BUFFER.getItem(buffername_value) : valueToVerify = buffername_value;
-
-        if (datatype.toLowerCase() == "integer") {
-            valueToVerify = Number(valueToVerify);
-        } else if (datatype.toLowerCase() == "boolean") {
-            valueToVerify = Boolean(valueToVerify);
-        } else if (datatype.toLowerCase() == "decimal") {
-            valueToVerify = parseFloat(valueToVerify);
-        } else if (datatype.toLowerCase() == "string") {
-            valueToVerify = valueToVerify.toString();
-        }
-
-        expect(attribute).toBe(valueToVerify, `${attribute_name}  --> Expected value: ${valueToVerify}, but got: ${attribute}`);
-        assertionStatus = true; // If assertion passes, set status to true
-
-        console.log(`Attribute name : ${attribute_name} verification passed. Actual text: ${attribute}, Expected text: ${valueToVerify}.`);
-        let annotationMessage = `Attribute name : ${attribute_name} - verification passed. Actual text: ${attribute}, Expected text: ${valueToVerify}.`;
-        await amendToBrowserstack(annotationMessage, "info");
-
+        expect(actualValue).toBe(expectedValue);
+        await amendToBrowserstack(
+            `${attributeName} verification passed`,
+            "info"
+        );
     } catch (e) {
-        console.error('Error in validateAttributeData:', e);
-        console.log(`Attribute name : ${attribute_name} verification failed. Expected text: ${valueToVerify}. error: ${e.toString()}`);
-        let annotationMessage = `Attribute name : ${attribute_name} - verification failed. Expected text: ${valueToVerify}. error: ${e.toString()}`;
-        await amendToBrowserstack(annotationMessage, "error");
-
+        await amendToBrowserstack(
+            `${attributeName} verification failed`,
+            "error"
+        );
         throw e;
     }
 }
 
-module.exports = { callapi, validate };
+/**
+ * ===============================
+ * EXPORTS
+ * ===============================
+ */
+module.exports = {
+    callapi,
+    validate
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "froth-webdriverio-framework",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "readme": "WendriverIO Integration with [BrowserStack](https://www.browserstack.com)",
   "description": "Selenium examples for WebdriverIO and BrowserStack App Automate",
   "scripts": {