@5minds/node-red-contrib-processcube-tools 1.2.0-feature-7ac247-mg92hchl → 1.2.0-feature-608421-mg9cjskq

package/src/test/framework/integration-test-runner.ts

@@ -1,101 +0,0 @@
-import type { Node, NodeMessageInFlow } from 'node-red';
-import { NodeTestRunner } from './node-test-runner';
-import type { TestScenario } from './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[];
-}
-
-export class IntegrationTestRunner {
-    static async runIntegrationScenario(
-        nodeConstructor: Function,
-        scenario: IntegrationTestScenario,
-    ): Promise<IntegrationTestContext> {
-        console.log(`[SCENARIO START] ${scenario.name}`);
-
-        const context: IntegrationTestContext = {
-            nodes: {},
-            messages: [],
-            errors: [],
-        };
-
-        const mainNodeConfig = scenario.flow.find((n) => n.id === scenario.nodeId);
-
-        if (!mainNodeConfig) {
-            throw new Error(`Node with id ${scenario.nodeId} not found in flow`);
-        }
-
-        const testScenario: TestScenario = {
-            name: scenario.name,
-            config: mainNodeConfig,
-            input: scenario.input,
-            timeout: scenario.timeout || 5000,
-        };
-
-        if (scenario.expectedMessages && scenario.expectedMessages.length > 0) {
-            testScenario.expectedOutput = scenario.expectedMessages[0].expectedMsg;
-        }
-
-        const testContext = await NodeTestRunner.runScenario(nodeConstructor, testScenario, {
-            sendHandler: function (msg: any) {
-                // When send is called with array (multi-output), handle each output
-                if (Array.isArray(msg)) {
-                    msg.forEach((m, index) => {
-                        if (scenario.expectedMessages && scenario.expectedMessages[index]) {
-                            context.messages.push({
-                                nodeId: scenario.expectedMessages[index].nodeId,
-                                message: m,
-                                timestamp: Date.now(),
-                            });
-                        }
-                    });
-                } else {
-                    // Single message - use first expected message nodeId if available
-                    const nodeId =
-                        scenario.expectedMessages && scenario.expectedMessages[0]
-                            ? scenario.expectedMessages[0].nodeId
-                            : scenario.nodeId;
-
-                    context.messages.push({
-                        nodeId: nodeId,
-                        message: msg,
-                        timestamp: Date.now(),
-                    });
-                }
-            },
-            errorHandler: function (error: any) {
-                context.errors.push(error);
-            },
-        });
-
-        context.nodes[scenario.nodeId] = testContext.nodeInstance;
-
-        if (scenario.setup) {
-            scenario.setup(context.nodes);
-        }
-
-        console.log(`[SCENARIO COMPLETE] ${scenario.name}`);
-        return context;
-    }
-}

package/src/test/framework/node-assertions.ts

@@ -1,63 +0,0 @@
-import { expect } from 'chai';
-import type { TestContext } from './types';
-
-export class NodeAssertions {
-    static expectMessage(context: TestContext, expectedMsg: any): void {
-        expect(context.messages, 'No messages were sent').to.have.length.greaterThan(0);
-        const lastMessage = context.messages[context.messages.length - 1];
-
-        if (typeof expectedMsg === 'object' && expectedMsg !== null) {
-            Object.keys(expectedMsg).forEach((key) => {
-                expect(lastMessage, `Message missing property: ${key}`).to.have.property(key);
-                if (expectedMsg[key] !== undefined) {
-                    expect(lastMessage[key], `Message property ${key} does not match`).to.deep.equal(expectedMsg[key]);
-                }
-            });
-        } else {
-            expect(lastMessage, 'Message does not match expected value').to.deep.equal(expectedMsg);
-        }
-    }
-
-    static expectError(context: TestContext, expectedError: string | RegExp): void {
-        expect(context.errors, 'No errors were recorded').to.have.length.greaterThan(0);
-        const error = context.errors[context.errors.length - 1];
-        const errorMessage = error?.message || error?.toString() || '';
-
-        if (typeof expectedError === 'string') {
-            expect(errorMessage, 'Error message does not contain expected text').to.include(expectedError);
-        } else {
-            expect(errorMessage, 'Error message does not match expected pattern').to.match(expectedError);
-        }
-    }
-
-    static expectStatus(context: TestContext, expectedStatus: { fill: string; text?: string }): void {
-        expect(context.statuses, 'No status updates were recorded').to.have.length.greaterThan(0);
-        const status = context.statuses[context.statuses.length - 1];
-
-        expect(status.fill, 'Status fill color does not match').to.equal(expectedStatus.fill);
-        if (expectedStatus.text) {
-            expect(status.text, 'Status text does not match').to.include(expectedStatus.text);
-        }
-    }
-
-    static expectNodeProperty(context: TestContext, property: string, value: any): void {
-        expect(context.nodeInstance, 'Node instance does not exist').to.exist;
-        expect(context.nodeInstance, `Node missing property: ${property}`).to.have.property(property, value);
-    }
-
-    static expectNoErrors(context: TestContext): void {
-        expect(context.errors, 'Unexpected errors occurred').to.have.length(0);
-    }
-
-    static expectNoMessages(context: TestContext): void {
-        expect(context.messages, 'Unexpected messages were sent').to.have.length(0);
-    }
-
-    static expectMessageCount(context: TestContext, count: number): void {
-        expect(context.messages, `Expected ${count} messages`).to.have.length(count);
-    }
-
-    static expectStatusCount(context: TestContext, count: number): void {
-        expect(context.statuses, `Expected ${count} status updates`).to.have.length(count);
-    }
-}

package/src/test/framework/node-test-runner.ts

@@ -1,260 +0,0 @@
-import type { NodeAPI } from 'node-red';
-import type { TestScenario, TestContext, MockNodeREDOptions } from './types';
-
-// Minimal extension for dependency injection
-export interface DependencyContainer {
-    [key: string]: any;
-}
-
-export interface EnhancedMockNodeREDOptions extends MockNodeREDOptions {
-    dependencies?: DependencyContainer;
-}
-
-export class NodeTestRunner {
-    private static createMockNodeRED(context: TestContext, options: EnhancedMockNodeREDOptions = {}): any {
-        return {
-            nodes: {
-                createNode: function (node: any, config: any) {
-                    Object.assign(node, config);
-
-                    // Inject dependencies if available
-                    if (options.dependencies) {
-                        Object.keys(options.dependencies).forEach((key) => {
-                            if (!node[key]) {
-                                node[key] = options.dependencies![key];
-                            }
-                        });
-                    }
-
-                    // Set up event handlers
-                    node.on =
-                        options.onHandler ||
-                        function (event: string, callback: Function) {
-                            if (event === 'input') {
-                                (node as any).inputCallback = callback;
-                            }
-                        };
-
-                    // Override node methods to capture calls
-                    node.send = function (msg: any) {
-                        context.messages.push(msg);
-                        if (options.sendHandler) {
-                            options.sendHandler.call(this, msg);
-                        }
-                    };
-
-                    node.error = function (error: any) {
-                        context.errors.push(error);
-                        if (options.errorHandler) {
-                            options.errorHandler.call(this, error);
-                        }
-                    };
-
-                    node.status = function (status: any) {
-                        context.statuses.push(status);
-                        if (options.statusHandler) {
-                            options.statusHandler.call(this, status);
-                        }
-                    };
-
-                    // Add logging methods
-                    node.log = function (msg: any) {
-                        if (options.logHandler) {
-                            options.logHandler.call(this, msg);
-                        }
-                        // Optionally store logs in context
-                        if (!context.logs) context.logs = [];
-                        context.logs.push(msg);
-                    };
-
-                    node.warn = function (msg: any) {
-                        if (options.warnHandler) {
-                            options.warnHandler.call(this, msg);
-                        }
-                        if (!context.warnings) context.warnings = [];
-                        context.warnings.push(msg);
-                    };
-
-                    node.debug = function (msg: any) {
-                        if (options.debugHandler) {
-                            options.debugHandler.call(this, msg);
-                        }
-                        if (!context.debugs) context.debugs = [];
-                        context.debugs.push(msg);
-                    };
-
-                    node.trace = function (msg: any) {
-                        if (options.traceHandler) {
-                            options.traceHandler.call(this, msg);
-                        }
-                    };
-
-                    return node;
-                },
-                registerType: function (type: string, constructor: Function) {
-                    (this as any).lastRegisteredType = type;
-                    (this as any).lastRegisteredConstructor = constructor;
-                },
-            },
-            util: {
-                evaluateNodeProperty: (value: any, type: string, node: any, msg: any): any => {
-                    switch (type) {
-                        case 'str':
-                            return String(value);
-                        case 'num':
-                            return Number(value);
-                        case 'bool':
-                            return Boolean(value);
-                        case 'json':
-                            try {
-                                return typeof value === 'string' ? JSON.parse(value) : value;
-                            } catch {
-                                return value;
-                            }
-                        case 'msg':
-                            const keys = value.split('.');
-                            let result = msg;
-                            for (const key of keys) {
-                                result = result?.[key];
-                            }
-                            return result;
-                        case 'flow':
-                        case 'global':
-                            return value;
-                        default:
-                            return value;
-                    }
-                },
-            },
-        };
-    }
-
-    private static createTestContext(options: EnhancedMockNodeREDOptions = {}): TestContext {
-        const context: TestContext = {
-            mockRED: null,
-            nodeInstance: null,
-            messages: [],
-            errors: [],
-            statuses: [],
-        };
-
-        context.mockRED = this.createMockNodeRED(context, options);
-        return context;
-    }
-
-    static async runScenario(
-        nodeConstructorFn: Function,
-        scenario: TestScenario,
-        mockOptions: EnhancedMockNodeREDOptions = {},
-    ): Promise<TestContext> {
-        const context = this.createTestContext(mockOptions);
-
-        return new Promise((resolve, reject) => {
-            let completed = false;
-
-            const timeout = setTimeout(() => {
-                if (!completed) {
-                    reject(new Error(`Test scenario '${scenario.name}' timed out after ${scenario.timeout || 5000}ms`));
-                }
-            }, scenario.timeout || 5000);
-
-            const complete = () => {
-                if (completed) return;
-                completed = true;
-                clearTimeout(timeout);
-                // Small delay to catch any additional events
-                setTimeout(() => resolve(context), 50);
-            };
-
-            try {
-                // Register the node - pass dependencies as second parameter if available
-                if (mockOptions.dependencies) {
-                    nodeConstructorFn(context.mockRED as unknown as NodeAPI, mockOptions.dependencies);
-                } else {
-                    nodeConstructorFn(context.mockRED as unknown as NodeAPI);
-                }
-
-                // Create node instance
-                const NodeConstructor = (context.mockRED.nodes as any).lastRegisteredConstructor;
-                context.nodeInstance = new NodeConstructor(scenario.config);
-
-                if ((context.nodeInstance as any).configError) {
-                    setTimeout(() => {
-                        if (scenario.expectedError && context.errors.length > 0) {
-                            complete();
-                        } else if (scenario.expectedStatus && context.statuses.length > 0) {
-                            complete();
-                        }
-                    }, 100);
-                    return;
-                }
-
-                // Set up completion detection based on scenario configuration
-                const originalSend = context.nodeInstance.send;
-                const originalError = context.nodeInstance.error;
-                const originalStatus = context.nodeInstance.status;
-
-                // Override send to detect expected output
-                if (scenario.expectedOutput) {
-                    context.nodeInstance.send = function (msg: any) {
-                        originalSend.call(this, msg);
-                        complete();
-                    };
-                }
-
-                // Override error to detect expected errors
-                if (scenario.expectedError) {
-                    let errorCount = context.errors.length;
-                    context.nodeInstance.error = function (error: any) {
-                        originalError.call(this, error);
-                        // ✅ Only complete on NEW errors (not construction errors we already saw)
-                        if (context.errors.length > errorCount) {
-                            errorCount = context.errors.length;
-                            complete();
-                        }
-                    };
-                }
-
-                // Override status to detect completion patterns
-                if (scenario.expectedStatus) {
-                    let statusCount = context.statuses.length;
-                    context.nodeInstance.status = function (status: any) {
-                        originalStatus.call(this, status);
-
-                        // ✅ Only check NEW statuses
-                        if (context.statuses.length > statusCount) {
-                            statusCount = context.statuses.length;
-
-                            const fillMatches =
-                                !scenario.expectedStatus!.fill || status.fill === scenario.expectedStatus!.fill;
-                            const shapeMatches =
-                                !scenario.expectedStatus!.shape || status.shape === scenario.expectedStatus!.shape;
-                            const textMatches =
-                                !scenario.expectedStatus!.text || status.text?.includes(scenario.expectedStatus!.text);
-
-                            if (fillMatches && shapeMatches && textMatches) {
-                                complete();
-                            }
-                        }
-                    };
-                }
-
-                // If no specific expectations, complete after a short delay
-                if (!scenario.expectedOutput && !scenario.expectedError && !scenario.expectedStatus) {
-                    setTimeout(() => complete(), 100);
-                    return;
-                }
-
-                // Trigger input if provided
-                if (scenario.input && (context.nodeInstance as any).inputCallback) {
-                    setTimeout(() => {
-                        (context.nodeInstance as any).inputCallback(scenario.input);
-                    }, 10);
-                }
-            } catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-}

package/src/test/framework/test-scenario-builder.ts

@@ -1,74 +0,0 @@
-import { EnhancedMockNodeREDOptions } from './node-test-runner';
-import type { TestScenario } from './types';
-
-export class TestScenarioBuilder {
-    private scenarios: TestScenario[] = [];
-
-    addScenario(scenario: TestScenario): this {
-        this.scenarios.push(scenario);
-        return this;
-    }
-
-    addValidScenario(
-        name: string,
-        config: any,
-        input?: any,
-        expectedOutput?: any,
-        mockOptions?: Partial<EnhancedMockNodeREDOptions>,
-    ): this {
-        return this.addScenario({
-            name,
-            config,
-            input,
-            expectedOutput,
-            mockOptions,
-        });
-    }
-
-    addErrorScenario(
-        name: string,
-        config: any,
-        expectedError: any,
-        input?: any,
-        mockOptions?: Partial<EnhancedMockNodeREDOptions>,
-    ): this {
-        this.scenarios.push({
-            name,
-            config,
-            input,
-            expectedError,
-            mockOptions,
-        });
-        return this;
-    }
-
-    addStatusScenario(
-        name: string,
-        config: any,
-        expectedStatus: any,
-        input?: any,
-        mockOptions?: Partial<EnhancedMockNodeREDOptions>, // Accept full mock options
-    ): this {
-        this.scenarios.push({
-            name,
-            config,
-            input,
-            expectedStatus,
-            mockOptions,
-        });
-        return this;
-    }
-
-    addCustomScenario(scenario: Partial<TestScenario> & { name: string; config: any }): this {
-        return this.addScenario(scenario as TestScenario);
-    }
-
-    getScenarios(): TestScenario[] {
-        return [...this.scenarios]; // Return copy to prevent mutation
-    }
-
-    clear(): this {
-        this.scenarios = [];
-        return this;
-    }
-}

package/src/test/framework/types.ts

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

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

@@ -1,16 +0,0 @@
-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' },
-    ],
-};