@devassure/tpp-engine 0.0.0-stage → 1.8.1

package/src/hooks/each-hook.js

@@ -0,0 +1,45 @@
+const { importGetHooks } = require("./hook-utils");
+
+class EachTestHook {
+
+    constructor(actions) {
+      this.actions = actions;
+    }
+
+    async runBeforeEach() {
+        const getHooks = importGetHooks();
+        if(!getHooks) return;
+
+        const actions = this.actions.newChild('BeforeEach');
+        const hooks = getHooks(actions);
+        if(!hooks?.find(hook => hook?.beforeEach)) return;
+
+		actions.startLog('');
+        for (let i = 0; i < hooks.length; i++) {
+            const hook = hooks[i];
+            hook?.beforeEach && await hook.beforeEach();
+        }
+
+        actions.endLog('');
+    }
+
+    async runAfterEach() {
+        const getHooks = importGetHooks();
+        if(!getHooks) return;
+
+        const actions = this.actions.newChild('AfterEach');
+        const hooks = getHooks(actions);
+        if(!hooks?.find(hook => hook?.afterEach)) return;
+
+		actions.startLog('');
+        for (let i = 0; i < hooks.length; i++) {
+            const hook = hooks[i];
+            hook?.afterEach && await hook.afterEach();
+        }
+
+        actions.endLog('');
+    }
+
+}
+
+exports.EachTestHook = EachTestHook;

package/src/hooks/hook-utils.js

@@ -0,0 +1,21 @@
+const { chromium } = require('@playwright/test');
+
+const openBrowser = async () => {
+    const browser = await chromium.launch();
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    // await page.waitForTimeout(120000);
+    const { Actions } = require('../actions');
+    return new Actions(page, page.request, true);
+};
+
+const importGetHooks = () => {
+    try {
+        const { getAllHooks } = require('../../../../../custom-functions/hooks/tpp_all_hooks');
+        return getAllHooks;
+    } catch (_ex) {}
+    return undefined;
+}
+
+exports.openBrowser = openBrowser;
+exports.importGetHooks = importGetHooks;

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

@@ -0,0 +1,43 @@
+const {authenticator} = require("otplib");
+const { Logger } = require("../../utils/logger");
+
+class AuthenticatorUtils {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    async get_authenticator_otp(secret) {
+        const logLabel = `Get Authenticator OTP from secret`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!secret?.trim()) {
+            logger.failureLog(logLabel);
+            throw {message: "Secret to generate OTP is empty"};
+        }
+        secret = secret.replace(/ /g, ""); // Remove spaces if any
+        const now = Math.floor(Date.now() / 1000);
+        const remaining = 30 - (now % 30);
+        if(remaining < 5) await new Promise(r => setTimeout(r, (remaining + 1) * 1000));
+        try {
+            let otp = authenticator.generate(secret);
+            logger.endLog(logLabel);
+            return otp;
+        } catch (error) {
+            logger.failureLog(logLabel, error);
+            throw {message: error.message || "Failed to generate OTP"};
+        }
+    }
+
+}
+
+exports.AuthenticatorUtils = AuthenticatorUtils;

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

@@ -0,0 +1,297 @@
+const fs = require('fs');
+const { Logger } = require('../../utils/logger');
+const path = require('path');
+const { FileUtils } = require('../file/file-utils');
+const { isNumber, getAnyElements, getElementsInRange, getElementsAtIndices, getLastElements, getBoolean, getFirstElements } = require('../../utils/common-utils');
+const { TableUtils } = require('../table/table-utils');
+
+class CsvUtils {
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    compare_data(filePath1, filePath2) {
+        const logLabel = `CSV.Compare rows of ${filePath1} and ${filePath2}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const lines1 = this.read_csv_lines(filePath1, logLabel).filter(line => !!line);
+        const lines2 = this.read_csv_lines(filePath2, logLabel).filter(line => !!line);
+
+        if(lines1.length !== lines2.length) {
+            let message = `The number of rows in the 2 files are different! File 1 has ${lines1.length} rows and File 2 has ${lines2.length} rows`;
+            logger.failureLog(logLabel);
+            throw {message};
+        }
+
+        const data1 = lines1.map(line => line.split(','));
+        const data2 = lines2.map(line => line.split(','));
+
+        let failures = [];
+
+        data1.forEach((dataRow, index) => {
+            let row1 = JSON.stringify(dataRow);
+            let row2 = JSON.stringify(data2.at(index));
+            if(row1 !== row2) {
+                let message = `❌ Row ${index} is different!`;
+                failures.push(message);
+                logger.log(logLabel, message);
+                logger.log(logLabel, `Row from 1st File: ${row1}`);
+                logger.log(logLabel, `Row from 2nd File: ${row2}`);
+            }
+        })
+
+        if(failures.length) {
+            logger.failureLog(logLabel);
+            throw {message: `There are ${failures.length} rows that do not match in the 2 files!`}
+        }
+
+        logger.endLog(logLabel);
+    }
+
+    read_rows_as_array(csvPath) {
+        const logLabel = `CSV.Read rows as array ${csvPath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const lines = this.read_csv_lines(csvPath, logLabel);
+        const data = lines.map(line => line.split(','));
+        logger.endLog(logLabel);
+        return data;
+    }
+
+    read_rows_as_object(csvPath) {
+        const logLabel = `CSV.Read rows as objects ${csvPath}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs)
+        logger.startLog(logLabel);
+        const lines = this.read_csv_lines(csvPath, logLabel);
+        if(lines.length < 1) {
+            logger.failureLog(logLabel);
+            throw {message: `No rows or header present in CSV`};
+        }
+        const fields = lines[0].split(',').map(field => field.trim());
+        const dataLines = lines.slice(1);
+        const data = dataLines.map(line => {
+            const cells = line.split(',');
+            let row = {};
+            for(let i=0; i < fields.length; i++) {
+                if(!fields[i]) continue;
+                row[`${fields[i]}`] = i < cells.length ? cells[i] || '' : '';
+            }
+            return row;
+        })
+        logger.endLog(logLabel);
+        return data;
+    }
+
+    advanced_csv_read(params) {
+        const logLabel = `CSV.Advanced Read`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        if(!params.filePath?.trim()) {
+            logger.failureLog(logLabel);
+            throw {message: `No file path provided!`}
+        }
+        const lines = this.read_csv_lines(params.filePath, logLabel);
+
+        const ignore = getBoolean(params.ignoreMissingData);
+        const isFirstRowHeader = getBoolean(params.isFirstRowHeader);
+        const getRowsAsObjects = getBoolean(params.getRowsAsObjects);
+
+        //Split header if first row is header
+        let firstRowHeader = isFirstRowHeader && lines?.length > 0;
+        let fields = firstRowHeader
+        ? lines[0].split(',').map(field => field.trim())
+        : lines[0].split(',').map((_line, index) => index);
+
+        let allFields = fields.slice();
+
+        let dataLines = isFirstRowHeader && lines?.length > 0 ? lines.slice(1) : lines;
+
+        //Filter rows
+        if(!!params.rows && params.rows !== 'all') {
+            if(params.rows.startsWith('last')) {
+                const count = params.rows.replaceAll('last', '').trim();
+                if(!isNumber(count)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.rows} is not a valid rows filter!`}
+                }
+                const data = getLastElements(dataLines, parseInt(count), ignore);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                dataLines = data.data;
+            } else if(params.rows.startsWith('first')) {
+                const count = params.rows.replaceAll('first', '').trim();
+                if(!isNumber(count)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.rows} is not a valid rows filter!`}
+                }
+                const data = getFirstElements(dataLines, parseInt(count), ignore);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                dataLines = data.data;
+            } else if(params.rows.startsWith('any')) {
+                const count = params.rows.replaceAll('any', '').trim();
+                if(!isNumber(count)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.rows} is not a valid rows filter!`}
+                }
+                const data = getAnyElements(dataLines, parseInt(count), ignore);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                dataLines = data.data;
+            } else if(params.rows.includes('-')) {
+                const data = getElementsInRange(dataLines, params.rows, ignore);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                dataLines = data.data;
+            } else if(params.rows.includes(',')) {
+                const data = getElementsAtIndices(dataLines, params.rows, ignore);
+                if(!data.success) {
+                    logger.failureLog(logLabel);
+                    throw {message: data.error};
+                }
+                dataLines = data.data;
+            } else {
+                if(!isNumber(params.rows)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.rows} is not a valid rows filter!`}
+                }
+                const index = parseInt(params.rows.trim());
+                if(index < 0 || (index >= dataLines.length && !ignore)) {
+                    logger.failureLog(logLabel);
+                    throw {message: `${params.rows} - index is invalid. Data size - ${dataLines.length}`}
+                }
+                if(ignore && index >= dataLines.length) {
+                    dataLines = [];
+                } else {
+                    dataLines = [dataLines[index]];
+                }
+            }
+        }
+
+        //Filter columns
+        fields = new TableUtils(this.caller, this.blacklistedLogs, logLabel)
+        .filterColumns(params, fields, ignore, firstRowHeader);
+
+        const dataObject = dataLines.map(line => {
+            const cells = line.split(',');
+            let row = getRowsAsObjects ? {} : [];
+            for(let i=0; i < allFields.length; i++) {
+                const skip = firstRowHeader 
+                ? !fields.includes(allFields[i])
+                : !fields.includes(i);
+                if(skip) continue;
+                const val = i < cells.length ? cells[i] || '' : '';
+                if(getRowsAsObjects) {
+                    const fieldName = firstRowHeader ? allFields[i] : `column_${i}`;
+                    row[`${fieldName}`] = val;
+                } else {
+                    row.push(val);
+                }
+            }
+            return row;
+        })
+        logger.endLog(logLabel);
+        return dataObject;
+    }
+
+    advanced_csv_write(params) {
+        const logLabel = `CSV.Advanced Write`;
+        const logger = new Logger(this.caller, this.blacklistedLogs)
+        logger.startLog(logLabel);
+
+        if (!params.data || !Array.isArray(params.data)) {
+            logger.failureLog(logLabel);
+            throw {message: `Not a valid data! Data should be an array.`}
+        }
+
+        const createMissingFile = getBoolean(params.createMissingFile);
+        const isRowsAsObjects = getBoolean(params.isRowsAsObjects);
+
+        let csvPath = params.filePath;
+        csvPath = new FileUtils().getFilePath(csvPath);
+        if(!fs.existsSync(csvPath) && !createMissingFile) {
+            logger.failureLog(logLabel);
+            throw {message: `CSV file ${csvPath} does not exists!`}
+        }
+        
+        let lines = "";
+
+        //Write header line
+        if(getBoolean(params.isFirstRowHeader)) {
+            if(!isRowsAsObjects && !params.headers?.length) {
+                logger.failureLog(logLabel);
+                throw {message: `headers not present! Headers are mandatroy when isFirstRowHeader and isRowsAsObjects is false`}
+            }
+            if(!params.headers?.length && !params.data?.length) {
+                logger.failureLog(logLabel);
+                throw {message: `No headers present! isFirstRowHeader is true but headers and data feilds are empty.`}
+            }
+            lines += params.headers?.length || !isRowsAsObjects
+            ? params.headers.join(",")
+            : Object.keys(params.data[0]).join(",");
+            lines +=  '\n';
+        }
+
+        const headers = isRowsAsObjects 
+        ? params.headers?.length ? params.headers : Object.keys(params.data[0]) 
+        : undefined
+
+        //Transform row to string line
+        params.data.forEach((row, i) => {
+            if (!row || (!isRowsAsObjects && !Array.isArray(row))) {
+                logger.failureLog(logLabel);
+                throw {message: `Row ${i} is not a valid row!.`}
+            }
+            const newLine = i === 0 ? '' : '\n';
+            if(!isRowsAsObjects) {
+                lines += `${newLine}${row.join(',')}`;
+            } else {
+                lines += `${newLine}${headers.map(header => row[header] || '').join(',')}`;
+            }
+        });
+
+        //Create parent
+        if(!fs.existsSync(csvPath) && createMissingFile) {
+            new FileUtils().createParentIfNotPresent(csvPath);
+        }
+
+        fs.writeFileSync(csvPath, lines);
+
+        logger.endLog(logLabel);
+        return path.resolve(csvPath);
+    }
+
+
+    read_csv_lines(csvPath, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        csvPath = new FileUtils().getFilePath(csvPath);
+        if(!fs.existsSync(csvPath)) {
+            logger.failureLog(logLabel);
+            throw {message: `CSV file ${csvPath} does not exists!`}
+        }
+        const content = fs.readFileSync(csvPath, {encoding: 'utf-8'})?.replaceAll('\r', '');
+        const lines = content.split("\n");
+        return lines;
+    }
+
+}
+
+exports.CsvUtils = CsvUtils;

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

@@ -0,0 +1,168 @@
+const { Logger } = require("../../utils/logger");
+const _ = require('lodash');
+
+const dayjs = require("dayjs");
+const customParseFormat = require("dayjs/plugin/customParseFormat");
+dayjs.extend(customParseFormat);
+
+class DateUtils {
+
+    static DEFAULT_FORMAT = "YYYY-MM-DD";
+
+    constructor(caller, blacklistedLogs) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    relative_date_from_current_date(days, format) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+
+        let safeDays = Number(days);
+        if (!Number.isFinite(safeDays)) safeDays = 0; 
+
+        const safeFormat = this.#ensureValidFormat(format);
+        const logLabel = `Date.Get date ${safeDays} days from current date in format ${safeFormat}`;
+
+        try {
+            logger.startLog(logLabel);
+            
+            // Reuse getTargetDate method for date calculation
+            const targetDate = this.getTargetDate({
+                offsetDays: safeDays,
+                format: safeFormat
+            });
+            
+            const resultDate = targetDate.format(safeFormat);
+            logger.endLog(logLabel);
+            return resultDate;
+        } catch (err) {
+            try { 
+                logger.endLog(logLabel); 
+            } catch (_) {}
+            throw new Error(`relative_date_from_current_date failed: ${err.message}`);
+        }
+    }
+
+    /**
+     * Parse a date string from various formats
+     * @param {string} dateStr - Date string to parse
+     * @param {string} format - Expected format (default: 'MM/DD/YYYY')
+     * @returns {Object} dayjs object representing the parsed date
+     * @throws {Error} If date cannot be parsed
+     */
+    parseDate(dateStr, format = 'MM/DD/YYYY') {
+        let targetDate = dayjs(dateStr);
+        
+        if (!targetDate.isValid()) {
+            // Try parsing with custom format
+            targetDate = dayjs(dateStr, format);
+        }
+        
+        if (!targetDate.isValid()) {
+            // Try common date formats
+            targetDate = dayjs(dateStr, ['YYYY-MM-DD', 'MM/DD/YYYY', 'DD/MM/YYYY', 'YYYY/MM/DD']);
+        }
+        
+        if (!targetDate.isValid()) {
+            throw new Error(`Unable to parse date: ${dateStr}`);
+        }
+        
+        return targetDate;
+    }
+
+    /**
+     * Calculate target date from offset days or parse from date string
+     * @param {Object} options - Options object
+     * @param {string} options.date - Date string to parse (optional)
+     * @param {number} options.offsetDays - Days to offset from today (optional, default: 0)
+     * @param {string} options.format - Expected date format (optional, default: 'MM/DD/YYYY')
+     * @returns {Object} dayjs object representing the target date
+     */
+    getTargetDate(options = {}) {
+        const { date, offsetDays = 0, format = 'MM/DD/YYYY' } = options;
+        
+        if (date) {
+            return this.parseDate(date, format);
+        } else {
+            const safeOffsetDays = offsetDays !== undefined ? Number(offsetDays) : 0;
+            const targetDate = dayjs().add(safeOffsetDays, 'day');
+            
+            if (!targetDate.isValid()) {
+                throw new Error(`Invalid offsetDays: ${offsetDays}`);
+            }
+            
+            return targetDate;
+        }
+    }
+
+    /**
+     * Calculate the difference in months between current date and target date
+     * @param {number} currentY - Current year
+     * @param {number} currentM - Current month (0-indexed)
+     * @param {number} targetY - Target year
+     * @param {number} targetM - Target month (0-indexed)
+     * @returns {number} Difference in months (positive for future, negative for past)
+     */
+    diffInMonths(currentY, currentM, targetY, targetM) {
+        return (targetY - currentY) * 12 + (targetM - currentM);
+    }
+
+    /**
+     * Calculate month difference between today and target date
+     * @param {Object} targetDate - dayjs object for target date
+     * @returns {number} Difference in months
+     */
+    getMonthDifference(targetDate) {
+        const today = dayjs();
+        const currentY = today.year();
+        const currentM = today.month(); // 0-indexed
+        const targetY = targetDate.year();
+        const targetM = targetDate.month(); // 0-indexed
+        
+        return this.diffInMonths(currentY, currentM, targetY, targetM);
+    }
+
+    /**
+     * Format date in various formats for date picker matching
+     * @param {Object} targetDate - dayjs object for target date
+     * @param {string} format - User-specified format (default: 'MM/DD/YYYY')
+     * @returns {Array<string>} Array of formatted date strings to try
+     */
+    getDatePickerFormats(targetDate, format = 'MM/DD/YYYY') {
+        const options = { weekday: 'long', month: 'long', day: 'numeric' };
+        const formattedFutureDate = targetDate.toDate().toLocaleDateString('en-US', options);
+        
+        return [
+            targetDate.format(format), // User-specified format
+            targetDate.format('D'), // Just the day number (e.g., "30")
+            targetDate.format('DD'), // Two-digit day (e.g., "30")
+            formattedFutureDate, // "Thursday, October 30"
+            targetDate.format('MMMM D, YYYY'), // "October 30, 2024"
+        ];
+    }
+
+    #ensureValidFormat(format) {
+        if (!_.isString(format) || _.isEmpty(format.trim())) {
+            return DateUtils.DEFAULT_FORMAT;
+        }
+        const f = format.trim();
+        const hasYear = /(Y{2,4})/.test(f);
+        const hasMonth = /\b(M{1,4})\b/.test(f);     
+        const hasDay = /\b(D{1,2})\b/.test(f);       
+
+        if (hasYear || hasMonth || hasDay) {
+            return f;
+        }
+        return DateUtils.DEFAULT_FORMAT;
+    }
+}
+
+exports.DateUtils = DateUtils;

package/src/library/emailTesting/TokenConfig.js

@@ -0,0 +1,46 @@
+const crypto = require('crypto');
+const { FileUtils } = require('../../library/file/file-utils');
+
+const DECRYPTION_TOKEN = "hCXkfcVxqxI8cMGO6XbQHA7lstowjzp9TbZCbJobmMkLmR16q16tIHAZQRLTSGXy";
+
+class TokenConfig {
+    static async getConfig() {
+        try {
+
+            const keyString = Buffer.from(DECRYPTION_TOKEN);
+
+            function createKey(keyString) {
+                return crypto.createHash('sha256').update(keyString).digest();
+            }
+
+            function decrypt(encryptedBase64) {
+                const key = createKey(keyString);
+    
+                const encrypted = Buffer.from(encryptedBase64, 'base64');
+
+                const iv = encrypted.subarray(0, 16);
+                const ciphertext = encrypted.subarray(16); 
+                
+                const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+                
+                let decrypted = decipher.update(ciphertext);
+                decrypted = Buffer.concat([decrypted, decipher.final()]);
+                return decrypted.toString('utf8');
+            }
+
+            const configData = new FileUtils().readTextContent('toktmp/tmp.json', "{}");
+            const config = JSON.parse(configData);
+
+            return {
+                access_token: decrypt(config.access_token),
+                token_type: config.token_type,
+                offline: config.offline
+            };
+        } catch (error) {
+            console.error('Error reading token config:', error);
+            throw error;
+        }
+    }
+}
+
+module.exports = TokenConfig;