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

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

@@ -0,0 +1,67 @@
+import { expect } from 'chai';
+import type { IntegrationTestContext } from './integration-test-runner';
+
+export class IntegrationAssertions {
+    static expectNodeExists(context: IntegrationTestContext, nodeId: string): void {
+        expect(context.nodes[nodeId], `Node ${nodeId} should exist`).to.exist;
+    }
+
+    static expectNodeProperty(context: IntegrationTestContext, nodeId: string, property: string, value: any): void {
+        this.expectNodeExists(context, nodeId);
+        expect(context.nodes[nodeId], `Node ${nodeId} should have property ${property}`).to.have.property(
+            property,
+            value,
+        );
+    }
+
+    static expectMessageReceived(context: IntegrationTestContext, nodeId: string): void {
+        const messages = context.messages.filter((m) => m.nodeId === nodeId);
+        expect(messages, `Node ${nodeId} should have received at least one message`).to.have.length.greaterThan(0);
+    }
+
+    static expectMessageCount(context: IntegrationTestContext, nodeId: string, count: number): void {
+        const messages = context.messages.filter((m) => m.nodeId === nodeId);
+        expect(messages, `Node ${nodeId} should have received ${count} messages`).to.have.length(count);
+    }
+
+    static expectMessageContent(context: IntegrationTestContext, nodeId: string, expectedContent: any): void {
+        const messages = context.messages.filter((m) => m.nodeId === nodeId);
+        expect(messages, `Node ${nodeId} should have received messages`).to.have.length.greaterThan(0);
+
+        const lastMessage = messages[messages.length - 1].message;
+        if (typeof expectedContent === 'object') {
+            Object.keys(expectedContent).forEach((key) => {
+                expect(lastMessage, `Message should have property ${key}`).to.have.property(key);
+                if (expectedContent[key] !== undefined) {
+                    expect(lastMessage[key], `Message property ${key} should match`).to.deep.equal(
+                        expectedContent[key],
+                    );
+                }
+            });
+        } else {
+            expect(lastMessage.payload).to.equal(expectedContent);
+        }
+    }
+
+    static expectNoMessages(context: IntegrationTestContext, nodeId: string): void {
+        const messages = context.messages.filter((m) => m.nodeId === nodeId);
+        expect(messages, `Node ${nodeId} should not have received any messages`).to.have.length(0);
+    }
+
+    static expectAllNodesExist(context: IntegrationTestContext, nodeIds: string[]): void {
+        nodeIds.forEach((nodeId) => {
+            this.expectNodeExists(context, nodeId);
+        });
+    }
+
+    static expectMessageOrder(context: IntegrationTestContext, nodeIds: string[]): void {
+        const sortedMessages = [...context.messages].sort((a, b) => a.timestamp - b.timestamp);
+
+        nodeIds.forEach((expectedNodeId, index) => {
+            expect(sortedMessages[index], `Message ${index} should be from node ${expectedNodeId}`).to.have.property(
+                'nodeId',
+                expectedNodeId,
+            );
+        });
+    }
+}

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

@@ -0,0 +1,77 @@
+import { expect } from 'chai';
+import type { IntegrationTestScenario } from './integration-test-runner';
+import type { Node } from 'node-red';
+
+export class IntegrationScenarioBuilder {
+    private scenarios: IntegrationTestScenario[] = [];
+
+    addScenario(scenario: IntegrationTestScenario): this {
+        this.scenarios.push(scenario);
+        return this;
+    }
+
+    addLoadingScenario(name: string, flow: any[], nodeId: string): this {
+        return this.addScenario({
+            name,
+            flow,
+            nodeId,
+            timeout: 2000,
+        });
+    }
+
+    addMessageFlowScenario(
+        name: string,
+        flow: any[],
+        sourceNodeId: string,
+        input: any,
+        expectedMessages: Array<{ nodeId: string; expectedMsg: any }>,
+    ): this {
+        return this.addScenario({
+            name,
+            flow,
+            nodeId: sourceNodeId,
+            input,
+            expectedMessages,
+            timeout: 3000,
+        });
+    }
+
+    addConnectionScenario(name: string, flow: any[], nodeIds: string[]): this {
+        return this.addScenario({
+            name,
+            flow,
+            nodeId: nodeIds[0], // Primary node
+            setup: (nodes) => {
+                // Verify all nodes are connected
+                nodeIds.forEach((nodeId) => {
+                    expect(nodes[nodeId], `Node ${nodeId} should exist in connection test`).to.exist;
+                });
+            },
+        });
+    }
+
+    addLifecycleScenario(
+        name: string,
+        flow: any[],
+        nodeId: string,
+        operations: Array<(nodes: Record<string, Node>) => void>,
+    ): this {
+        return this.addScenario({
+            name,
+            flow,
+            nodeId,
+            setup: (nodes) => {
+                operations.forEach((operation) => operation(nodes));
+            },
+        });
+    }
+
+    getScenarios(): IntegrationTestScenario[] {
+        return [...this.scenarios];
+    }
+
+    clear(): this {
+        this.scenarios = [];
+        return this;
+    }
+}

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

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

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

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

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