@5minds/node-red-contrib-processcube-tools 1.0.1 → 1.0.2-develop-e3d5d9-mfm8oea8

package/test/integration/email-sender.integration.test.js

@@ -0,0 +1,239 @@
+const { expect } = require('chai');
+const helper = require('node-red-node-test-helper');
+const {
+    setupModuleMocks,
+    emailSenderConfigs,
+    testFlows,
+    testUtils,
+} = require('../../test/helpers/email-sender.mocks.js');
+
+describe('E-Mail Sender Node - Integration Tests', function () {
+    // Set a reasonable timeout for integration tests
+    this.timeout(10000);
+
+    let emailSenderNode;
+    let cleanupMocks;
+
+    beforeEach(function (done) {
+        // Set up mocks using helper
+        cleanupMocks = setupModuleMocks();
+
+        // Load the node with mocked dependencies
+        emailSenderNode = require('../../email-sender/email-sender.js');
+
+        // CRITICAL: Initialize the helper with Node-RED
+        helper.init(require.resolve('node-red'));
+        done();
+    });
+
+    afterEach(function () {
+        // Clean up mocks using helper cleanup function
+        if (cleanupMocks) {
+            cleanupMocks();
+        }
+    });
+
+    beforeEach(function (done) {
+        helper.startServer(done);
+    });
+
+    afterEach(function (done) {
+        helper.unload();
+        helper.stopServer(done);
+    });
+
+    describe('Node Loading', function () {
+        it('should load in Node-RED test environment', function (done) {
+            // ARRANGE: Use test flow from helpers
+            const flow = [emailSenderConfigs.valid];
+
+            // ACT: Load the node in the test helper environment
+            helper.load(emailSenderNode, flow, function () {
+                try {
+                    // ASSERT: Verify the node loaded correctly
+                    const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                    expect(n1).to.exist;
+                    expect(n1).to.have.property('name', emailSenderConfigs.valid.name);
+                    expect(n1).to.have.property('type', 'email-sender');
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+        });
+
+        it('should load with minimal configuration', function (done) {
+            // ARRANGE: Use minimal test config from helpers
+            const flow = [emailSenderConfigs.minimal];
+
+            // ACT: Load the node
+            helper.load(emailSenderNode, flow, function () {
+                try {
+                    // ASSERT: Verify the node loaded with minimal config
+                    const n1 = helper.getNode(emailSenderConfigs.minimal.id);
+                    expect(n1).to.exist;
+                    expect(n1).to.have.property('type', 'email-sender');
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+        });
+    });
+
+    describe('Node Connections', function () {
+        it('should create wired connections correctly', function (done) {
+            // ARRANGE: Use connected test flow from helpers
+            const flow = testFlows.connected;
+
+            // ACT: Load nodes and verify connections
+            helper.load(emailSenderNode, flow, function () {
+                try {
+                    const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                    const h1 = helper.getNode('h1');
+
+                    // ASSERT: Both nodes should exist and be connected
+                    expect(n1).to.exist;
+                    expect(h1).to.exist;
+                    expect(n1).to.have.property('name', emailSenderConfigs.valid.name);
+                    expect(h1).to.have.property('type', 'helper');
+
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+        });
+
+        it('should handle multiple output connections', function (done) {
+            // ARRANGE: Use multi-output test flow from helpers
+            const flow = testFlows.multiOutput;
+
+            // ACT: Load nodes
+            helper.load(emailSenderNode, flow, function () {
+                try {
+                    const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                    const h1 = helper.getNode('h1');
+                    const h2 = helper.getNode('h2');
+
+                    // ASSERT: All nodes should exist
+                    expect(n1).to.exist;
+                    expect(h1).to.exist;
+                    expect(h2).to.exist;
+                    expect(n1).to.have.property('name', emailSenderConfigs.valid.name);
+
+                    done();
+                } catch (err) {
+                    done(err);
+                }
+            });
+        });
+    });
+
+    describe('Message Flow', function () {
+        it('should handle input without crashing', async function () {
+            // ARRANGE: Use test flow from helpers
+            const flow = testFlows.single;
+
+            return new Promise((resolve, reject) => {
+                helper.load(emailSenderNode, flow, function () {
+                    try {
+                        const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                        expect(n1).to.exist;
+
+                        // Send input - this should not crash due to mocked IMAP
+                        n1.receive({ payload: 'test input' });
+
+                        // ASSERT: If we reach here, the node handled input gracefully
+                        testUtils.wait(500).then(() => {
+                            resolve(); // Success if no errors thrown
+                        });
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+        });
+
+        it('should process messages through connected nodes', function (done) {
+            // ARRANGE: Use connected test flow from helpers
+            const flow = testFlows.connected;
+
+            // ACT: Load nodes and set up message listener
+            helper.load(emailSenderNode, flow, function () {
+                try {
+                    const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                    const h1 = helper.getNode('h1');
+
+                    // Set up listener for messages from email receiver
+                    h1.on('input', function (msg) {
+                        try {
+                            // ASSERT: Should receive a message with expected properties
+                            expect(msg).to.exist;
+                            expect(msg.payload).to.exist;
+                            done();
+                        } catch (err) {
+                            done(err);
+                        }
+                    });
+
+                    // Simulate the email processing
+                    // The email-sender node likely starts processing emails automatically
+                    // Let's trigger the mock IMAP flow by simulating what happens when emails are found
+                    setTimeout(() => {
+                        // Simulate the email receiver processing emails and sending a message
+                        // This is what your email-sender node should do internally
+                        try {
+                            const mockEmailMessage = {
+                                payload: 'This is a mock email body for testing purposes.',
+                                topic: 'email',
+                                from: 'sender@test.com',
+                                subject: 'Mock Email Subject',
+                            };
+
+                            // Directly send a message through the node (simulating internal processing)
+                            n1.send(mockEmailMessage);
+                        } catch (err) {
+                            done(err);
+                        }
+                    }, 100);
+                } catch (err) {
+                    done(err);
+                }
+            });
+        });
+
+        it('should handle message timeout gracefully', async function () {
+            // ARRANGE: Use connected test flow
+            const flow = testFlows.connected;
+
+            return new Promise((resolve, reject) => {
+                helper.load(emailSenderNode, flow, function () {
+                    try {
+                        const n1 = helper.getNode(emailSenderConfigs.valid.id);
+                        const h1 = helper.getNode('h1');
+
+                        // Use testUtils.waitForMessage with timeout
+                        testUtils
+                            .waitForMessage(h1, 1000)
+                            .then((msg) => {
+                                // ASSERT: Should receive message within timeout
+                                expect(msg).to.exist;
+                                resolve();
+                            })
+                            .catch((err) => {
+                                // ASSERT: Should handle timeout appropriately
+                                expect(err.message).to.include('Timeout waiting for message');
+                                resolve(); // This is expected behavior for this test
+                            });
+
+                        // Don't trigger anything to test timeout behavior
+                        // The timeout should occur as expected
+                    } catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+        });
+    });
+});

package/test/unit/email-receiver.unit.test.js

@@ -0,0 +1,304 @@
+const { expect } = require('chai');
+const { createMockNodeRED, setupModuleMocks, testConfigs, testUtils } = require('../helpers/email-receiver.mocks.js');
+
+describe('E-Mail Receiver Node - Unit Tests', function () {
+    this.timeout(10000);
+
+    let emailReceiverNode;
+    let cleanupMocks;
+
+    before(function () {
+        // Set up module mocks using helper
+        cleanupMocks = setupModuleMocks();
+
+        // Load the node with mocked dependencies
+        emailReceiverNode = require('../../email-receiver/email-receiver.js');
+    });
+
+    after(function () {
+        // Clean up mocks
+        if (cleanupMocks) {
+            cleanupMocks();
+        }
+    });
+
+    describe('Module Export', function () {
+        it('should export a function', function () {
+            expect(emailReceiverNode).to.be.a('function');
+        });
+    });
+
+    describe('Node Registration', function () {
+        it('should register node type without errors', function () {
+            // ARRANGE: Create mock Node-RED with tracking
+            const mockRED = createMockNodeRED();
+
+            // ACT: Register the node
+            emailReceiverNode(mockRED);
+
+            // ASSERT: Verify registration
+            expect(mockRED.nodes.lastRegisteredType).to.equal('email-receiver');
+            expect(mockRED.nodes.lastRegisteredConstructor).to.be.a('function');
+        });
+    });
+
+    describe('Node Instantiation', function () {
+        it('should handle node instantiation with valid config', function () {
+            // ARRANGE: Track node creation
+            let createdNode = null;
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    createdNode = this;
+                },
+            });
+
+            // ACT: Register and create node instance
+            emailReceiverNode(mockRED);
+            new mockRED.nodes.lastRegisteredConstructor(testConfigs.valid);
+
+            // ASSERT: Verify node was created with correct properties
+            expect(createdNode).to.exist;
+            expect(createdNode).to.have.property('name', testConfigs.valid.name);
+            expect(createdNode).to.have.property('id', testConfigs.valid.id);
+        });
+
+        it('should handle minimal config', function () {
+            // ARRANGE: Use minimal test config
+            let createdNode = null;
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    createdNode = this;
+                },
+            });
+
+            // ACT: Register and create node with minimal config
+            emailReceiverNode(mockRED);
+            new mockRED.nodes.lastRegisteredConstructor(testConfigs.minimal);
+
+            // ASSERT: Verify node creation
+            expect(createdNode).to.exist;
+            expect(createdNode).to.have.property('id', testConfigs.minimal.id);
+        });
+    });
+
+    describe('Folder Configuration', function () {
+        it('should handle array of folders', async function () {
+            // ARRANGE: Set up message tracking
+            let sentMessage = null;
+            const mockRED = createMockNodeRED({
+                sendHandler: function (msg) {
+                    sentMessage = msg;
+                },
+            });
+
+            // ACT: Register node and create instance with array folders
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(testConfigs.arrayFolders);
+
+            // Wait for processing
+            await testUtils.wait(50);
+
+            // ASSERT: Should handle array folders without error
+            expect(nodeInstance).to.exist;
+            expect(nodeInstance).to.have.property('name', testConfigs.arrayFolders.name);
+        });
+    });
+
+    describe('Error Handling', function () {
+        it('should call node.error for invalid folder type', function (done) {
+            // ARRANGE: Set up error tracking
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                errorHandler: function (err) {
+                    // ASSERT: Should receive appropriate error message
+                    expect(err).to.include("The 'folders' property must be an array of strings.");
+                    done();
+                },
+            });
+
+            // ACT: Register node and create instance with invalid config
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(testConfigs.invalidFolderType);
+
+            // Trigger the error by sending an input message
+            // Use a small delay to ensure the constructor has completed
+            setTimeout(() => {
+                if (nodeInstance.inputCallback) {
+                    nodeInstance.inputCallback({ payload: 'test' });
+                } else {
+                    done(new Error('inputCallback was not set on the node instance'));
+                }
+            }, 10);
+        });
+
+        it('should call node.error for missing config', function (done) {
+            // ARRANGE: Set up error and status tracking
+            let statusCalled = false;
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    statusCalled = true;
+                    if (status.fill) {
+                        expect(status.fill).to.equal('red');
+                    }
+                },
+                errorHandler: function (err) {
+                    // ASSERT: Should receive config error
+                    expect(err).to.include('Missing required IMAP config');
+                    expect(statusCalled).to.be.true;
+                    done();
+                },
+            });
+
+            // ACT: Register node and create instance with invalid config
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(testConfigs.invalidConfig);
+
+            // Trigger the error by sending an input message
+            // Use a small delay to ensure the constructor has completed
+            setTimeout(() => {
+                if (nodeInstance.inputCallback) {
+                    nodeInstance.inputCallback({ payload: 'test' });
+                } else {
+                    done(new Error('inputCallback was not set on the node instance'));
+                }
+            }, 10);
+        });
+
+        it('should handle connection errors gracefully', function (done) {
+            // ARRANGE: Set up connection error scenario with done() protection
+            let testCompleted = false;
+
+            const completeDone = () => {
+                if (!testCompleted) {
+                    testCompleted = true;
+                    done();
+                }
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'red' && status.text && status.text.includes('error')) {
+                        completeDone(); // Success - error status was set
+                    }
+                },
+                errorHandler: function (err) {
+                    // Also accept errors as valid completion
+                    expect(err).to.exist;
+                    completeDone();
+                },
+            });
+
+            // Use a config that should cause connection issues
+            const badConfig = {
+                ...testConfigs.valid,
+                host: 'nonexistent.invalid.host.com',
+                port: 12345, // Invalid port
+            };
+
+            // ACT: Register node and create instance with invalid config
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(badConfig);
+
+            // Trigger the error by sending an input message
+            // Use a small delay to ensure the constructor has completed
+            setTimeout(() => {
+                if (nodeInstance.inputCallback) {
+                    nodeInstance.inputCallback({ payload: 'test' });
+                } else {
+                    completeDone(new Error('inputCallback was not set on the node instance'));
+                }
+            }, 10);
+        });
+    });
+
+    describe('IMAP Connection', function () {
+        it('should handle connection success', function (done) {
+            // ARRANGE: Set up connection tracking
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    // ASSERT: Check for 'connected' status and then complete the test
+                    if (status.fill === 'green' && status.text === 'connected') {
+                        done();
+                    }
+                },
+            });
+
+            // ACT: Create node with config that should fail
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(testConfigs.valid);
+
+            // Trigger the connection attempt by sending an input message
+            setTimeout(() => {
+                if (nodeInstance.inputCallback) {
+                    nodeInstance.inputCallback({ payload: 'test' });
+                } else {
+                    done(new Error('inputCallback was not set on the node instance'));
+                }
+            }, 10);
+        });
+
+        it('should handle connection errors', function (done) {
+            // ARRANGE: Set up error tracking
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        // Store the callback on the node instance
+                        this.inputCallback = callback;
+                    }
+                },
+                errorHandler: function (err) {
+                    // ASSERT: Should handle connection errors gracefully
+                    expect(err).to.exist;
+                    done();
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'red') {
+                        // Connection failed status
+                        expect(status.text).to.include('error');
+                    }
+                },
+            });
+
+            // ACT: Create node with config that should fail
+            emailReceiverNode(mockRED);
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+
+            // Use invalid config to trigger connection error
+            const invalidConfig = { ...testConfigs.valid, host: 'invalid.host.com' };
+            const nodeInstance = new nodeConstructor(invalidConfig);
+
+            // Trigger the connection attempt by sending an input message
+            setTimeout(() => {
+                if (nodeInstance.inputCallback) {
+                    nodeInstance.inputCallback({ payload: 'test' });
+                } else {
+                    done(new Error('inputCallback was not set on the node instance'));
+                }
+            }, 10);
+        });
+    });
+});