@5minds/node-red-contrib-processcube-tools 1.0.1-feature-f506be-mfe3agh6 → 1.0.1-feature-20a8ee-mff2npts

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

@@ -0,0 +1,353 @@
+const should = require('should');
+const {
+  createMockImap,
+  createMockMailparser,
+  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();
+
+      // ACT: Register the node
+      emailReceiverNode(mockRED);
+
+      // 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;
+        }
+      });
+
+      // ACT: Register and create node instance
+      emailReceiverNode(mockRED);
+      new mockRED.nodes.lastRegisteredConstructor(testConfigs.valid);
+
+      // 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);
+    });
+
+    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
+      should.exist(createdNode);
+      createdNode.should.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
+      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);
+    });
+
+    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);
+    });
+
+    it('should handle connection errors gracefully', function(done) {
+      // ARRANGE: Set up connection error scenario
+      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')) {
+            done(); // Success - error status was set
+          }
+        },
+        errorHandler: function(err) {
+          // Also accept errors as valid completion
+          should.exist(err);
+          done();
+        }
+      });
+
+      // ACT: Create node and trigger connection attempt
+      emailReceiverNode(mockRED);
+      const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+
+      // Use a config that should cause connection issues
+      const badConfig = {
+        ...testConfigs.valid,
+        host: 'nonexistent.invalid.host.com',
+        port: 12345 // Invalid port
+      };
+
+      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 {
+          done(new Error('inputCallback was not set on the node instance'));
+        }
+      }, 10);
+    });
+  });
+
+  describe('Message Processing', function() {
+    it('should process email message correctly', async function() {
+      // ARRANGE: Set up message capture
+      let processedMessage = null;
+      const mockRED = createMockNodeRED({
+        sendHandler: function(msg) {
+          processedMessage = msg;
+        }
+      });
+
+      // ACT: Create node and simulate email processing
+      emailReceiverNode(mockRED);
+      const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+      const nodeInstance = new nodeConstructor(testConfigs.valid);
+
+      // Simulate input trigger (this would depend on your node's implementation)
+      // The actual trigger mechanism would need to match your node's design
+
+      await testUtils.wait(100);
+
+      // ASSERT: Message processing behavior would be verified here
+      // The specific assertions depend on your node's output format
+      should.exist(nodeInstance);
+    });
+
+    it('should handle multiple messages', async function() {
+      // ARRANGE: Set up message collection
+      const messages = [];
+      const mockRED = createMockNodeRED({
+        sendHandler: function(msg) {
+          messages.push(msg);
+        }
+      });
+
+      // ACT: Create node and simulate multiple emails
+      emailReceiverNode(mockRED);
+      const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+      const nodeInstance = new nodeConstructor(testConfigs.valid);
+
+      await testUtils.wait(150);
+
+      // ASSERT: Should handle multiple messages appropriately
+      should.exist(nodeInstance);
+    });
+  });
+
+  describe('IMAP Connection', function() {
+    it('should handle connection success', function(done) {
+      // ARRANGE: Set up connection tracking
+      const mockRED = createMockNodeRED({
+        statusHandler: function(status) {
+          if (status.fill === 'green') {
+            // ASSERT: Should show connected status
+            status.text.should.containEql('connected');
+            done();
+          }
+        }
+      });
+
+      // ACT: Create node which should attempt connection
+      emailReceiverNode(mockRED);
+      const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+      new nodeConstructor(testConfigs.valid);
+    });
+
+    it('should handle connection errors', function(done) {
+      // ARRANGE: Set up error tracking
+      const mockRED = createMockNodeRED({
+        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' };
+      new nodeConstructor(invalidConfig);
+    });
+  });
+
+  describe('Message Verification Utilities', function() {
+    it('should verify message properties using testUtils', function() {
+      // ARRANGE: Create a test message
+      const testMessage = {
+        payload: 'test content',
+        topic: 'email/received',
+        from: 'test@example.com'
+      };
+
+      // ACT & ASSERT: Use helper to verify message properties
+      testUtils.verifyMessage(testMessage, {
+        payload: 'test content',
+        topic: 'email/received'
+      });
+
+      // Should not throw any errors if verification passes
+      testMessage.should.have.property('from', 'test@example.com');
+    });
+
+    it('should use wait utility for async operations', async function() {
+      // ARRANGE: Record start time
+      const startTime = Date.now();
+
+      // ACT: Use the wait utility
+      await testUtils.wait(100);
+
+      // ASSERT: Should have waited approximately the right amount of time
+      const elapsed = Date.now() - startTime;
+      elapsed.should.be.approximately(100, 50); // Allow 50ms tolerance
+    });
+  });
+});

package/email-sender/email-sender.html

@@ -1,257 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('email-sender', {
-        category: 'ProcessCube Tools',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: "" },
-            // Mail fields
-            sender: { value: "Stoelting Ticket-System", required: true, validate: RED.validators.typedInput("senderType") },
-            senderType: { value: "str" },
-            address: { value: "", required: true, validate: RED.validators.typedInput("addressType") },
-            addressType: { value: "str" },
-            to: { value: "", required: true, validate: RED.validators.typedInput("toType") },
-            toType: { value: "str" },
-            cc: { value: "", validate: RED.validators.typedInput("ccType") },
-            ccType: { value: "str" },
-            bcc: { value: "", validate: RED.validators.typedInput("bccType") },
-            bccType: { value: "str" },
-            subject: { value: "", required: true, validate: RED.validators.typedInput("subjectType") },
-            subjectType: { value: "str" },
-            attachments: { value: "", validate: RED.validators.typedInput("attachmentsType") },
-            attachmentsType: { value: "msg" },
-            htmlContent: { value: "", required: true, validate: RED.validators.typedInput("htmlContentType") },
-            htmlContentType: { value: "str" },
-
-            // SMTP-Fields
-            host: { value: "", required: true, validate: RED.validators.typedInput("hostType") },
-            hostType: { value: "str" },
-            port: { value: "", required: true, validate: RED.validators.typedInput("portType") },
-            portType: { value: "num" },
-            user: { value: "", required: true, validate: RED.validators.typedInput("userType") },
-            userType: { value: "str" },
-            password: { value: "", required: true, type: "password" },
-            passwordType: { value: "env", required: true },
-            secure: { value: "", required: true, validate: RED.validators.typedInput("secureType") },
-            secureType: { value: "bool" },
-            rejectUnauthorized: { value: "", required: true, validate: RED.validators.typedInput("rejectUnauthorizedType") },
-            rejectUnauthorizedType: { value: "bool" }
-        },
-        inputs: 1,
-        outputs: 1,
-        icon: "font-awesome/fa-paper-plane",
-        label: function() {
-            return this.name || "Email Sender";
-        },
-        oneditprepare: function() {
-            // Mail Fields
-            $('#node-input-sender').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-senderType'
-            });
-            $('#node-input-address').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-addressType'
-            });
-            $('#node-input-to').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-toType'
-            });
-            $('#node-input-cc').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-ccType'
-            });
-            $('#node-input-bcc').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-bccType'
-            });
-            $('#node-input-subject').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-subjectType'
-            });
-            $('#node-input-attachments').typedInput({
-                default: 'msg',
-                types: ['msg', 'flow', 'global'],
-                typeField: '#node-input-attachmentsType'
-            });
-            $('#node-input-htmlContent').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'json'],
-                typeField: '#node-input-htmlContentType'
-            });
-
-            // SMTP Fields
-            $('#node-input-host').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-hostType'
-            });
-            $('#node-input-port').typedInput({
-                default: 'num',
-                types: ['num', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-portType'
-            });
-            $('#node-input-user').typedInput({
-                default: 'str',
-                types: ['str', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-userType'
-            });
-            $('#node-input-password').typedInput({
-                default: 'env',
-                types: ['msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-passwordType'
-            });
-            $('#node-input-secure').typedInput({
-                default: 'bool',
-                types: ['bool', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-secureType'
-            });
-            $('#node-input-rejectUnauthorized').typedInput({
-                default: 'bool',
-                types: ['bool', 'msg', 'flow', 'global', 'env'],
-                typeField: '#node-input-rejectUnauthorizedType'
-            });
-        }
-    });
-</script>
-
-<script type="text/html" data-template-name="email-sender">
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="Name">
-    </div>
-
-    <h3>Mail Configuration</h3>
-    <div class="form-row">
-        <label for="node-input-sender"><i class="fa fa-user"></i> Sender</label>
-        <input type="text" id="node-input-sender" placeholder="John Doe">
-        <input type="hidden" id="node-input-senderType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-address"><i class="fa fa-envelope"></i> Address</label>
-        <input type="text" id="node-input-address" placeholder="john.doe@example.com">
-        <input type="hidden" id="node-input-addressType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-to"><i class="fa fa-user"></i> To</label>
-        <input type="text" id="node-input-to" placeholder="my.test@example.com">
-        <input type="hidden" id="node-input-toType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-cc"><i class="fa fa-user-plus"></i> CC</label>
-        <input type="text" id="node-input-cc">
-        <input type="hidden" id="node-input-ccType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-bcc"><i class="fa fa-user-secret"></i> BCC</label>
-        <input type="text" id="node-input-bcc">
-        <input type="hidden" id="node-input-bccType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-subject"><i class="fa fa-info-circle"></i> Subject</label>
-        <input type="text" id="node-input-subject">
-        <input type="hidden" id="node-input-subjectType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-attachments"><i class="fa fa-paperclip"></i> Attachments</label>
-        <input type="text" id="node-input-attachments">
-        <input type="hidden" id="node-input-attachmentsType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-htmlContent"><i class="fa fa-file-code-o"></i> HTML Content</label>
-        <input type="text" id="node-input-htmlContent">
-        <input type="hidden" id="node-input-htmlContentType">
-    </div>
-
-    <h3>SMTP Configuration</h3>
-    <div class="form-row">
-        <label for="node-input-host"><i class="fa fa-server"></i> Host</label>
-        <input type="text" id="node-input-host" placeholder="smtp.gmail.com">
-        <input type="hidden" id="node-input-hostType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-port"><i class="fa fa-plug"></i> Port</label>
-        <input type="text" id="node-input-port" placeholder="587">
-        <input type="hidden" id="node-input-portType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-user"><i class="fa fa-user"></i> User</label>
-        <input type="text" id="node-input-user" placeholder="test.user@config.com">
-        <input type="hidden" id="node-input-userType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-password"><i class="fa fa-lock"></i> Password</label>
-        <input type="password" id="node-input-password">
-        <input type="hidden" id="node-input-passwordType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-secure"><i class="fa fa-shield"></i> SSL/TLS (Secure)</label>
-        <input type="text" id="node-input-secure">
-        <input type="hidden" id="node-input-secureType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-rejectUnauthorized"><i class="fa fa-ban"></i> Reject Unauthorized</label>
-        <input type="text" id="node-input-rejectUnauthorized">
-        <input type="hidden" id="node-input-rejectUnauthorizedType">
-    </div>
-</script>
-
-<script type="text/html" data-help-name="email-sender">
-    <p>A custom node to send emails using an SMTP server. The configuration for each field can be sourced from a fixed value, or from a <code>msg</code>, <code>flow</code>, <code>global</code>, or <code>env</code> variable.</p>
-
-    <h3>Configuration</h3>
-    <p>Every field on the configuration panel is a <b>typed input</b>. Use the dropdown menu next to each field to select the source of its value. Note that <b>Sender</b>, <b>Address</b>, <b>To</b>, <b>Subject</b>, and <b>HTML Content</b> are required fields and must be configured before the node can be deployed.</p>
-
-    <h4>Mail Configuration</h4>
-    <dl class="message-properties">
-        <dt>Sender <span class="property-type">string | variable</span></dt>
-        <dd>The name of the sender, as displayed to the recipient.</dd>
-
-        <dt>Address <span class="property-type">string | variable</span></dt>
-        <dd>The sender's email address.</dd>
-
-        <dt>To <span class="property-type">string | variable</span></dt>
-        <dd>The primary recipient's email address. Separate multiple addresses with a comma.</dd>
-
-        <dt>CC <span class="property-type">string | variable</span></dt>
-        <dd>Addresses to be carbon-copied on the email.</dd>
-
-        <dt>BCC <span class="property-type">string | variable</span></dt>
-        <dd>Addresses to be blind-carbon-copied on the email.</dd>
-
-        <dt>Subject <span class="property-type">string | variable</span></dt>
-        <dd>The subject line of the email.</dd>
-
-        <dt>Attachments <span class="property-type">array | variable</span></dt>
-        <dd>A list of file attachments. This should be a variable containing an array of attachment objects.</dd>
-
-        <dt>HTML Content <span class="property-type">string | variable</span></dt>
-        <dd>The HTML body of the email.</dd>
-    </dl>
-
-    <h4>SMTP Configuration</h4>
-    <dl class="message-properties">
-        <dt>Host <span class="property-type">string | variable</span></dt>
-        <dd>The hostname or IP address of the SMTP server.</dd>
-
-        <dt>Port <span class="property-type">number | variable</span></dt>
-        <dd>The port number of the SMTP server.</dd>
-
-        <dt>User <span class="property-type">string | variable</span></dt>
-        <dd>The username for SMTP authentication.</dd>
-
-        <dt>Password <span class="property-type">string | variable</span></dt>
-        <dd>The password for SMTP authentication.</dd>
-
-        <dt>SSL/TLS (Secure) <span class="property-type">boolean | variable</span></dt>
-        <dd>Use a secure connection. Set to <code>true</code> for SSL/TLS, <code>false</code> for a non-secure connection.</dd>
-
-        <dt>Reject Unauthorized <span class="property-type">boolean | variable</span></dt>
-        <dd>If <code>true</code>, the server's certificate is rejected if it's not authorized by a trusted CA.</dd>
-    </dl>
-</script>