froth-webdriverio-framework 7.0.42 → 7.0.44

package/froth_common_actions_back/dropDown.js

@@ -1,34 +0,0 @@
-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 };

package/froth_common_actions_back/emailParsing.js

@@ -1,161 +0,0 @@
-// // process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-
-// const Imap = require('imap');
-// const { simpleParser } = require('mailparser');
-// const cheerio = require('cheerio');
-
-// /**
-//  * Connects to an IMAP inbox, parses emails, and extracts all unique links.
-//  * @param {Object} config - IMAP config { user, password, host, port, tls }
-//  * @param {Object} [filter] - Optional filter { subject, from }
-//  * @returns {Promise<Array<{link: string, text: string}>>}
-//  */
-// async function getEmailLinks(username,app_password, subjectdetails,fromemail) {
-//     const config = {
-//         user: username,
-//         password: app_password,
-//         host: 'imap.gmail.com',
-//         port: 993,
-//         tls: true
-//     };
-//     const filter = {
-//              subject: subjectdetails,
-//              from: fromemail
-//         };
-//     const imap = new Imap(config);
-
-//     function openInbox(cb) {
-//         imap.openBox('INBOX', true, cb);
-//     }
-
-//     return new Promise((resolve, reject) => {
-//         let results = new Map();
-//         let allLinks = [];
-//         let parseDone;
-//         const parsePromise = new Promise(res => { parseDone = res; });
-
-//         imap.once('ready', function () {
-//             openInbox(function (err, box) {
-//                 if (err) return cleanup(err);
-
-//                 // Build search criteria
-//                 let searchCriteria = ['ALL'];
-//                 if (filter.subject) searchCriteria.push(['HEADER', 'SUBJECT', filter.subject]);
-//                 if (filter.from) searchCriteria.push(['FROM', filter.from]);
-
-//                 imap.search(searchCriteria, function (err, uids) {
-//                     if (err) return cleanup(err);
-//                     if (!uids.length) return cleanup(null, []);
-
-//                     // Sort UIDs descending to get the latest email first
-//                     uids = uids.sort((a, b) => b - a);
-//                     // Only fetch the latest email
-//                     const latestUid = uids[0];
-//                     const fetch = imap.fetch([latestUid], { bodies: '' });
-//                     fetch.on('message', function (msg) {
-//                         let buffer = '';
-//                         msg.on('body', function (stream) {
-//                             stream.on('data', function (chunk) {
-//                                 buffer += chunk.toString('utf8');
-//                             });
-//                         });
-//                         msg.once('end', async function () {
-//                             try {
-//                                 const parsed = await simpleParser(buffer);
-//                                 let links = [];
-
-//                                 // Extract from HTML with element context
-//                                 if (parsed.html) {
-//                                     const $ = cheerio.load(parsed.html);
-//                                     $('a[href], button[href], [role="button"][href], img[src], area[href]').each((_, el) => {
-//                                         let link = null;
-//                                         let text = '';
-//                                         let elementType = el.tagName;
-//                                         if (elementType === 'a' || elementType === 'area') {
-//                                             link = $(el).attr('href');
-//                                             text = $(el).text().trim() || link;
-//                                         } else if (elementType === 'img') {
-//                                             link = $(el).attr('src');
-//                                             text = $(el).attr('alt') || link;
-//                                         } else if (elementType === 'button' || $(el).attr('role') === 'button') {
-//                                             link = $(el).attr('href');
-//                                             text = $(el).text().trim() || link;
-//                                         }
-//                                         if (link) {
-//                                             links.push({ link, text, element: elementType });
-//                                         }
-//                                     });
-//                                 }
-
-//                                 // Extract from plaintext
-//                                 if (parsed.text) {
-//                                     const urlRegex = /(https?:\/\/[^\s]+)/g;
-//                                     let match;
-//                                     while ((match = urlRegex.exec(parsed.text))) {
-//                                         links.push({ link: match[1], text: match[1], element: 'text' });
-//                                     }
-//                                 }
-
-//                                 // Deduplicate by link and element context
-//                                 for (const l of links) {
-//                                     const key = l.link + '|' + l.element + '|' + l.text;
-//                                     if (!results.has(key)) {
-//                                         results.set(key, { link: l.link, text: l.text, element: l.element });
-//                                     }
-//                                 }
-//                                 allLinks = Array.from(results.values());
-//                                 parseDone();
-//                             } catch (e) {
-//                                 // Log and continue
-//                                 console.error('Parse error:', e);
-//                                 parseDone();
-//                             }
-//                         });
-//                     });
-//                     fetch.once('error', cleanup);
-//                     fetch.once('end', async () => {
-//                         await parsePromise;
-//                         cleanup(null, allLinks);
-//                     });
-//                 });
-//             });
-//         });
-
-//         imap.once('error', cleanup);
-
-//         function cleanup(err, data) {
-//             imap.end();
-//             if (err) reject(err);
-//             else resolve(data);
-//         }
-
-//         imap.connect();
-//     });
-// }
-
-// async function findLinks(links,searchText) {
-//         const findLinkByText = (links, searchText) => {
-//             return links.find(l => l.text && l.text.toLowerCase().includes(searchText.toLowerCase()));
-//         };
-//         // Example usage:
-//         const found = findLinkByText(links, searchText);
-//         return found ? found.link : null;
-// }
-
-
-// // Example main function for direct execution
-// // if (require.main === module) {
-// //     (async () => {
-        
-// //         const links = await extractEmailLinks('gfntesting44@gmail.com','wtrd qfee dicr hpba', "GFN Testing, review your Google Account settings","no-reply@google.com");
-// //         console.log('Extracted links in main:', links); 
-// //         const foundLink = await findLinks(links,"Privacy Policy");
-// //         console.log('Found Link: ', foundLink);
-        
-
-// //     })();
-   
-// // }
-
-// module.exports = {  getEmailLinks ,findLinks}
-

package/froth_common_actions_back/jwt.js

@@ -1,64 +0,0 @@
-// JWT generation script adapted from
-// https://gist.github.com/corbanb/db03150abbe899285d6a86cc480f674d
-const CryptoJS = require('crypto-js');
-
-var jwtSecret = "PJJP3CB51A29E8B9A70B29AB5FA3FC5FAFEFB34CFD881D629F3C892E9DF9F169AFA3PJPJ"
-
-// Set headers for JWT
-var header = {
-    'typ': 'JWT',
-    'alg': 'HS256'
-};
-
-// Prepare timestamp in seconds
-var currentTimestamp = Math.floor(Date.now() / 1000)
-
-
-function base64urlEncode(source) {
-    let encoded = CryptoJS.enc.Base64.stringify(source);
-    encoded = encoded.replace(/=+$/, ''); // Remove padding
-    encoded = encoded.replace(/\+/g, '-'); // Replace "+" with "-"
-    encoded = encoded.replace(/\//g, '_'); // Replace "/" with "_"
-    return encoded;
-}
-
-function generateJWTToken(payload) {
-    // Encode the header
-    const stringifiedHeader = CryptoJS.enc.Utf8.parse(JSON.stringify(header));
-    const encodedHeader = base64urlEncode(stringifiedHeader);
-
-    // Encode the payload
-    const stringifiedPayload = CryptoJS.enc.Utf8.parse(JSON.stringify(payload));
-    const encodedPayload = base64urlEncode(stringifiedPayload);
-
-    // Combine the header and payload
-    const token = `${encodedHeader}.${encodedPayload}`;
-
-    // Sign the token
-    const signature = CryptoJS.HmacSHA256(token, jwtSecret);
-    const encodedSignature = base64urlEncode(signature);
-
-    // Return the full token
-    return `${token}.${encodedSignature}`;
-}
-
-//const jwt = generateJWT();
-//pm.environment.set('jwt_signed', signedToken)
-//console.log('Signed and encoded JWT', jwt)
-
-
-// function main() {
-//     // JWT Payload
-//     const payload = {
-//         iss: "YTLC_TEST_AUTOMATION_APP",
-//         iat: currentTimestamp, // Issued at
-//         exp: currentTimestamp + 200, // Expiry time: 30 seconds from issuance
-//         user_agent: {
-//             id: "janga.reddy@ytl.com"
-//         }
-//     };
-
-//     console.log('JWT signed token:', generateJWTToken(payload));
-// }
-//main()
-module.exports = { generateJWTToken}

package/froth_common_actions_back/logData.js

@@ -1,73 +0,0 @@
-const amendToBrowserstack = require("../froth_api_calls/browsersatckSessionInfo").amend2Browserstack;
-
-async function logJsonData2Table(jsonData) {
-    try {
-        console.log("Logging JSON data to table format in BrowserStack:");
-        console.log(JSON.stringify(jsonData, null, 2));
-
-        if (!Array.isArray(jsonData) || jsonData.length === 0) {
-            await amendToBrowserstack("No data to log", "info");
-            return;
-        }
-
-        // --- Extract keys dynamically (columns) ---
-        const keys = Object.keys(jsonData[0]);
-
-        // --- Calculate max width for each column ---
-        const colWidths = {};
-        keys.forEach(key => {
-            colWidths[key] = Math.max(
-                key.length,
-                ...jsonData.map(row => String(row[key] ?? "").length)
-            ) + 2;
-        });
-
-        // --- Build line separator ---
-        const line = "-".repeat(
-            keys.reduce((sum, key) => sum + colWidths[key], 0) + keys.length + 1
-        );
-
-        // --- Build header ---
-        let table = line + "\n";
-        table += "|" + keys.map(key => ` ${key.padEnd(colWidths[key])}`).join("|") + "|\n";
-        table += line + "\n";
-
-        // --- Build rows ---
-        jsonData.forEach(row => {
-            table += "|" + keys.map(key => ` ${String(row[key] ?? "").padEnd(colWidths[key])}`).join("|") + "|\n";
-        });
-
-        table += line;
-        console.log(table);
-        // --- Send to BrowserStack ---
-        await amendToBrowserstack(table, "info");
-
-    } catch (error) {
-        console.error('Error occurred while logging JSON data to table:', error);
-        // let annotationMessage = `Error occurred while logging JSON data to table: ${error.message}.`;
-        // await amendToBrowserstack(annotationMessage, "error");
-    }
-}
-module.exports = {
-    logJsonData2Table
-};
-
-// // Main function to execute the API call
-// async function main() {
-//     try {
-//         /// BUFFER.setItem("EXECUTION_SESSIONID","297666e2fd4195de98d7da3b359669072ff41a2a");
-//         const pageTimes = "[{ name: 'Homepage', time: 120 },{ name: 'Service Account Page', time: 250 },{ name: 'Search Results', time: 180 }]";
-
-//         await logJsonData2Table(pageTimes, "info");
-//         // const data = [
-//         //     { id: 1, score: 95.5, passed: true },
-//         //     { id: 2, score: 67.2, passed: false },
-//         //     { id: 3, score: null, passed: "N/A" }
-//         // ];
-//         // await logJsonData2Table(data, "info");
-//     } catch (error) {
-//         console.error('Error in main function:', error);
-//     }
-// }
-
-// main();

package/froth_common_actions_back/random.js

@@ -1,230 +0,0 @@
-const RandExp = require('randexp');
-
-// Random number generator that can handle both range and length
-async function RNDNUMBER(minOrLength, max) {
-    if (max !== undefined) {
-        // If max is provided, generate a number within the specified range
-        return Math.floor(Math.random() * (max - minOrLength + 1)) + minOrLength;
-    } else {
-        // Otherwise, generate a random number of the specified length
-        const length = minOrLength || 18; // Default to 18 digits if no length is provided
-        //  if (length <= 0) length = 18; // Default to 18 digits if length is invalid
-
-        const min = Math.pow(10, length - 1); // Minimum value for the given length
-        const max = Math.pow(10, length) - 1; // Maximum value for the given length
-
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-}
-
-// Random floating-point number between 0 and 1
-async function RNDFLOAT() {
-    return Math.random();
-}
-
-// Random integer between 0 and 100000 (large multiplier range)
-async function RNDINT() {
-    return Math.floor(Math.random() * 100000);
-}
-
-// Random text string of specified length
-async function RANDOMTEXT(length) {
-    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += characters.charAt(Math.floor(Math.random() * characters.length));
-    }
-    return result;
-}
-
-// Random alphanumeric string of specified length
-async function RNDALPHANUM(length) {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return result;
-}
-
-async function RNDDECIMAL(minOrLength, max, decimalPlaces) {
-    if (max !== undefined) {
-        // If max is provided, generate a decimal number within the specified range
-        let randomNum = Math.random() * (max - minOrLength) + minOrLength;
-        console.log(randomNum);
-        return parseFloat(randomNum.toFixed(decimalPlaces));
-    } else {
-        // Otherwise, generate a random decimal number between 0 and 1, rounded to the specified decimal places
-        let length = minOrLength;
-        const integerLength = length - decimalPlaces - 1; // Subtract 1 for the decimal point
-        let integerPart = 0;
-
-        if (integerLength > 0) {
-            const minInt = Math.pow(10, integerLength - 1);
-            const maxInt = Math.pow(10, integerLength) - 1;
-
-            // Generate the integer part
-            integerPart = Math.floor(Math.random() * (maxInt - minInt + 1)) + minInt;
-        }
-        // Generate the decimal part
-        const decimalFactor = Math.pow(10, decimalPlaces);
-        const decimalPart = Math.floor(Math.random() * decimalFactor);
-        // Combine integer and decimal parts
-        const result = `${integerPart}.${decimalPart.toString().padStart(decimalPlaces, '0')}`;
-        return result;
-    }
-}
-
-
-// Random string based on regex pattern
-async function RNDREGEX(regex) {
-    console.log("inside random regex", regex);
-    return new RandExp(regex).gen();
-}
-
-async function RNDDATE(startYear = 1950, endYear = 2005, format = 'YYMMDD') {
-    // Generate a random year between startYear and endYear
-    const start = new Date(`${startYear}-01-01`).getTime();
-    const end = new Date(`${endYear}-12-31`).getTime();
-
-    const randomTimestamp = start + Math.random() * (end - start);
-    const randomDate = new Date(randomTimestamp);
-    console.log(randomDate);
-    return FORMATDATE(randomDate, format);
-}
-
-async function FORMATDATE(date, format) {
-    const yy = String(date.getFullYear()).slice(2);
-    const yyyy = String(date.getFullYear());
-    const mm = String(date.getMonth() + 1).padStart(2, '0');
-    const dd = String(date.getDate()).padStart(2, '0');
-
-    switch (format.toUpperCase()) {
-        case 'YYMMDD': return `${yy}${mm}${dd}`;
-        case 'DDMMYY': return `${dd}${mm}${yy}`;
-        case 'YYYYMMDD': return `${yyyy}${mm}${dd}`;
-        case 'DDMMYYYY': return `${dd}${mm}${yyyy}`;
-        case 'MMDDYY': return `${mm}${dd}${yy}`;
-        case 'MMDDYYYY': return `${mm}${dd}${yyyy}`;
-        case 'YYDDMM': return `${yy}${dd}${mm}`;
-        case 'YYYYDDMM': return `${yyyy}${dd}${mm}`;
-        default: return `${yy}${mm}${dd}`; // Fallback to YYMMDD
-    }
-}
-// Main function to process templates and replace placeholders with random values
-async function RANDOM(template, datatype) {
-    const regex = /\{(.*?)\}/g;
-    let matches = [...template.matchAll(regex)];
-
-    // Iterate over all matches and replace them with the resolved values
-    let replacements = await Promise.all(matches.map(async (match) => {
-        const content = match[1]; // Get the content inside { ... }
-
-        const parts = content.split(/[\[\]]/).filter(Boolean); // Split by square brackets
-        const type = parts[0];
-        console.log("type is :" + type);
-        console.log("parts are :" + parts);
-        switch (type) {
-            case 'RND':
-                if (parts.length === 1) {
-                    return await RNDNUMBER(); // {RND} - Default to 5-digit number
-                }
-                else if (parts.length === 2) {
-                    return await RNDNUMBER(parseInt(parts[1])); // {RND[length]}
-                } else if (parts.length === 3) {
-                    return await RNDNUMBER(parseInt(parts[1]), parseInt(parts[2])); // {RND[min][max]}
-                } else {
-                    return await RNDNUMBER(); // {RND} - Default to 5-digit number
-                }
-                break;
-
-            case 'RNDDECIMAL':
-                console.log(parts);
-                if (parts.length === 3) {
-                    return await RNDDECIMAL(parseInt(parts[1]), undefined, parseInt(parts[2])); // {RNDDECIMAL[length][decimalPlaces]}
-                } else if (parts.length === 4) {
-                    return await RNDDECIMAL(parseInt(parts[1]), parseInt(parts[2]), parseInt(parts[3])); // {RNDDECIMAL[length][decimalPlaces]}
-                } else {
-                    return await RNDDECIMAL(6, undefined, 2); // {RNDDECIMAL[length][decimalPlaces]}
-                }
-                break;
-
-            case 'RANDOMTEXT':
-                return await RANDOMTEXT(parseInt(parts[1])); // {RANDOMTEXT[length]}
-                break;
-            case 'CTMSTMP':
-                console.log("inside CTMSTMP",Date.now());
-                return Date.now(); // Current timestamp
-                break;
-
-            case 'RANDOMREGEX':
-                let regexPattern;
-                if (parts.length === 3) {
-                    regexPattern = `[${parts[1]}]{${parts[2]}}`; // {RANDOMREGEX[pattern][length]}
-                    console.log("regex pattern is :" + regexPattern);
-                } else if (parts.length === 2) {
-                    regexPattern = `[${parts[1]}]{10}`; // {RANDOMREGEX[pattern][length]}
-                    console.log("regex pattern is :" + regexPattern);
-                }
-                let regex = new RegExp(regexPattern);
-                return await RNDREGEX(regex); // Generate random string based on regex
-                break;
-
-            case 'RNDDATE':
-                return await RNDDATE(parseInt(parts[1]), parseInt(parts[2])); // Generate random date of birth
-                break;
-
-            default:
-                return match[0]; // If no match found, return original template string
-                break;
-
-        }
-    }));
-
-    // Replace all matches with their resolved values
-    let result = template;
-    matches.forEach((match, index) => {
-        result = result.replace(match[0], replacements[index]);
-    });
-    datatype = datatype.toLowerCase();
-
-    if (datatype == 'integer') {
-        result = parseInt(result);
-    }
-    else if (datatype == 'decimal') {
-        console.log("insude decimal");
-        result = parseFloat(result);
-    }
-    else if (datatype == 'string') {
-        result = result.toString();
-    }
-
-    return result;
-}
-
-// Example function to test the template replacement
-// async function main() {
-
-//     let template = "SUBHRASUBUDHI {CTMSTMP} @GMAQIL.COM";
-//     let result = await RANDOM(template, 'STRING');
-//     console.log(result);
-//     console.log(typeof result);
-//     // template = "{RANDOMREGEX[\\\\d{5}(-\\\\\d{4})?][10]}";
-//     // result = await RANDOM(template, 'STRING');
-//     // console.log(result);
-//     // console.log(typeof result);
-
-// }
-
-//main();
-module.exports = {
-    RNDNUMBER,
-    RNDFLOAT,
-    RNDINT,
-    RANDOMTEXT,
-    RNDALPHANUM,
-    RNDDECIMAL,
-    RNDREGEX,
-    RANDOM,
-    RNDDATE
-};

package/froth_common_actions_back/scroll.js

@@ -1,104 +0,0 @@
-async function scrollToEnd(maxSwipes, steps) {
-
-    try {
-        console.log('Scrolling to end');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollToEnd(' + maxSwipes + ',' + steps + ')');
-        await driver.pause(3000);
-        console.log('Scrolled to end');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-
-async function scrollToLeft(steps) {
-
-    try {
-        console.log('Scrolling to left');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollable.setAsHorizontalList().scrollBackward(' + steps + ')');
-        await driver.pause(3000);
-        console.log('Scrolled to left');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-
-async function scrollToBeginning(maxSwipes, steps) {
-
-    try {
-        console.log('Scrolling to beginning');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollToBeginning(' + maxSwipes + ',' + steps + ')');
-        await driver.pause(3000);
-        console.log('Scrolled to beginning');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-async function scrollRightToView(text) {
-
-    try {
-        console.log('Scrolling to right until text is found');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).setAsHorizontalList().scrollTextIntoView("' + text + '")');
-        await driver.pause(3000);
-        console.log('Scrolled to right completed');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-async function scrollDownToView(text) {
-
-    try {
-        console.log('Scrolling down until text is found');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollTextIntoView("' + text + '")');
-        await driver.pause(3000);
-        console.log('Scrolled down completed');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-async function scrollToRight(steps) {
-
-    try {
-        console.log('Scrolling to right');
-        await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollable.setAsHorizontalList().scrollForward(' + steps + ')');
-        await driver.pause(3000);
-        console.log('Scrolled to right');
-    } catch (error) {
-        console.error(error.message);
-    }
-}
-
-async function scrollIntoView(element){
-    try{
-        const elem = await $(element);
-        // scroll to specific element
-        await elem.scrollIntoView();
-        // center element within the viewport
-      //  await elem.scrollIntoView({ block: 'center', inline: 'center' });
-
-    }catch(error){
-        console.error(error.message);
-    }
-}
-
-async function scrollupUntilVisible(selector) {
-    const element = await $(selector);
-
-    while (!(await element.isDisplayed())) {
-        await driver.performActions([
-            {
-                type: 'pointer',
-                id: 'finger1',
-                parameters: { pointerType: 'touch' },
-                actions: [
-                    { type: 'pointerMove', duration: 0, x: 200, y: 800 },
-                    { type: 'pointerDown', button: 0 },
-                    { type: 'pause', duration: 100 },
-                    { type: 'pointerMove', duration: 500, x: 200, y: 200 },
-                    { type: 'pointerUp', button: 0 }
-                ]
-            }
-        ]);
-        await browser.pause(500);
-    }
-}
-module.exports = { scrollToEnd, scrollToLeft, scrollToBeginning, scrollRightToView, scrollDownToView, scrollToRight ,scrollIntoView,scrollupUntilVisible};