froth-webdriverio-framework 7.0.17 → 7.0.19

package/froth_common_actions_back/Utils.js

@@ -0,0 +1,167 @@
+const assert = require("assert");
+
+// This file contains the common methods that are used in the test scripts
+let scrollToEnd = null;
+let scrollToBeginning = null;
+let scrollToLeft = null;
+let scrollToRight = null;
+let scrollDownToView = null;
+let scrollRightToView = null;
+let scrollUpUntilVisible = null;
+
+let swipeRight = null;
+let swipeLeft = null;
+let swipeUp = null;
+let swipeDown = null;
+let swipetoFit = null;
+let swipeWithCoordinates = null;
+
+let clickIfVisible = null;
+let doubleClick = null;
+
+let assertText = null;
+
+let random = null;
+let randomtext = null;
+let randomnumber = null;
+let randomfloat = null;
+let randomint = null;
+let randomalphanum = null;
+let randomdecimal = null;
+let randomregex = null;
+let randomdate = null;
+
+let storetext = null;
+let storevalue = null;
+let storeattributevalue = null;
+let assertAttributeValue = null;
+let basepath = null;
+let scrollIntoView = null;
+
+let api = null;
+
+let selectDropDownValue = null;
+let selectDropDownText  = null;
+
+let acceptAlert = null;
+let dismissAlert = null;
+
+let generateJWT = null;
+
+let switchToWindowByTitle = null;
+let switchToWindowByIndex = null;
+
+let captureLoadNavigation = null;
+let amendBrowserStackLog = null;
+let logJsonDataToTable = null;
+
+let extractEmailLinks = null;
+
+if (process.env.LOCATION == null || process.env.LOCATION == 'local') {
+    basepath = ".";
+} else {
+    basepath = "froth-webdriverio-framework/froth_common_actions";
+}
+
+scrollToEnd = require(basepath + "/scroll").scrollToEnd;
+scrollToBeginning = require(basepath + '/scroll').scrollToBeginning;
+scrollToLeft = require(basepath + '/scroll').scrollToLeft;
+scrollToRight = require(basepath + '/scroll').scrollToRight;
+scrollDownToView = require(basepath + '/scroll').scrollDownToView;
+scrollRightToView = require(basepath + '/scroll').scrollRightToView;
+scrollIntoView = require(basepath + '/scroll').scrollIntoView;
+scrollUpUntilVisible = require(basepath + '/scroll').scrollupUntilVisible;
+switchToWindowByTitle = require(basepath + '/swicthWindowTab').switch2WindowByTitle;
+switchToWindowByIndex = require(basepath + '/swicthWindowTab').switch2WindowByIndex;
+
+swipeDown = require(basepath + '/swipe').swipedown;
+swipeLeft = require(basepath + '/swipe').swipeleft;
+swipeRight = require(basepath + '/swipe').swiperight;
+swipeUp = require(basepath + '/swipe').swipeup;
+swipetoFit = require(basepath + '/swipe').swipetofit;
+swipeWithCoordinates = require(basepath + '/swipe').swipewithcoordinates;
+
+clickIfVisible = require(basepath + "/click").clickIfVisible;
+clickByIdWithExecute = require(basepath + "/click").clickByIdWithExecute;
+doubleClick = require(basepath + "/click").doubleclick;
+
+assertText = require(basepath + '/assert').assertText;
+assertAttributeValue = require(basepath + '/assert').assertAttributeValue;
+
+randomtext = require(basepath + '/random').RANDOMTEXT;
+randomnumber = require(basepath + '/random').RNDNUMBER;
+randomfloat = require(basepath + '/random').RNDFLOAT;
+randomint = require(basepath + '/random').RNDINT;
+randomalphanum = require(basepath + '/random').RNDALPHANUM;
+randomdecimal = require(basepath + '/random').RNDDECIMAL;
+randomregex = require(basepath + '/random').RNDREGEX;
+random = require(basepath + '/random').RANDOM;
+randomdate = require(basepath + '/random').RNDDATE;
+
+storetext = require(basepath + '/storeToBuffer').STORETEXT;
+storevalue = require(basepath + '/storeToBuffer').STOREVALUE;
+storeattributevalue = require(basepath + '/storeToBuffer').STOREATTRIBUTEVALUE;
+
+api = require(basepath + '/apicall').callapi;
+validate = require(basepath + '/apicall').validate;
+
+selectDropDownValue = require(basepath + '/dropDown').select4mDropDownValue;
+selectDropDownText= require(basepath + '/dropDown').select4mDropDownText;
+
+acceptAlert = require(basepath + '/alert.js').acceptalert;
+dismissAlert = require(basepath + '/alert.js').dismissalert;
+
+generateJWT = require(basepath + '/jwt').generateJWTToken;
+captureLoadNavigation= require(basepath + '/captureNavigationTime').captureLoadNavigationTime;
+
+amendBrowserStackLog= require(basepath + '/../froth_api_calls/browsersatckSessionInfo').amend2Browserstack;
+logJsonDataToTable= require(basepath + '/logData').logJsonData2Table;
+
+extractEmailLinks = require(basepath + '/emailParsing');
+//export the variabels
+module.exports = {
+    scrollToEnd,
+    scrollToBeginning,
+    scrollToLeft,
+    scrollToRight,
+    scrollDownToView,
+    scrollRightToView,
+    clickIfVisible,
+    clickByIdWithExecute,
+    doubleClick,
+    assertText,
+    assertAttributeValue,
+    random,
+    randomtext,
+    randomnumber,
+    randomfloat,
+    randomint,
+    randomalphanum,
+    randomdecimal,
+    randomregex,
+    randomdate,
+    storetext,
+    storevalue,
+    storeattributevalue,
+    scrollIntoView,
+    scrollUpUntilVisible,
+    api,
+    validate,
+    selectDropDownValue,
+    selectDropDownText,
+    acceptAlert,
+    dismissAlert,
+    swipeLeft,
+    swipeRight,
+    swipeDown,
+    swipeUp,
+    swipetoFit,
+    swipeWithCoordinates,
+    generateJWT,
+    switchToWindowByTitle,
+    switchToWindowByIndex,
+    captureLoadNavigation,
+    amendBrowserStackLog,
+    logJsonDataToTable,
+    extractEmailLinks
+};

package/froth_common_actions_back/alert.js

@@ -0,0 +1,49 @@
+async function acceptalert() {
+
+    try {
+        let alertFound = false;
+        for (let i = 0; i < 6; i++) {
+            if (await browser.isAlertOpen()) {
+                alertFound = true;
+                break;
+            }
+            await browser.pause(10000); // wait for 10 seconds
+        }
+        if (!alertFound) {
+            console.log('Expected alert to appear but it did not');
+            return;
+        }
+        // await browser.waitUntil(async () => {
+        //     return await browser.isAlertOpen();
+        // }, {
+        //     timeout: 5000,
+        //     timeoutMsg: 'Expected alert to appear but it did not'
+        // });
+        await browser.acceptAlert();
+
+    } catch (e) {
+        console.log("error occured while accepting alert", e)
+    }
+
+}
+
+async function dismissalert() {
+    try {
+        await browser.waitUntil(async () => {
+            return await browser.isAlertOpen();
+        }, {
+            timeout: 5000,
+            timeoutMsg: 'Expected alert to appear but it did not'
+        });
+        await browser.dismissAlert();
+
+    } catch (e) {
+        console.log("error occured while dismissing alert", e)
+
+    }
+
+}
+
+
+
+module.exports = { acceptalert, dismissalert };

package/froth_common_actions_back/apicall.js

@@ -0,0 +1,179 @@
+const axios = require('axios');
+
+const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
+
+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);
+
+
+    try {
+
+        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).");
+        }
+
+
+        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;
+        }
+        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);
+
+    } 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");
+        throw error;
+    }
+    return response;
+}
+async 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);
+                }
+            }
+        } else {
+            formData.append(parentKey, data);
+        }
+    }
+
+    appendFormData(json);
+    console.log("FormData in json to formdata:", formData);
+    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);
+            }
+        }
+        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");
+    }
+    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);
+
+    }
+    // } 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;
+
+    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");
+
+    } 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");
+
+        throw e;
+    }
+}
+
+module.exports = { callapi, validate };

package/froth_common_actions_back/assert.js

@@ -0,0 +1,85 @@
+// Function to verify text in Android app
+import assert from 'assert';
+const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
+
+async function assertText(elementSelector, expectedText) {
+
+
+  console.log("inside the assert text function" + elementSelector)
+  try {
+    let element = await $(elementSelector)
+    try {
+      await expect(element).toHaveText(expectedText);
+      console.log("Assertion succeeded.");
+      actualText = await element.getText();
+      let annotationMessage = `Assertion passed. Actual text: ${actualText}, Expected text: ${expectedText}.`;
+      await amendToBrowserstack(annotationMessage, "info");
+    } catch (error) {
+      console.log(`Assertion failed. Expected text: ${expectedText}.`);
+      let annotationMessage = `Assertion failed. Expected text: ${expectedText}.`;
+      await amendToBrowserstack(annotationMessage, "error");
+      if (!browser.testErrors) browser.testErrors = [];
+     // browser.testErrors.push(`Assertion failed.: ${error.message}`);
+      assert.fail(`Text assertion failed: ${error.message}`);
+    }
+
+
+  } catch (error) {
+    console.error('Error occurred while verifying text:', error);
+    let annotationMessage = `Error occurred while verifying text: ${error.message}.`;
+    await amendToBrowserstack(annotationMessage, "error");
+    if (!browser.testErrors) browser.testErrors = [];
+   // browser.testErrors.push(`Assertion failed.: ${error.message}`);
+    assert.fail(`Text assertion failed: ${error.message}`);
+    // throw error;
+  }
+
+
+}
+
+async function assertAttributeValue(elementSelector, attributeName, expectedText) {
+
+
+  console.log("inside the assertAttributeValue function" + elementSelector)
+  try {
+    let element = await $(elementSelector)
+    try {
+      await expect(element).toHaveAttribute(attributeName, expectedText);
+      let actualText;
+      actualText = await element.getAttribute(attributeName);
+      console.log("Assertion succeeded.");
+      let annotationMessage = `Assertion passed. Attribute value: ${actualText}, Expected value: ${expectedText}.`;
+      await amendToBrowserstack(annotationMessage, "info");
+    } catch (error) {
+      console.warn("Assertion failed:", error.message);
+      let annotationMessage = `Assertion failed. Expected text: ${expectedText}. ,${error.message}`;
+      await amendToBrowserstack(annotationMessage, "error");
+      console.log("Assertion failed. Expected text: ", expectedText);
+      if (!browser.testErrors) browser.testErrors = [];
+     // browser.testErrors.push(`Assertion failed.: ${error.message}`);
+      assert.fail(`Text assertion failed: ${error.message}`);
+    }
+  } catch (error) {
+    console.error('Error occurred while verifying text:', error);
+    let annotationMessage = `Error occurred while asserting Attribute: ${error.message}.`;
+    await amendToBrowserstack(annotationMessage, "error");
+    if (!browser.testErrors) browser.testErrors = [];
+   // browser.testErrors.push(`Assertion failed.: ${error.message}`);
+    assert.fail(`Text assertion failed: ${error.message}`);
+  }
+
+
+}
+
+// async function amendToBrowserstack(annotationMessage, level) {
+//   try {
+//     await driver.execute('browserstack_executor: {"action": "annotate", "arguments": {"data":"' + annotationMessage + '","level": "' + level + '"}}');
+
+//   } catch (error) {
+//     console.error('Error occurred while annoting into BS', error);
+//     throw error;
+//   }
+// }
+module.exports = { assertText, assertAttributeValue };
+
+

package/froth_common_actions_back/captureNavigationTime.js

@@ -0,0 +1,53 @@
+
+const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
+
+/**
+ * Capture Navigation / Page Load time
+ * @param {string} pageName - (Optional) Custom name for the page
+ */
+async function captureLoadNavigationTime(pageName = '') {
+  let pageLoadTime;
+  try {
+    // Try modern API first
+    let perfEntries = await browser.execute(() => {
+      if (performance.getEntriesByType) {
+        const [nav] = performance.getEntriesByType('navigation');
+        return nav ? nav.toJSON() : null;
+      }
+      return null;
+    });
+
+
+    if (perfEntries && perfEntries.loadEventEnd) {
+      pageLoadTime = perfEntries.loadEventEnd;
+    } else {
+      // Fallback to old API
+      const perfTiming = await browser.execute(() => JSON.stringify(window.performance.timing));
+      const timing = JSON.parse(perfTiming);
+      pageLoadTime = timing.loadEventEnd - timing.navigationStart;
+    }
+
+    // If no custom name passed, use the page title
+    let title = pageName || await browser.getTitle();
+
+    // Clean title: remove special characters, keep words separated by space
+    title = title
+      .replace(/[^a-zA-Z0-9]+/g, ' ')  // replace non-alphanumeric with space
+      .replace(/\s+/g, ' ')            // collapse multiple spaces
+      .trim();                         // remove leading/trailing spaces
+
+    pageLoadTime = perfEntries.loadEventEnd; // Already relative to startTime
+    pageLoadTime = (pageLoadTime / 1000).toFixed(2); // Convert ms to seconds, keep 2 decimals
+    await amendToBrowserstack(`⏱ Page Load Time for ${title}: ${pageLoadTime} seconds`, "info");
+
+    console.log(`⏱ Page Load Time for ${title}: ${pageLoadTime} seconds`);
+  } catch (error) {
+    console.error('Error capturing navigation timing:', error);
+  }
+
+  return pageLoadTime;
+}
+
+
+module.exports = { captureLoadNavigationTime };
+

package/froth_common_actions_back/click.js

@@ -0,0 +1,57 @@
+async function clickIfVisible(elementSelector) {
+  try {
+    let isDisplayed;
+    // Wait for the element to be visible
+    await driver.waitUntil(async () => {
+      console.log("Waiting for element to be visible");
+      const element = await $(elementSelector);
+      isDisplayed = await element.isDisplayed();
+      console.log("Element is displayed:", isDisplayed);
+      if (isDisplayed) {
+        // Get the actual text from the element
+        const element = await $(elementSelector);
+        await element.click();
+        console.log("Element is clicked successfully.");
+        return;
+      }
+    }, { timeout: 30000 });
+  } catch (error) {
+    console.error("Element not found or not visible within 30 seconds");
+  }
+}
+
+async function doubleclick(elementSelector) {
+  try {
+    let isDisplayed;
+    // Wait for the element to be visible
+    await driver.waitUntil(async () => {
+      console.log("Waiting for element to be visible");
+      const element = await $(elementSelector);
+      isDisplayed = await element.isDisplayed();
+      console.log("Element is displayed:", isDisplayed);
+      if (isDisplayed) {
+        // Get the actual text from the element
+        const element = await $(elementSelector);
+        await element.doubleClick();
+        console.log("Element is double clicked successfully.");
+        return;
+      }
+    }, { timeout: 30000 });
+  } catch (error) {
+    console.error("Element not found or not visible within 30 seconds");
+  }
+}
+
+
+
+async function clickByIdWithExecute(elementid) {
+  try {
+    await browser.execute(() => {
+      document.getElementById(elementid).click();
+    });
+  } catch (error) {
+    console.error("Failed to click on element with id:", elementid);
+  }
+}
+
+module.exports = { clickIfVisible, clickByIdWithExecute ,doubleclick};

package/froth_common_actions_back/dropDown.js

@@ -0,0 +1,34 @@
+const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
+
+async function select4mDropDownValue(elementSelector, selectOption) {
+    try {
+       // let selectBox = await $(elementSelector);
+         await $(elementSelector).selectByAttribute('value', selectOption);
+
+    } catch (error) {
+        console.error('Error occurred while selecting the option:', error);
+        let annotationMessage = `Error occurred while selecting the option: ${error.message}.`;
+        await amendToBrowserstack(annotationMessage, "error");
+    }
+}
+
+async function select4mDropDownText(elementSelector, visibleText) {
+    try {
+        await $(elementSelector).selectByVisibleText(visibleText);
+    } catch (error) {
+        console.error('Error occurred while selecting the option by text:', error);
+        let annotationMessage = `Error occurred while selecting the option by text: ${error.message}.`;
+        await amendToBrowserstack(annotationMessage, "error");
+    }
+}
+
+// async function amendToBrowserstack(annotationMessage, level) {
+//     try {
+//         await driver.execute('browserstack_executor: {"action": "annotate", "arguments": {"data":"' + annotationMessage + '","level": "' + level + '"}}');
+
+//     } catch (error) {
+//         console.error('Error occurred while verifying text:', error);
+//        // throw error;
+//     }
+// }
+module.exports = { select4mDropDownValue,select4mDropDownText };