@devassure/tpp-engine 0.0.0-stage → 1.8.1

package/src/mobile/recorder-utils/mobile-recorder.js

@@ -0,0 +1,266 @@
+const fs = require('fs');
+const path = require('path');
+const { FileUtils } = require('../../library/file/file-utils');
+const { getScreenshotPath } = require('../../utils/screenshot-utils');
+const { sleep } = require('../../utils/common-utils');
+
+const EVENT_TAG = "[[TPP_EVENT_LOG]]";
+
+class MobileRecorderControl {
+
+    constructor(mobileActions) {
+        this.mobileActions = mobileActions;
+    }
+
+    async openMobileRecorder() {
+        console.log(`${EVENT_TAG} [[TPP Mobile Opened]]`)
+        await this.printMobileState();
+
+        const commandFilePath = `.mobile-recorder-commands/commands_${Date.now()}`;
+        new FileUtils().writeTextContent(commandFilePath, 'ready')
+        console.log(`${EVENT_TAG} [[TPP Mobile Recorder FILE]] ${path.resolve(commandFilePath)}`);
+
+        async function readCommandFromFile() {
+            return new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    if (fs.existsSync(commandFilePath)) {
+                        const command = fs.readFileSync(commandFilePath, 'utf-8').trim();
+                        if (command !== 'ready') {
+                            console.log(`Received command: ${command}`);
+                            clearInterval(checkInterval);
+                            resolve(command);
+                        }
+                    } else {
+                        resolve('stop_recording');
+                    }
+                }, 500); // Check every 500ms
+            });
+        }
+
+        while (true) {
+            console.log('Waiting for a new command...');
+            const command = await readCommandFromFile();
+    
+            if (command === 'stop_recording') {
+                console.log('Stopping recording...');
+                break;
+            }
+    
+            fs.writeFileSync(commandFilePath, 'ready');
+            try {
+                await this.processMobileCommand(command);
+            } catch(error) {
+                this.mobileActions.log(undefined, `[RECORDER-ERROR] ${error?.message || 'Error performing action on device!'}`);
+            }
+        }
+        
+        if (fs.existsSync(commandFilePath)) { fs.unlinkSync(commandFilePath); }
+    }
+
+    async getWebViewDom() {
+
+        const finderScript = fs.readFileSync(path.resolve(__dirname, 'finder.js'), 'utf-8');
+        const cssSelectorScript = fs.readFileSync(path.resolve(__dirname, 'css-selector-generator.js'), 'utf-8');
+
+        const structuredTree = await this.mobileActions.driver.executeScript(`
+            ${cssSelectorScript}
+
+            ${finderScript}
+
+            function processNode(node, keyPrefix = 'da-node') {
+                if (!node || node.nodeType !== Node.ELEMENT_NODE) return null;
+        
+                // Extract attributes and bounds
+                const attributes = Array.from(node.attributes || []).reduce((acc, attr) => {
+                    acc[attr.name] = attr.value;
+                    return acc;
+                }, {});
+        
+                // Calculate bounds for the element
+                const getWebBounds = (el) => {
+                    // const rect = el.getBoundingClientRect();
+                    // return rect.width > 0 && rect.height > 0
+                    //     ? \`[\${rect.left},\${rect.top}][\${rect.left + rect.width},\${rect.top + rect.height}]\`
+                    //     : '';
+                    return ''; //TODO fix
+                };
+        
+                // Recursive processing of children
+                const children = Array.from(node.children || []).map((child, index) =>
+                    processNode(child, \`\${keyPrefix}-\${index}\`)
+                ).filter(child => child); // Filter out null/undefined children
+
+                const allLocators = tppGetUniqueLocators(node);
+        
+                // Determine label
+                let label = allLocators.find(loc => loc?.name && !!loc.name.trim())?.name.replace(tppElementNameRegex, '');
+                if(!label) {
+                    const innerText = node.textContent.trim();
+                    if (children.length === 0 && innerText && innerText.length < 50 && !innerText.includes('\\n')) {
+                        label = innerText;
+                    } else {
+                        label = attributes['aria-label'] || attributes['alt'] || attributes['src'] || node.tagName.toLowerCase();
+                    }
+                }
+
+                // Replace special characters with underscores
+                label = label.replace(/[^a-zA-Z0-9_]/g, '_');
+        
+                return {
+                    key: \`\${keyPrefix}-\${node.tagName.toLowerCase()}\`,
+                    name: node.tagName || 'Element',
+                    data: attributes,
+                    locator: allLocators[0]?.locator,
+                    locatorType: allLocators[0]?.locatorType,
+                    bounds: getWebBounds(node),
+                    links: children.length > 0 ? children : undefined,
+                    url: '',
+                    isExpanded: false,
+                    label: label,
+                    innerText: children.length > 0 ? '' : node.textContent.trim() || '',
+                };
+            }
+        
+            // Start processing from the <body> element
+            const bodyElement = document.querySelector('body');
+            return processNode(bodyElement);
+        `, []);
+
+        new FileUtils().writeTextContent('temp-dom.json', JSON.stringify(structuredTree, null, 4));
+
+        return structuredTree;
+    }
+
+    async getCurrentPage() {
+        if(this.mobileActions.config?.os === 'ios') {
+            const context = await this.mobileActions.driver.execute('mobile: deviceInfo', {});
+            const viewController = context?.viewController;
+            const pageName = viewController?.trim()
+            ?.replaceAll('ViewController', '')
+            ?.replaceAll('Controller', '');
+            return pageName?.replace(/[^a-zA-Z0-9]/g, "") || 'Unknown';
+        }
+        const activity = await this.mobileActions.driver.getCurrentActivity();
+        const pageName = activity?.trim()
+        ?.split('.')?.at(-1)
+        ?.replaceAll('Activity', '');
+        return pageName?.replace(/[^a-zA-Z0-9]/g, "") || 'Unknown';
+    };
+
+    async isLandscape() {
+        const {height, width} = await this.mobileActions.driver.getWindowSize();
+        return width >= height;
+    }
+
+    async printMobileState(isWebView, retry) {
+        try {
+            const pageSource = isWebView
+            ? await this.getWebViewDom()
+            : await this.mobileActions.driver.getPageSource();
+            if(!pageSource || (typeof pageSource === 'string' && !pageSource.trim())) {
+                throw {message: 'Unable to fetch page source from device!'}
+            }
+
+            const filePath = getScreenshotPath(`recorder_snap_${Date.now()}`);
+            await this.mobileActions.addScreenshot(filePath);
+            const mobileState = {
+                pageSource,
+                screenshot: path.resolve(filePath),
+                isWebView: isWebView,
+                currentPage: await this.getCurrentPage(),
+                os: this.mobileActions.config?.os,
+                landscape: await this.isLandscape(),
+            }
+            console.log(`${EVENT_TAG} [[TPP Mobile State]] ${JSON.stringify(mobileState)}`);
+        } catch (err) {
+            let errorMsg = `Error reading mobile state! ${err?.message || err}`;
+            if(retry && retry > 3) {
+                throw {message: errorMsg};
+            } else {
+                console.log(errorMsg);
+                await sleep(2000);
+                this.printMobileState(isWebView, retry ? retry + 1 : 1);
+            }
+        }
+    }
+
+    //TODO add try catch and throw appropriate error message
+    async processMobileCommand(command) {
+        let isWebView = false;
+        if(!command?.trim()) {
+            return;
+        } else if(command.trim().startsWith('tap_on_element')) {
+            const data = JSON.parse(command.split('tap_on_element').at(-1).trim());
+            await this.mobileActions.tap_on_element(data.element);
+            await sleep(500); //Wait for UI to load after tap
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('input_value')) {
+            const data = JSON.parse(command.split('input_value').at(-1).trim());
+            await this.mobileActions.input_value(data.value || '', data.element);
+            await sleep(100);
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('clear_text')) {
+            const data = JSON.parse(command.split('clear_text').at(-1).trim());
+            await this.mobileActions.clear_text(data.element);
+            await sleep(100);
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('vertical_scroll_element')) {
+            const data = JSON.parse(command.split('vertical_scroll_element').at(-1).trim());
+            await this.mobileActions.vertical_scroll_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('horizontal_scroll_element')) {
+            const data = JSON.parse(command.split('horizontal_scroll_element').at(-1).trim());
+            await this.mobileActions.horizontal_scroll_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('swipe_up_on_element')) {
+            const data = JSON.parse(command.split('swipe_up_on_element').at(-1).trim());
+            await this.mobileActions.swipe_up_on_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('swipe_down_on_element')) {
+            const data = JSON.parse(command.split('swipe_down_on_element').at(-1).trim());
+            await this.mobileActions.swipe_down_on_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('swipe_left_on_element')) {
+            const data = JSON.parse(command.split('swipe_left_on_element').at(-1).trim());
+            await this.mobileActions.swipe_left_on_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('swipe_right_on_element')) {
+            const data = JSON.parse(command.split('swipe_right_on_element').at(-1).trim());
+            await this.mobileActions.swipe_right_on_element(data.element);
+            await sleep(500); //Wait for UI to load after scroll
+            isWebView = !!data?.isWebView;
+        } else if(command.trim().startsWith('switch_to_web_view')) {
+            await this.mobileActions.switch_to_webview();
+            isWebView = true;
+        } else if(command.trim().startsWith('switch_to_native_view')) {
+            await this.mobileActions.switch_to_native_app();
+        } else if(command.trim().startsWith('press_back_button')) {
+            await this.mobileActions.press_back_button();
+        } else if(command.trim().startsWith('hide_keyboard')) {
+            await this.mobileActions.hide_keyboard();
+        } else if(command.trim().startsWith('close_app')) {
+            await this.mobileActions.close_app();
+        } else if(command.trim().startsWith('open_app')) {
+            await this.mobileActions.open_app();
+        } else if(command.trim().startsWith('type_text')) {
+            const data = JSON.parse(command.split('type_text').at(-1).trim());
+            await this.mobileActions.type_text(data.text || '');
+            await sleep(100);
+        } else if(command.trim().startsWith('reload_state')) {
+            try {
+                const data = JSON.parse(command.split('reload_state').at(-1).trim() || '{}');
+                isWebView = !!data?.isWebView;
+            } catch (_er) {}
+        } else {
+            return;
+        }
+        await this.printMobileState(isWebView);
+    }
+}
+
+exports.MobileRecorderControl = MobileRecorderControl;

package/src/mobile/web-driver-utils.js

@@ -0,0 +1,110 @@
+const { isNumber, getBoolean } = require("../utils/common-utils");
+const { getDeviceCloudCapabilties, getDeviceCloudConnection } = require("./device-cloud/device-cloud-service");
+
+function getCapabilities(config, app, testInfo, timeouts) {
+    return mobileCapabilities(config, app, testInfo, timeouts);
+}
+
+function mobileCapabilities(config, app, testInfo, timeouts) {
+    const commonCaps = {
+        'appium:newCommandTimeout': timeouts?.inactiveTimeout || 2 * 60,
+        'appium:noReset': config?.preferences?.resetData == false,
+        'appium:autoLaunch': true,
+    };
+
+    const osCaps = config?.os === 'ios'
+    ? {
+        ...commonCaps,
+        platformName: 'iOS',
+        'appium:platformVersion': config.device?.os_version,
+        ...(app.ios.bundleId ? {'appium:bundleId': app.ios.bundleId} : {}),
+        'appium:useNewWDA': false,
+        'appium:autoAcceptAlerts': true,
+    }
+    : {
+        ...commonCaps,
+        platformName: 'Android',
+        ...(app.android.package ? {'appium:appPackage': app.android.package} : {}),
+        ...(app.android.activity ? {'appium:appActivity': app.android.activity} : {}),
+        'appium:disableWindowAnimation': true,  // Speeds up interactions
+        'appium:autoGrantPermissions': true,
+        'appium:autoDismissAlerts': true,
+    };
+
+    if(config.deviceCloud) {
+        return {
+            ...osCaps,
+            ...getDeviceCloudCapabilties(config, app, testInfo),
+            ...getUserCapabilities(config.preferences?.capabilities),
+        };
+    }
+
+    if(config?.os === 'ios') {
+        let nameLabel = app?.name ? ` - ${app.name}` : '';
+        if(config.device?.simulator) {
+            if(!app?.ios?.appPath) throw {message: `.app file path is need to test app in simulator ${nameLabel}`};
+        } else {
+            if(!app?.ios?.ipaPath) throw {message: `.ipa file path is need to test app in device ${nameLabel}`};
+        }
+    } else if(config?.os === 'android' && !app?.android?.apkPath) {
+        let nameLabel = app?.name ? ` - ${app.name}` : '';
+        throw { message: `The app doesn't have Android apk details ${nameLabel}` };
+    }
+
+    const localDeviceCaps = config?.os === 'ios'
+    ? {
+        "appium:automationName": "XCUITest",
+        'appium:app': config.device?.simulator ? app.ios.appPath : app.ios.ipaPath,
+        'appium:showXcodeLog': true,
+        'appium:udid': config.device?.id,
+    }
+    : {
+        'appium:automationName': 'UiAutomator2',
+        'appium:deviceName': 'Android',
+        'appium:app': app.android.apkPath,
+        'appium:udid': config.device?.id,
+    };
+
+    return {
+        ...osCaps,
+        ...localDeviceCaps,
+        ...getUserCapabilities(config?.preferences?.capabilities),
+    }
+}
+
+function getUserCapabilities(caps) {
+    if(!caps) return {};
+
+    let capabilities = {};
+    caps.forEach(cap => {
+        if(!cap?.name?.trim()) {
+            return;
+        }
+
+        if(cap.type === 'boolean') {
+            capabilities[cap.name] = getBoolean(cap.value);
+        } else if(cap.type === 'number') {
+            if(!isNumber(cap.value)) {
+                throw {message: `Capability ${cap.name} type mismatch. Expected number but found ${cap.value}`};
+            }
+            capabilities[cap.name] = Number(cap.value);
+        } else {
+            capabilities[cap.name] = cap.value;
+        }
+    });
+    return capabilities;
+}
+
+function getConnectionDetails(config) {
+    if(config.deviceCloud) {
+        return getDeviceCloudConnection(config);
+    }
+
+    return {
+        port: config.appium.port, 
+        hostname: '127.0.0.1',
+    }
+}
+
+exports.getCapabilities = getCapabilities;
+exports.getConnectionDetails = getConnectionDetails;

package/src/models/tpp-element.js

@@ -0,0 +1,58 @@
+const { LocatorType } = require("../types/elements.types");
+const path = require("path");
+
+class TppElement {
+
+  constructor(element, page, fromAi) {
+    this.element = element;
+    this.page = page;
+    this.fromAi = fromAi
+  }
+
+  getSelector() {
+    if(this.element.locator?.startsWith('/html')) {
+      return `/${this.element.locator}`;
+    }
+
+    switch(this.element.locatorType) {
+      case LocatorType.id: return `#${this.element.locator}`;
+      default: return this.element.locator;
+    }
+  }
+
+  getPageLoc() {
+    return this.page.locator(this.getSelector());
+  }
+
+  locator() {
+    let chainedLocator = this.element.chainedLocator;
+    if(chainedLocator?.length) {
+      let currentLocator = this.page;
+      for(let i=0; i<chainedLocator.length; i++) {
+        currentLocator = currentLocator.locator(chainedLocator[i].locator)
+        if(chainedLocator[i].containsText) {
+          currentLocator = currentLocator.getByText(chainedLocator[i].containsText);
+        }
+        const eleIndex = (chainedLocator[i].index || 1) - 1;
+        currentLocator = currentLocator.nth(eleIndex);
+      }
+      return currentLocator;
+    }
+    const loc = this.getPageLoc();
+    if(this.fromAi) {
+      return loc.nth(0); //AI response could match more than one element.
+    } else if(this.element.index != null) {
+      return loc.nth(this.element.index);
+    }
+    return loc;
+  }
+
+  label() {
+    return JSON.stringify(this.element);
+  }
+
+}
+
+
+
+exports.TppElement = TppElement;

package/src/models/tpp-mobile-element.js

@@ -0,0 +1,50 @@
+const { LocatorType } = require("../types/elements.types");
+
+class TppElement {
+
+  constructor(element, driver) {
+    this.element = element;
+    this.driver = driver;
+  }
+
+  getSelector() {
+    switch (this.element.locatorType) {
+      case 'id': return `id=${this.element.locator}`;
+      case 'accessibilityId': return `~${this.element.locator}`;
+      case 'className': return `.${this.element.locator}`;
+      default: return this.element.locator;
+    }
+  }
+
+  async getPageLoc() {
+    let uiElement = await this.driver.$(this.getSelector());
+    for(let i=0; i<3 && !uiElement.elementId; i++) {
+      console.log(`Element ${this.label()} is unstable, retrying...`);
+      uiElement = await this.driver.$(this.getSelector());
+    }
+    return uiElement;
+  }
+
+  async getCount() {
+    try {
+      const elements = await this.driver.$$(this.getSelector());
+      return elements?.length;
+    } catch (_ex) {
+      return 0;
+    }
+  }
+
+  async locator() {
+    if (this.element.index != null) {
+      return (await this.driver.$$(this.getSelector()))[this.element.index];
+    }
+    return await this.getPageLoc();
+  }
+
+  label() {
+    return JSON.stringify(this.element);
+  }
+
+}
+
+exports.TppElement = TppElement;

package/src/network-log/network-log-manager.js

@@ -0,0 +1,96 @@
+class NetworkLogManager {
+
+    constructor(networkConfig, page) {
+        this.enabled = !!networkConfig?.enabled;
+        if(!networkConfig?.enabled || !page) {
+            return;
+        }
+        
+        this.networkLogs = [];
+        this.webSocketRequestLogs = [];
+        this.webSocketResponseLogs = [];
+        this.openWebSockets = [];
+        this.closedWebSockets = [];
+        this.domains = networkConfig.domains;
+        this.startLogTracing(page);
+    }
+
+    startLogTracing(page) {
+        if(!this.enabled) {
+            return;
+        }
+        const handleResponse = async (response) => {
+            const request = response.request();
+            const url = request.url();
+            const resourceType = request.resourceType();
+
+            let responseBody;
+            try {
+                if (response.status() < 300 || response.status() >= 400) { 
+                    responseBody = await response.text();
+                }
+            } catch(_ex) {}
+
+            if (
+                (resourceType === 'fetch' || resourceType === 'xhr' || resourceType === 'websocket') 
+                && (!this.domains?.length || this.domains.some(domain => url.includes(domain)))
+            ) {
+                const requestData = {
+                    url,
+                    requestType: resourceType,
+                    method: request.method(),
+                    headers: request.headers(),
+                    requestPayload: request.postData(),
+                    status: response.status(),
+                    responseHeaders: response.headers(),
+                    responseBody: responseBody,
+                };
+                this.networkLogs.push(requestData);
+            }
+        };
+
+        const handleWebSocketData = (url, event, type) => {
+            if(!this.domains?.length || this.domains.some(domain => url.includes(domain))) {
+                if(type === 'framesent') {
+                    this.webSocketRequestLogs.push({
+                        url,
+                        message: event.payload,
+                        timestamp: Date.now(),
+                    });
+                } else if(type === 'framereceived') {
+                    this.webSocketResponseLogs.push({
+                        url,
+                        message: event.payload,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+        }
+
+        const handleWebSocket = (ws) => {
+            this.openWebSockets.push(ws.url());
+            ws.on('framesent', event => {
+                handleWebSocketData(ws.url(), event, 'framesent');
+            });
+            ws.on('framereceived', event => {
+                handleWebSocketData(ws.url(), event, 'framereceived');
+            });
+            ws.on('close', () => {
+                this.openWebSockets = this.openWebSockets.filter(w => w !== ws.url());
+                this.closedWebSockets.push(ws.url());
+            });
+        }
+
+        page.on('response', handleResponse);
+
+        page.on('websocket', ws => handleWebSocket(ws));
+
+        page.context().on('page', async (newPage) => {
+            newPage.on('response', handleResponse);
+            newPage.on('websocket', ws => handleWebSocket(ws));
+        });
+    }
+
+};
+
+exports.NetworkLogManager = NetworkLogManager;