@5minds/node-red-contrib-processcube-tools 1.0.1-feature-f506be-mfe3agh6 → 1.0.1-feature-7fb5cf-mff3dkae

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

@@ -0,0 +1,337 @@
+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('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') {
+            // Store the callback on the node instance
+            this.inputCallback = callback;
+          }
+        },
+        statusHandler: function(status) {
+          if (status.fill === 'green') {
+            // ASSERT: Should show connected status
+            status.text.should.containEql('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
+          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('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>

package/email-sender/email-sender.js

@@ -1,91 +0,0 @@
-module.exports = function(RED) {
-    "use strict";
-    const nodemailer = require("nodemailer");
-
-    function EmailSenderNode(config) {
-        RED.nodes.createNode(this, config);
-        var node = this;
-
-        node.on('input', function(msg, send, done) {
-            send = send || function() { node.send.apply(node, arguments); };
-            done = done || function(err) { if (err) node.error(err, msg); };
-
-            // Retrieve and evaluate mail configuration values
-            const sender = RED.util.evaluateNodeProperty(config.sender, config.senderType, node, msg);
-            const address = RED.util.evaluateNodeProperty(config.address, config.addressType, node, msg);
-            const to = RED.util.evaluateNodeProperty(config.to, config.toType, node, msg);
-            const cc = RED.util.evaluateNodeProperty(config.cc, config.ccType, node, msg) || "";
-            const bcc = RED.util.evaluateNodeProperty(config.bcc, config.bccType, node, msg) || "";
-            const subject = RED.util.evaluateNodeProperty(config.subject, config.subjectType, node, msg) || msg.topic || "Message from Node-RED";
-            const attachments = RED.util.evaluateNodeProperty(config.attachments, config.attachmentsType, node, msg);
-            const htmlContent = RED.util.evaluateNodeProperty(config.htmlContent, config.htmlContentType, node, msg);
-
-            // Retrieve and evaluate SMTP configuration values
-            const host = RED.util.evaluateNodeProperty(config.host, config.hostType, node, msg);
-            const port = RED.util.evaluateNodeProperty(config.port, config.portType, node, msg);
-            const user = RED.util.evaluateNodeProperty(config.user, config.userType, node, msg);
-            const password = RED.util.evaluateNodeProperty(config.password, config.passwordType, node, msg);
-            const secure = RED.util.evaluateNodeProperty(config.secure, config.secureType, node, msg);
-            const rejectUnauthorized = RED.util.evaluateNodeProperty(config.rejectUnauthorized, config.rejectUnauthorizedType, node, msg);
-
-            // Create SMTP transporter
-            const transporter = nodemailer.createTransport({
-                host: host,
-                port: port,
-                secure: secure,
-                auth: {
-                    user: user,
-                    pass: password
-                },
-                tls: {
-                    rejectUnauthorized: rejectUnauthorized
-                }
-            });
-
-            // Create email object
-            const mailOptions = {
-                from: {
-                    name: sender,
-                    address: address
-                },
-                to: to,
-                cc: cc,
-                bcc: bcc,
-                subject: subject,
-                html: Buffer.from(htmlContent, 'utf-8'),
-                attachments: attachments
-            };
-
-            // Send email
-            transporter.sendMail(mailOptions, (error, info) => {
-                if (error) {
-                    node.status({ fill: "red", shape: "dot", text: "error sending" });
-                    done(error);
-                } else {
-                    node.log('Email sent: ' + info.response);
-                    msg.payload = info;
-
-                    if (msg.payload.accepted && msg.payload.accepted.length > 0) {
-                        msg.payload = msg.input;
-                        node.status({ fill: "green", shape: "dot", text: "sent" });
-                        send(msg);
-                        done();
-                    } else if (msg.payload.rejected && msg.payload.rejected.length > 0) {
-                        msg.error = { result: msg.payload.rejected };
-                        node.status({ fill: "red", shape: "dot", text: "rejected" });
-                        done(new Error('Email rejected: ' + msg.payload.rejected.join(', ')));
-                    } else if (msg.payload.pending && msg.payload.pending.length > 0) {
-                        msg.error = { result: msg.payload.pending };
-                        node.status({ fill: "yellow", shape: "dot", text: "pending" });
-                        done(new Error('Email pending: ' + msg.payload.pending.join(', ')));
-                    } else {
-                        node.status({ fill: "red", shape: "dot", text: "unknown error" });
-                        done(new Error('Unknown error while sending email.'));
-                    }
-                }
-            });
-        });
-    }
-
-    RED.nodes.registerType("email-sender", EmailSenderNode);
-};