@5minds/node-red-contrib-processcube-tools 1.2.0-develop-2eb127-mg68t7xt → 1.2.0-develop-59ef22-mg9d9ja5

package/src/test/mocks/imap-mock.ts

@@ -0,0 +1,147 @@
+import { EventEmitter } from 'events';
+import { ImapConfig } from '../interfaces/imap-config';
+import { ImapMailbox } from '../interfaces/imap-mailbox';
+
+export class MockImap extends EventEmitter {
+    private config: ImapConfig;
+    private isConnected = false;
+    private currentBox: string | null = null;
+    public state: string = 'disconnected';
+
+    constructor(config: ImapConfig) {
+        super();
+        this.config = config;
+    }
+
+    connect(): void {
+        setTimeout(() => {
+            if (this.isConnectionInvalid()) {
+                const error = new Error('Connection failed') as Error & { code: string };
+                error.code = 'ENOTFOUND';
+                this.emit('error', error);
+            } else {
+                this.isConnected = true;
+                this.state = 'authenticated';
+                this.emit('ready');
+            }
+        }, 10);
+    }
+
+    openBox(folder: string, readOnly: boolean, callback: (err: Error | null, box?: ImapMailbox) => void): void {
+        if (!this.isConnected) {
+            callback(new Error('Not connected'));
+            return;
+        }
+
+        setTimeout(() => {
+            this.currentBox = folder;
+            callback(null, {
+                messages: { total: this.getMessageCount(folder) },
+                name: folder,
+                readOnly,
+            });
+        }, 5);
+    }
+
+    search(criteria: any[], callback: (err: Error | null, results?: number[]) => void): void {
+        setTimeout(() => {
+            const messageIds = this.getFixedMessageIds();
+            callback(null, messageIds);
+        }, 10);
+    }
+
+    fetch(results: number[], options?: any) {
+        const fetchEmitter = new EventEmitter();
+
+        setTimeout(() => {
+            results.forEach((id, index) => {
+                setTimeout(() => {
+                    const mockMessage = this.createMockMessage(id);
+                    fetchEmitter.emit('message', mockMessage, id);
+                }, index * 5);
+            });
+
+            // Emit end after all messages are processed
+            setTimeout(() => fetchEmitter.emit('end'), results.length * 10 + 50);
+        }, 10);
+
+        return fetchEmitter;
+    }
+
+    end(): void {
+        this.isConnected = false;
+        this.state = 'disconnected';
+        setTimeout(() => this.emit('end'), 5);
+    }
+
+    addFlags(source: number | number[], flags: string[], callback: (err: Error | null) => void): void {
+        setTimeout(() => callback(null), 5);
+    }
+
+    // Private helper methods
+    private isConnectionInvalid(): boolean {
+        return (
+            !this.config.host ||
+            this.config.host.includes('invalid') ||
+            this.config.host.includes('nonexistent') ||
+            this.config.host.includes('unreachable') ||
+            !this.config.user ||
+            !this.config.password
+        );
+    }
+
+    private getMessageCount(folder: string): number {
+        const counts: Record<string, number> = {
+            INBOX: 5,
+            SENT: 2,
+            DRAFTS: 1,
+            JUNK: 0,
+        };
+        return counts[folder.toUpperCase()] || 3;
+    }
+
+    private getFixedMessageIds(): number[] {
+        return this.currentBox === 'INBOX' ? [123, 456, 789, 1011, 1213] : [123, 456, 789];
+    }
+
+    private createMockMessage(id: number) {
+        const message = new EventEmitter();
+
+        setTimeout(() => {
+            const emailContent = this.generateEmailContent(id);
+            // Create a proper readable stream
+            const { Readable } = require('stream');
+            const mockStream = new Readable({
+                read() {
+                    this.push(Buffer.from(emailContent));
+                    this.push(null); // End the stream
+                },
+            });
+            message.emit('body', mockStream);
+        }, 5);
+
+        setTimeout(() => {
+            message.emit('attributes', {
+                uid: id,
+                flags: Math.random() > 0.5 ? ['\\Seen'] : [],
+                date: new Date(),
+                size: Math.floor(Math.random() * 10000) + 500,
+            });
+        }, 10);
+
+        return message;
+    }
+
+    private generateEmailContent(id: number): string {
+        return [
+            `Message-ID: <${id}@test.com>`,
+            `From: sender${id}@test.com`,
+            `To: recipient@test.com`,
+            `Subject: Test Email ${id}`,
+            `Date: ${new Date().toUTCString()}`,
+            ``,
+            `This is test email content for message ${id}.`,
+            `Generated for testing purposes.`,
+        ].join('\r\n');
+    }
+}

package/src/test/mocks/mailparser-mock.ts

@@ -0,0 +1,82 @@
+import { EmailData } from '../interfaces/email-data';
+
+export function createMockMailparser() {
+    return function mockMailParser(stream: NodeJS.ReadableStream, callback: (err: Error | null, parsed?: any) => void) {
+        // Read the stream data
+        let emailData = '';
+
+        stream.on('data', (chunk) => {
+            emailData += chunk.toString();
+        });
+
+        stream.on('end', () => {
+            // Parse the email content using your existing helper
+            const parsedData = parseEmailContent(emailData);
+            const parsedMail = {
+                subject: parsedData.subject || 'Mock Email Subject',
+                text: parsedData.text || 'Mock email content',
+                html: parsedData.html || '<p>Mock email content</p>',
+                from: {
+                    text: parsedData.from || 'sender@test.com',
+                    value: [{ address: parsedData.from || parsedData.from || 'sender@test.com' }],
+                },
+                replyTo: {
+                    text: parsedData.from || 'sender@test.com',
+                    value: [{ address: parsedData.to || parsedData.to || 'recipient@test.com' }],
+                },
+                date: parsedData.date || new Date(),
+                messageId: parsedData.messageId || '<mock@test.com>',
+                headers: new Map([
+                    ['message-id', parsedData.messageId || '<mock@test.com>'],
+                    ['subject', parsedData.subject || 'Mock Email Subject'],
+                    ['from', parsedData.from || 'sender@test.com'],
+                ]),
+                attachments: parsedData.attachments || [],
+            };
+
+            // Call the callback asynchronously to simulate real parsing
+            setTimeout(() => {
+                callback(null, parsedMail);
+            }, 5);
+        });
+
+        stream.on('error', (err) => {
+            callback(err);
+        });
+    };
+}
+
+// Helper to parse basic email content
+function parseEmailContent(content: string): Partial<EmailData> {
+    const lines = content.split('\r\n');
+    const result: Partial<EmailData> = {};
+    let bodyStart = false;
+    let bodyLines: string[] = [];
+
+    for (const line of lines) {
+        if (!bodyStart) {
+            if (line === '') {
+                bodyStart = true;
+                continue;
+            }
+
+            if (line.startsWith('Subject: ')) {
+                result.subject = line.substring(9);
+            } else if (line.startsWith('From: ')) {
+                result.from = line.substring(6);
+            } else if (line.startsWith('To: ')) {
+                result.to = line.substring(4);
+            } else if (line.startsWith('Message-ID: ')) {
+                result.messageId = line.substring(12);
+            }
+        } else {
+            bodyLines.push(line);
+        }
+    }
+
+    if (bodyLines.length > 0) {
+        result.text = bodyLines.join('\n');
+    }
+
+    return result;
+}

package/src/test/mocks/nodemailer-mock.ts

@@ -0,0 +1,118 @@
+import { EnhancedMockNodeREDOptions } from '../framework/node-test-runner';
+import { MailOptions, MockNodemailerOptions } from '../interfaces/mail-options';
+import { SendMailResult } from '../interfaces/send-mail-result';
+
+class MockNodemailer {
+    constructor(private options: MockNodemailerOptions = {}) {}
+
+    sendMail(mailOptions: MailOptions, callback: (err: Error | null, result?: SendMailResult) => void): void {
+        if (this.options.onSendMail) {
+            this.options.onSendMail(mailOptions);
+        }
+
+        if (this.options.shouldFail) {
+            console.log('💥 Triggering failure');
+            const error = new Error(
+                this.options.failureMessage || 'Invalid login: 535 Authentication credentials invalid',
+            ) as Error & { code: string };
+            error.code = this.options.failureCode || 'EAUTH';
+            return callback(error);
+        }
+
+        // Process recipient status
+        const recipients = this.normalizeRecipients(mailOptions.to);
+        const result = this.categorizeRecipients(recipients);
+
+        // Simulate realistic delays
+        setTimeout(() => {
+            callback(null, {
+                messageId: this.generateMessageId(),
+                response: this.getResponseMessage(result),
+                accepted: result.accepted,
+                rejected: result.rejected,
+                pending: result.pending,
+            });
+        }, 10);
+    }
+
+    verify(callback?: (err: Error | null, success?: boolean) => void): Promise<boolean> | void {
+        if (callback) {
+            setTimeout(() => {
+                if (this.options.shouldFailVerify) {
+                    const error = new Error('Mock verify error') as Error & { code: string };
+                    error.code = 'ECONNREFUSED';
+                    callback(error);
+                } else {
+                    callback(null, true);
+                }
+            }, 10);
+        } else {
+            // Return a promise if no callback provided
+            return new Promise((resolve, reject) => {
+                if (this.options.shouldFailVerify) {
+                    const error = new Error('Mock verify error') as Error & { code: string };
+                    error.code = 'ECONNREFUSED';
+                    reject(error);
+                } else {
+                    resolve(true);
+                }
+            });
+        }
+    }
+
+    private normalizeRecipients(to: string | string[]): string[] {
+        if (Array.isArray(to)) return to;
+        if (typeof to === 'string') return to.split(',').map((email) => email.trim());
+        return [];
+    }
+
+    private categorizeRecipients(recipients: string[]): { accepted: string[]; rejected: string[]; pending: string[] } {
+        const result = { accepted: [] as string[], rejected: [] as string[], pending: [] as string[] };
+
+        recipients.forEach((email) => {
+            if (this.options.rejectedEmails?.includes(email)) {
+                result.rejected.push(email);
+            } else if (this.options.pendingEmails?.includes(email)) {
+                result.pending.push(email);
+            } else if (this.options.acceptedEmails?.length) {
+                if (this.options.acceptedEmails.includes(email)) {
+                    result.accepted.push(email);
+                }
+            } else {
+                // Default: accept all emails not explicitly rejected or pending
+                result.accepted.push(email);
+            }
+        });
+
+        return result;
+    }
+
+    private getResponseMessage(result: { accepted: string[]; rejected: string[]; pending: string[] }): string {
+        if (result.rejected.length > 0) return '550 Mailbox unavailable';
+        if (result.pending.length > 0) return '451 Requested action aborted: local error';
+        return '250 OK: Message accepted';
+    }
+
+    private generateMessageId(): string {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substr(2, 9);
+        return `<${timestamp}.${random}@test.com>`;
+    }
+}
+
+export function createMockNodemailer(options: MockNodemailerOptions = {}) {
+    return {
+        createTransport: (config?: any) => new MockNodemailer(options),
+        restore: () => {
+            // Cleanup method for compatibility
+        },
+    };
+}
+
+export function withNodemailerMock(options: MockNodemailerOptions): Partial<EnhancedMockNodeREDOptions> {
+    return {
+        dependencies: {
+            nodemailer: createMockNodemailer(options),
+        },
+    };
+}