@bigbinary/neeto-playwright-commons 1.26.23 → 1.26.25

package/index.cjs.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var child_process = require('child_process');
 var neetoCist = require('@bigbinary/neeto-cist');
 var faker = require('@faker-js/faker');
 var require$$0$4 = require('fs');
@@ -9,7 +10,6 @@ var test = require('@playwright/test');
 var playwrightI18nextFixture = require('playwright-i18next-fixture');
 var require$$0$3 = require('util');
 var ramda = require('ramda');
-var child_process = require('child_process');
 var dayjs = require('dayjs');
 var require$$0$7 = require('stream');
 var node_module = require('node:module');
@@ -133,7 +133,7 @@ const NEETO_ROUTES = {
     imageUploader: "/neeto_image_uploader_engine",
 };
 const PROFILE_LINKS = {
-    neetoStatus: "https://neetostatus.com/",
+    neetoStatus: "https://www.neetostatus.com/",
     neetoCommunity: "https://www.launchpass.com/neetohq",
 };
 
@@ -221,6 +221,91 @@ class MemberApis {
     }
 }
 
+class RailsEmailRakeClient {
+    constructor() {
+        this.convertRawEmail = (rawEmail) => {
+            var _a;
+            return ({
+                from: rawEmail.from,
+                to: rawEmail.to,
+                cc: rawEmail.cc,
+                bcc: rawEmail.bcc,
+                replyTo: rawEmail.reply_to,
+                subject: rawEmail.subject,
+                htmlBody: rawEmail.html_body,
+                textBody: rawEmail.text_body,
+                receivedAt: rawEmail.received_at,
+                attachments: (_a = rawEmail.attachments) === null || _a === void 0 ? void 0 : _a.map(att => ({
+                    name: att.filename,
+                    type: att.mime_type,
+                    content: att.data,
+                })),
+            });
+        };
+        this.executeRakeTask = async (taskName, args = []) => {
+            var _a, _b;
+            const childProcess = child_process.spawn("bundle", ["exec", "rake", taskName, "--", ...args], {
+                cwd: this.workingDirectory,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", data => {
+                stdout += data.toString();
+            });
+            (_b = childProcess.stderr) === null || _b === void 0 ? void 0 : _b.on("data", data => {
+                stderr += data.toString();
+            });
+            const exitCode = await new Promise((resolve, reject) => {
+                childProcess.on("error", reject);
+                childProcess.on("close", resolve);
+            });
+            if (exitCode !== 0) {
+                throw new Error(`Rake task ${taskName} failed: ${stderr || stdout || `Exit code ${exitCode}`}`);
+            }
+            return this.extractJsonFromOutput(stdout);
+        };
+        this.extractJsonFromOutput = (output) => {
+            const delimiterMatch = output.match(/<-- Captured Emails Start-->([\s\S]*?)<-- Captured Emails End-->/);
+            return delimiterMatch ? delimiterMatch[1].trim() : output.trim();
+        };
+        this.listEmails = async (searchParams) => {
+            try {
+                const args = this.buildSearchArgs(searchParams);
+                const output = await this.executeRakeTask("playwright:fetch_captured_emails", args);
+                if (!output)
+                    return [];
+                const rawEmails = JSON.parse(output);
+                return rawEmails.map(this.convertRawEmail);
+            }
+            catch (error) {
+                console.error("Failed to fetch emails:", error);
+                return [];
+            }
+        };
+        this.buildSearchArgs = (searchParams) => Object.entries(neetoCist.keysToSnakeCase(searchParams !== null && searchParams !== void 0 ? searchParams : {}))
+            .filter(([, value]) => value != null && value !== "")
+            .map(([key, value]) => `--${key}=${value}`);
+        this.getLatestEmail = async (searchParams) => {
+            const emails = await this.listEmails(searchParams);
+            if (emails.length === 0)
+                return null;
+            return emails.reduce((latest, current) => new Date(current.receivedAt) > new Date(latest.receivedAt)
+                ? current
+                : latest);
+        };
+        this.clearEmails = async () => {
+            try {
+                await this.executeRakeTask("playwright:clear_captured_emails");
+            }
+            catch (error) {
+                console.error("Failed to clear emails:", error);
+            }
+        };
+        this.workingDirectory = process.env.RAILS_ROOT || "..";
+    }
+}
+
 class RoleApis {
     constructor(neetoPlaywrightUtilities) {
         this.neetoPlaywrightUtilities = neetoPlaywrightUtilities;
@@ -57361,6 +57446,168 @@ const hexToRGB = (hex) => {
     return `rgb(${Number(r)}, ${Number(g)}, ${Number(b)})`;
 };
 
+class RailsEmailUtils {
+    constructor(neetoPlaywrightUtilities) {
+        this.neetoPlaywrightUtilities = neetoPlaywrightUtilities;
+        this.convertRailsEmailToFormattedList = (railsEmail) => {
+            var _a;
+            if (!railsEmail)
+                return null;
+            const LINK_REGEX = /(http|ftp|https):\/\/([\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])/g;
+            const CODE_REGEX = /(?<![#/])\b\d{4,}\b/g;
+            const htmlBody = railsEmail.htmlBody || "";
+            const textBody = railsEmail.textBody || "";
+            const htmlBodyWithStrippedHead = htmlBody.split("</head>").at(-1) || htmlBody;
+            const extractMatches = (text, regex) => text.match(regex) || null;
+            const parseEmailAddress = (address) => {
+                if (!address)
+                    return [];
+                const addresses = Array.isArray(address) ? address : [address];
+                return addresses.map(addr => {
+                    const match = addr.match(/^(.+?)\s*<(.+?)>$|^(.+)$/);
+                    return match
+                        ? {
+                            name: match[1] || match[3] || "",
+                            email: match[2] || match[3] || addr,
+                        }
+                        : { name: "", email: addr };
+                });
+            };
+            return {
+                html: {
+                    body: htmlBody,
+                    links: extractMatches(htmlBodyWithStrippedHead, LINK_REGEX),
+                    codes: extractMatches(htmlBodyWithStrippedHead, CODE_REGEX),
+                },
+                text: {
+                    body: textBody,
+                    links: extractMatches(textBody, LINK_REGEX),
+                    codes: extractMatches(textBody, CODE_REGEX),
+                },
+                id: `${railsEmail.receivedAt}-${Math.random().toString(36).substring(2, 9)}`,
+                from: parseEmailAddress(railsEmail.from),
+                to: parseEmailAddress(railsEmail.to),
+                cc: parseEmailAddress(railsEmail.cc),
+                bcc: parseEmailAddress(railsEmail.bcc),
+                replyTo: parseEmailAddress(railsEmail.replyTo),
+                received: new Date(railsEmail.receivedAt).toISOString(),
+                subject: railsEmail.subject,
+                attachments: ((_a = railsEmail.attachments) === null || _a === void 0 ? void 0 : _a.map(att => ({
+                    name: att.name,
+                    type: att.type,
+                }))) || [],
+                blobId: "",
+            };
+        };
+        this.clearEmails = () => this.railsEmailRakeClient.clearEmails();
+        this.getLatestEmail = (searchParams) => this.railsEmailRakeClient.getLatestEmail(searchParams);
+        this.listEmails = (searchParams) => this.railsEmailRakeClient.listEmails(searchParams);
+        this.listMessages = async (messageSearchCriteria = {}, { receivedAfter = new Date(new Date().valueOf() - 60 * 60 * 1000), } = {}) => {
+            const emails = await this.railsEmailRakeClient.listEmails({
+                ...messageSearchCriteria,
+                receivedAfter: receivedAfter.toISOString(),
+            });
+            return emails
+                .map(email => this.convertRailsEmailToFormattedList(email))
+                .filter((email) => email !== null);
+        };
+        this.findMessage = async (messageSearchCriteria = {}, { timeout = 10000, receivedAfter = new Date(new Date().valueOf() - 60 * 60 * 1000), expectedEmailCount = 1, } = {}, shouldThrowErrorOnTimeout = true) => {
+            const email = (await this.neetoPlaywrightUtilities.executeRecursively({
+                callback: async () => {
+                    const railsEmail = await this.railsEmailRakeClient.getLatestEmail({
+                        ...messageSearchCriteria,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    if (!railsEmail)
+                        return null;
+                    return this.convertRailsEmailToFormattedList(railsEmail);
+                },
+                condition: async () => {
+                    const emails = await this.railsEmailRakeClient.listEmails({
+                        ...messageSearchCriteria,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    return emails.length >= expectedEmailCount;
+                },
+                timeout,
+            }));
+            if (!email) {
+                if (shouldThrowErrorOnTimeout && expectedEmailCount > 0) {
+                    throw new Error("Timed out waiting for matching message");
+                }
+                return {};
+            }
+            return email;
+        };
+        this.findOtpFromEmail = async ({ email, subjectSubstring = OTP_EMAIL_PATTERN, timeout = 10000, receivedAfter = new Date(), expectedEmailCount = 1, }) => {
+            const otp = await this.neetoPlaywrightUtilities.executeRecursively({
+                callback: async () => {
+                    var _a, _b;
+                    const railsEmail = await this.railsEmailRakeClient.getLatestEmail({
+                        to: email,
+                        subject: subjectSubstring,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    if (!railsEmail)
+                        return null;
+                    const formattedEmail = this.convertRailsEmailToFormattedList(railsEmail);
+                    if (!formattedEmail)
+                        return null;
+                    return ((_a = formattedEmail.html.codes) === null || _a === void 0 ? void 0 : _a[0]) || ((_b = formattedEmail.text.codes) === null || _b === void 0 ? void 0 : _b[0]);
+                },
+                condition: async () => {
+                    const emails = await this.railsEmailRakeClient.listEmails({
+                        to: email,
+                        subject: subjectSubstring,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    return emails.length >= expectedEmailCount;
+                },
+                timeout,
+            });
+            return otp || undefined;
+        };
+        this.getEmailAttachment = async (attachmentName, messageSearchCriteria = {}, { receivedAfter = new Date(new Date().valueOf() - 60 * 60 * 1000), expectedEmailCount = 1, timeout = 10000, } = {}, shouldThrowErrorOnTimeout = true) => {
+            const attachmentDetails = (await this.neetoPlaywrightUtilities.executeRecursively({
+                callback: async () => {
+                    var _a;
+                    const railsEmail = await this.railsEmailRakeClient.getLatestEmail({
+                        ...messageSearchCriteria,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    if (!railsEmail)
+                        return null;
+                    const attachment = (_a = railsEmail.attachments) === null || _a === void 0 ? void 0 : _a.find(att => att.name.includes(attachmentName));
+                    if (!attachment)
+                        return null;
+                    return {
+                        filename: attachment.name,
+                        type: attachment.type,
+                        content: Buffer.from(attachment.content, "base64"),
+                        contentType: attachment.type,
+                    };
+                },
+                condition: async () => {
+                    const emails = await this.railsEmailRakeClient.listEmails({
+                        ...messageSearchCriteria,
+                        receivedAfter: receivedAfter.toISOString(),
+                    });
+                    return emails.length >= expectedEmailCount;
+                },
+                timeout,
+            }));
+            if (!attachmentDetails) {
+                if (shouldThrowErrorOnTimeout) {
+                    throw new Error("Timed out waiting for matching message or attachment not found");
+                }
+                return undefined;
+            }
+            return attachmentDetails;
+        };
+        this.railsEmailRakeClient = new RailsEmailRakeClient();
+    }
+}
+
 const dateTimeOneHourAgo = () => new Date(new Date().valueOf() - 60 * 60 * 1000);
 class MailerUtils {
     constructor(neetoPlaywrightUtilities) {
@@ -57404,8 +57651,10 @@ class MailerUtils {
                 const emailBodyWithStrippedHead = emailBody.split("</head>").at(-1);
                 const links = emailBodyWithStrippedHead.match(LINK_REGEX);
                 const codes = emailBodyWithStrippedHead.match(CODE_REGEX);
+                // Remove first and last links as Fastmail adds dot image links
+                const filteredLinks = links && links.length > 2 ? links.slice(1, -1) : links;
                 const contentRecognitions = {
-                    links: links && [...links],
+                    links: filteredLinks,
                     codes: codes && [...codes],
                 };
                 const html = { body: emailBody, ...contentRecognitions };
@@ -57433,6 +57682,9 @@ class MailerUtils {
             return formattedList;
         };
         this.listMessages = async (messageSearchCriteria = {}, listMessagesFilterCriteria = {}) => {
+            if (IS_DEV_ENV) {
+                return this.railsEmailUtils.listMessages(messageSearchCriteria, listMessagesFilterCriteria);
+            }
             const { ids } = await this.queryEmail(messageSearchCriteria, listMessagesFilterCriteria);
             return this.getEmails(ids);
         };
@@ -57460,12 +57712,24 @@ class MailerUtils {
             return ids;
         };
         this.findMessage = async (messageSearchCriteria = {}, { timeout = 10000, receivedAfter = dateTimeOneHourAgo(), expectedEmailCount = 1, } = {}, shouldThrowErrorOnTimeout = true) => {
+            if (IS_DEV_ENV) {
+                return this.railsEmailUtils.findMessage(messageSearchCriteria, { receivedAfter, expectedEmailCount, timeout: timeout / 3 }, shouldThrowErrorOnTimeout);
+            }
             const ids = await this.getEmailIds(messageSearchCriteria, { expectedEmailCount, receivedAfter, timeout }, shouldThrowErrorOnTimeout);
             const emails = await this.getEmails(ids);
             const filteredEmails = emails.filter(email => this.matchesCriteria(email, messageSearchCriteria));
             return filteredEmails[0] || {};
         };
         this.findOtpFromEmail = async ({ email, subjectSubstring = OTP_EMAIL_PATTERN, timeout = 2 * 60 * 1000, receivedAfter = new Date(), expectedEmailCount = 1, }) => {
+            if (IS_DEV_ENV) {
+                return this.railsEmailUtils.findOtpFromEmail({
+                    email,
+                    subjectSubstring,
+                    receivedAfter,
+                    expectedEmailCount,
+                    timeout: timeout / 3,
+                });
+            }
             if (!this.accountId) {
                 await this.fastmailApi.authorizeAndSetAccountId();
             }
@@ -57474,6 +57738,9 @@ class MailerUtils {
         };
         this.generateRandomEmail = () => faker.faker.internet.email({ provider: process.env.FASTMAIL_DOMAIN_NAME });
         this.getEmailAttachment = async (attachmentName, messageSearchCriteria = {}, { timeout = 10000, receivedAfter = dateTimeOneHourAgo(), expectedEmailCount = 1, } = {}, shouldThrowErrorOnTimeout = true) => {
+            if (IS_DEV_ENV) {
+                return this.railsEmailUtils.getEmailAttachment(attachmentName, messageSearchCriteria, { receivedAfter, expectedEmailCount, timeout: timeout / 3 }, shouldThrowErrorOnTimeout);
+            }
             const { blobId, attachments: attachmentNameAndTypes } = await this.findMessage(messageSearchCriteria, { expectedEmailCount, receivedAfter, timeout }, shouldThrowErrorOnTimeout);
             const attachment = attachmentNameAndTypes.find(attachment => attachment.name.includes(attachmentName));
             if (!attachment)
@@ -57485,6 +57752,7 @@ class MailerUtils {
             return attachments.find(attachment => attachment.filename.includes(attachmentName));
         };
         this.fastmailApi = new FastmailApi(neetoPlaywrightUtilities);
+        this.railsEmailUtils = new RailsEmailUtils(neetoPlaywrightUtilities);
     }
     matchesCriteria(email, criteria) {
         const { to, from, subject, body } = criteria;
@@ -114031,7 +114299,7 @@ const GOOGLE_LOGIN_TEXTS = {
 const ENGAGE_TEXTS = { subscribe: "Subscribe" };
 const COMMUNITY_TEXTS = { joinNow: "Join Now" };
 const STATUS_TEXTS = {
-    application: (appName) => `Neeto${appName} Application`,
+    appName: (appName) => `Neeto${appName}`,
 };
 const COMMON_TEXTS = {
     skipCleanup: "@SKIP_CLEANUP",
@@ -114424,9 +114692,7 @@ class HelpAndProfilePage {
                 await statusPage.waitForLoadState();
                 await Promise.all([
                     test.expect(statusPage).toHaveURL(PROFILE_LINKS.neetoStatus),
-                    test.expect(statusPage.getByText(STATUS_TEXTS.application(appName), {
-                        exact: true,
-                    })).toBeVisible(),
+                    test.expect(statusPage.getByRole("link", { name: STATUS_TEXTS.appName(appName) })).toBeVisible(),
                 ]);
             });
         };
@@ -114460,7 +114726,7 @@ class HelpAndProfilePage {
                     return;
                 const actionName = plan === "Free" ? "Upgrade" : "Downgrade";
                 const productRow = this.page.getByRole("row", {
-                    name: `Neeto${product}`,
+                    name: STATUS_TEXTS.appName(product),
                 });
                 await Promise.all([
                     test.expect(productRow.getByRole("cell", { name: plan })).toBeVisible(),
@@ -124972,6 +125238,8 @@ exports.PROFILE_SECTION_SELECTORS = PROFILE_SECTION_SELECTORS;
 exports.PROJECT_TRANSLATIONS_PATH = PROJECT_TRANSLATIONS_PATH;
 exports.ROLES_SELECTORS = ROLES_SELECTORS;
 exports.ROUTES = ROUTES;
+exports.RailsEmailRakeClient = RailsEmailRakeClient;
+exports.RailsEmailUtils = RailsEmailUtils;
 exports.RoleApis = RoleApis;
 exports.RolesPage = RolesPage;
 exports.SIGNUP_SELECTORS = SIGNUP_SELECTORS;