@5minds/node-red-contrib-processcube-tools 1.0.1-develop-8bf22b-mffg2ve3 → 1.0.1-develop-4412ca-mfm8hzs3

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

@@ -1,309 +1,304 @@
-const should = require('should');
-const {
-  createMockNodeRED,
-  setupModuleMocks,
-  testConfigs,
-  testUtils
-} = require('../helpers/email-receiver.mocks.js');
-
-describe('Email Receiver Node - Unit Tests with Helpers', 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() {
-      emailReceiverNode.should.be.type('function');
-    });
-  });
-
-  describe('Node Registration', function() {
-    it('should register node type without errors', function() {
-      // ARRANGE: Create mock Node-RED with tracking
-      const mockRED = createMockNodeRED();
+const { expect } = require('chai');
+const { createMockNodeRED, setupModuleMocks, testConfigs, testUtils } = require('../helpers/email-receiver.mocks.js');
 
-      // ACT: Register the node
-      emailReceiverNode(mockRED);
+describe('E-Mail Receiver Node - Unit Tests', function () {
+    this.timeout(10000);
 
-      // ASSERT: Verify registration
-      mockRED.nodes.lastRegisteredType.should.equal('email-receiver');
-      mockRED.nodes.lastRegisteredConstructor.should.be.type('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;
-        }
-      });
+    let emailReceiverNode;
+    let cleanupMocks;
 
-      // ACT: Register and create node instance
-      emailReceiverNode(mockRED);
-      new mockRED.nodes.lastRegisteredConstructor(testConfigs.valid);
+    before(function () {
+        // Set up module mocks using helper
+        cleanupMocks = setupModuleMocks();
 
-      // ASSERT: Verify node was created with correct properties
-      should.exist(createdNode);
-      createdNode.should.have.property('name', testConfigs.valid.name);
-      createdNode.should.have.property('id', testConfigs.valid.id);
+        // Load the node with mocked dependencies
+        emailReceiverNode = require('../../email-receiver/email-receiver.js');
     });
 
-    it('should handle minimal config', function() {
-      // ARRANGE: Use minimal test config
-      let createdNode = null;
-      const mockRED = createMockNodeRED({
-        onHandler: function(event, callback) {
-          createdNode = this;
+    after(function () {
+        // Clean up mocks
+        if (cleanupMocks) {
+            cleanupMocks();
         }
-      });
-
-      // ACT: Register and create node with minimal config
-      emailReceiverNode(mockRED);
-      new mockRED.nodes.lastRegisteredConstructor(testConfigs.minimal);
+    });
 
-      // ASSERT: Verify node creation
-      should.exist(createdNode);
-      createdNode.should.have.property('id', testConfigs.minimal.id);
+    describe('Module Export', function () {
+        it('should export a function', function () {
+            expect(emailReceiverNode).to.be.a('function');
+        });
     });
-  });
-
-  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);
+    describe('Node Registration', function () {
+        it('should register node type without errors', function () {
+            // ARRANGE: Create mock Node-RED with tracking
+            const mockRED = createMockNodeRED();
 
-      // Wait for processing
-      await testUtils.wait(50);
+            // ACT: Register the node
+            emailReceiverNode(mockRED);
 
-      // ASSERT: Should handle array folders without error
-      should.exist(nodeInstance);
-      nodeInstance.should.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
-          err.should.containEql("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);
+            // ASSERT: Verify registration
+            expect(mockRED.nodes.lastRegisteredType).to.equal('email-receiver');
+            expect(mockRED.nodes.lastRegisteredConstructor).to.be.a('function');
+        });
     });
 
-    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) {
-            status.fill.should.equal('red');
-          }
-        },
-        errorHandler: function(err) {
-          // ASSERT: Should receive config error
-          err.should.containEql('Missing required IMAP config');
-          statusCalled.should.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);
+    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);
+        });
     });
 
-    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
-          should.exist(err);
-          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('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('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);
+
+    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);
+        });
     });
 
-    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
-          should.exist(err);
-          done();
-        },
-        statusHandler: function(status) {
-          if (status.fill === 'red') {
-            // Connection failed status
-            status.text.should.containEql('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);
+    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);
+        });
     });
-  });
-});
+});