@5minds/node-red-contrib-processcube-tools 1.0.1-feature-4ad612-mfdvfdql → 1.0.1-feature-df88cf-mfdx610k

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

@@ -0,0 +1,332 @@
+const should = require('should');
+
+describe('Email Receiver Node - Unit Tests', function() {
+  // Set a reasonable timeout
+  this.timeout(10000);
+
+  // Module and mocking setup
+  let emailReceiverNode;
+  let originalLoad;
+  let mockImap;
+  let mockMailparser;
+
+  before(function() {
+    // Create mock modules with correct behavior
+    mockImap = function(config) {
+      this.config = config;
+      this.connect = () => {
+        // Simulate a successful connection by immediately emitting 'ready'
+        if (this.events && this.events.ready) {
+          this.events.ready();
+        }
+      };
+      this.openBox = (folder, readOnly, callback) => { callback(null, { messages: { total: 1 } }); };
+      this.search = (criteria, callback) => { callback(null, [123]); };
+      this.fetch = (results, options) => {
+        return {
+          on: (event, cb) => {
+            if (event === 'message') {
+              cb({ on: (e, bodyCb) => { if (e === 'body') bodyCb({}); } });
+            }
+          },
+          once: (event, cb) => {
+            if (event === 'end') { cb(); }
+          }
+        };
+      };
+      this.end = () => {};
+      this.once = (event, callback) => {
+        if (!this.events) this.events = {};
+        this.events[event] = callback;
+      };
+      return this;
+    };
+
+    mockMailparser = {
+      simpleParser: function() {
+        return Promise.resolve({
+          subject: 'test',
+          text: 'test body',
+          html: '<p>test</p>',
+          from: { text: 'test@test.com' },
+          date: new Date(),
+          headers: new Map(),
+          attachments: []
+        });
+      }
+    };
+
+    const mockModules = {
+      'node-imap': mockImap,
+      'mailparser': mockMailparser
+    };
+
+    // Override require
+    const Module = require('module');
+    originalLoad = Module._load;
+    Module._load = function(request, parent) {
+      if (mockModules[request]) {
+        return mockModules[request];
+      }
+      return originalLoad.apply(this, arguments);
+    };
+
+    // Load the node with mocked dependencies
+    emailReceiverNode = require('../../email-receiver/email-receiver.js');
+  });
+
+  after(function() {
+    // Restore original module loading
+    if (originalLoad) {
+      const Module = require('module');
+      Module._load = originalLoad;
+    }
+  });
+
+  describe('Module Export', function() {
+    it('should export a function', function() {
+      // ARRANGE: Node module is already loaded
+
+      // ACT: Check the type of the exported module
+
+      // ASSERT: Should be a function
+      emailReceiverNode.should.be.type('function');
+    });
+  });
+
+  describe('Node Registration', function() {
+    it('should register node type without errors', function() {
+      // ARRANGE: Set up mock RED object and capture registration calls
+      let registeredType;
+      let registeredConstructor;
+
+      const mockRED = {
+        nodes: {
+          createNode: function(node, config) {
+            node.id = config.id;
+            node.type = config.type;
+            node.name = config.name;
+            node.on = function() {};
+            node.status = function() {};
+            node.error = function() {};
+            node.send = function() {};
+            return node;
+          },
+          registerType: function(type, constructor) {
+            registeredType = type;
+            registeredConstructor = constructor;
+          }
+        },
+        util: {
+          evaluateNodeProperty: function(value, type) {
+            return value;
+          },
+          encrypt: function(value) {
+            return 'encrypted:' + value;
+          }
+        }
+      };
+
+      // ACT: Call the node registration function
+      emailReceiverNode(mockRED);
+
+      // ASSERT: Verify registration was called correctly
+      registeredType.should.equal('email-receiver');
+      registeredConstructor.should.be.type('function');
+    });
+  });
+
+  describe('Node Instantiation', function() {
+    it('should handle node instantiation with valid config', function() {
+      // ARRANGE: Set up mock RED object and node instance tracking
+      let nodeInstance;
+
+      const mockRED = {
+        nodes: {
+          createNode: function(node, config) {
+            nodeInstance = node;
+            node.id = config.id;
+            node.type = config.type;
+            node.name = config.name;
+            node.on = function() {};
+            node.status = function() {};
+            node.error = function() {};
+            node.send = function() {};
+            return node;
+          },
+          registerType: function(type, NodeConstructor) {
+            // Simulate creating a node instance with valid config
+            const config = {
+              id: 'test-node',
+              type: 'email-receiver',
+              name: 'Test Email Receiver',
+              host: 'imap.test.com',
+              hostType: 'str',
+              port: 993,
+              portType: 'num',
+              user: 'test@test.com',
+              userType: 'str',
+              password: 'testpass',
+              passwordType: 'str',
+              folder: ["INBOX"],
+              folderType: 'json',
+              markseen: true,
+              markseenType: 'bool'
+            };
+
+            new NodeConstructor(config);
+          }
+        },
+        util: {
+          evaluateNodeProperty: function(value, type) {
+            return value;
+          },
+          encrypt: function(value) {
+            return 'encrypted:' + value;
+          }
+        }
+      };
+
+      // ACT: Register the node and create an instance
+      emailReceiverNode(mockRED);
+
+      // ASSERT: Verify the node instance was created with correct properties
+      should.exist(nodeInstance);
+      nodeInstance.should.have.property('name', 'Test Email Receiver');
+    });
+  });
+
+  describe('Folder Configuration', function() {
+    it('should handle an array of folders', function(done) {
+      // ARRANGE: Mock the Node-RED environment
+      let nodeInstance;
+      let inputCallback;
+      let messagesSent = 0;
+      const expectedMessages = 2;
+
+      const mockRED = {
+        nodes: {
+          createNode: function(node, config) {
+            nodeInstance = node;
+            node.on = (event, callback) => { if (event === 'input') inputCallback = callback; };
+            node.status = () => {};
+            node.error = () => {};
+            node.send = (msg) => {
+              should.exist(msg);
+              msg.payload.should.equal('test body');
+              messagesSent++;
+              if (messagesSent === expectedMessages) {
+                done();
+              }
+            };
+            return node;
+          },
+          registerType: (type, constructor) => {
+          const mockNode = {
+            id: 'mock-node-id',
+            on: (event, callback) => {
+              if (event === 'input') {
+                inputCallback = callback;
+              }
+            },
+            status: () => {},
+            error: () => {},
+            send: (msg) => {
+              should.exist(msg);
+              msg.payload.should.equal('test body');
+              messagesSent++;
+              if (messagesSent === expectedMessages) {
+                done();
+              }
+            },
+          };
+          // Create an instance of the node with the test configuration
+          const node = new constructor(mockNode, {
+            host: "imap.test.com", hostType: "str",
+            port: 993, portType: "num",
+            user: "test@test.com", userType: "str",
+            password: "testpass", passwordType: "str",
+            folder: ["INBOX", "Junk"], folderType: 'json',
+            markseen: true, markseenType: 'bool'
+          });
+        }
+      },
+      util: { evaluateNodeProperty: (value) => value },
+    };
+
+      // ACT: Register the node, then simulate input
+       emailReceiverNode(mockRED);
+    // After the node is registered, simulate an input to trigger the flow
+    setTimeout(() => {
+        if (inputCallback) {
+            inputCallback({});
+        } else {
+            done(new Error("Input callback not set up."));
+        }
+    }, 50); // Use a small timeout to ensure the mocks are fully set up
+  });
+});
+
+  describe('Error Handling', function() {
+    it('should call node.error for invalid folder type', function(done) {
+      // ARRANGE: Mock the node instance to capture errors
+      let errorCalled = false;
+      const nodeInstance = {
+        config: { folder: 123, folderType: 'num' },
+        on: (event, callback) => { if (event === 'input') nodeInstance.inputCallback = callback; },
+        status: () => {},
+        error: (err) => {
+          errorCalled = true;
+          err.should.containEql('The \'folders\' property must be an array of strings');
+          done();
+        },
+        send: () => {},
+      };
+      const mockRED = {
+        nodes: {
+          createNode: (node, config) => Object.assign(node, { on: nodeInstance.on, status: nodeInstance.status, error: nodeInstance.error, send: nodeInstance.send }),
+          registerType: (type, constructor) => new constructor(nodeInstance.config),
+        },
+        util: { evaluateNodeProperty: (value, type) => value },
+      };
+
+      // ACT: Register and instantiate the node, then simulate an input message
+      emailReceiverNode(mockRED);
+      nodeInstance.inputCallback({});
+    });
+
+    it('should call node.error for missing config', function(done) {
+      // ARRANGE: Mock the node instance to capture errors
+      let errorCalled = false;
+      let statusCalled = false;
+      const nodeInstance = {
+        config: {
+          host: "imap.test.com", hostType: "str",
+          port: 993, portType: "num",
+          user: "test@test.com", userType: "str",
+          password: "", passwordType: "str", // Empty password should trigger error
+          folder: ["INBOX"], folderType: "json"
+        },
+        on: (event, callback) => { if (event === 'input') nodeInstance.inputCallback = callback; },
+        status: (s) => { statusCalled = true; s.fill.should.equal('red'); },
+        error: (err) => {
+          errorCalled = true;
+          err.should.containEql('Missing required IMAP config');
+          done();
+        },
+        send: () => {},
+      };
+      const mockRED = {
+        nodes: {
+          createNode: (node, config) => Object.assign(node, { on: nodeInstance.on, status: nodeInstance.status, error: nodeInstance.error, send: nodeInstance.send }),
+          registerType: (type, constructor) => new constructor(nodeInstance.config),
+        },
+        util: { evaluateNodeProperty: (value, type) => value },
+      };
+
+      // ACT: Register and instantiate the node, then simulate an input message
+      emailReceiverNode(mockRED);
+      nodeInstance.inputCallback({});
+    });
+  });
+});

package/email-sender/email-sender.html

@@ -1,50 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('email-sender',{
-        category: 'network',
-        color: '#a6bbcf',
-        defaults: {
-            name: {value: ""},
-            email: {value: "", type: "json"},
-            smtp: {value: "", type: "json"}
-        },
-        inputs:1,
-        outputs:1,
-        icon: "font-awesome/fa-envelope",
-        label: function() {
-            return this.name || "Custom Email Sender";
-        },
-        labelStyle: function() {
-            return this.name?"node_label_italic":"";
-        }
-    });
-</script>
-
-<script type="text/html" data-template-name="custom-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>
-    <div class="form-row">
-        <label for="node-input-email"><i class="fa fa-envelope"></i> E-Mail Konfiguration</label>
-        <input type="text" id="node-input-email" placeholder="JSON-Objekt oder J:...">
-        <input type="hidden" id="node-input-emailType">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtp"><i class="fa fa-cogs"></i> SMTP Konfiguration</label>
-        <input type="text" id="node-input-smtp" placeholder="JSON-Objekt oder J:...">
-        <input type="hidden" id="node-input-smtpType">
-    </div>
-</script>
-
-<script type="text/html" data-help-name="custom-email-sender">
-    <p>Eine benutzerdefinierte Node, um E-Mails über einen SMTP-Server zu versenden.</p>
-    <h3>Inputs</h3>
-    <dl class="message-properties">
-        <dt>payload
-            <span class="property-type">object</span>
-        </dt>
-        <dd>Beinhaltet die Daten zum E-Mail-Versand.</dd>
-    </dl>
-    <h3>Details</h3>
-    <p>Die Node verwendet Nodemailer, um eine E-Mail zu senden. Die Konfiguration kann über die Node-Eigenschaften oder die eingehende Nachricht erfolgen.</p>
-</script>

package/email-sender/email-sender.js

@@ -1,84 +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) {
-
-            // Konfiguration und Daten aus der Nachricht extrahieren
-            const emailConfig = RED.util.evaluateNodeProperty(config.email, config.emailType, node, msg) || {};
-            const smtpConfig = RED.util.evaluateNodeProperty(config.smtp, config.smtpType, node, msg) || {};
-
-            // Fallback für send und done, falls ältere Node-RED Version
-            send = send || function() { node.send.apply(node, arguments); }
-            done = done || function(err) { if (err) node.error(err, msg); }
-
-            // Logik vom Code-Snippet
-            const transporter = nodemailer.createTransport({
-                host: smtpConfig.host,
-                port: smtpConfig.port,
-                auth: {
-                    user: smtpConfig.auth?.user,
-                    pass: smtpConfig.auth?.pass
-                },
-                secure: smtpConfig.secure !== undefined ? smtpConfig.secure : true,
-                proxy: smtpConfig.proxy || undefined,
-                tls: {
-                    rejectUnauthorized: smtpConfig.tls?.rejectUnauthorized !== undefined
-                        ? smtpConfig.tls.rejectUnauthorized
-                        : true
-                }
-            });
-
-            const mail = {
-                from: emailConfig.from,
-                to: emailConfig.to,
-                cc: emailConfig.cc || "",
-                bcc: emailConfig.bcc || "",
-                subject: emailConfig.subject || msg.topic || "Message from Node-RED",
-                attachments: emailConfig.attachments,
-                text: emailConfig.text,
-                html: emailConfig.html,
-                amp: emailConfig.amp,
-                priority: emailConfig.priority || "normal"
-            };
-
-            // E-Mail senden und den Status überprüfen
-            transporter.sendMail(mail, (error, info) => {
-                if (error) {
-                    node.error(error, msg);
-                    done(error); // Fehler an Node-RED weiterleiten
-                    return;
-                }
-
-                node.log('E-Mail gesendet: ' + info.response);
-                msg.payload = info;
-
-                // Statusprüfung basierend auf dem Code-Auszug
-                if (msg.payload.accepted && msg.payload.accepted.length > 0) {
-                    msg.payload = { result: msg.input };
-                    send(msg); // Nachricht an den nächsten Knoten senden
-                } else if (msg.payload.rejected && msg.payload.rejected.length > 0) {
-                    msg.error = { result: msg.payload.rejected };
-                    done('E-Mail abgelehnt: ' + msg.payload.rejected.join(', '));
-                    node.status({fill:"red", shape:"dot", text:"rejected"});
-                    return;
-                } else if (msg.payload.pending && msg.payload.pending.length > 0) {
-                    msg.error = { result: msg.payload.pending };
-                    done('E-Mail ausstehend: ' + msg.payload.pending.join(', '));
-                    node.status({fill:"yellow", shape:"dot", text:"pending"});
-                    return;
-                } else {
-                    done('Unbekannter Fehler beim Senden der E-Mail.');
-                    node.status({fill:"red", shape:"dot", text:"error"});
-                    return;
-                }
-            });
-        });
-    }
-
-    RED.nodes.registerType("email-sender", EmailSenderNode);
-};