froth-webdriverio-framework 7.0.9 → 7.0.11

package/froth_api_calls/aesEncryptionDecryption.js

@@ -0,0 +1,125 @@
+const crypto = require('crypto');
+
+//const SECRET_KEY = "froth-testops@rd";
+
+async function encryptData(data, secretKey) {
+    try {
+        if (!data) return null
+
+        // Generate 12-byte nonce (GCM standard)
+        const nonce = crypto.getRandomValues(new Uint8Array(12))
+
+        // Import key (must be exactly 32 bytes)
+        const key = await crypto.subtle.importKey(
+            "raw",
+            new TextEncoder().encode(secretKey),
+            { name: "AES-GCM" },
+            false,
+            ["encrypt"]
+        )
+
+        // Encrypt
+        const encryptedBuffer = await crypto.subtle.encrypt(
+            {
+                name: "AES-GCM",
+                iv: nonce,
+                tagLength: 128, // 16 bytes
+            },
+            key,
+            new TextEncoder().encode(data)
+        )
+
+        // WebCrypto output = ciphertext + tag
+        const encryptedBytes = new Uint8Array(encryptedBuffer)
+
+        const ciphertext = encryptedBytes.slice(0, encryptedBytes.length - 16)
+        const tag = encryptedBytes.slice(encryptedBytes.length - 16)
+
+        // nonce + tag + ciphertext (same as backend)
+        const payload = new Uint8Array(
+            nonce.length + tag.length + ciphertext.length
+        )
+        payload.set(nonce)
+        payload.set(tag, nonce.length)
+        payload.set(ciphertext, nonce.length + tag.length)
+
+        // Base64 encode
+        return btoa(String.fromCharCode(...payload))
+    } catch (err) {
+        console.error("Encryption failed:", err)
+        return null
+    }
+}
+
+
+
+
+async function decrpytData(encryptedData) {
+    try {
+        if (!encryptedData) return null
+
+        // Base64 → Uint8Array
+        const encryptedBytes = Uint8Array.from(atob(encryptedData), c =>
+            c.charCodeAt(0)
+        )
+
+        // Extract nonce, tag, ciphertext
+        const nonce = encryptedBytes.slice(0, 12) // 12 bytes
+        const tag = encryptedBytes.slice(12, 28) // 16 bytes
+        const ciphertext = encryptedBytes.slice(28)
+
+        // WebCrypto expects: ciphertext + tag
+        const encryptedPayload = new Uint8Array(ciphertext.length + tag.length)
+        encryptedPayload.set(ciphertext)
+        encryptedPayload.set(tag, ciphertext.length)
+
+        // Import key
+        const key = await crypto.subtle.importKey(
+            "raw",
+            new TextEncoder().encode(config.encryptKeyValue),
+            { name: "AES-GCM" },
+            false,
+            ["decrypt"]
+        )
+
+        // Decrypt
+        const decryptedBuffer = await crypto.subtle.decrypt(
+            {
+                name: "AES-GCM",
+                iv: nonce,
+                tagLength: 128, // bits (16 bytes)
+            },
+            key,
+            encryptedPayload
+        )
+
+        return new TextDecoder().decode(decryptedBuffer)
+    } catch (error) {
+        console.error("Error decrypting:", error)
+        return null
+    }
+
+}
+
+module.exports = {
+    encryptData,
+    decrpytData
+};
+
+await encryptData(
+    data,
+    secret_key
+)
+
+const decrypted_data = await decrpytData(response)
+const data = JSON.parse(decrypted_data)
+console.log("decrpted data" + data)
+return data
+
+// Encrypt a password
+//const encryptedPassword = encryptData("admin@1234", SECRET_KEY);
+//console.log("Encrypted Password:", encryptedPassword);
+
+
+
+

package/froth_api_calls/browsersatckSessionInfo.js

@@ -91,32 +91,34 @@ async function getBSSessionDetails(sessionType, bsUsername, bsPassword) {
 
 async function amend2Browserstack(annotationMessage, level) {
     try {
-        const MAX_CHUNK_SIZE = 800 * 1024; // 800 KB
+        const MAX_CHUNK_BYTES = 800 * 1024; // 800 KB (BYTE-based)
 
-        // 1️⃣ Convert to string
+        // 1️⃣ Convert message to string
         let messageStr =
             typeof annotationMessage === "string"
                 ? annotationMessage
                 : JSON.stringify(annotationMessage, null, 2);
-        console.log("mesage is full: "+messageStr)
-        // 2️⃣ Escape for BrowserStack executor (IMPORTANT)
+
+        // 2️⃣ Escape for BrowserStack executor
         let escapedMessage = messageStr
             .replace(/\\/g, "\\\\")
             .replace(/"/g, '\\"')
             .replace(/\n/g, "\\n")
             .replace(/\r/g, "\\r");
 
-        // 3️⃣ Split into chunks
+        // 3️⃣ Convert to Buffer (UTF-8)
+        const buffer = Buffer.from(escapedMessage, "utf8");
+
+        // 4️⃣ Split into BYTE chunks
         const chunks = [];
-        for (let i = 0; i < escapedMessage.length; i += MAX_CHUNK_SIZE) {
-            chunks.push(escapedMessage.slice(i, i + MAX_CHUNK_SIZE));
+        for (let i = 0; i < buffer.length; i += MAX_CHUNK_BYTES) {
+            chunks.push(buffer.subarray(i, i + MAX_CHUNK_BYTES).toString("utf8"));
         }
-
         console.log(
-            `BrowserStack Annotation → total chars: ${escapedMessage.length}, chunks: ${chunks.length}`
+            `BrowserStack Annotation → total bytes: ${buffer.length}, chunks: ${chunks.length}`
         );
 
-        // 4️⃣ Print + send chunks
+        // 5️⃣ Print + send each chunk
         for (let i = 0; i < chunks.length; i++) {
             const chunkMessage =
                 chunks.length > 1
@@ -124,10 +126,7 @@ async function amend2Browserstack(annotationMessage, level) {
                     : chunks[i];
 
             // 🔍 LOCAL LOG
-            console.log("=======================================");
-            console.log(`BrowserStack Chunk ${i + 1}/${chunks.length}`);
-            console.log(chunkMessage);
-            console.log("=======================================");
+            console.log(`=======> BrowserStack Chunk ${i + 1}/${chunks.length}`, JSON.stringify(chunkMessage, null, 2));
 
             // 🚀 SEND TO BROWSERSTACK (WDIO-safe)
             if (process.env.PLATFORM === "browserstack") {
@@ -143,44 +142,6 @@ async function amend2Browserstack(annotationMessage, level) {
 }
 
 
-// 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":"${JSON.stringify(chunkMessage)}","level": "${level}"}}`);
-//                 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 = {

package/froth_api_calls/getexecutionDetails.js

@@ -1,3 +1,4 @@
+const aes=require('./aesEncryptionDecryption')
 /* =========================================================
    Execution / Script API Helpers (Normalized)
    ========================================================= */
@@ -261,3 +262,24 @@ module.exports = {
     updateScriptExecutionStatus,
     update_CICDRUNID_ReportUrl
 };
+
+async function main() {
+    try {
+        const frothUrl = "devapi.frothtestops.com";
+        // const username = "subhra.subudhi@roboticodigital.com";
+        // const password = "V2VsY29tZUAxMjM=";
+
+        // const token = await getLoginToken(frothUrl, username, password);
+        // if (!token) {
+        //     throw new Error('Login failed, no token obtained');
+        // }
+        const token='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzcyNTgyMzk5LCJpYXQiOjE3NjQ3NjU3OTQsImp0aSI6IjRhOWUyNjlkNWZhMzRlYzQ4NjZhZjk5MTc3Y2MwNzZiIiwidXNlcl9pZCI6NH0.1a_KwJvW3LOoBgzWMZBCoyGnA3eNm_XYeiah6Ql_EoA'
+        const id = 147;
+        const data = await getExecuitonDetails(frothUrl, token, id);
+        console.log("Retrieved JSON Data:", data);
+    } catch (error) {
+        console.error('Error in main function:', error);
+    }
+}
+
+main();

package/froth_common_actions/apicall.js

@@ -8,7 +8,7 @@ const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo"
  * UTILS
  * ===============================
  */
-function safeStringify(data) {
+async function safeStringify(data) {
     try {
         return JSON.stringify(data, null, 2);
     } catch {
@@ -32,6 +32,7 @@ async function callapi(
 ) {
     let response;
     const startTime = Date.now();
+    console.log("Final API URL:", api_url);
 
     try {
         const method = methodType.toUpperCase();
@@ -39,11 +40,18 @@ async function callapi(
 
         let body;
         if (bodyType === "raw" && payloadDetails) {
+            console.log("Payload (JSON):", JSON.stringify(payloaddetails));
             body = payloadDetails;
+            console.log("Payload (raw):", body);
+
         }
 
         if (bodyType === "form-data" && payloadDetails) {
-            body = jsonToFormData(payloadDetails);
+            body = await jsonToFormData(payloadDetails);
+            console.log("Payload (FormData):", body);
+            for (let [key, value] of body.entries()) {
+                console.log(`FormData Key: ${key}, Value: ${value}`);
+            }
             Object.assign(headers, body.getHeaders());
         }
 
@@ -52,7 +60,7 @@ async function callapi(
         * Full request annotated with chunking handled in amend2Browserstack
         */
         await amendToBrowserstack.amend2Browserstack(
-            safeStringify({
+            await safeStringify({
                 method,
                 url: apiUrl,
                 bodyType,
@@ -73,14 +81,15 @@ async function callapi(
         const duration = Date.now() - startTime;
 
         // Always store full response
-        BUFFER.setItem("LAST_API_RESPONSE", response.data);
+       // BUFFER.setItem("LAST_API_RESPONSE", response.data);
+        console.log("Response Data:", response.data);
 
         /**
          * -------- ANNOTATE FULL RESPONSE --------
          * Now chunking is handled in amend2Browserstack
          */
         await amendToBrowserstack.amend2Browserstack(
-            safeStringify({
+            await safeStringify({
                 status: response.status,
                 durationMs: duration,
                 data: response.data
@@ -89,8 +98,9 @@ async function callapi(
         );
 
     } catch (error) {
+        console.error('Error during API call in call api menthod:', error);
         await amendToBrowserstack.amend2Browserstack(
-            safeStringify({
+            await safeStringify({
                 message: error.message,
                 status: error.response?.status,
                 data: error.response?.data
@@ -109,20 +119,21 @@ async function callapi(
  * JSON → FORM DATA
  * ===============================
  */
-function jsonToFormData(json) {
+async function jsonToFormData(json) {
     const formData = new FormData();
 
-    function append(data, parentKey) {
+    async function append(data, parentKey) {
         if (data && typeof data === "object" && !Array.isArray(data)) {
-            Object.keys(data).forEach(key =>
-                append(data[key], parentKey ? `${parentKey}[${key}]` : key)
-            );
+            for (const key of Object.keys(data)) {
+                await append(data[key], parentKey ? `${parentKey}[${key}]` : key);
+            }
         } else {
             formData.append(parentKey, data);
         }
     }
 
-    append(json);
+    await append(json);
+    console.log("FormData in json to formdata:", formData);
     return formData;
 }
 
@@ -149,6 +160,8 @@ async function formHeaders(authentication, headers = {}, bodyType) {
             ).toString("base64")}`;
         }
     }
+    console.log('Headers:', headers);
+
 
     return headers;
 }
@@ -168,7 +181,7 @@ async function validate(
 ) {
     switch (actionName.toLowerCase()) {
         case "verify":
-            return validateAttributeData(
+            return await validateAttributeData(
                 attributeName,
                 actualValue,
                 useBuffer,
@@ -189,7 +202,7 @@ async function validate(
                 `Retrieved value from BUFFER: ${bufferKey}`,
                 "info"
             );
-            return BUFFER.getItem(bufferKey);
+            return await BUFFER.getItem(bufferKey);
     }
 }
 
@@ -200,6 +213,7 @@ async function validateAttributeData(
     bufferKey,
     datatype
 ) {
+    let assertionStatus = false; // Initialize status
     let expectedValue = useBuffer
         ? BUFFER.getItem(bufferKey)
         : bufferKey;
@@ -220,14 +234,16 @@ async function validateAttributeData(
     }
 
     try {
-        expect(actualValue).toBe(expectedValue);
+        expect(attribute).toBe(expectedValue, `${attributeName}  --> Expected value: ${expectedValue}, but got: ${attribute}`);
+        let annotationMessage = `Attribute name : ${attributeName} - verification passed. Actual text: ${attribute}, Expected text: ${expectedValue}.`;
         await amendToBrowserstack.amend2Browserstack(
-            `${attributeName} verification passed`,
+            annotationMessage,
             "info"
         );
     } catch (e) {
+        let annotationMessage = `Attribute name : ${attributeName} - verification failed. Expected text: ${expectedValue}. error: ${e.toString()}`;
         await amendToBrowserstack.amend2Browserstack(
-            `${attributeName} verification failed`,
+            annotationMessage,
             "error"
         );
         throw e;

package/froth_configs/browserstack/mobile.config.js

@@ -36,7 +36,7 @@ module.exports = (bsCaps) => {
                 debug: bsCaps.debug,
                 networkLogs: bsCaps.networkLogs,
                 interactiveDebugging: bsCaps.interactiveDebugging,
-
+                
             }
         }],
 

package/package.json

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

package/froth_api_calls/aesEncryption.js

@@ -1,33 +0,0 @@
-const crypto = require('crypto');
-
-//const SECRET_KEY = "froth-testops@rd";
-
-async function encryptData(data, secretKey) {
-    // Generate a random 16-byte IV (Initialization Vector)
-    const iv = crypto.randomBytes(16);
-
-    // Ensure the key is 16 bytes long
-    const key = Buffer.from(secretKey, 'utf-8');
-
-    // Initialize cipher in CBC mode with the key and IV
-    const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
-
-    // Encrypt the data
-    let encrypted = cipher.update(data, 'utf-8', 'base64');
-    encrypted += cipher.final('base64');
-
-    // Combine the IV and encrypted data, encode as base64
-    const encryptedData = Buffer.concat([iv, Buffer.from(encrypted, 'base64')]).toString('base64');
-
-    return encryptedData;
-}
-
-
-
-// Encrypt a password
-//const encryptedPassword = encryptData("admin@1234", SECRET_KEY);
-//console.log("Encrypted Password:", encryptedPassword);
-
-module.exports = encryptData;
-
-