@devassure/tpp-engine 0.0.0-stage → 1.8.0

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

@@ -0,0 +1,527 @@
+const { Logger, LOG_PREFIX } = require("../../utils/logger");
+const axios = require('axios');
+const TokenConfig = require('./TokenConfig');
+const config = require('../../app-config.json');
+
+const WEBAPP_API_BASE = config.webAppUrl;
+
+class EmailTestingUtils{
+    
+    constructor(caller, blacklistedLogs, takeScreenShot, page) {
+        this.caller = caller;
+        this.blacklistedLogs = blacklistedLogs;
+        this.takeScreenShot = takeScreenShot;
+        this.page = page;
+    }
+
+    setCaller(caller) {
+        this.caller = caller;
+    }
+
+    setBlacklistedLogs(blacklistedLogs) {
+        this.blacklistedLogs = blacklistedLogs;
+    }
+
+    setPage(page) {
+        this.page = page;
+    }
+
+    async open_html_in_browser(html){
+      await this.page.goto('about:blank');
+      await this.page.setContent(html, { 
+        waitUntil: 'networkidle' 
+      });
+      await this.page.evaluate((title) => {
+        document.title = title;
+      }, "Email Viewer");
+    }
+
+    async initializeConfig() {
+        if (!this.config) {
+            this.config = await TokenConfig.getConfig();
+        }
+        return this.config;
+    }
+
+    async getAuthHeaders() {
+        const config = await this.initializeConfig();
+        return {
+            'Content-Type': 'application/json',
+            'Authorization': `${config.token_type} ${config.access_token}`
+        };
+    }
+
+    async getOfflineStatus() {
+        const config = await this.initializeConfig();
+        return config.offline;
+    }
+
+    async create_testing_mail_id(prefix = '', mail_id_type = 'Automation') {
+        const logLabel = `Create Testing Mail ID`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+    
+            const response = await axios.post(
+                `${WEBAPP_API_BASE}/testing_mail_ids`,
+                {
+                    prefix,
+                    mail_id_type,
+                },
+                {
+                    headers: await this.getAuthHeaders()
+                }
+            );
+    
+            if (response.status > 201) {
+                const errorMessage = `Failed to create testing mail id, status code: ${response.status}`;
+                throw {
+                    status: response.status,
+                    message: errorMessage,
+                    response_data: response.data
+                };
+            }
+    
+            const createdMailId = response.data.mail_id;
+            logger.endLog(logLabel);
+            return createdMailId;
+        } catch (error) {
+            let errorMessage = error.response
+                ? `Error creating testing mail id: ${error.response.data.error || error.response.data.message}`
+                : `Unexpected error: ${error.message}`;
+
+            if(errorMessage.includes('MailTestSetting is disabled')) {
+                errorMessage = 'EmailTesting is disabled! Enable Email testing from DevAssure web portal.';
+            }
+    
+            logger.failureLog(logLabel);
+    
+            throw {
+                status: error.response ? error.response.status : 500,
+                message: errorMessage,
+                details: error.response ? error.response.data : {}
+            };
+        }
+    }
+    
+
+    async create_testing_mail_id_with_prefix(prefix){
+        let created_mail_id = await this.create_testing_mail_id(prefix);
+        return created_mail_id;
+    }
+
+    async fetchEmails(url) {
+        try {
+            const response = await axios.get(url, {
+                headers: await this.getAuthHeaders(),
+            });
+            return response.data.emails;
+        } catch (error) {
+            const status = error.response?.status || 500;
+            const message = error.response?.data?.error || error.message || "Unknown error occurred";
+            throw { status, message };
+        }
+    }
+    
+    async get_emails_for_recipient(mail_id, limit = 1, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+            let url = `${WEBAPP_API_BASE}/testing_mail_ids/emails/recipient/${mail_id}`;
+            if (limit > 0) {
+                url += `?limit=${limit}`;
+            }
+    
+            const emails = await this.fetchEmails(url);
+            if (emails.length === 0) {
+                const message = `No emails found for the email ID: ${mail_id}`;
+                throw { status: 404, message };
+            }
+            logger.endLog(logLabel);
+            return emails;
+        } catch (error) {
+            const status = error.status || 500;
+            const message = error.message || "Error fetching emails for recipient";
+            logger.failureLog(logLabel);
+            throw { status, message };
+        }
+    }
+
+    async get_last_email_for_recipient (mail_id) {
+        const logLabel = `Get last email for recipient`;
+        let email = await this.get_emails_for_recipient (mail_id,1,logLabel);
+        return email;
+    }
+
+    async get_last_n_emails_for_recipient (limit, mail_id) {
+        const logLabel = `Get last ${limit} emails for recipient`;
+        let emails = await this.get_emails_for_recipient (mail_id,limit, logLabel);
+        return emails;
+    }
+
+    async get_last_n_emails_with_verification (limit, mail_id, from, subject) {
+        const logLabel = `Get last ${limit} emails with matching subject and from address`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+    
+            let url = `${WEBAPP_API_BASE}/testing_mail_ids/emails/recipient/${mail_id}`;
+    
+            const emails = await this.verifySubForEmails(url, from, subject,limit);
+    
+            if (emails.length === 0) {
+                const errorMessage = `No matching emails found for mail_id: ${mail_id}`;
+                throw {
+                    status: 404,
+                    message: errorMessage,
+                    mail_id,
+                };
+            }
+    
+            logger.log(logLabel,`Successfully validated email subject and from address.`);
+            logger.endLog(logLabel);
+            return emails;
+        } catch (error) {
+            logger.failureLog(logLabel);
+            throw {
+                status: error.status || 500,
+                message: error.message || 'Unexpected error while verifying email.',
+                details: error.details || {},
+            };
+        }
+    }
+
+    async verifySubForEmails(url, from_address, subject, limit) {
+        try {
+            const fromRegex = new RegExp(from_address, 'i'); 
+            const subRegex = new RegExp(subject, 'i');
+            const emails = await this.fetchEmails(url);
+            const matchingEmails = [];
+    
+            for (const email of emails) {
+                if (fromRegex.test(email.from_address) && subRegex.test(email.subject)) {
+                    matchingEmails.push(email);
+
+                    if (matchingEmails.length >= limit) {
+                        break;
+                    }
+                }
+            }
+    
+            return matchingEmails; 
+        } catch (error) {
+            return [];
+        }
+    }
+    
+    async wait_for_email(mail_id, timeout, limit = 1) {
+        const logLabel = `Wait for Email`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+    
+            let url = `${WEBAPP_API_BASE}/testing_mail_ids/emails/recipient/${mail_id}`;
+            if (limit > 0) {
+                url += `?limit=${limit}`;
+            }
+    
+            const emails = await this.pollForEmails(url, timeout, logLabel);
+    
+            if (emails.length > 0) {
+                logger.log(logLabel,`Successfully found email(s) for ${mail_id}`);
+                logger.endLog(logLabel);
+                return emails;
+            }
+    
+            const message = `No emails found for recipient ${mail_id} within the timeout of ${timeout / 1000} seconds.`;
+            throw {
+                status: 404,
+                message,
+            };
+        } catch (error) {
+            logger.failureLog(logLabel);
+            throw {
+                status: error.status || 500,
+                message: error.message || `Unexpected error while waiting for email.`,
+            };
+        }
+    }
+    
+    async wait_for_email_with_verification(mail_id, fromRegex, subRegex, timeout, limit = 0) {
+        const logLabel = `Wait for Email with subject and from address`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+    
+            let url = `${WEBAPP_API_BASE}/testing_mail_ids/emails/recipient/${mail_id}`;
+            if (limit > 0) {
+                url += `?limit=${limit}`;
+            }
+    
+            const emails = await this.pollForEmailsWithFromAddressAndSubject(url, timeout, logLabel,fromRegex,subRegex);
+    
+            if (emails.length === 0) {
+                const errorMessage = `No matching emails found for mail_id: ${mail_id} within ${timeout / 1000} seconds.`;
+                throw {
+                    status: 404,
+                    message: errorMessage,
+                    mail_id,
+                    timeout,
+                };
+            }
+    
+            logger.log(logLabel,`Successfully validated email subject and from address.`);
+            logger.endLog(logLabel);
+            return emails;
+        } catch (error) {
+            logger.failureLog(logLabel);
+            throw {
+                status: error.status || 500,
+                message: error.message || 'Unexpected error while verifying email.',
+                details: error.details || {},
+            };
+        }
+    }
+
+    async pollForEmails(url, timeout, logLabel) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        const totalSeconds = Math.ceil(timeout / 1000);
+        const delay = 1000; 
+    
+        for (let attempt = 0; attempt < totalSeconds; attempt++) {
+            try {
+                const emails = await this.fetchEmails(url);
+    
+                if (emails.length > 0) {
+                    logger.log(logLabel,`Email(s) found after ${attempt + 1} second(s).`);
+                    return emails;
+                }
+    
+                if (attempt < totalSeconds - 1) {
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            } catch (error) {
+                if (attempt === totalSeconds - 1) {
+                    logger.failureLog(logLabel);
+                    throw new Error(
+                        `Failed to fetch emails after ${totalSeconds} attempts: ${error.message}`
+                    );
+                }
+            }
+        }
+        logger.log(logLabel,`No emails found after ${totalSeconds} second(s).`);
+        return [];
+    }
+
+    async pollForEmailsWithFromAddressAndSubject(url, timeout, logLabel, from_address, subject) {
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        const delay = 1000; 
+        const startTime = Date.now(); 
+    
+        const fromRegex = new RegExp(from_address, 'i'); 
+        const subRegex = new RegExp(subject, 'i');
+    
+        while (true) {
+            try {
+                const emails = await this.fetchEmails(url);
+        
+                if (emails.length > 0) {
+                    const matchingEmail = emails.find(email => 
+                        fromRegex.test(email.from_address) && subRegex.test(email.subject)
+                    );
+    
+                    if (matchingEmail) {
+                        logger.log(logLabel, `Matching email found after ${(Date.now() - startTime) / 1000} second(s).`);
+                        return matchingEmail;
+                    }
+                }
+    
+                if (Date.now() - startTime >= timeout) {
+                    break; 
+                }
+    
+                await new Promise((resolve) => setTimeout(resolve, delay)); 
+            } catch (error) {
+                logger.failureLog(logLabel);
+                throw new Error(`Failed to fetch emails: ${error.message}`);
+            }
+        }
+    
+        logger.log(logLabel, `No matching email found after ${(Date.now() - startTime) / 1000} second(s).`);
+        return [];
+    }
+    
+    async get_subject(emailTest){
+        const logLabel = `Get Subject From email`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const email = this.extractEmail(emailTest);
+        if (!email) {
+            logger.failureLog(logLabel);
+            throw { message: 'Invalid email object' };
+        }
+        logger.endLog(logLabel);
+        return email.subject;
+    }
+
+    async get_content(emailTest){
+        const logLabel = `Get Content From email`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const email = this.extractEmail(emailTest);
+        if (!email) {
+            logger.failureLog(logLabel);
+            throw { message: 'Invalid email object' };
+        }
+        logger.endLog(logLabel);
+        return email.content;
+    }
+
+    async get_from_address(emailTest){
+        const logLabel = `Get from address From email`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+        const email = this.extractEmail(emailTest);
+        if (!email) {
+            logger.failureLog(logLabel);
+            throw { message: 'Invalid email object' };
+        }
+        logger.endLog(logLabel);
+        return email.from_address;
+    }
+
+    async delete_all_emails(mail_id) {
+        const logLabel = `Delete All Emails`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+    
+            const url = `${WEBAPP_API_BASE}/testing_mail_ids/emails/recipient/${mail_id}`;
+            
+            const response = await axios.delete(url, {
+                headers: await this.getAuthHeaders(),
+            });
+    
+            if (response.status > 201) {
+                const errorMessage = `Failed to delete emails for recipient ${mail_id}. Response code: ${response.status}`;
+                throw {
+                    status: response.status,
+                    message: errorMessage,
+                    mail_id,
+                    response_data: response.data,
+                };
+            }
+    
+            logger.endLog(logLabel);
+            return response.data;
+        } catch (error) {
+            const errorMessage = error.response
+                ? `Error deleting emails: ${error.response.data.error}`
+                : `Unexpected error: ${error.message}`;
+    
+            logger.failureLog(logLabel);
+    
+            throw {
+                status: error.response ? error.response.status : 500,
+                message: errorMessage,
+                mail_id,
+                details: error.response ? error.response.data : {},
+            };
+        }
+    }
+    
+
+    async open_email_in_browser(emailTest, type = 'html') {
+        const logLabel = `Open Email in Browser`;
+        const logger = new Logger(this.caller, this.blacklistedLogs);
+        logger.startLog(logLabel);
+    
+        try {
+            const offline = await this.getOfflineStatus();
+            if (offline) {
+                this.handle_offline_mode();
+                return;
+            }
+        
+            const email = this.extractEmail(emailTest);
+            if (!email) {
+                throw { message: 'Invalid email object' };
+            }
+            const message_id = email.message_id;
+            const response = await axios.get(
+                `${WEBAPP_API_BASE}/testing_mail_ids/email_content`,
+                {
+                    params: { message_id, type },
+                    headers: await this.getAuthHeaders()
+                }
+            );
+    
+            if (response.status > 201 || !response.data.content) {
+                throw { message: 'Failed to fetch email content' };
+            }
+    
+            const emailContent = response.data.content;
+    
+            await this.open_html_in_browser(emailContent);
+            logger.endLog(logLabel);
+    
+        } catch (error) {
+            logger.failureLog(logLabel);
+            throw { message: `Error opening email in browser: ${error.message}` };
+        }
+    }
+    
+
+    extractEmail(emailTest) {
+        if (Array.isArray(emailTest)) {
+            if (!emailTest?.length) {
+                throw { message: 'Email array is empty!' };
+            }
+            return emailTest.at(-1);
+        }
+        return emailTest;
+    }
+
+    handle_offline_mode(){
+        throw {message: `Email testing actions should not be proceeded with offline`}
+    }
+    
+}
+
+exports.EmailTestingUtils = EmailTestingUtils;