@devassure/tpp-engine 0.0.0-stage → 1.8.1

package/src/library/softAssert/softAssert-utils.js

@@ -0,0 +1,154 @@
+const { Logger, LOG_PREFIX } = require("../../utils/logger");
+const { compare } = require("../../utils/assert-utils");
+
+class SoftAssertUtils{
+    constructor(caller, blacklistedLogs, takeScreenShot) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.takeScreenShot = takeScreenShot;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    create_soft_assert() {
+        const logLabel = `Create Soft Assert`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const softAssert = {
+            assertions: [],
+        };
+        logger.endLog(logLabel);
+        return softAssert;
+    }
+
+    async soft_assert_text(softAssert, text, comparator, expected, customMessage) {
+        const logLabel = customMessage?.trim()
+        ? `Soft Assert text, message: ${customMessage}, text: ${text?.toString()?.replaceAll("\n", " ")}, ${comparator}, expected: ${expected}`
+        : `Soft Assert text, text: ${text?.toString()?.replaceAll("\n", " ")}, ${comparator}, expected: ${expected}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = compare(text, comparator, expected);
+        if (!result) {
+            logger.log(logLabel, "Soft assertion failure.");
+            await this.takeScreenShot(`softAssertFailure ${softAssert.assertions.length+1}`);
+            let message = `Soft Assert Text is not as expected. actual: ${text} ---- comparator: ${comparator} ---- expected: ${expected}`;
+            if(customMessage) {
+                message = `${customMessage} -- ${message}`;
+            }
+            softAssert.assertions.push({ result, message });
+        } 
+        logger.endLog(logLabel);
+    }
+
+    async soft_assert_number(softAssert, number, comparator, expected, customMessage) {
+        const logLabel = customMessage?.trim()
+        ? `Soft Assert number, message: ${customMessage}, number: ${number}, ${comparator}, expected: ${expected}`
+        : `Soft Assert number, number: ${number}, ${comparator}, expected: ${expected}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);     
+        const result = compare(number, comparator, expected);
+        if (!result) {
+            logger.log(logLabel, "Soft assertion failure.");
+            await this.takeScreenShot(`softAssertFailure ${softAssert.assertions.length+1}`);
+            let message = `Soft Assert Number is not as expected. actual: ${number} ---- comparator: ${comparator} ---- expected: ${expected}`;
+            if(customMessage) {
+                message = `${customMessage} -- ${message}`;
+            }
+            softAssert.assertions.push({ result, message });
+        } 
+        logger.endLog(logLabel);
+    }
+
+    async soft_assert_boolean(softAssert, value, expected, customMessage) {
+        const logLabel = customMessage?.trim()
+        ? `Soft Assert boolean, message: ${customMessage}, value: ${value}, expected: ${expected}`
+        : `Soft Assert boolean, value: ${value}, expected: ${expected}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);      
+        const result = !!value === !!expected;
+        if (!result) {
+            logger.log(logLabel, "Soft assertion failure.");
+            await this.takeScreenShot(`softAssertFailure ${softAssert.assertions.length+1}`);
+            let message = `Soft Assert Boolean value is not as expected. actual: ${value} ---- expected: ${expected}`;
+            if(customMessage) {
+                message = `${customMessage} -- ${message}`;
+            }
+            softAssert.assertions.push({ result, message });
+        }   
+        logger.endLog(logLabel);
+    }
+
+    async soft_assert_text_with_message(softAssert, text, comparator, expected, message) {
+        this.soft_assert_text(softAssert, text, comparator, expected, message);
+    }
+
+    async soft_assert_number_with_message(softAssert ,number, comparator, expected, message) {
+        this.soft_assert_number(softAssert ,number, comparator, expected, message)
+    }
+
+    async soft_assert_boolean_with_message(softAssert ,value, expected, message) {
+        this.soft_assert_boolean(softAssert ,value, expected, message)
+    }
+
+    async soft_assert_is_not_null_with_message(softAssert, value, customMessage) {
+        const logLabel = customMessage?.trim()
+        ? `Soft Assert is NOT NULL, message: ${customMessage}, variable: ${value}`
+        : `Soft Assert is NOT NULL, variable: ${value}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = value != null;
+        if (!result) {
+            logger.log(logLabel, "Soft assertion failure.");
+            await this.takeScreenShot(`softAssertFailure ${softAssert.assertions.length+1}`);
+            let message = `Soft Assert - input variable is null. value: ${value}`;
+            if(customMessage) {
+                message = `${customMessage} -- ${message}`;
+            }
+            softAssert.assertions.push({ result, message });
+        }   
+        logger.endLog(logLabel);
+    }
+
+    async soft_assert_is_null_with_message(softAssert, value, customMessage) {
+        const logLabel = customMessage?.trim()
+        ? `Soft Assert is NULL, message: ${customMessage}, variable: ${value}`
+        : `Soft Assert is NULL, variable: ${value}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const result = value == null;
+        if (!result) {
+            logger.log(logLabel, "Soft assertion failure.");
+            await this.takeScreenShot(`softAssertFailure ${softAssert.assertions.length+1}`);
+            let message = `Soft Assert - input variable is not null. value: ${value}`;
+            if(customMessage) {
+                message = `${customMessage} -- ${message}`;
+            }
+            softAssert.assertions.push({ result, message });
+        }   
+        logger.endLog(logLabel);
+    }
+
+    soft_assert_all(softAssert){
+        const logLabel = `Soft Assert All`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if (softAssert.assertions?.length > 0) {
+            const errors = softAssert.assertions.map(a => a.message).join('\n');
+            logger.failureLog(logLabel);
+            logger.action_log(`${LOG_PREFIX}${this.caller} :: [EXCEPTION] Soft assertion failures:`);
+            softAssert.assertions.forEach(error => 
+                logger.action_log(`${LOG_PREFIX}${this.caller} :: [EXCEPTION] ${error.message}`)
+            );
+            throw {message: `Soft assert - ${softAssert.assertions.length} validations failed!\n${errors}`};
+        }
+        logger.endLog(logLabel);
+    }
+}
+
+exports.SoftAssertUtils = SoftAssertUtils;

package/src/library/table/table-utils.js

@@ -0,0 +1,92 @@
+const { isNumber, getLastElements, getFirstElements, getElementsInRange, getElementsAtIndices } = require("../../utils/common-utils");
+const { Logger } = require("../../utils/logger");
+
+class TableUtils {
+
+    constructor(caller, blacklistedLogs, logLabel) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.logLabel = logLabel;
+    }
+
+    filterColumns(params, fields, ignoreMissingData, firstRowHeader) {
+        let logLabel = this.logLabel;
+        let logger = new Logger(this.caller, this.blacklistedLogs);
+
+        //Filter columns
+        if(!!params.columns && params.columns !== 'all') {
+            if(params.columns.startsWith('last')) {
+                const count = params.columns.replaceAll('last', '').trim();
+                if(!isNumber(count)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.columns} is not a valid columns filter!`}
+                }
+                fields = getLastElements(fields, parseInt(count), ignoreMissingData)
+            } if(params.columns.startsWith('first')) {
+                const count = params.columns.replaceAll('first', '').trim();
+                if(!isNumber(count)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.columns} is not a valid columns filter!`}
+                }
+                fields = getFirstElements(fields, parseInt(count), ignoreMissingData)
+            } else if(params.columns.includes('-')) {
+                const data = getElementsInRange(fields, params.columns, ignoreMissingData);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                fields = data.data;
+            } else if(params.columns.includes(',')) {
+                if(isNumber(params.columns.split(',')[0].trim())) {
+                    const data = getElementsAtIndices(fields, params.columns, ignoreMissingData);
+                    if(!data.success) {
+                        logger.failureLog(logLabel);
+                        throw {message: data.error};
+                    }
+                    fields = data.data;
+                } else {
+                    if(!firstRowHeader) {
+                        logger.failureLog(logLabel);
+                        throw {message: `First row is not a set as header, column names can't be used to filter data!`}
+                    }
+                    let columns = params.columns.split(',');
+                    const missing = ignoreMissingData 
+                    ? []
+                    : columns.filter(c => !fields.find(f => f.trim() === c.trim()));
+                    if(missing?.length) {
+                        logger.failureLog(logLabel);
+                        throw {message: `Some columns are missing! ${missing.join(',')}`}
+                    }
+                    if(ignoreMissingData) columns = columns.filter(c => fields.find(f => f.trim() === c.trim()))
+                    fields = columns;
+                }
+            } else {
+                if(isNumber(params.columns)) {
+                    const index = parseInt(params.columns.trim());
+                    if(index < 0 || (index >= fields.length && !ignoreMissingData)) {
+                        logger.failureLog(logLabel);
+                        throw {message: `${params.columns} - index is invalid. Columns = ${fields.length}`};
+                    }
+                    fields = ignoreMissingData && index >= fields.length ? [] : [fields[index]];
+                } else {
+                    if(!firstRowHeader) {
+                        logger.failureLog(logLabel);
+                        throw {message: `First row is not a set as header, column names can't be used to filter data!`}
+                    }
+                    const col = params.columns.trim();
+                    const missing = !fields.find(f => f.trim() === col);
+                    if(!ignoreMissingData && missing) {
+                        logger.failureLog(logLabel);
+                        throw {message: `Column ${params.columns} is not found!`};
+                    }
+                    fields = ignoreMissingData && missing ? [] : [params.columns.trim()];
+                }
+            }
+        }
+
+        return fields;
+    }
+
+}
+
+exports.TableUtils = TableUtils;

package/src/library/text/text-utils.js

@@ -0,0 +1,45 @@
+const { Logger } = require("../../utils/logger");
+const _ = require('lodash');
+
+class TextUtils {
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    random_string(length) {
+        const logLabel = `Text.Random string of length ${length}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        logger.endLog(logLabel);
+        return result;
+    }
+
+    random_alphanumeric_string(length) {
+        const logLabel = `Text.Random alphanumeric string of length ${length}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        logger.endLog(logLabel);
+        return result;
+    }
+}
+
+exports.TextUtils = TextUtils;

package/src/library/tpp-library.js

@@ -0,0 +1,81 @@
+const { ConsoleLogUtils } = require("../console-log/console-log-utils");
+const { DownloadsUtils } = require("../downloads/downloads-utils");
+const { NetworkLogUtils } = require("../network-log/network-log-utils");
+const { CsvUtils } = require("./csv/csv-utils");
+const { FileActionUtils } = require("./file/file-action-utils");
+const { MathUtils } = require("./math/math-utils");
+const { TextUtils } = require("./text/text-utils");
+const { SoftAssertUtils } = require("./softAssert/softAssert-utils");
+const { EmailTestingUtils } = require("./emailTesting/emailTesting-utils");
+const { ExcelUtils } = require("./excel/excel-utils");
+const { AuthenticatorUtils } = require("./authenticator/authenticator-utils");
+const { JsonUtils } = require("./json/json-utils");
+const { DateUtils } = require("./date/date-utils");
+
+
+class TppLibrary {
+
+    constructor(caller, blackListedLogs, webComponents, customConfig, takeScreenShot, page) {
+        this.file = new FileActionUtils(caller, blackListedLogs);
+        this.csv = new CsvUtils(caller, blackListedLogs);
+        this.excel = new ExcelUtils(caller, blackListedLogs, customConfig);
+        this.hasWebComponents = !!webComponents;
+        if(!!webComponents) {
+            this.networkLog = new NetworkLogUtils(caller, blackListedLogs, webComponents.networkLogManager);
+            this.consoleLog = new ConsoleLogUtils(caller, blackListedLogs, webComponents.consoleLogManager);
+            this.downloads = new DownloadsUtils(caller, blackListedLogs, webComponents.downloadsManager);
+        }
+        this.math = new MathUtils(caller, blackListedLogs);
+        this.text = new TextUtils(caller, blackListedLogs);
+        this.date = new DateUtils(caller, blackListedLogs);
+        this.json = new JsonUtils(caller, blackListedLogs);
+        this.softAssert = new SoftAssertUtils(caller, blackListedLogs, takeScreenShot);
+        this.emailTesting = new EmailTestingUtils(caller, blackListedLogs, takeScreenShot, page);
+        this.authenticator = new AuthenticatorUtils(caller, blackListedLogs);
+        this.customConfig = customConfig;
+    }
+
+    setCaller(caller) {
+        this.file.setCaller(caller);
+        this.csv.setCaller(caller);
+        this.excel.setCaller(caller);
+        this.math.setCaller(caller);
+        this.text.setCaller(caller);
+        this.date.setCaller(caller);
+        this.json.setCaller(caller);
+        if(this.hasWebComponents) {
+            this.networkLog.setCaller(caller);
+            this.consoleLog.setCaller(caller);
+            this.downloads.setCaller(caller);
+            this.downloads.downloadsManager?.setCaller(caller);
+        }
+        this.softAssert.setCaller(caller);
+        this.emailTesting.setCaller(caller);
+        this.authenticator.setCaller(caller);
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.file.setBlacklistedLogs(blacklistedLogs);
+        this.csv.setBlacklistedLogs(blacklistedLogs);
+        this.excel.setBlacklistedLogs(blacklistedLogs);
+        this.math.setBlacklistedLogs(blacklistedLogs);
+        this.text.setBlacklistedLogs(blacklistedLogs);
+        this.date.setBlacklistedLogs(blacklistedLogs);
+        this.json.setBlacklistedLogs(blacklistedLogs);
+        if(this.hasWebComponents) {
+            this.networkLog.setBlacklistedLogs(blacklistedLogs);
+            this.consoleLog.setBlacklistedLogs(blacklistedLogs);
+            this.downloads.setBlacklistedLogs(blacklistedLogs);
+        }
+        this.softAssert.setBlacklistedLogs(blacklistedLogs);
+        this.emailTesting.setBlacklistedLogs(blacklistedLogs);
+        this.authenticator.setBlacklistedLogs(blacklistedLogs);
+    }
+
+    setPage(page) {
+        this.emailTesting.setPage(page);
+    }
+
+}
+
+exports.TppLibrary = TppLibrary;

package/src/library/web/slider-utils.js

@@ -0,0 +1,66 @@
+class SliderUtils {
+
+  constructor(page) {
+    this.page = page;
+  }
+
+  validateSliderRange(targetValue, startValue, endValue) {
+    if(startValue === endValue) {
+      throw {message: `Start and end can't be same! (${startValue}, ${endValue})`, source: 'tpp'};
+    }
+    const isIncreasing = startValue < endValue;
+    if((isIncreasing && (targetValue < startValue || targetValue > endValue)) ||
+        (!isIncreasing && (targetValue > startValue || targetValue < endValue))) {
+            throw {message: `Value ${targetValue} is not in range of ${startValue} and ${endValue}`, source: 'tpp'};
+    }
+  }
+
+  async pickValueInSlider(tppElement, value, start, end, stepValue = null) {
+    this.validateSliderRange(value, start, end);
+
+    let ratio;
+
+    if (stepValue) {
+      const numberOfSteps = Math.floor(Math.abs(end - start) / stepValue);
+      const stepIndex = (value - start) / stepValue;
+      ratio = stepIndex / numberOfSteps;
+    } else {
+      ratio = Math.abs(value - start) / Math.abs(end - start);
+    }
+
+    await this.clickSliderAtRatio(tppElement, ratio, start > end);
+  }
+
+  async clickSliderAtRatio(tppElement, ratio, isDecreasing = false) {
+    if (ratio < 0 || ratio > 1) {
+      throw {message: `Ratio ${ratio} is not in range 0 to 1`, source: 'tpp'};
+    }
+
+    const slider = tppElement.locator();
+    const boundingBox = await slider.boundingBox();
+    if (!boundingBox) {
+      throw {message: 'Unable to retrieve bounding box for slider!', source: 'tpp'};
+    }
+
+    const sliderWidth = boundingBox.width;
+
+    let clickX = !isDecreasing
+      ? boundingBox.x + sliderWidth * ratio
+      : boundingBox.x + sliderWidth * (1 - ratio);
+
+    // To avoid clicking outside the slider
+    if(ratio == 1) {
+      clickX = isDecreasing ? clickX + 1 : clickX - 1; 
+    } else if (ratio === 0) {
+      clickX = isDecreasing ? clickX - 1 : clickX + 1;
+    }
+    const clickY = boundingBox.y + boundingBox.height / 2;
+
+    let page = this.page.page && this.page.page() ? this.page.page() : this.page;
+    await page.mouse.click(clickX, clickY);
+  }
+
+}
+
+exports.SliderUtils = SliderUtils;
+

package/src/mobile/appium/appium-manager.js

@@ -0,0 +1,158 @@
+const { spawn, exec } = require('child_process');
+const net = require('net');
+const os = require('os');
+const { FileUtils } = require('../../library/file/file-utils');
+const { FileActionUtils } = require('../../library/file/file-action-utils');
+const treeKill = require('tree-kill');
+
+function isPortAvailable(port) {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            } else {
+                reject(err);
+            }
+        });
+        server.once('listening', () => {
+            try {
+                server.close(() => resolve(true));
+            } catch (_e) {
+                resolve(false);
+            }
+        });
+        server.listen(port, '0.0.0.0');
+    });
+}
+
+function isPortAvailableCommand(port) {
+    return new Promise((resolve, reject) => {
+        let command;
+
+        if (os.platform() === 'win32') {
+            command = `netstat -ano | findstr :${port}`;
+        } else {
+            command = `lsof -i :${port}`;
+        }
+
+        exec(command, (error, stdout, stderr) => {
+            if (error) {
+                if (stderr.includes('not recognized') || error.message.includes('not recognized')) {
+                    reject(new Error(`netstat not found`));
+                } else {
+                    resolve(true);
+                }
+            } else if (stdout) {
+                resolve(false);
+            } else {
+                reject(stderr);
+            }
+        });
+    });
+}
+
+async function startAppiumServers(appiumStartScript, count = 1) {
+    let startPort = 4723
+    const pids = [];
+    const ports = [];
+    for (let i = 0; i < count; i++) {
+        const {pid, port} = await startAppiumServer(appiumStartScript, startPort);
+        pids.push(pid);
+        ports.push(port);
+        startPort = port + 1;
+    }
+    const data = {pids: pids, ports: ports};
+    new FileUtils().writeTextContent("mobile-status/appium.json", JSON.stringify(data, null, 4));
+}
+
+async function startAppiumServer(appiumStartScript, startPort = 4723, maxRetries = 10) {
+    let currentPort = startPort;
+    let retries = 0;
+
+    while (retries < maxRetries) {
+        let portAvailable;
+        try{
+            portAvailable = await isPortAvailable(currentPort);
+        } catch (err) {
+            console.log("Error checking port status", err);
+            try {
+                portAvailable = await isPortAvailableCommand(currentPort);
+            } catch (err2) {
+                console.log("Error checking port status via command", err2);
+            }
+        }
+        if (!!portAvailable) {
+            return new Promise((resolve, reject) => {
+                let resolved = false;
+                const appiumProcess = spawn(appiumStartScript, [currentPort.toString()], { shell: true });
+
+                appiumProcess.stdout.on('data', (data) => {
+                    const output = data.toString();
+                    console.log(`Appium: ${output}`);
+                    if (output.includes("Appium REST http interface listener started on")) {
+                        setTimeout(() => {   
+                            resolved = true;
+                            resolve({ pid: appiumProcess.pid, port: currentPort });
+                        }, 1000);
+
+                    }
+                });
+
+                appiumProcess.stderr.on('data', (data) => {
+                    console.error(`Appium error: ${data}`);
+                });
+
+                appiumProcess.on('close', (code) => {
+                    console.log(`Appium server stopped with code ${code}`);
+                    if(!resolved) resolve({});
+                });
+
+            });
+        } else {
+            console.log(`Port ${currentPort} is in use. Trying port ${currentPort + 1}...`);
+            currentPort++;
+            retries++;
+        }
+    }
+
+    const errorMessage = `Could not find an available port after ${maxRetries} retries.`;
+    console.log(`[[TPP]] Could not find an available port after ${maxRetries} retries. :: [ERROR]`);
+    throw {message: errorMessage};
+}
+
+async function stopAppiumServers() {
+    const {pids} = getAppiumConfig();
+    for (let i = 0; i < (pids?.length || 0); i++) {
+        await stopAppiumServer(pids?.at(i));
+    }
+}
+
+async function stopAppiumServer(pid) {
+    return new Promise((resolve, _reject) => {
+        treeKill(pid, 'SIGKILL', (err) => {
+            if (err) {
+                console.error(`Failed to kill Appium process ${pid}:`, err);
+            } else {
+                console.log(`Appium process and all child processes killed. ${pid}:`);
+            }
+          resolve(`Appium process ${pid} killed successfully.`);
+        });
+    });
+}
+
+function getAppiumConfig() {
+    const content = new FileActionUtils().readContentIgnoreMissing("mobile-status/appium.json", "{}");
+    return JSON.parse(content);
+}
+
+function resetAppiumConfig() {
+    new FileUtils().writeTextContent("mobile-status/appium.json", "{}");
+}
+
+exports.startAppiumServers = startAppiumServers;
+exports.stopAppiumServers = stopAppiumServers;
+exports.getAppiumConfig = getAppiumConfig;
+exports.resetAppiumConfig = resetAppiumConfig;
+exports.startAppiumServer = startAppiumServer;
+exports.stopAppiumServer = stopAppiumServer;

package/src/mobile/device-cloud/browserstack-service.js

@@ -0,0 +1,44 @@
+const { generateRandomString } = require("../../utils/common-utils");
+
+function getBrowserStackCapabilities(config, app, testInfo) {
+    const cloudConfig = config.deviceCloud;
+    let platformVersion = config?.os === 'ios'
+    ? config.cloudDevice.iosVersion
+    : config.cloudDevice.androidVersion;
+    return {
+        'bstack:options': {
+            'userName': cloudConfig.config.userName,
+            'accessKey': cloudConfig.config.accessKey,
+            "sessionName" : testInfo?.label || "devassure-desktop-app-editor",
+            "projectName" : testInfo?.projectInfo?.projectId || "devassure-default",
+            "buildName" : `${testInfo?.projectInfo?.jobName || "devassure-desktop-app"} ${testInfo?.projectInfo?.jobId || generateRandomString()}`,
+        },
+        'appium:app': app.cloudData?.app_url,
+        'appium:deviceName': config.cloudDevice.name,
+        'appium:platformVersion': platformVersion,
+    }
+}
+
+function getBrowserStackConnectionProps(_config) {
+    return {
+        hostname: 'hub-cloud.browserstack.com',
+        port: 443,
+        baseUrl: 'https://hub-cloud.browserstack.com',
+        path: '/wd/hub',
+        protocol: 'https',
+    }
+}
+
+async function setBrowserStackTestStatus(driver, pass, message) {
+    if(pass == null) {
+        return;
+    }
+    let status = pass ? 'passed' : 'failed';
+    try {
+        await driver.execute(`browserstack_executor: {"action": "setSessionStatus", "arguments": {"status":"${status}","reason": "${message || ""}"}}`);
+    } catch(ex) {}
+}
+
+exports.getBrowserStackCapabilities = getBrowserStackCapabilities;
+exports.getBrowserStackConnectionProps = getBrowserStackConnectionProps;
+exports.setBrowserStackTestStatus = setBrowserStackTestStatus;

package/src/mobile/device-cloud/commands/browserstack-commands.js

@@ -0,0 +1,20 @@
+class BrowserStackCommands {
+
+    constructor(driver) {
+        this.driver = driver;
+    }
+
+    async openApp() {
+        await this.driver.launchApp();
+    }
+
+    async closeApp() {
+        await this.driver.closeApp();
+    }
+
+    async minimiseApp(timeInSeconds) {
+        await this.driver.background(timeInSeconds);
+    }
+}
+
+exports.BrowserStackCommands = BrowserStackCommands;

package/src/mobile/device-cloud/commands/device-cloud-commands.js

@@ -0,0 +1,17 @@
+const { BrowserStackCommands } = require("./browserstack-commands");
+
+
+function getCloudCommand(config, driver) {
+
+    if(!config.deviceCloud) {
+        return undefined
+    }
+
+    switch(config.deviceCloud?.type) {
+        case 'BrowserStack': return new BrowserStackCommands(driver);
+    }
+
+    return undefined;
+}
+
+exports.getCloudCommand=getCloudCommand;