qa360 2.2.20 → 2.3.1

package/dist/core/crawler/email-testing-handler.js

@@ -0,0 +1,398 @@
+/**
+ * Email Testing Handler
+ *
+ * P1 - Email testing for applications that send emails
+ *
+ * Supports:
+ * - Mailhog integration
+ * - Mailtrap integration
+ * - Mailgun API
+ * - SendGrid API
+ * - Generic IMAP/POP3 access
+ * - Email parsing and validation
+ * - Link extraction from emails
+ * - Attachment handling
+ *
+ * @see https://github.com/mailhog/MailHog
+ */
+/**
+ * Email Testing Handler class
+ */
+export class EmailTestingHandler {
+    mailhogUrl;
+    timeout;
+    mailtrapToken;
+    mailgunApiKey;
+    sendgridApiKey;
+    constructor(config = {}) {
+        this.mailhogUrl = config.mailhogUrl || 'http://localhost:8025';
+        this.timeout = config.timeout || 30000;
+        this.mailtrapToken = config.mailtrapToken;
+        this.mailgunApiKey = config.mailgunApiKey;
+        this.sendgridApiKey = config.sendgridApiKey;
+    }
+    /**
+     * Fetch all messages from Mailhog
+     */
+    async fetchMessages() {
+        const response = await fetch(`${this.mailhogUrl}/api/v2/messages`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch messages: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return (data.items || []).map(this.parseMailhogMessage);
+    }
+    /**
+     * Delete all messages from Mailhog
+     */
+    async deleteAllMessages() {
+        await fetch(`${this.mailhogUrl}/api/v1/messages`, { method: 'DELETE' });
+    }
+    /**
+     * Get a specific message by ID
+     */
+    async getMessage(id) {
+        const response = await fetch(`${this.mailhogUrl}/api/v2/messages/${id}`);
+        if (!response.ok) {
+            if (response.status === 404)
+                return null;
+            throw new Error(`Failed to fetch message: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return this.parseMailhogMessage(data);
+    }
+    /**
+     * Wait for a new email matching criteria
+     */
+    async waitForEmail(options = {}, timeout) {
+        const timeoutMs = timeout || this.timeout;
+        const startTime = Date.now();
+        let lastCount = 0;
+        // Get initial count
+        try {
+            const initialMessages = await this.fetchMessages();
+            lastCount = initialMessages.length;
+        }
+        catch {
+            // Mailhog might not be available yet
+        }
+        while (Date.now() - startTime < timeoutMs) {
+            await this.sleep(500);
+            try {
+                const messages = await this.fetchMessages();
+                // Check for new messages
+                if (messages.length > lastCount) {
+                    const newMessages = messages.slice(lastCount);
+                    // Find matching message
+                    for (const message of newMessages) {
+                        if (this.matchesCriteria(message, options)) {
+                            return message;
+                        }
+                    }
+                    lastCount = messages.length;
+                }
+            }
+            catch (e) {
+                // Continue waiting on error
+            }
+        }
+        return null;
+    }
+    /**
+     * Search for messages matching criteria
+     */
+    async searchMessages(options) {
+        const messages = await this.fetchMessages();
+        return messages.filter(msg => this.matchesCriteria(msg, options));
+    }
+    /**
+     * Get the most recent email matching criteria
+     */
+    async getLatestEmail(options = {}) {
+        const messages = await this.searchMessages(options);
+        if (messages.length === 0)
+            return null;
+        // Sort by received date descending
+        messages.sort((a, b) => b.received.getTime() - a.received.getTime());
+        return messages[0];
+    }
+    /**
+     * Extract all links from an email
+     */
+    extractLinks(message) {
+        const textLinks = [];
+        const htmlLinks = [];
+        // Extract from plain text
+        if (message.text) {
+            const urlRegex = /https?:\/\/[^\s]+/gi;
+            const matches = message.text.match(urlRegex);
+            if (matches) {
+                textLinks.push(...matches);
+            }
+        }
+        // Extract from HTML
+        if (message.html) {
+            const hrefRegex = /href=["']([^"']+)["']/gi;
+            let match;
+            while ((match = hrefRegex.exec(message.html)) !== null) {
+                htmlLinks.push(match[1]);
+            }
+        }
+        return {
+            textLinks,
+            htmlLinks,
+            allLinks: [...textLinks, ...htmlLinks],
+        };
+    }
+    /**
+     * Extract verification links (common patterns)
+     */
+    extractVerificationLinks(message) {
+        const links = this.extractLinks(message).allLinks;
+        const result = {
+            verifyEmail: [],
+            resetPassword: [],
+            unsubscribe: [],
+            other: [],
+        };
+        for (const link of links) {
+            const lower = link.toLowerCase();
+            if (lower.includes('verify') || lower.includes('confirm')) {
+                result.verifyEmail.push(link);
+            }
+            else if (lower.includes('reset') || lower.includes('forgot') || lower.includes('recover')) {
+                result.resetPassword.push(link);
+            }
+            else if (lower.includes('unsubscribe')) {
+                result.unsubscribe.push(link);
+            }
+            else {
+                result.other.push(link);
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract OTP/code from email
+     */
+    extractCode(message) {
+        const content = message.text || message.html || '';
+        // Try common patterns
+        const patterns = [
+            // "Your code is: 123456"
+            /(?:code|verification|otp|pin|token)[:\s]+([A-Z0-9]{4,12})/i,
+            // "123456 is your verification code"
+            /(\d{4,8})\s+(?:is your|verification|code|otp)/i,
+            // Just a 6-digit number (common pattern)
+            /\b(\d{6})\b/g,
+        ];
+        let bestMatch = null;
+        for (const pattern of patterns) {
+            const matches = content.match(pattern);
+            if (matches) {
+                const code = matches[1] || matches[0];
+                const confidence = code.length >= 6 ? 0.9 : 0.5;
+                if (!bestMatch || confidence > bestMatch.confidence) {
+                    bestMatch = { code, confidence };
+                }
+            }
+        }
+        if (bestMatch) {
+            return {
+                code: bestMatch.code,
+                type: /^\d+$/.test(bestMatch.code) ? 'numeric' : 'alphanumeric',
+                confidence: bestMatch.confidence,
+            };
+        }
+        return { confidence: 0 };
+    }
+    /**
+     * Parse a Mailhog message
+     */
+    parseMailhogMessage(data) {
+        const raw = data.Content || {};
+        const headers = raw.Headers || {};
+        const from = headers.From || headers.from || '';
+        const to = headers.To || headers.to || [];
+        const toList = Array.isArray(to) ? to : [to];
+        return {
+            id: data.ID || '',
+            from: this.parseEmailAddress(from),
+            to: toList.map((a) => this.parseEmailAddress(a)),
+            cc: headers.Cc || headers.cc ? [headers.Cc || headers.cc].flat() : undefined,
+            subject: headers.Subject || headers.subject || '',
+            text: raw.Body || raw.Text,
+            html: raw.HTML || raw.Html,
+            received: new Date(data.Created || Date.now()),
+            attachments: this.parseAttachments(raw.Attachments || []),
+            headers: headers,
+        };
+    }
+    /**
+     * Parse email address from string
+     */
+    parseEmailAddress(address) {
+        // Remove display name and quotes
+        const match = address.match(/<([^>]+)>/);
+        if (match)
+            return match[1];
+        // Remove extra whitespace
+        return address.trim();
+    }
+    /**
+     * Parse attachments from Mailhog format
+     */
+    parseAttachments(data) {
+        if (!data || !Array.isArray(data))
+            return [];
+        return data.map(att => ({
+            filename: att.FileName || att.filename || 'unknown',
+            contentType: att.ContentType || att.contentType || 'application/octet-stream',
+            size: att.Size || att.size || 0,
+            downloadUrl: att.DownloadUrl || att.downloadUrl,
+        }));
+    }
+    /**
+     * Check if message matches search criteria
+     */
+    matchesCriteria(message, options) {
+        if (options.to) {
+            const toFilter = options.to;
+            if (!message.to.some((t) => t.includes(toFilter))) {
+                return false;
+            }
+        }
+        if (options.from && !message.from.includes(options.from)) {
+            return false;
+        }
+        if (options.subject && !message.subject.toLowerCase().includes(options.subject.toLowerCase())) {
+            return false;
+        }
+        if (options.contains) {
+            const content = (message.text || '') + (message.html || '');
+            if (!content.toLowerCase().includes(options.contains.toLowerCase())) {
+                return false;
+            }
+        }
+        if (options.after && message.received < options.after) {
+            return false;
+        }
+        if (options.before && message.received > options.before) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Assert email was received
+     */
+    async assertEmailReceived(options, timeout) {
+        const email = await this.waitForEmail(options, timeout);
+        if (email) {
+            return { received: true, email };
+        }
+        return {
+            received: false,
+            error: `No email received matching criteria: ${JSON.stringify(options)}`,
+        };
+    }
+    /**
+     * Assert email contains link
+     */
+    assertEmailContainsLink(message, linkPattern) {
+        const links = this.extractLinks(message).allLinks;
+        const foundLinks = links.filter(link => {
+            if (typeof linkPattern === 'string') {
+                return link.includes(linkPattern);
+            }
+            return linkPattern.test(link);
+        });
+        return {
+            contains: foundLinks.length > 0,
+            foundLinks,
+        };
+    }
+    /**
+     * Get Mailhog status
+     */
+    async getMailhogStatus() {
+        try {
+            const response = await fetch(`${this.mailhogUrl}/api/v2/messages`);
+            return { available: response.ok || response.status === 200 };
+        }
+        catch (e) {
+            return {
+                available: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Fetch messages from Mailtrap (alternative to Mailhog)
+     */
+    async fetchMailtrapMessages(inboxId) {
+        if (!this.mailtrapToken) {
+            throw new Error('Mailtrap token not configured');
+        }
+        // Mailtrap API v1
+        const response = await fetch(`https://mailtrap.io/api/v1/inboxes/${inboxId || '1'}/messages`, {
+            headers: {
+                'Api-Token': this.mailtrapToken,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Mailtrap messages: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return (data || []).map(this.parseMailtrapMessage);
+    }
+    /**
+     * Parse Mailtrap message
+     */
+    parseMailtrapMessage(data) {
+        return {
+            id: data.id.toString(),
+            from: data.from_email || data.from || '',
+            to: [data.to_email || data.to || ''].filter(Boolean),
+            subject: data.subject || '',
+            text: data.text_body || data.text_body,
+            html: data.html_body || data.html_body,
+            received: new Date(data.created_at || Date.now()),
+            attachments: data.attachments?.map((att) => ({
+                filename: att.filename,
+                contentType: att.content_type,
+                size: att.size,
+                downloadUrl: att.download_url,
+            })) || [],
+        };
+    }
+    /**
+     * Create email testing utilities for test helpers
+     */
+    createTestHelpers() {
+        return {
+            waitForEmail: this.waitForEmail.bind(this),
+            getLatestEmail: this.getLatestEmail.bind(this),
+            extractLinks: this.extractLinks.bind(this),
+            extractCode: this.extractCode.bind(this),
+            deleteAll: this.deleteAllMessages.bind(this),
+            assertEmailReceived: this.assertEmailReceived.bind(this),
+        };
+    }
+}
+/**
+ * Factory function to create Email Testing Handler
+ */
+export function createEmailTestingHandler(config) {
+    return new EmailTestingHandler(config);
+}
+/**
+ * Quick function to wait for email
+ */
+export async function waitForEmail(config, options, timeout) {
+    const handler = new EmailTestingHandler(config);
+    return handler.waitForEmail(options, timeout);
+}
+export default EmailTestingHandler;

package/dist/core/crawler/error-tracking-handler.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Error Tracking Handler
+ *
+ * P1 - Global error tracking and monitoring
+ *
+ * Supports:
+ * - JavaScript error capture
+ * - Unhandled rejection tracking
+ * - Error aggregation and deduplication
+ * - Error context collection
+ * - Error reporting
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers
+ */
+export interface ErrorInfo {
+    /** Error message */
+    message: string;
+    /** Error stack trace */
+    stack: string;
+    /** Error name */
+    name: string;
+    /** Source file */
+    filename?: string;
+    /** Line number */
+    line?: number;
+    /** Column number */
+    column?: number;
+    /** Error type */
+    type: 'error' | 'unhandledrejection' | 'resource' | 'console';
+    /** Timestamp */
+    timestamp: number;
+    /** User agent */
+    userAgent: string;
+    /** Page URL */
+    pageUrl: string;
+    /** Additional context */
+    context?: {
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        console?: string[];
+        localStorage?: Record<string, string>;
+    };
+}
+export interface ErrorGroup {
+    /** Unique error key */
+    key: string;
+    /** Error name */
+    name: string;
+    /** Error message */
+    message: string;
+    /** Count of occurrences */
+    count: number;
+    /** First occurrence timestamp */
+    firstSeen: number;
+    /** Last occurrence timestamp */
+    lastSeen: number;
+    /** Sample stack trace */
+    stack: string;
+    /** Affected pages */
+    pages: string[];
+}
+export interface ResourceError {
+    /** Resource URL */
+    url: string;
+    /** Resource type */
+    type: string;
+    /** Error status */
+    status: number;
+    /** Error message */
+    message: string;
+    /** Timestamp */
+    timestamp: number;
+}
+export interface ErrorReport {
+    /** Total errors captured */
+    totalErrors: number;
+    /** Errors by type */
+    errorsByType: Record<string, number>;
+    /** Grouped errors */
+    groupedErrors: ErrorGroup[];
+    /** Resource errors */
+    resourceErrors: ResourceError[];
+    /** Most frequent error */
+    mostFrequent: ErrorGroup | null;
+    /** Unhandled rejections */
+    unhandledRejections: number;
+    /** Console errors */
+    consoleErrors: number;
+}
+/**
+ * Error Tracking Handler class
+ */
+export declare class ErrorTrackingHandler {
+    private page;
+    private errors;
+    private resourceErrors;
+    private trackingEnabled;
+    private consoleErrors;
+    constructor(page: any);
+    /**
+     * Setup global error tracking
+     */
+    setupTracking(): Promise<void>;
+    /**
+     * Get all captured errors from the page
+     */
+    getErrors(): Promise<ErrorInfo[]>;
+    /**
+     * Get all resource errors
+     */
+    getResourceErrors(): Promise<ResourceError[]>;
+    /**
+     * Get console errors
+     */
+    getConsoleErrors(): Promise<string[]>;
+    /**
+     * Generate error report
+     */
+    generateReport(): Promise<ErrorReport>;
+    /**
+     * Group errors by similarity
+     */
+    private groupErrors;
+    /**
+     * Capture error with additional context
+     */
+    captureError(error: Error, context?: Record<string, unknown>): Promise<void>;
+    /**
+     * Clear all captured errors
+     */
+    clearErrors(): Promise<void>;
+    /**
+     * Get errors by type
+     */
+    getErrorsByType(type: ErrorInfo['type']): Promise<ErrorInfo[]>;
+    /**
+     * Get errors by page URL
+     */
+    getErrorsByPage(pageUrl: string): Promise<ErrorInfo[]>;
+    /**
+     * Check if there are any critical errors
+     */
+    hasCriticalErrors(): Promise<boolean>;
+    /**
+     * Get error statistics
+     */
+    getStatistics(): Promise<{
+        total: number;
+        byType: Record<string, number>;
+        critical: number;
+        unique: number;
+        avgPerMinute: number;
+    }>;
+    /**
+     * Export errors as JSON
+     */
+    exportErrors(): Promise<string>;
+    /**
+     * Setup error threshold monitoring
+     */
+    setupThresholdMonitoring(threshold: number, callback: (errors: ErrorInfo[]) => void | Promise<void>): Promise<() => void>;
+    /**
+     * Check if tracking is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Disable error tracking
+     */
+    disableTracking(): Promise<void>;
+}
+/**
+ * Factory function to create Error Tracking Handler
+ */
+export declare function createErrorTrackingHandler(page: any): ErrorTrackingHandler;
+export default ErrorTrackingHandler;