@5minds/node-red-contrib-processcube-tools 1.2.0-feature-37541f-mg92jkdw → 1.2.0-feature-8f3d72-mg9cplxi

package/src/test/helpers/email-sender-test-configs.ts

@@ -1,123 +0,0 @@
-import { EmailSenderConfig } from '../interfaces/email-sender-config';
-
-const EmailSenderTestConfigs = {
-    valid: {
-        id: 'test-sender-1',
-        type: 'email-sender',
-        name: 'Test Email Sender',
-        sender: 'Test Sender',
-        address: 'test.sender@example.com',
-        to: 'recipient@example.com',
-        subject: 'Test Subject',
-        htmlContent: '<b>Test Content</b>',
-        attachments: '',
-        attachmentsType: 'str',
-        host: 'smtp.example.com',
-        port: 587,
-        user: 'testuser',
-        password: 'testpass',
-        secure: false,
-        rejectUnauthorized: true,
-    } as EmailSenderConfig,
-
-    minimal: {
-        id: 'test-sender-minimal',
-        type: 'email-sender',
-        sender: 'Test Sender',
-        address: 'test.sender@example.com',
-        to: 'recipient@example.com',
-        subject: 'Minimal Subject',
-        htmlContent: 'Minimal content',
-        host: 'smtp.minimal.com',
-        port: 587,
-        user: 'minimal-user',
-        password: 'minimal-pass',
-        secure: false,
-        rejectUnauthorized: true,
-    } as EmailSenderConfig,
-
-    invalid: {
-        id: 'test-sender-invalid',
-        type: 'email-sender',
-        name: 'Invalid Sender',
-        sender: '', // Missing sender
-        to: 'test@example.com',
-        subject: 'Invalid Test',
-        host: '', // Missing host
-        port: 587,
-        user: 'user',
-        password: '', // Missing password
-    } as EmailSenderConfig,
-
-    minimalDataDriven: {
-        id: 'test-sender-minimal',
-        type: 'email-sender',
-        sender: 'Test Sender',
-        address: 'test.sender@example.com',
-        subject: 'Minimal Subject',
-        htmlContent: 'Minimal content',
-        host: 'smtp.minimal.com',
-        port: 587,
-        user: 'minimal-user',
-        password: 'minimal-pass',
-        secure: false,
-        rejectUnauthorized: true,
-    } as EmailSenderConfig,
-
-    withAttachments: {
-        id: 'test-sender-attachments',
-        type: 'email-sender',
-        name: 'Sender With Attachments',
-        to: 'recipient@example.com',
-        subject: 'Attachment Test',
-        htmlContent: 'Email with attachments',
-        attachments: JSON.stringify([{ filename: 'test.txt', content: 'Test attachment' }]),
-        attachmentsType: 'json',
-        host: 'smtp.example.com',
-        port: 587,
-        user: 'testuser',
-        password: 'testpass',
-    } as EmailSenderConfig,
-
-    errorScenarios: {
-        networkError: {
-            id: 'test-sender-network-error',
-            type: 'email-sender',
-            name: 'Network Error Scenario',
-            host: 'unreachable.invalid.host.com',
-            shouldFail: true,
-        } as EmailSenderConfig,
-
-        rejectedEmail: {
-            id: 'test-sender-rejected',
-            type: 'email-sender',
-            name: 'Rejected Email Scenario',
-            rejectedEmails: ['recipient@example.com'],
-        } as EmailSenderConfig,
-
-        pendingEmail: {
-            id: 'test-sender-pending',
-            type: 'email-sender',
-            name: 'Pending Email Scenario',
-            pendingEmails: ['recipient@example.com'],
-        } as EmailSenderConfig,
-    },
-};
-
-const baseConfig = EmailSenderTestConfigs.valid;
-EmailSenderTestConfigs.errorScenarios.networkError = {
-    ...baseConfig,
-    ...EmailSenderTestConfigs.errorScenarios.networkError,
-};
-
-EmailSenderTestConfigs.errorScenarios.rejectedEmail = {
-    ...baseConfig,
-    ...EmailSenderTestConfigs.errorScenarios.rejectedEmail,
-};
-
-EmailSenderTestConfigs.errorScenarios.pendingEmail = {
-    ...baseConfig,
-    ...EmailSenderTestConfigs.errorScenarios.pendingEmail,
-};
-
-export { EmailSenderTestConfigs };

package/src/test/helpers/email-sender-test-flows.ts

@@ -1,16 +0,0 @@
-import { EmailSenderTestConfigs } from './email-sender-test-configs';
-
-export const testFlows = {
-    single: [EmailSenderTestConfigs.valid],
-
-    connected: [
-        { ...EmailSenderTestConfigs.valid, wires: [['h1']] },
-        { id: 'h1', type: 'helper' },
-    ],
-
-    multiOutput: [
-        { ...EmailSenderTestConfigs.valid, wires: [['h1', 'h2']] },
-        { id: 'h1', type: 'helper' },
-        { id: 'h2', type: 'helper' },
-    ],
-};

package/src/test/integration/email-receiver.integration.test.ts

@@ -1,41 +0,0 @@
-import { expect } from 'chai';
-import emailReceiverNode from '../../email-receiver/email-receiver';
-import { EmailReceiverTestConfigs } from '../helpers/email-receiver-test-configs';
-
-// Import our comprehensive test framework
-import { NodeTestRunner, NodeAssertions, type TestScenario, MockNodeREDOptions } from '../framework';
-
-import { MockImap } from '../mocks/imap-mock';
-import { createMockMailparser } from '../mocks/mailparser-mock';
-
-describe('E-Mail Receiver Node - Integration Tests', function () {
-    // ========================================================================
-    // INTEGRATION WITH EXISTING MOCK SYSTEM
-    // ========================================================================
-
-    describe('Mock System Integration', function () {
-        it('should work with all mock configurations', async function () {
-            const mockConfigs = [
-                EmailReceiverTestConfigs.valid,
-                EmailReceiverTestConfigs.minimal,
-                EmailReceiverTestConfigs.arrayFolders,
-            ];
-
-            for (const config of mockConfigs) {
-                const scenario: TestScenario = {
-                    name: `mock integration - ${config.name || 'unnamed'}`,
-                    config,
-                    input: { payload: 'test' },
-                    timeout: 2000,
-                };
-
-                const context = await NodeTestRunner.runScenario(emailReceiverNode, scenario);
-                expect(context.nodeInstance).to.exist;
-
-                if (config.name) {
-                    NodeAssertions.expectNodeProperty(context, 'name', config.name);
-                }
-            }
-        });
-    });
-});

package/src/test/integration/email-sender.integration.test.ts

@@ -1,129 +0,0 @@
-import { describe, it } from 'mocha';
-import { expect } from 'chai';
-import {
-    IntegrationTestRunner,
-    IntegrationAssertions,
-    IntegrationScenarioBuilder,
-    type IntegrationTestScenario,
-} from '../framework';
-import { EmailSenderTestConfigs } from '../helpers/email-sender-test-configs';
-import { testFlows } from '../helpers/email-sender-test-flows';
-
-const emailSenderNode = require('../../email-sender/email-sender');
-
-describe('E-Mail Sender Node - Integration Tests (Framework)', function () {
-    // ========================================================================
-    // NODE LOADING TESTS USING FRAMEWORK
-    // ========================================================================
-
-    describe('Node Loading (Enhanced)', function () {
-        const loadingTests = new IntegrationScenarioBuilder()
-            .addLoadingScenario('valid configuration', [EmailSenderTestConfigs.valid], EmailSenderTestConfigs.valid.id)
-            .addLoadingScenario(
-                'minimal configuration',
-                [EmailSenderTestConfigs.minimal],
-                EmailSenderTestConfigs.minimal.id,
-            );
-
-        loadingTests.getScenarios().forEach((scenario) => {
-            it(`should load with ${scenario.name}`, async function () {
-                const context = await IntegrationTestRunner.runIntegrationScenario(emailSenderNode, scenario);
-
-                IntegrationAssertions.expectNodeExists(context, scenario.nodeId);
-                IntegrationAssertions.expectNodeProperty(context, scenario.nodeId, 'type', 'email-sender');
-
-                const nodeConfig = scenario.flow.find((n) => n.id === scenario.nodeId);
-                if (nodeConfig.name) {
-                    IntegrationAssertions.expectNodeProperty(context, scenario.nodeId, 'name', nodeConfig.name);
-                }
-            });
-        });
-    });
-
-    // ========================================================================
-    // CONNECTION TESTS USING FRAMEWORK
-    // ========================================================================
-
-    describe('Node Connections', function () {
-        it('should load node in a flow configuration', async function () {
-            const scenario: IntegrationTestScenario = {
-                name: 'node in flow',
-                flow: testFlows.connected,
-                nodeId: EmailSenderTestConfigs.valid.id,
-                timeout: 2000,
-            };
-
-            const context = await IntegrationTestRunner.runIntegrationScenario(emailSenderNode, scenario);
-
-            // Only verify the main node exists - helper nodes aren't actually created
-            IntegrationAssertions.expectNodeExists(context, EmailSenderTestConfigs.valid.id);
-            IntegrationAssertions.expectNodeProperty(
-                context,
-                EmailSenderTestConfigs.valid.id,
-                'name',
-                EmailSenderTestConfigs.valid.name,
-            );
-        });
-    });
-
-    // ========================================================================
-    // CONFIGURATION VALIDATION INTEGRATION
-    // ========================================================================
-
-    describe('Configuration Validation Integration', function () {
-        const validationTests = new IntegrationScenarioBuilder()
-            .addScenario({
-                name: 'minimal configuration handling',
-                flow: [EmailSenderTestConfigs.minimal],
-                nodeId: EmailSenderTestConfigs.minimal.id,
-                input: { payload: 'test', topic: 'test' },
-                timeout: 2000,
-            })
-            .addScenario({
-                name: 'complex configuration handling',
-                flow: [
-                    {
-                        ...EmailSenderTestConfigs.valid,
-                        attachments: JSON.stringify([{ filename: 'config-test.txt', content: 'Configuration test' }]),
-                        priority: 'high',
-                    },
-                ],
-                nodeId: EmailSenderTestConfigs.valid.id,
-                input: { payload: 'complex test', topic: 'complex' },
-                timeout: 3000,
-            });
-
-        validationTests.getScenarios().forEach((scenario) => {
-            it(`should handle ${scenario.name}`, async function () {
-                const context = await IntegrationTestRunner.runIntegrationScenario(emailSenderNode, scenario);
-                IntegrationAssertions.expectNodeExists(context, scenario.nodeId);
-                // Node should handle different configurations gracefully
-            });
-        });
-    });
-
-    // ========================================================================
-    // LIFECYCLE TESTS USING FRAMEWORK
-    // ========================================================================
-
-    describe('Node Lifecycle', function () {
-        it('should handle multiple load/unload cycles', async function () {
-            const cycles = 3;
-
-            for (let i = 0; i < cycles; i++) {
-                const scenario: IntegrationTestScenario = {
-                    name: `lifecycle cycle ${i}`,
-                    flow: testFlows.single,
-                    nodeId: EmailSenderTestConfigs.valid.id,
-                    input: { payload: `test cycle ${i}`, topic: `cycle ${i}` },
-                    timeout: 1000,
-                };
-
-                const context = await IntegrationTestRunner.runIntegrationScenario(emailSenderNode, scenario);
-                IntegrationAssertions.expectNodeExists(context, EmailSenderTestConfigs.valid.id);
-
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
-        });
-    });
-});

package/src/test/interfaces/email-data.ts

@@ -1,10 +0,0 @@
-export interface EmailData {
-    subject?: string;
-    from?: string;
-    to?: string;
-    text?: string;
-    html?: string;
-    date?: Date;
-    messageId?: string;
-    attachments?: any[];
-}

package/src/test/interfaces/email-receiver-config.ts

@@ -1,12 +0,0 @@
-export interface EmailReceiverConfig {
-    id: string;
-    type: string;
-    name?: string;
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    folder: string | string[];
-    tls?: boolean;
-    markseen?: boolean;
-}

package/src/test/interfaces/email-sender-config.ts

@@ -1,26 +0,0 @@
-export interface EmailSenderConfig {
-    id: string;
-    type: string;
-    name?: string;
-    sender?: string;
-    address?: string;
-    to?: string;
-    cc?: string;
-    bcc?: string;
-    subject?: string;
-    htmlContent?: string;
-    attachments?: string;
-    attachmentsType?: string;
-    host?: string;
-    port?: number;
-    user?: string;
-    password?: string;
-    secure?: boolean;
-    rejectUnauthorized?: boolean;
-    wires?: string[][];
-    // Test-specific properties
-    shouldFail?: boolean;
-    rejectedEmails?: string[];
-    pendingEmails?: string[];
-    acceptedEmails?: string[];
-}

package/src/test/interfaces/imap-config.ts

@@ -1,9 +0,0 @@
-export interface ImapConfig {
-    host: string;
-    port: number;
-    secure?: boolean;
-    user: string;
-    password: string;
-    authTimeout?: number;
-    connTimeout?: number;
-}

package/src/test/interfaces/imap-mailbox.ts

@@ -1,5 +0,0 @@
-export interface ImapMailbox {
-    messages: { total: number };
-    name: string;
-    readOnly: boolean;
-}

package/src/test/interfaces/mail-options.ts

@@ -1,20 +0,0 @@
-export interface MailOptions {
-    to: string | string[];
-    from?: string;
-    subject?: string;
-    html?: string;
-    text?: string;
-    attachments?: any[];
-    [key: string]: any;
-}
-
-export interface MockNodemailerOptions {
-    onSendMail?: (mailOptions: MailOptions) => void;
-    shouldFail?: boolean;
-    shouldFailVerify?: boolean;
-    failureMessage?: string;
-    failureCode?: string;
-    rejectedEmails?: string[];
-    pendingEmails?: string[];
-    acceptedEmails?: string[];
-}

package/src/test/interfaces/parsed-email.ts

@@ -1,11 +0,0 @@
-export interface ParsedEmail {
-    subject?: string;
-    text?: string;
-    html?: string;
-    from?: { text: string; value: Array<{ address: string; name?: string }> };
-    to?: { text: string; value: Array<{ address: string; name?: string }> };
-    date?: Date;
-    messageId?: string;
-    headers: Map<string, string>;
-    attachments?: any[];
-}

package/src/test/interfaces/send-mail-result.ts

@@ -1,7 +0,0 @@
-export interface SendMailResult {
-    messageId: string;
-    response: string;
-    accepted: string[];
-    rejected: string[];
-    pending: string[];
-}

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

@@ -1,147 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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;
-}