@5minds/node-red-contrib-processcube-tools 1.2.0-develop-d19f89-mg68thdf → 1.2.0-develop-59ef22-mg9d9ja5

package/src/test/framework/types.ts

@@ -0,0 +1,61 @@
+import type { Node, NodeMessageInFlow } from 'node-red';
+
+export interface TestScenario {
+    name: string;
+    config: any;
+    input?: any;
+    expectedOutput?: any;
+    expectedError?: string | RegExp;
+    expectedStatus?: { fill: string; shape?: string; text?: string };
+    timeout?: number;
+    mockOptions?: MockNodeREDOptions;
+}
+
+export interface TestContext {
+    mockRED: any;
+    nodeInstance: any;
+    messages: any[];
+    errors: any[];
+    statuses: any[];
+    logs?: any[];
+    warnings?: any[];
+    debugs?: any[];
+}
+
+export interface MockNodeREDOptions {
+    dependencies?: Record<string, any>;
+    onHandler?: (this: Node, event: string, callback: Function) => void;
+    sendHandler?: (msg: any) => void;
+    errorHandler?: (err: any) => void;
+    statusHandler?: (status: any) => void;
+    logHandler?: (msg: any) => void;
+    warnHandler?: (msg: any) => void;
+    debugHandler?: (msg: any) => void;
+    traceHandler?: (msg: any) => void;
+}
+
+// Integration Test Types
+export interface IntegrationTestScenario {
+    name: string;
+    flow: any[];
+    nodeId: string;
+    input?: any;
+    expectedMessages?: Array<{
+        nodeId: string;
+        expectedMsg: any;
+        timeout?: number;
+    }>;
+    timeout?: number;
+    setup?: (nodes: Record<string, Node>) => void;
+    cleanup?: () => void;
+}
+
+export interface IntegrationTestContext {
+    nodes: Record<string, Node>;
+    messages: Array<{
+        nodeId: string;
+        message: NodeMessageInFlow;
+        timestamp: number;
+    }>;
+    errors: any[];
+}

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

@@ -0,0 +1,67 @@
+import { EmailReceiverConfig } from '../interfaces/email-receiver-config';
+
+export const EmailReceiverTestConfigs = {
+    valid: {
+        id: 'test-node-1',
+        type: 'email-receiver',
+        name: 'Test Email Receiver',
+        host: 'imap.test.com',
+        port: 993,
+        user: 'test@test.com',
+        password: 'testpass',
+        folder: ['INBOX'],
+        tls: true,
+        markseen: true,
+    } as EmailReceiverConfig,
+
+    minimal: {
+        id: 'test-node-minimal',
+        type: 'email-receiver',
+        host: 'imap.minimal.com',
+        port: 993,
+        user: 'minimal@test.com',
+        password: 'minimalpass',
+        folder: 'INBOX',
+    } as EmailReceiverConfig,
+
+    arrayFolders: {
+        id: 'test-node-array',
+        type: 'email-receiver',
+        name: 'Array Folders Test',
+        host: 'imap.test.com',
+        port: 993,
+        user: 'test@test.com',
+        password: 'testpass',
+        folder: ['INBOX', 'SENT', 'DRAFTS'],
+    } as EmailReceiverConfig,
+
+    invalidFolderType: {
+        id: 'test-node-invalid-folder',
+        type: 'email-receiver',
+        host: 'imap.test.com',
+        port: 993,
+        user: 'test@test.com',
+        password: 'testpass',
+        folder: 123 as any, // Invalid type
+    } as EmailReceiverConfig,
+
+    invalidConfig: {
+        id: 'test-node-invalid',
+        type: 'email-receiver',
+        host: '', // Missing host
+        port: 993,
+        user: 'test@test.com',
+        password: '', // Missing password
+        folder: ['INBOX'],
+    } as EmailReceiverConfig,
+
+    networkError: {
+        id: 'test-node-network-error',
+        type: 'email-receiver',
+        host: 'unreachable.invalid.host.com',
+        port: 993,
+        user: 'test@test.com',
+        password: 'testpass',
+        folder: ['INBOX'],
+    } as EmailReceiverConfig,
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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