@devassure/tpp-engine 0.0.0-stage → 1.8.0

package/src/console-log/console-log-utils.js

@@ -0,0 +1,201 @@
+const { compare } = require("../utils/assert-utils");
+const { Logger } = require("../utils/logger");
+
+class ConsoleLogUtils {
+
+    constructor(caller, blacklistedLogs, consoleLogManager) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.consoleLogManager = consoleLogManager;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    checkConsoleLogEnabled(logLabel) {
+        if(!this.consoleLogManager?.enabled) {
+            if(logLabel) {
+                (new Logger(this.caller, this.blacklistedLogs)).failureLog(logLabel);
+            }
+            throw { message: 'Console logs tracing is not enabled! Enable it under Project preferences.' };
+        }
+    }
+
+    get_console_logs_matching_text(searchText) {
+        const logLabel = `Get Console Logs matching text - ${searchText}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs({
+            searchText: searchText,
+        });
+        logger.endLog(logLabel);
+        return logs || [];
+    }
+
+    get_last_console_log_matching(logType, url) {
+        const logLabel = `Get Last Console Log matching log type - ${logType} and sourceUrl - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs({
+            limit: 1,
+            sourceUrl: url,
+            logTypes: [method],
+        });
+        if(!logs?.length) {
+            return undefined;
+        }
+        logger.endLog(logLabel);
+        return logs[0];
+    }
+
+    get_last_n_console_logs_matching(n, logType, url) {
+        const logLabel = `Get Last ${n} Console Logs matching logType - ${logType} and sourceUrl - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs({
+            limit: n,
+            sourceUrl: url,
+            logTypes: [logType],
+        });
+        logger.endLog(logLabel);
+        return logs || [];
+    }
+
+    get_all_console_logs() {
+        const logLabel = `Get All Console Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs({});
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_last_n_console_logs(n) {
+        const logLabel = `Get Last ${n} Console Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs({limit: n});
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    query_console_logs(query) {
+        const logLabel = `Query Console Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let logs = this.queryLogs(query);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    //Private Fn
+    queryLogs(query) {
+        let logs = this.consoleLogManager?.consoleLogs;
+        if(query?.sourceUrl) {
+            if(query.urlComparator) {
+                logs = logs.filter(log => compare(log.sourceUrl, query.urlComparator, query.sourceUrl))
+            } else {
+                let regex;
+                try {
+                    regex = new RegExp(query.sourceUrl);
+                } catch(_ex) {};
+                const check = regex 
+                ? (log) => regex.test(log.sourceUrl) || log.sourceUrl?.includes(query.sourceUrl)
+                : (log) => log.sourceUrl?.includes(query.sourceUrl)
+                logs = logs.filter(check);
+            }
+        }
+        if(query?.logTypes?.length) {
+            logs = logs.filter(log => query.logTypes.some(logType => log.type === logType));
+        }
+        if(query?.searchText) {
+            logs = logs.filter(log => compare(log.text?.toLowerCase(), query.textComparator || 'contains', query.searchText.toLowerCase()));
+        }
+        if(query?.limit && query.limit > 0) {
+            logs = logs.slice(-1 * query.limit);
+        }
+        return logs
+    }
+
+    print_all_console_logs() {
+        const logs = this.consoleLogManager?.consoleLogs;
+        this.checkConsoleLogEnabled();
+        const title = `###### All console logs: (${logs?.length || 0}) ######`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.log(undefined, title);
+        this.print_console_logs(logs);
+    }
+
+    print_console_logs(consoleLog, index) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        if(Array.isArray(consoleLog)) {
+            consoleLog?.forEach((log, i) => this.print_console_logs(log, i));
+            return;
+        } else if(!consoleLog || typeof consoleLog !== "object") {
+            logger.log(undefined, 'Invalid console log!!');
+            return;
+        }
+        const title = index == null
+        ? "---------------------------------CONSOLE LOG---------------------------------"
+        : `-- ${index + 1} -------------------------------------------------------------------------`
+        logger.log(undefined, title);
+        let content = JSON.stringify(consoleLog, undefined, 4);
+        content.split('\n').forEach(line => logger.log(undefined, line));
+        logger.log(undefined, "_______________________________________________________________________________");
+    }
+
+    console_log_or_last_in_array(consoleLog, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        if(!consoleLog) {
+            logger.failureLog(logLabel);
+            throw { message: 'Invalid console log object!' };
+        }
+        if(Array.isArray(consoleLog)) {
+            if(!consoleLog?.length) {
+                logger.failureLog(logLabel);
+                throw { message: 'Console logs is empty!' };
+            } 
+            let log = consoleLog.at(-1);
+            if(!log) {
+                logger.failureLog(logLabel);
+                throw { message: 'Invalid console logs!' };
+            }
+            return log;
+        }
+        return consoleLog;
+    }
+
+    get_console_log_source_url(consoleLog) {
+        const logLabel = `Get Console Log Source Url`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let log = this.console_log_or_last_in_array(consoleLog, logLabel)
+        logger.endLog(logLabel);
+        return log.sourceUrl;
+    }
+
+    get_console_log_text(consoleLog) {
+        const logLabel = `Get Console Log Text`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkConsoleLogEnabled(logLabel);
+        let log = this.console_log_or_last_in_array(consoleLog, logLabel)
+        logger.endLog(logLabel);
+        return log.text;
+    }
+
+}
+
+exports.ConsoleLogUtils = ConsoleLogUtils;

package/src/database/mysql/mysql-service.js

@@ -0,0 +1,23 @@
+const mysql = require('mysql2/promise');
+
+class MySQLService {
+
+    async executeQuery(dbConfig, query, params, paramValues) {
+        const pool = mysql.createPool({
+            host: dbConfig.host,
+            user: dbConfig.username,
+            password: dbConfig.password,
+            port: dbConfig.port,
+            database: dbConfig.database,
+        });
+
+        for (let i = 0; i < params.length; i++) {
+            query = query.replace("@" + params[i].name, paramValues[i]);
+        }
+
+		const [rows, columnData] = await pool.query(query);
+		return rows;
+    }
+}
+
+exports.MySQLService = MySQLService;

package/src/database/neo4j/neo4j-service.js

@@ -0,0 +1,32 @@
+const neo4j = require('neo4j-driver');
+
+class Neo4jService {
+    async executeQuery(dbConfig, query, params, paramValues) {
+        const uri = `bolt://${dbConfig.host}:${dbConfig.port}`;
+        
+        const driver = neo4j.driver(
+            uri,
+            neo4j.auth.basic(dbConfig.username, dbConfig.password)
+        );
+        
+        const session = driver.session({
+            database: dbConfig.database || 'neo4j'
+        });
+        
+        const queryParams = {};
+        for (let i = 0; i < params.length; i++) {
+            queryParams[params[i].name] = paramValues[i];
+        }
+        
+        try {
+            const result = await session.run(query, queryParams);
+            const records = result.records.map(record => record.toObject());
+            return records;
+        } finally {
+            await session.close();
+            await driver.close();
+        }
+    }
+}
+
+exports.Neo4jService = Neo4jService;

package/src/database/oracle/oracle-service.js

@@ -0,0 +1,48 @@
+const oracledb = require('oracledb');
+
+class OracleService {
+
+    async executeQuery(dbConfig, query, params, paramValues) {
+        let connection;
+        
+        try {
+            // Create connection
+            connection = await oracledb.getConnection({
+                user: dbConfig.username,
+                password: dbConfig.password,
+                connectString: `${dbConfig.host}:${dbConfig.port}/${dbConfig.service_name}`
+            });
+
+            // Build bind parameters object
+            const bindParams = {};
+            for (let i = 0; i < params.length; i++) {
+                bindParams[params[i].name] = paramValues[i];
+            }
+
+            // Execute query with bind parameters
+            const result = await connection.execute(query, bindParams, {
+                outFormat: oracledb.OUT_FORMAT_OBJECT, // Return rows as objects
+                autoCommit: true
+            });
+
+            return result.rows;
+        }  
+        catch (err) {
+            throw {
+                message: `${err.message}`
+            };
+        } 
+        finally {
+            // Always close the connection
+            if (connection) {
+                try {
+                    await connection.close();
+                } catch (err) {
+                    console.error('Error closing connection:', err);
+                }
+            }
+        }
+    }
+}
+
+exports.OracleService = OracleService;

package/src/database/pg/pg-service.js

@@ -0,0 +1,29 @@
+const { Pool } = require('pg');
+
+class PostgreSQLService {
+
+    async executeQuery(dbConfig, query, params, paramValues) {
+        const pool = new Pool({
+            host: dbConfig.host,
+            user: dbConfig.username,
+            password: dbConfig.password,
+            port: dbConfig.port,
+            database: dbConfig.database,
+        });
+
+        // Replace named parameters with positional placeholders
+        for (let i = 0; i < params.length; i++) {
+            query = query.replace("@" + params[i].name, paramValues[i]);
+        }
+        
+        const client = await pool.connect();
+        try {
+            const result = await client.query(query);
+            return result.rows;
+        } finally {
+            client.release();
+        }
+    }
+}
+
+exports.PostgreSQLService = PostgreSQLService;

package/src/downloads/downloads-manager.js

@@ -0,0 +1,86 @@
+const path = require('path');
+const fs = require('fs');
+const { Logger } = require('../utils/logger');
+
+const DOWNLOADS_FOLDER = 'downloads';
+
+class DownloadsManager {
+
+    constructor(downloadsConfig, page) {
+        this.downloads = [];
+        this.overwriteFile = !!downloadsConfig?.overwriteFile;
+        this.handleDownloads(page);
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    handleDownloads(page) {
+        if(!page) {
+            return;
+        }
+
+        function getUniqueFilePath(directory, fileName, overwriteFile) {
+            if (!fs.existsSync(directory)) {
+                fs.mkdirSync(directory);
+            }
+
+            const ext = path.extname(fileName);
+            let uniqueFilePath = path.join(directory, fileName);
+
+            if(overwriteFile) {
+                return uniqueFilePath;
+            }
+
+            const baseName = path.basename(fileName, ext);
+            let counter = 1;
+            while (fs.existsSync(uniqueFilePath)) {
+              uniqueFilePath = path.join(directory, `${baseName} (${counter})${ext}`);
+              counter++;
+            }
+        
+            return uniqueFilePath;
+        }
+
+        const handleDownload = async (download) => {
+            const fileName = download.suggestedFilename();
+            const filePath = getUniqueFilePath(DOWNLOADS_FOLDER, fileName, this.overwriteFile);
+            const logMessage = `Downloading file ${fileName}`;
+            const logger = new Logger(this.caller);
+            logger.startLog(logMessage);
+            try {
+                let doDownload = async () => {
+                    fs.writeFileSync(filePath, "");
+                    await download.saveAs(filePath);
+                    logger.log(undefined, `Downloaded file saved at ${filePath}`);
+                    logger.endLog(logMessage);
+                };
+                const promise = doDownload();
+                this.downloads.push({
+                    fileName: fileName,
+                    filePath: filePath,
+                    promise: promise,
+                    timestamp: Date.now(),
+                });
+                await promise;
+            } catch (ex) {
+                if(ex?.message?.includes('context or browser has been closed')) {
+                   logger.log(undefined, 'Browser closed before download is complete!')
+                } else {
+                    logger.log(undefined, `${ex}`);
+                }
+                logger.failureLog(logMessage);
+            }
+        };
+
+        page.on('download', handleDownload);
+
+        page.context().on('page', async (newPage) => {
+            newPage.on('download', handleDownload);
+        });
+    }
+
+};
+
+exports.DownloadsManager = DownloadsManager;

package/src/downloads/downloads-utils.js

@@ -0,0 +1,113 @@
+const { sleep } = require("../utils/common-utils");
+const { Logger } = require("../utils/logger");
+
+class DownloadsUtils {
+
+    constructor(caller, blacklistedLogs, downloadsManager) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.downloadsManager = downloadsManager;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    async wait_for_downloads_complete_ms(timeout) {
+        await this.wait_for_downloads_complete(timeout);
+    }
+
+    async wait_for_downloads_complete(timeout) {
+        const logLabel = timeout ? 
+        `Wait for downloads to complete within ${timeout} ms`
+        : `Wait for downloads to complete`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+
+        let maxTries = timeout ? timeout / 1000 : 30;
+        let count = 0;
+        let latestDownloads = [];
+
+        while(!latestDownloads?.length && count < maxTries) {
+            //Filters all downloads in the last 5s
+            latestDownloads = this.downloadsManager.downloads
+            ?.filter(download => download?.timestamp && (Date.now() - download.timestamp <= 5 * 1000));
+            count += 1;
+            console.log(`No new downloads. Retrying... #${count}`);
+            await sleep(1000);
+        }
+
+        if(!latestDownloads?.length) {
+            logger.log(logLabel, `No new download has started in the last ${count}s... You can ignore if the download was triggered earlier!`)
+            logger.endLog(logLabel);
+            return;
+        }
+
+        const promises = latestDownloads
+        ?.map(download => download?.promise)
+        ?.filter(promise => !!promise);
+        await Promise.all(promises);
+        logger.endLog(logLabel);
+    }
+
+    async get_last_downloaded_file() {
+        const logLabel = `Get last downloaded file`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!this.downloadsManager?.downloads?.length) {
+            logger.failureLog(logLabel)
+            throw { message: 'No downloads present!' };
+        }
+        const download = this.downloadsManager.downloads.at(-1);
+        await download.promise;
+        logger.endLog(logLabel);
+        return download.filePath;
+    }
+
+    async get_last_downloaded_file_name_match(searchTerm) {
+        const logLabel = `Get last downloaded file with name matching ${searchTerm}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!this.downloadsManager?.downloads?.length) {
+            logger.failureLog(logLabel)
+            throw { message: 'No downloads present!' };
+        }
+        let regex;
+        try {
+            regex = new RegExp(searchTerm);
+        } catch(_ex) {};
+        const check = regex 
+        ? (download) => regex.test(download.fileName) || download.fileName?.includes(searchTerm)
+        : (download) => download.fileName?.includes(searchTerm);
+        const download = this.downloadsManager.downloads.reverse().find(check);
+        if(!download) {
+            logger.failureLog(logLabel)
+            throw { message: 'There are no downloads matching given searchTerm!' };
+        }
+        await download.promise;
+        logger.endLog(logLabel);
+        return download.filePath;
+    }
+
+    async get_all_downloaded_files() {
+        const logLabel = `Get all downloaded files`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!this.downloadsManager?.downloads?.length) {
+            logger.failureLog(logLabel)
+            throw { message: 'No downloads present!' };
+        }
+        const downloads = this.downloadsManager.downloads
+        .filter(download => !!download?.promise && !!download.filePath);
+        await Promise.all(downloads.map(download => download.promise));
+        logger.endLog(logLabel);
+        return downloads.map(download => download.filePath);
+    }
+
+}
+
+exports.DownloadsUtils = DownloadsUtils;

package/src/globalsetup.js

@@ -0,0 +1,68 @@
+const { chromium } = require('@playwright/test');
+const { openBrowser, importGetHooks } = require('./hooks/hook-utils');
+const { startAppiumServers } = require('./mobile/appium/appium-manager');
+const { FileUtils } = require('./library/file/file-utils');
+const path = require('path');
+const { getAutohealPath } = require('./utils/autoheal-utils');
+
+async function globalSetup(config) {
+    const packageInfo = require('.././package.json');
+    console.log('Engine version : ', packageInfo?.version);
+
+    await new FileUtils().writeJSONContent(getAutohealPath(), {});
+
+    let playwrightConfig;
+    if(config?.configFile) {
+        playwrightConfig = require(config.configFile);
+    }
+
+    if(playwrightConfig?.customConfig?.testType === 'web' ) {
+        const channels = config.projects.map(project => project.use.channel).filter(c => !!c);
+        for (let i = 0; i < channels.length; i++) {
+            const channel = channels[i];
+            try {
+                const browser = await chromium.launch({ channel: channel });
+                await browser.close();
+            } catch(ex) {
+                console.log(`[[TPP]] Error launching ${channel} !!! Make sure browser is installed. :: [ERROR]`);
+                throw {message: `Browser ${channel} not installed!`};
+            }
+        }
+        if(playwrightConfig?.customConfig?.chromeExtension) {
+            console.log(`[[TPP_PRINT_ONLY]] 🌐 Only Chromium Browser will be used as Chrome Extension is enabled!`);
+        }
+    }
+
+    //TODO move to separate hook for mobile
+    //Start Appium
+
+    if(playwrightConfig?.customConfig?.testType === 'mobile' 
+        && !playwrightConfig.customConfig.mobileConfig?.deviceCloud
+    ) {
+        console.log(`[[TPP_PRINT_ONLY]] 📱 Mobile setup :: [BEGIN]`);
+        await startAppiumServers(playwrightConfig.customConfig.mobileConfig.appiumStartScript, playwrightConfig.workers || 1);
+        console.log(`[[TPP_PRINT_ONLY]] 📱 Mobile setup :: [END]`);
+    }
+
+    let getHooks = importGetHooks();
+    if(!getHooks) return;
+
+    const actions = await openBrowser();
+    const hooks = getHooks(actions);
+    if(!hooks?.find(hook => hook?.beforeAll)) return;
+
+    let exception;
+    try {
+        actions.setCaller('', 'BeforeAll');
+        actions.testStartLog();
+        for (let i = 0; i < hooks.length; i++) {
+            const hook = hooks[i];
+            hook?.beforeAll && await hook.beforeAll();
+        }
+    } catch(ex) {
+        exception = ex;
+    }
+    await actions.handleResult(exception);
+}
+  
+exports.default = globalSetup;

package/src/globalteardown.js

@@ -0,0 +1,57 @@
+const { generateCombinedA11yReport } = require('./accessibility/combined-a11y-report');
+const { openBrowser, importGetHooks } = require('./hooks/hook-utils');
+const { FileUtils } = require('./library/file/file-utils');
+const { stopAppiumServers, resetAppiumConfig } = require('./mobile/appium/appium-manager');
+const { getAutohealPath } = require('./utils/autoheal-utils');
+const { resetTokenFile } = require("./utils/token-utils");
+
+
+async function globalTeardown(config) {
+    resetTokenFile();
+    generateCombinedA11yReport();
+
+    await new FileUtils().deleteFile(getAutohealPath());
+    //TODO move to separate hook for mobile
+    //Stop Appium
+    let playwrightConfig;
+    if(config?.configFile) {
+        playwrightConfig = require(config.configFile);
+    }
+    if(playwrightConfig.customConfig?.testType === 'mobile'
+        && !playwrightConfig.customConfig?.mobileConfig?.deviceCloud
+    ) {
+        console.log(`[[TPP_PRINT_ONLY]] Mobile teardown :: [BEGIN]`);
+        await stopAppiumServers();
+        resetAppiumConfig();
+        console.log(`[[TPP_PRINT_ONLY]] Mobile teardown :: [END]`);
+    }
+
+    let getHooks = importGetHooks();
+    if(!getHooks) return;
+
+    const actions = await openBrowser();
+    const hooks = getHooks(actions);
+    if(!hooks?.find(hook => hook?.afterAll)) {
+        await closBrowser();
+        return;
+    }
+
+    let exception;
+    try {
+        actions.setCaller('', 'AfterAll');
+        actions.testStartLog();
+        for (let i = 0; i < hooks.length; i++) {
+            const hook = hooks[i];
+            hook?.afterAll && await hook.afterAll();
+        }
+    } catch(ex) {
+        exception = ex;
+    }
+    await actions.handleResult(exception);
+}
+
+async function closBrowser(action) {
+    await action?.page?.context()?.browser()?.close();
+}
+  
+exports.default = globalTeardown;