@devassure/tpp-engine 0.0.0-stage → 1.8.1

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

@@ -0,0 +1,361 @@
+const { compare } = require("../utils/assert-utils");
+const { Logger } = require("../utils/logger");
+
+class NetworkLogUtils {
+
+    constructor(caller, blacklistedLogs, networkLogManager) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.networkLogManager = networkLogManager;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    checkNetworkLogEnabled(logLabel) {
+        if(!this.networkLogManager?.enabled) {
+            if(logLabel) {
+                (new Logger(this.caller, this.blacklistedLogs)).failureLog(logLabel);
+            }
+            throw { message: 'Network logs tracing is not enabled! Enable it under Project preferences.' };
+        }
+    }
+
+    get_last_network_log_matching(method, url) {
+        const logLabel = `Get Last Network Log matching method - ${method} and urlRegex - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs({
+            limit: 1,
+            url: url,
+            methods: [method],
+        });
+        if(!logs?.length) {
+            logger.failureLog(logLabel);
+            throw { message: 'No network log recorded!' };
+        }
+        logger.endLog(logLabel);
+        return logs[0];
+    }
+
+    get_last_n_network_logs_matching(n, method, url) {
+        const logLabel = `Get Last ${n} Network Logs matching method - ${method} and urlRegex - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs({
+            limit: n,
+            url: url,
+            methods: [method],
+        });
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_network_logs() {
+        const logLabel = `Get All Network Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs({});
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_last_n_network_logs(n) {
+        const logLabel = `Get Last ${n} Network Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs({limit: n});
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    query_netwrok_logs(query) {
+        const logLabel = `Query Network Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs(query);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    //Private Fn
+    queryLogs(query) {
+        let logs = this.networkLogManager?.networkLogs;
+        if(query?.url) {
+            if(query.urlComparator) {
+                logs = logs.filter(log => compare(log.url, query.urlComparator, query.url))
+            } else {
+                let regex;
+                try {
+                    regex = new RegExp(query.url);
+                } catch(_ex) {};
+                const check = regex 
+                ? (log) => regex.test(log.url) || log.url?.includes(query.url)
+                : (log) => log.url?.includes(query.url)
+                logs = logs.filter(check);
+            }
+        }
+        if(query?.methods?.length) {
+            logs = logs.filter(log => query.methods.some(method => log.method === method));
+        }
+        if(query?.status) {
+            logs = logs.filter(log => compare(log.status, query.statusComparator || '==', query.status));
+        }
+        if(query?.limit && query.limit > 0) {
+            logs = logs.slice(-1 * query.limit);
+        }
+        return logs
+    }
+
+    verify_last_network_log_status(comparator, status) {
+        const logLabel = `Verify Last Network Log Status ${comparator} ${status}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.queryLogs({limit: 1});
+        if(!logs?.length) {
+            logger.failureLog(logLabel);
+            throw { message: 'No network log recorded!' };
+        } 
+        if(!compare(logs[0].status, comparator, status)) {
+            logger.failureLog(logLabel);
+            throw {
+              message: `Status is not as expected. actual: ${logs[0].status} ---- comparator: ${comparator} ---- expected: ${status}`,
+            };
+          }
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    print_all_network_logs() {
+        const logs = this.networkLogManager?.networkLogs;
+        this.checkNetworkLogEnabled();
+        const title = `###### All network logs: (${logs?.length || 0}) ######`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.log(undefined, title);
+        this.print_network_logs(logs);
+    }
+
+    print_network_logs(networkLog, index) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        if(Array.isArray(networkLog)) {
+            networkLog?.forEach((log, i) => this.print_network_logs(log, i));
+            return;
+        } else if(!networkLog || typeof networkLog !== "object") {
+            logger.log(undefined, 'Invalid network log!!');
+            return;
+        }
+        const title = index == null
+        ? "---------------------------------NETWORK LOG---------------------------------"
+        : `-- ${index + 1} -------------------------------------------------------------------------`
+        logger.log(undefined, title);
+        let content = JSON.stringify(networkLog, undefined, 4);
+        content.split('\n').forEach(line => logger.log(undefined, line));
+        logger.log(undefined, "_______________________________________________________________________________");
+    }
+
+    network_log_or_last_in_array(networkLog, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        if(!networkLog) {
+            logger.failureLog(logLabel);
+            throw { message: 'Invalid network log object!' };
+        }
+        if(Array.isArray(networkLog)) {
+            if(!networkLog?.length) {
+                logger.failureLog(logLabel);
+                throw { message: 'Network logs is empty!' };
+            } 
+            let log = networkLog.at(-1);
+            if(!log) {
+                logger.failureLog(logLabel);
+                throw { message: 'Invalid network logs!' };
+            }
+            return log;
+        }
+        return networkLog;
+    }
+
+    get_network_log_method(networkLog) {
+        const logLabel = `Get Network Log method`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.method;
+    }
+
+    get_network_log_status(networkLog) {
+        const logLabel = `Get Network Log status`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.status;
+    }
+
+    get_network_log_url(networkLog) {
+        const logLabel = `Get Network Log URL`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.url;
+    }
+
+    get_network_log_request_headers(networkLog) {
+        const logLabel = `Get Network Log request headers`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.headers;
+    }
+
+    get_network_log_response_headers(networkLog) {
+        const logLabel = `Get Network Log response headers`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.responseHeaders;
+    }
+
+    get_network_log_request_payload(networkLog) {
+        const logLabel = `Get Network Log request payload`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.requestPayload || '';
+    }
+
+    get_network_log_response_body(networkLog) {
+        const logLabel = `Get Network Log response body`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let log = this.network_log_or_last_in_array(networkLog, logLabel)
+        logger.endLog(logLabel);
+        return log.responseBody || '';
+    }
+
+    get_all_web_socket_request_logs() {
+        const logLabel = `Get All Web Socket Request Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketRequestLogs;
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_web_socket_response_logs() {
+        const logLabel = `Get All Web Socket Response Logs`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketResponseLogs;
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_open_web_sockets() {
+        const logLabel = `Get All Open Web Sockets`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.openWebSockets;
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_closed_web_sockets() {
+        const logLabel = `Get All Closed Web Sockets`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.closedWebSockets;
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_web_socket_requests_matching(url) {
+        const logLabel = `Get All Web Socket Requests Matching URL - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketRequestLogs.filter(log => this.isUrlMatching(log.url, url));
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_all_web_socket_responses_matching(url) {
+        const logLabel = `Get All Web Socket Responses Matching URL - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketResponseLogs.filter(log => this.isUrlMatching(log.url, url));
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    get_last_n_web_socket_requests_matching(n, url) {
+        const logLabel = `Get Last ${n} Web Socket Requests Matching URL - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketRequestLogs?.filter(log => this.isUrlMatching(log.url, url));
+        // Sort ascending by timestamp, then take the last n elements
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp)?.slice(-n);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    //get last n logs based on timestamp and return in ascending order of timestamp
+    get_last_n_web_socket_responses_matching(n, url) {
+        const logLabel = `Get Last ${n} Web Socket Responses Matching URL - ${url}`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        this.checkNetworkLogEnabled(logLabel);
+        let logs = this.networkLogManager?.webSocketResponseLogs?.filter(log => this.isUrlMatching(log.url, url));
+        // Sort ascending by timestamp, then take the last n elements
+        logs = logs?.sort((a, b) => a.timestamp - b.timestamp)?.slice(-n);
+        logger.endLog(logLabel);
+        return logs;
+    }
+
+    isUrlMatching(url, urlRegex) {
+        let regex;
+        try {
+            regex = new RegExp(urlRegex);
+        } catch(_ex) {};
+        const check = regex 
+        ? regex.test(url) || url?.includes(urlRegex)
+        : url?.includes(urlRegex)
+        return check;
+    }
+
+}
+
+exports.NetworkLogUtils = NetworkLogUtils;

package/src/types/elements.types.js

@@ -0,0 +1,24 @@
+const ElementType = { //Optional for information and logs only
+    section: 'Section',
+    button:'Button',
+    input: 'Input',
+    checkBox: 'Check Box',
+    radio: 'Radio Button',
+    switch: 'Switch',
+    link: 'Link',
+    text: 'Text',
+    nav: 'Nav',
+};
+
+const LocatorType = {
+    name: 'name',
+    id: 'id',
+    role: 'role',
+    text: 'text',
+    className: 'className',
+    css: 'CSS',
+    xpath: 'XPATH',
+};
+
+exports.ElementType = ElementType;
+exports.LocatorType = LocatorType;

package/src/utils/ai-utils.js

@@ -0,0 +1,48 @@
+const TokenConfig = require("../library/emailTesting/TokenConfig");
+const config = require("../app-config.json");
+const WebSocket = require('ws');
+
+ const AI_ENDPOINTS = {
+    AUTOHEAL: "/api/v1/ws/locator_fallback",
+}
+
+const BASE_SOCKET_URL = config.aiCoreUrl;
+
+const aiWebSocketCall = async (
+    path,
+    token,
+    request,
+) => {
+    const url = new URL(path, BASE_SOCKET_URL).toString();
+
+    return new Promise((resolve, reject) => {
+    let socket = new WebSocket(url);
+
+    socket.onopen = (_event) => {
+        socket.send(JSON.stringify({ token: token.access_token, type: token.token_type }));
+        socket.send((JSON.stringify({ data: request }))); 
+    };
+
+    socket.onmessage = (messageEvent) => {
+        const response = JSON.parse(messageEvent.data || '{}');
+        if(response.message !== 'ping') {
+            socket.close();
+            resolve(response);
+        }
+    }
+
+    socket.onerror = (ev) => {
+        socket.close();
+        reject(ev)
+    }
+
+    socket.onclose = () => {
+        resolve(() => {});
+    }
+    })
+}
+
+module.exports = {
+    AI_ENDPOINTS,
+    aiWebSocketCall
+};

package/src/utils/assert-utils.js

@@ -0,0 +1,50 @@
+const compare = (lhs, comparator, rhs) => {
+    switch(comparator) {
+        case "equals":
+        case "==": return lhs == rhs;
+        case "equals_ignore_case": {
+            if(lhs == rhs) return true;
+            if(typeof lhs !== "string" || typeof rhs !== "string") return false;
+            return lhs?.toLowerCase() === rhs?.toLowerCase();
+        };
+        case "regex_match": {
+            if(lhs == rhs) return true;
+            if(typeof lhs !== "string" || typeof rhs !== "string") return false;
+            try {
+                const pattern = new RegExp(rhs);
+                return pattern.test(lhs);
+            } catch (e) {
+                throw {message: `Invalid regex pattern: ${e.message}`};
+            }
+        };
+        case "regex_not_match": {
+            if(lhs == rhs) return false;
+            if(typeof lhs !== "string" || typeof rhs !== "string") return true;
+            try {
+                const pattern = new RegExp(rhs);
+                return !pattern.test(lhs);
+            } catch (e) {
+                throw {message: `Invalid regex pattern: ${e.message}`};
+            }
+        };
+        case "not_equals":
+        case "!=": return lhs != rhs;
+        case "contains": {
+            if(lhs == rhs) return true;
+            if(typeof lhs !== "string" || typeof rhs !== "string") return false;
+            return lhs?.includes(rhs);
+        }
+        case "contains_ignore_case": {
+            if(lhs == rhs) return true;
+            if(typeof lhs !== "string" || typeof rhs !== "string") return false;
+            return lhs?.toLowerCase()?.includes(rhs?.toLowerCase());
+        }
+        case ">": return lhs > rhs;
+        case "<": return lhs < rhs;
+        case ">=": return lhs >= rhs;
+        case "<=": return lhs <= rhs;
+        default: return false;
+    }
+};
+
+exports.compare = compare;

package/src/utils/autoheal-utils.js

@@ -0,0 +1,9 @@
+const path = require('path');
+
+const getAutohealPath = () => {
+    return path.join(process.cwd(), 'fallback.json');
+}
+
+module.exports = {
+    getAutohealPath
+}

package/src/utils/common-utils.js

@@ -0,0 +1,120 @@
+const isNumber = (str) => {
+    if(typeof str === "number") return true;
+    if(typeof str !== "string") return false;
+    str = str.trim();
+    if (str === '') return false;
+    return !isNaN(str);
+}
+
+const getBoolean = (str) => {
+    if(!str) return false;
+    if(str == true) return true;
+    if(typeof str !== "string") return false;
+    return str.toLowerCase() !== 'false' && str.toLowerCase() !== 'no';
+}
+
+const getAnyElements = (arr, n, ignore) => {
+    // Shuffling the array using Fisher-Yates (Knuth) shuffle algorithm
+    if(n > arr.length && !ignore) {
+        return {
+            success: false,
+            error: `${n} - count is greater than total size - ${arr.length}`,
+        }
+    }
+    let shuffled = arr.slice();
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    } 
+    return {
+        success: true,
+        data: shuffled.slice(0, n),
+    };
+}
+
+const getFirstElements = (arr, n, ignore) => {
+    if(n > arr.length && !ignore) {
+        return {
+            success: false,
+            error: `${n} - count is greater than total size - ${arr.length}`,
+        }
+    }
+    return {
+        success: true,
+        data: arr.slice(0, n),
+    };
+}
+
+const getLastElements = (arr, n, ignore) => {
+    if(n > arr.length && !ignore) {
+        return {
+            success: false,
+            error: `${n} - count is greater than total size - ${arr.length}`,
+        }
+    }
+    return {
+        success: true,
+        data: arr.slice(-n),
+    };
+}
+
+const getElementsInRange = (arr, range, ignore) => {
+    // Split the range string into x and y
+    let [x, y] = range.split('-').map(Number);
+  
+    // Ensure x and y are valid indices
+    if (isNaN(x) || isNaN(y) || x < 0 || y < 0 || x > y) {
+        let message = x > y 
+        ? 'Start is greater than End!' 
+        : `Invalid range ${range}. Total size = ${arr.length}`;
+        return {success: false, error: message};
+    }
+    // Ensure x and y are within range
+    if ((x >= arr.length || y >= arr.length) && !ignore) {
+        return {success: false, error: `Invalid range ${range}. Total size = ${arr.length}`};
+    }
+  
+    // Use slice to get elements from x to y (inclusive)
+    return {success: true, data: arr.slice(x, y + 1)};
+}
+
+const getElementsAtIndices = (arr, indices, ignore) => {
+    // Split the indices string into an array of index values
+    let indexArray = indices.split(',').map(Number);
+  
+    // Ensure all indices are valid
+    for (let index of indexArray) {
+      if (isNaN(index) || index < 0) {
+        return {success: false, error: `Invalid index: ${index}`};
+      }
+      if (index >= arr.length && !ignore) {
+        return {success: false, error: `Invalid index: ${index}. Total size = ${arr.length}`};
+      }
+    }
+    if(ignore) indexArray = indexArray.filter(i => i < arr.length);
+  
+    return {success: true, data: indexArray.map(index => arr[index])};
+}
+
+function generateRandomString(length = 6) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+function sleep(millis) {
+    return new Promise((resolve) => setTimeout(resolve, millis));
+}
+
+exports.isNumber = isNumber;
+exports.getAnyElements = getAnyElements;
+exports.getElementsInRange = getElementsInRange;
+exports.getElementsAtIndices = getElementsAtIndices;
+exports.getLastElements = getLastElements;
+exports.getFirstElements = getFirstElements;
+exports.getBoolean = getBoolean;
+exports.generateRandomString = generateRandomString;
+exports.sleep = sleep;

package/src/utils/cookie-utils.js

@@ -0,0 +1,70 @@
+const fs = require('fs');
+const { sleep } = require('./common-utils');
+
+const STORAGE_STATES_DIR = 'storage-states'
+
+const writeStorageStateToFile = async (page, label) => {
+    const state = await page?.context()?.storageState();
+    if(!fs.existsSync(STORAGE_STATES_DIR)) {
+        fs.mkdirSync(STORAGE_STATES_DIR);
+    }
+    fs.writeFileSync(`${STORAGE_STATES_DIR}/${label}.json`, JSON.stringify(state, null, 4));
+}
+
+const loadStorageStateFromFile = async (page, label, logger, logLabel, remoteBrowserPort, customConfig) => {
+    const dynamicDataFile = `${STORAGE_STATES_DIR}/${label}.json`;
+    let state = undefined;
+    if(fs.existsSync(dynamicDataFile)) {
+        const content = fs.readFileSync(dynamicDataFile, {encoding: 'utf-8'});
+        try {
+            state = content ? JSON.parse(content) : undefined;
+        } catch (ex) {
+            logger.log(logLabel, `Invalid JSON content in cookie file ${label}.json`);
+            return undefined;
+        }
+    } else {
+        const staticCookieFile = `${STORAGE_STATES_DIR}/_STATIC_COOKIES.json`;
+        if(fs.existsSync(staticCookieFile)) {
+            const content = fs.readFileSync(staticCookieFile, {encoding: 'utf-8'});
+            try {
+                const staticCookies = state = content ? JSON.parse(content) : undefined;
+                state = staticCookies && staticCookies[label];
+            } catch (ex) {
+                logger.log(logLabel, `Invalid JSON content in cookie file ${label}`);
+                return undefined;
+            }
+        }
+    }
+    if(state) {
+        if(remoteBrowserPort) {
+            const browser = page?.context()?.browser();
+            const commandData = JSON.stringify({storageState: state, returnData: {fileName: label}});
+            console.log(`[[TPP]] [[TPP Remote-Execution COMMAND set_storage_state]] ${commandData}`);
+            await sleep(7000);
+            const newPage = browser.contexts()?.at(-1)?.pages()?.at(0);
+            return newPage;
+        }
+        const browser = page?.context()?.browser();
+        await page.close();
+        const viewport = page.viewportSize() || { width: 1280, height: 1024 };
+
+        let recordProp = {};
+        const recordVideo = customConfig?.advancedRunConfig?.recordVideo;
+        if(!!recordVideo?.trim() && recordVideo !== 'OFF') {
+            recordProp = {recordVideo: {dir: 'tpp_temp_videos'}};
+        }
+
+        const newContext = await browser?.newContext({
+            storageState: state,
+            viewport: viewport,
+            ...recordProp,
+        });
+        const newPage = await newContext?.newPage();
+        if(!newPage) return undefined;
+        return newPage;
+    }
+    return undefined;
+}
+
+exports.writeStorageStateToFile = writeStorageStateToFile;
+exports.loadStorageStateFromFile = loadStorageStateFromFile;

package/src/utils/json-utils.js

@@ -0,0 +1,10 @@
+const extractValue = (json, key) => {
+    const keys = key.split('.');
+    let value = json;
+    for (let i = 0; i < keys.length; i++) {
+        value = value[keys[i]];
+    }
+    return value;
+};
+
+exports.extractValue = extractValue;