froth-webdriverio-framework 7.0.17 → 7.0.19

package/froth_common_actions_back/swicthWindowTab.js

@@ -0,0 +1,36 @@
+/**
+ * Switches to a browser window/tab by its title using WebdriverIO.
+ * @param {string} title - The title of the window/tab to switch to.
+ */
+async function switch2WindowByTitle(title) {
+    const handles = await browser.getWindowHandles();
+    for (const handle of handles) {
+        await browser.switchToWindow(handle);
+        const currentTitle = await browser.getTitle();
+        if (currentTitle === title) {
+            return true; // Switched successfully
+        }
+    }
+    throw new Error(`No window with title "${title}" found.`);
+}
+
+/**
+ * Switches to a browser window/tab by its index using WebdriverIO.
+ * @param {number} index - The index of the window/tab to switch to (0-based).
+ */
+async function switch2WindowByIndex(index) {
+    const handles = await browser.getWindowHandles();
+    console.log(`Total open windows: ${handles.length}`);
+    console.log(`Switching to window at index: ${index}`);
+    console.log(`Available handles: ${handles.join(', ')}`);
+    if (index < 0 || index >= handles.length) {
+        throw new Error(`Invalid window index: ${index}. There are only ${handles.length} windows open.`);
+    }
+    await browser.switchToWindow(handles[index]);
+    return true; // Switched successfully
+}
+
+
+// Example usage in a test
+// await switchToWindowByTitle('Your Window Title');
+module.exports = {switch2WindowByTitle,switch2WindowByIndex};

package/froth_common_actions_back/swipe.js

@@ -0,0 +1,219 @@
+async function swipeleft(selector, xoffset, speedinsec) {
+    try {
+        console.log('Swiping left');
+
+        if (xoffset == null) {
+            driver.swipeLeft(selector, speedinsec);
+        } else {
+            driver.swipeLeft(selector, xoffset, speedinsec);
+        }
+    } catch (error) {
+        console.error(error.message);
+    }
+
+}
+
+async function swiperight(selector, xoffset, speedinsec) {
+    try {
+        console.log('Swiping right');
+
+        if (xoffset == null) {
+            driver.swipeRight(selector, speedinsec);
+        } else {
+            driver.swipeRight(selector, xoffset, speedinsec);
+        }
+    } catch (error) {
+        console.error(error.message);
+    }
+
+}
+
+async function swipeup(selector, yoffset, speedinsec) {
+    try {
+        console.log('Swiping up');
+
+        if (yoffset == null) {
+            driver.swipeUp(selector, speedinsec);
+        } else {
+            driver.swipeUp(selector, yoffset, speedinsec);
+        }
+    } catch (error) {
+        console.error(error.message);
+    }
+}
+
+async function swipedown(selector, yoffset, speedinsec) {
+    try {
+        console.log('Swiping down');
+
+        if (yoffset == null) {
+            driver.swipeDown(selector, speedinsec);
+        } else {
+            driver.swipeDown(selector, yoffset, speedinsec);
+        }
+    } catch (error) {
+        console.error(error.message);
+    }
+}
+
+async function swipewithcoordinates(StartX, StartY, EndX, EndY) {
+
+    await driver.performActions([
+        {
+            type: "pointer",
+            id: "finger1",
+            parameters: { pointerType: "touch" },
+            actions: [
+                { type: "pointerMove", duration: 0, x: StartX, y: StartY },
+                { type: "pointerDown", button: 0 },
+                { type: "pause", duration: 300 },
+                { type: "pointerMove", duration: 1000, x: EndX, y: EndY },
+                { type: "pointerUp", button: 0 }
+            ],
+        }
+    ]);
+}
+async function swipetofit() {
+    // Get screen size dynamically
+    const screenSize = await driver.getWindowRect();
+    const screenWidth = screenSize.width;
+    const screenHeight = screenSize.height;
+
+    console.log(`Screen Size: Width=${screenWidth}, Height=${screenHeight}`);
+
+    // Define approximate positions for corners
+    const topRightStartX = screenWidth * 0.88; // Top-right corner
+    const topRightStartY = screenHeight * 0.44;
+
+    const topRightEndX = screenWidth * 0.96; // Expand to the right
+    const topRightEndY = screenHeight * 0.39; // Move upwards slightly
+
+    const bottomLeftStartX = screenWidth * 0.12; // Bottom-left corner
+    const bottomLeftStartY = screenHeight * 0.69;
+
+    const bottomLeftEndX = screenWidth * 0.014; // Expand to the left
+    const bottomLeftEndY = screenHeight * 0.73; // Move down slightly
+
+    console.log(`Resizing top-right from (${topRightStartX}, ${topRightStartY}) to (${topRightEndX}, ${topRightEndY})`);
+    console.log(`Resizing bottom-left from (${bottomLeftStartX}, ${bottomLeftStartY}) to (${bottomLeftEndX}, ${bottomLeftEndY})`);
+
+    // Resize from top-right corner
+    await driver.performActions([
+        {
+            type: "pointer",
+            id: "finger1",
+            parameters: { pointerType: "touch" },
+            actions: [
+                { type: "pointerMove", duration: 0, x: topRightStartX, y: topRightStartY },
+                { type: "pointerDown", button: 0 },
+                { type: "pause", duration: 300 },
+                { type: "pointerMove", duration: 1000, x: topRightEndX, y: topRightEndY },
+                { type: "pointerUp", button: 0 }
+            ],
+        }
+    ]);
+
+    // Resize from bottom-left corner
+    await driver.performActions([
+        {
+            type: "pointer",
+            id: "finger2",
+            parameters: { pointerType: "touch" },
+            actions: [
+                { type: "pointerMove", duration: 0, x: bottomLeftStartX, y: bottomLeftStartY },
+                { type: "pointerDown", button: 0 },
+                { type: "pause", duration: 300 },
+                { type: "pointerMove", duration: 1000, x: bottomLeftEndX, y: bottomLeftEndY },
+                { type: "pointerUp", button: 0 }
+            ],
+        }
+    ]);
+
+    console.log("✅ Crop overlay resized from two corners successfully!");
+}
+
+// async function swipetofit(TopRStartXpct, TopRStartYpct, TopREndXpct, TopREndYpct, BottomLStartXpct, BottomLStartYpct, BottomLEndXpct, BottomLEndYpct) {
+    
+//     let topRightStartX; // Top-right corner
+//     let topRightStartY;
+
+//     let topRightEndX; // Expand to the right
+//     let topRightEndY; // Move upwards slightly
+
+//     let bottomLeftStartX; // Bottom-left corner
+//     let bottomLeftStartY;
+
+//     let bottomLeftEndX; // Expand to the left
+//     let bottomLeftEndY;
+
+//     // Get screen size dynamically
+//     const screenSize = await driver.getWindowRect();
+//     const screenWidth = screenSize.width;
+//     const screenHeight = screenSize.height;
+
+//     console.log(`Screen Size: Width=${screenWidth}, Height=${screenHeight}`);
+//     // Define approximate positions for corners
+
+//     if (TopRStartXpct === null) {// default calucaltion
+//         topRightStartX = screenWidth * 0.88; // Top-right corner
+//         topRightStartY = screenHeight * 0.44;
+
+//         topRightEndX = screenWidth * 0.96; // Expand to the right
+//         topRightEndY = screenHeight * 0.39; // Move upwards slightly
+
+//         bottomLeftStartX = screenWidth * 0.12; // Bottom-left corner
+//         bottomLeftStartY = screenHeight * 0.69;
+
+//         bottomLeftEndX = screenWidth * 0.014; // Expand to the left
+//         bottomLeftEndY = screenHeight * 0.73;
+//     } else {
+//         topRightStartX = screenWidth * (TopRStartXpct / 100); // Top-right corner
+//         topRightStartY = screenHeight * (TopRStartYpct / 100);
+
+//         topRightEndX = screenWidth * (TopREndXpct / 100); // Expand to the right
+//         topRightEndY = screenHeight * (TopREndYpct / 100); // Move upwards slightly
+
+//         bottomLeftStartX = screenWidth * (BottomLStartXpct / 100); // Bottom-left corner
+//         bottomLeftStartY = screenHeight * (BottomLStartYpct / 100);
+
+//         bottomLeftEndX = screenWidth * (BottomLEndXpct / 100); // Expand to the left
+//         bottomLeftEndY = screenHeight * (BottomLEndYpct / 100); // Move down slightly
+//     }
+//     console.log(`Resizing top-right from (${topRightStartX}, ${topRightStartY}) to (${topRightEndX}, ${topRightEndY})`);
+//     console.log(`Resizing bottom-left from (${bottomLeftStartX}, ${bottomLeftStartY}) to (${bottomLeftEndX}, ${bottomLeftEndY})`);
+
+//     // Resize from top-right corner
+//     await driver.performActions([
+//         {
+//             type: "pointer",
+//             id: "finger1",
+//             parameters: { pointerType: "touch" },
+//             actions: [
+//                 { type: "pointerMove", duration: 0, x: topRightStartX, y: topRightStartY },
+//                 { type: "pointerDown", button: 0 },
+//                 { type: "pause", duration: 300 },
+//                 { type: "pointerMove", duration: 1000, x: topRightEndX, y: topRightEndY },
+//                 { type: "pointerUp", button: 0 }
+//             ],
+//         }
+//     ]);
+
+//     // Resize from bottom-left corner
+//     await driver.performActions([
+//         {
+//             type: "pointer",
+//             id: "finger2",
+//             parameters: { pointerType: "touch" },
+//             actions: [
+//                 { type: "pointerMove", duration: 0, x: bottomLeftStartX, y: bottomLeftStartY },
+//                 { type: "pointerDown", button: 0 },
+//                 { type: "pause", duration: 300 },
+//                 { type: "pointerMove", duration: 1000, x: bottomLeftEndX, y: bottomLeftEndY },
+//                 { type: "pointerUp", button: 0 }
+//             ],
+//         }
+//     ]);
+
+//     console.log("✅ Crop overlay resized from two corners successfully!");
+// }
+module.exports = { swipeleft, swipedown, swiperight, swipeup, swipetofit, swipewithcoordinates };

package/froth_configs/commonhook.js

@@ -159,7 +159,7 @@ const commonHooks = {
         capabilities['bstack:options'] = bsOpts;
 
       }
-      //console.log('final cinfig dteials :' + JSON.stringify(capabilities))
+      console.log('final cinfig dteials :' + JSON.stringify(capabilities))
 
      // console.log("config details " + JSON.stringify(config))
 

package/froth_configs_back/commonconfig.js

@@ -0,0 +1,409 @@
+const path = require('path');
+const url = require('url');
+const fs = require('fs');
+const { LocalStorage } = require('node-localstorage');
+global.BUFFER = new LocalStorage('./storage');
+const setAllDetails = require("./setallDatailinBuffer")
+const exeDetails = require("../froth_api_calls/getexecutionDetails")
+const getBSSessionDetails = require("../froth_api_calls/browsersatckSessionInfo").getBSSessionDetails;
+const { fail } = require("assert");
+const { error } = require('console');
+//const isBrowserStackEnabled = process.env.BROWSERSTACK;
+let starttime;
+let endtime;
+let duration_tests = 0;
+console.log('===== common config===== ');
+const resultdetails = {
+    comments: [],
+    excution_status: null,        // Pass/Fail
+    excution_time: null,   // Execution time in milliseconds
+};
+// Description: This file contains the common configuration for the webdriverio framework.
+const commonconfig = {
+
+    onPrepare: async function (capabilities, specs) {
+        try {
+
+            console.log('==== ON PREPARE HOOK ====');
+            // This code runs before the test suite starts
+            await setAllDetails.setEnvVariables();
+            await setAllDetails.setExecutionDetails();
+            await setAllDetails.setSuiteDetails();
+            await setAllDetails.setTestDataDetails();
+            console.log("on prepare:", JSON.stringify(capabilities))
+
+            //  console.log("ALL JSON DATA in env variable :" + JSON.stringify(process.env));
+        } catch (e) {
+            console.log("====> Error in onPrepare:", e);
+
+        }
+    },
+
+
+    beforeSession: async function (config, capabilities, specs) {
+        try {
+            let syntaxFailed = false;
+
+            console.log('==== BEFORE SESSION HOOK ====');
+            // Perform any setup or pre-test actions here
+            console.log("specdat:", specs);
+            console.log("length:", specs.length);
+            //checking the syntax error in the test files
+            for (const fileUrl of specs) {
+                const filePath = url.fileURLToPath(fileUrl); // convert file:// URL to file path
+                try {
+                    const code = fs.readFileSync(filePath, 'utf8');
+                    new Function(code); // Try to compile
+                } catch (err) {
+                    // Extract line number from stack trace
+                    const match = err.stack.match(/\((.*):(\d+):(\d+)\)/);
+                    const lineInfo = match ? ` at line ${match[2]}, column ${match[3]}` : '';
+
+                    const errorMsg = `❌ Syntax error in '${path.basename(filePath)}'${lineInfo}: ${err.message}`;
+                    console.error("🚨", errorMsg);
+                    resultdetails.comments.push(errorMsg);
+                    syntaxFailed = true;
+                }
+            }
+            if (syntaxFailed) {
+                resultdetails.excution_status = 'FAILED';
+                await exeDetails.updateExecuitonDetails(
+                    BUFFER.getItem("ORGANISATION_DOMAIN_URL"),
+                    BUFFER.getItem("FROTH_LOGIN_TOKEN"),
+                    BUFFER.getItem("FROTH_EXECUTION_ID"),
+                    resultdetails
+                );
+                process.exit(1);
+            }
+            // set the capability like media and app and bs local
+            // if (process.env.PLATFORM === 'browserstack') {
+            //     /// console.log("capabilities:", capabilities);
+            //     capabilities.browserstackLocal = process.env.BROWSERSTACK_LOCAL;
+            //     // capabilities.accessKey = Buffer.from(capabilities.accessKey, 'base64').toString('utf-8');
+            //     if (capabilities.platformName === 'android' || capabilities.platformName === 'ios') {
+            //         capabilities.app = process.env.BROWSERSTACK_APP_PATH;
+            //         if (capabilities.app === undefined || capabilities.app === null || capabilities.app === '') {
+            //             console.error("🚨 Error: BROWSERSTACK_APP_PATH is not defined or empty.");
+            //             resultdetails.excution_status = 'FAILED';
+            //             resultdetails.comments.push("BROWSERSTACK_APP_PATH is not defined or empty.");
+            //             await exeDetails.updateExecuitonDetails(BUFFER.getItem("ORGANISATION_DOMAIN_URL"), BUFFER.getItem("FROTH_LOGIN_TOKEN"), BUFFER.getItem("FROTH_EXECUTION_ID"), resultdetails);
+            //             process.exit(1); // Stop execution if app path is not set
+            //         } else {
+            //             console.log("App Path:", capabilities.app);
+            //             console.log("Browserstack Local:", capabilities.browserstackLocal);
+            //         }
+            //     }
+
+            //     try {
+            //         let mediaFiles = process.env.MEDIA_FILES ? JSON.parse(process.env.MEDIA_FILES) : [];
+            //         console.log("Size of Media Files:", Array.isArray(mediaFiles) ? mediaFiles.length : "Invalid data");
+
+            //         if (Array.isArray(mediaFiles) && mediaFiles.length > 0) {
+            //             console.log("Media Files:", JSON.parse(process.env.MEDIA_FILES));
+            //             capabilities['browserstack.uploadMedia'] = JSON.parse(process.env.MEDIA_FILES);
+            //         }
+            //     } catch (error) {
+            //         console.error("Error parsing MEDIA_FILES:", error);
+            //     }
+
+            //     console.log(`Running tests on after app,bslocal,mediafiles: ${JSON.stringify(capabilities)}`);
+            // }
+
+        } catch (error) {
+            console.error('🚨 Error in beforeSession:', error);
+            console.error('🚨 Error in beforeSession:', error.message);
+            resultdetails.excution_status = 'FAILED';
+            resultdetails.comments.push("Session creation failed:", error.message);
+            await exeDetails.updateExecuitonDetails(BUFFER.getItem("ORGANISATION_DOMAIN_URL"), BUFFER.getItem("FROTH_LOGIN_TOKEN"), BUFFER.getItem("FROTH_EXECUTION_ID"), resultdetails)
+            //  throw new Error(`Session creation failed: ${error.message}`);
+            process.exit(1); // Stop execution if session creation fails
+
+        }
+
+
+    },
+    /**
+     * Gets executed before the suite starts (in Mocha/Jasmine only).
+     * @param {object} suite suite details
+     */
+    beforeSuite: async function (suite) {
+        try {
+            console.log('==== BEFORE SUITE HOOK ====');
+            console.log(`====> Test suite has been started ' ${suite.title}' `,);
+
+            starttime = new Date().getTime();
+
+            if (process.env.PLATFORM === 'browserstack')
+                await getBSSessionDetails(process.env.BS_SESSION_TYPE, process.env.BROWSERSTACK_USERNAME, process.env.BROWSERSTACK_ACCESS_KEY);
+
+
+            // const resultdetails = {};
+            await exeDetails.update_CICDRUNID_ReportUrl(BUFFER.getItem("ORGANISATION_DOMAIN_URL"), BUFFER.getItem("FROTH_LOGIN_TOKEN"), BUFFER.getItem("FROTH_EXECUTION_ID"))
+            BUFFER.setItem("UPDATE_EXECUTION", 'FALSE') //i need to recall 
+
+        } catch (e) {
+            console.log("Error in beforeSuite:", e);
+        }
+    },
+
+    before: async function (capabilities, specs) {
+        if (process.env.BS_SESSION_TYPE === 'automate') {
+            console.log('==== BEFORE HOOK ====')
+            await browser.maximizeWindow()
+        }
+        else {
+            console.log('==== BEFORE HOOK FOR MOBILE ====');
+        }
+
+    },
+
+    /**
+    * Function to be executed before a test (in Mocha/Jasmine only)
+    * @param {object} test    test object
+    * @param {object} context scope object the test was executed with
+    */
+    beforeTest: async function (test, context) {
+
+        console.log('==== BEFORE TEST HOOK ====');
+        console.log(`====> Test Started '${test.title}'`);
+
+    },
+
+
+    /**
+     * Function to be executed after a test (in Mocha/Jasmine only)
+     * @param {object}  test             test object
+     * @param {object}  context          scope object the test was executed with
+     * @param {Error}   result.error     error object in case the test fails, otherwise `undefined`
+     * @param {*}       result.result    return object of test function
+     * @param {number}  result.duration  duration of test
+     * @param {boolean} result.passed    true if test has passed, otherwise false
+     * @param {object}  result.retries   information about spec related retries, e.g. `{ attempts: 0, limit: 0 }`
+     */
+    afterTest: async function (test, context, { error, result, duration, passed, retries }) {
+        console.log('==== AFTER TEST HOOK ====');
+        console.log(`====> Test name finished '${test.title}'`);
+
+        const fileName = path.basename(test.file);
+        console.log('====> Test File Name:', fileName);
+        // BUFFER.setItem("FROTH_TOTAL_DURATION", Number(BUFFER.getItem("FROTH_TOTAL_DURATION")) + duration)
+        console.log(`====> Total Duration for this test: ${duration}ms`);
+        duration_tests += duration;
+        console.log(`====> Total Duration for all tests: ${duration_tests}ms`);
+        console.log(`====> Status of test: ${passed}`);
+
+        let scriptresult = "NOT RUN";
+        // Default assumption: test passed (unless soft assertion failed)
+        let finalPassed = passed;
+
+        if (passed) {
+            scriptresult = "PASSED"
+            resultdetails.comments.push(`${test.title} - passed`);
+            console.log(`====> resultdetails comments: ${resultdetails.comments}`);
+        }
+        else if (!finalPassed || error) {
+            scriptresult = "FAILED"
+            console.log(`====> Failed or error while executing the test: ${error ? error.message : "Test failed"}`);
+            if (!resultdetails.comments.some(comment => typeof comment === 'string' && comment.includes(test.title)))
+                resultdetails.comments.push(`${test.title} - failed: ${error ? error.message : "Test failed"}`);
+
+        }
+
+        let scriptDetails = BUFFER.getItem("FROTHE_SUITE_DETAILS");
+        if (typeof scriptDetails === "string") {
+            scriptDetails = JSON.parse(scriptDetails);
+        }
+        const jwtScript = scriptDetails.find(s => s.scriptName === fileName.replace(".js", ""));
+        console.log("jwtScript:", jwtScript);
+
+        await exeDetails.updateScriptExecutionStatus(
+            BUFFER.getItem("ORGANISATION_DOMAIN_URL"),
+            BUFFER.getItem("FROTH_LOGIN_TOKEN"),
+            jwtScript.scriptId,
+            jwtScript.platform.toLowerCase(),
+            scriptresult)
+
+
+    },
+    /**
+    * Hook that gets executed after the suite has ended (in Mocha/Jasmine only).
+    * @param {object} suite suite details
+    */
+    afterSuite: async function (suite) {
+        console.log('==== AFTER SUITE HOOK ====');
+        console.log(`====> Test suite has completed '${suite.title}'`);
+    },
+    /**
+    * Gets executed after all tests are done. You still have access to all global variables from
+    * the test.
+    * @param {number} result 0 - test pass, 1 - test fail
+    * @param {Array.<Object>} capabilities list of capabilities details
+    * @param {Array.<String>} specs List of spec file paths that ran
+    */
+    after: async function (result, config, capabilities, specs) {
+        console.log('==== AFTER HOOK ====');
+        console.log('====> All tests are completed.' + result);
+        BUFFER.setItem("RESULT_DATA", result);
+        console.log("====> Result data :" + BUFFER.getItem("RESULT_DATA"))
+        resultdetails.excution_status = BUFFER.getItem("RESULT_DATA") == 0 ? 'PASSED' : 'FAILED'
+        console.log("====> Total Duration taken for the suite:" + BUFFER.getItem("FROTH_TOTAL_DURATION"));
+        console.log("====> Execution Status from results" + resultdetails.excution_status);
+        // Capture WebDriver session errors
+
+        if (result !== 0) {
+            if (resultdetails.comments.length === 0) {
+                resultdetails.comments.push("❌ WebDriver session failed or timed out.");
+            }
+            resultdetails.comments.push(`Execution failed with exit code: ${result}`);
+
+            process.on('uncaughtException', (err) => {
+                console.error("Uncaught Exception:", err);
+                resultdetails.comments.push(`Execution failed : ${err}`);
+            });
+
+        }
+
+    },
+
+    onError: async function (error) {
+        console.error('==== ON ERROR HOOK ====');
+        console.error('====> Error occurred:', error.message);
+        if (error.message.includes('Automate testing time expired')) {
+            console.log('❌ Global error: Session timed out on BrowserStack.');
+            resultdetails.excution_status = 'FAILED';
+            resultdetails.comments.push(`Global error: Session timed out on BrowserStack.Please check ths session: ${result}`);
+
+            await exeDetails.updateExecuitonDetails(BUFFER.getItem("ORGANISATION_DOMAIN_URL"), BUFFER.getItem("FROTH_LOGIN_TOKEN"), BUFFER.getItem("FROTH_EXECUTION_ID"), resultdetails)
+            process.exit(1); // Stop execution if session timed out
+        }
+    },
+    afterSession: async function (config, capabilities, specs) {
+        console.log('==== AFTER SESSION HOOK ====');
+        console.log('====> This is the aftersession hook');
+        // console.log("Capabilities:", capabilities);
+        console.log("Specs:", specs);
+        //console.log("Config:", config);
+
+        process.on('uncaughtException', (err) => {
+            console.error("Uncaught Exception:", err);
+            resultdetails.comments.push(`Execution failed with exit code: ${err}`);
+        });
+
+        // Capture unhandled promise rejections
+        process.on('unhandledRejection', (reason, promise) => {
+            console.error("Unhandled Promise Rejection:", reason);
+            resultdetails.comments.push(`Execution failed with exit code: ${reason}`);
+        });
+
+        endtime = new Date().getTime();
+        let totalDuration = endtime - starttime;
+        console.log("====> Total Duration taken for :" + BUFFER.getItem("FROTH_TOTAL_DURATION"));
+        console.log("====> Total Duration in after session based on start time and end time:" + totalDuration);
+        console.log("====> Total Duration in after session based on summing up the test execution times:" + duration_tests);
+
+        resultdetails.excution_status = BUFFER.getItem("RESULT_DATA") == 0 ? 'PASSED' : 'FAILED'
+        const frothDuration = BUFFER.getItem("FROTH_TOTAL_DURATION");
+
+        if (await isInvalidDuration(frothDuration)) {
+            //  console.log("inside froth duration");
+            if (await isInvalidDuration(duration_tests)) {
+                console.log("inside froth duration_tests");
+                resultdetails.excution_time = await millisecondsToTime(totalDuration);
+            } else {
+                console.log("inside froth duration_tests comparision");
+                if (totalDuration > duration_tests)
+                    resultdetails.excution_time = await millisecondsToTime(totalDuration);
+                else
+                    resultdetails.excution_time = await millisecondsToTime(duration_tests);
+            }
+        } else {
+            console.log("inside froth duration else");
+            resultdetails.excution_time = await secondsToTime(frothDuration);
+        }
+
+        console.log("====> Total Duration calculation:" + resultdetails.excution_time);
+
+        await exeDetails.updateExecuitonDetails(BUFFER.getItem("ORGANISATION_DOMAIN_URL"), BUFFER.getItem("FROTH_LOGIN_TOKEN"), BUFFER.getItem("FROTH_EXECUTION_ID"), resultdetails)
+
+        // Perform any cleanup or post-test actions here
+        BUFFER.clear();
+    },
+
+    onComplete: async function (exitCode, config, capabilities, results) {
+        console.log('==== ON COMPLETE HOOK ====');
+        console.log('====> Results:', results);
+        console.log('==== Test Results Summary ======');
+        console.log('Total Tests:', results.total);
+        console.log('Passed:', results.passed);
+        console.log('Failed:', results.failed);
+        console.log('Exit Code:', exitCode);
+
+        console.log('==== ALL TESTS ARE COMPLETED ====');
+        return exitCode;
+    }
+
+};
+async function isInvalidDuration(val) {
+    console.log("val in isValidDuration:" + val);
+    // Check if the value is null, 0, or undefined
+    let isValid;
+    if (typeof val === 'string') {
+        val = val.trim().toLowerCase();
+        isValid = val === "null" || val === "0" || val === "undefined";
+
+    } else
+        isValid = val === null || val === 0 || val === undefined;
+
+    console.log("isValid in isValidDuration:" + isValid);
+
+    return isValid;
+}
+async function secondsToTime(secs) {
+    console.log("secs in secondsToTime :" + secs);
+    let hours = Math.floor(secs / 3600);
+    let minutes = Math.floor((secs % 3600) / 60);
+    let seconds = secs % 60;
+
+    // Adding leading zeros if the value is less than 10
+    if (hours < 10) hours = '0' + hours;
+    if (minutes < 10) minutes = '0' + minutes;
+    if (seconds < 10) seconds = '0' + seconds;
+    console.log("Time:" + hours + ':' + minutes + ':' + seconds);
+    return hours + ':' + minutes + ':' + seconds;
+}
+async function millisecondsToTime(ms) {
+    console.log("ms in millisecondsToTime: " + ms);
+
+    // Ensure input is a number
+    ms = Number(ms);
+    if (isNaN(ms)) {
+        return '00:00:00';
+    }
+
+    let totalSeconds = Math.floor(ms / 1000);
+    let hours = Math.floor(totalSeconds / 3600);
+    let minutes = Math.floor((totalSeconds % 3600) / 60);
+    let seconds = totalSeconds % 60;
+
+    // Pad with leading zeros
+    hours = hours < 10 ? '0' + hours : hours;
+    minutes = minutes < 10 ? '0' + minutes : minutes;
+    seconds = seconds < 10 ? '0' + seconds : seconds;
+
+    const timeStr = `${hours}:${minutes}:${seconds}`;
+    console.log("Formatted time:", timeStr);
+    return timeStr;
+}
+
+async function convertTimetoHHMMSS(time) {
+    const seconds = Math.floor((time / 1000) % 60);
+    const minutes = Math.floor((time / (1000 * 60)) % 60);
+    const hours = Math.floor((time / (1000 * 60 * 60)) % 24);
+    const formattedTime = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+
+    console.log("Time:" + hours + ':' + minutes + ':' + seconds);
+
+    return formattedTime;
+}
+
+module.exports = commonconfig;