@5minds/node-red-contrib-processcube-tools 1.0.1-feature-3af406-mfdy163c → 1.0.1-feature-050c1a-mfe18hnk

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

@@ -0,0 +1,279 @@
+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({
+        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;
+      new nodeConstructor(testConfigs.invalidConfig);
+    });
+
+    it('should call node.error for missing config', function(done) {
+      // ARRANGE: Set up error and status tracking
+      let statusCalled = false;
+      const mockRED = createMockNodeRED({
+        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;
+      new nodeConstructor(testConfigs.invalidConfig);
+    });
+  });
+
+  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,138 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('email-sender',{
-        category: 'ProcessCube Tools',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: "" },
-            // Definition der Felder mit dem Typ 'typedInput'
-            fromName: { value: "Stoelting Ticket-System", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            fromAddress: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            to: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            cc: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            bcc: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            subject: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            attachments: { value: "", type: "typedInput", types: ["msg", "flow", "global"] },
-            htmlContent: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "json"] },
-
-            // SMTP-Felder
-            smtpHost: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            smtpPort: { value: "", type: "typedInput", types: ["num", "str", "msg", "flow", "global", "env"] },
-            smtpUser: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            smtpPassword: { value: "", type: "typedInput", types: ["str", "msg", "flow", "global", "env"] },
-            smtpSecure: { value: true, type: "typedInput", types: ["bool", "msg", "flow", "global"] },
-            smtpRejectUnauthorized: { value: true, type: "typedInput", types: ["bool", "msg", "flow", "global"] }
-        },
-        inputs:1,
-        outputs:1,
-        icon: "font-awesome/fa-paper-plane",
-        label: function() {
-            return this.name || "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>
-
-    <h3>E-Mail Konfiguration</h3>
-    <div class="form-row">
-        <label for="node-input-fromName"><i class="fa fa-user"></i> Absendername</label>
-        <input type="text" id="node-input-fromName">
-    </div>
-    <div class="form-row">
-        <label for="node-input-fromAddress"><i class="fa fa-envelope"></i> Absenderadresse</label>
-        <input type="text" id="node-input-fromAddress">
-    </div>
-    <div class="form-row">
-        <label for="node-input-to"><i class="fa fa-user-plus"></i> Empfänger (To)</label>
-        <input type="text" id="node-input-to">
-    </div>
-    <div class="form-row">
-        <label for="node-input-cc"><i class="fa fa-user"></i> CC</label>
-        <input type="text" id="node-input-cc">
-    </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">
-    </div>
-    <div class="form-row">
-        <label for="node-input-subject"><i class="fa fa-info-circle"></i> Betreff</label>
-        <input type="text" id="node-input-subject">
-    </div>
-    <div class="form-row">
-        <label for="node-input-attachments"><i class="fa fa-paperclip"></i> Anhänge</label>
-        <input type="text" id="node-input-attachments">
-    </div>
-    <div class="form-row">
-        <label for="node-input-htmlContent"><i class="fa fa-file-code-o"></i> HTML Inhalt</label>
-        <input type="text" id="node-input-htmlContent">
-    </div>
-
-    <h3>SMTP Konfiguration</h3>
-    <div class="form-row">
-        <label for="node-input-smtpHost"><i class="fa fa-server"></i> Host</label>
-        <input type="text" id="node-input-smtpHost">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtpPort"><i class="fa fa-plug"></i> Port</label>
-        <input type="text" id="node-input-smtpPort">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtpUser"><i class="fa fa-user"></i> Benutzer</label>
-        <input type="text" id="node-input-smtpUser">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtpPassword"><i class="fa fa-lock"></i> Passwort</label>
-        <input type="password" id="node-input-smtpPassword">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtpSecure"><i class="fa fa-shield"></i> SSL/TLS (Secure)</label>
-        <input type="checkbox" id="node-input-smtpSecure">
-    </div>
-    <div class="form-row">
-        <label for="node-input-smtpRejectUnauthorized"><i class="fa fa-ban"></i> Zertifikate ablehnen</label>
-        <input type="checkbox" id="node-input-smtpRejectUnauthorized">
-    </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. Die Konfiguration kann über die Node-Eigenschaften, die eingehende Nachricht, Flow- oder Global-Kontexte oder Umgebungsvariablen erfolgen.</p>
-    <h3>Konfiguration der Felder</h3>
-    <p>Jedes Feld kann so konfiguriert werden, dass es einen festen Wert (string, number, boolean) oder einen Wert aus <code>msg</code>, <code>flow</code>, <code>global</code> oder <code>env</code> bezieht. Verwenden Sie das Dropdown-Menü neben dem Eingabefeld, um den Typ auszuwählen.</p>
-</script>
-
-<script type="text/javascript">
-    (function() {
-        // Initialisierung des typedInput-Widgets für die einzelnen Felder
-        function initializeTypedInput(id, types) {
-            $("#node-input-" + id).typedInput({
-                default: types[0],
-                types: types
-            });
-        }
-
-        // Initialisierung aller Felder
-        RED.events.on('nodes:load', function() {
-            initializeTypedInput('fromName', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('fromAddress', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('to', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('cc', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('bcc', ["str", "msg", "global", "env"]);
-            initializeTypedInput('subject', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('attachments', ["msg", "flow", "global"]);
-            initializeTypedInput('htmlContent', ["str", "msg", "flow", "global"]);
-
-            initializeTypedInput('smtpHost', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('smtpPort', ["num", "str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('smtpUser', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('smtpPassword', ["str", "msg", "flow", "global", "env"]);
-            initializeTypedInput('smtpSecure', ["bool", "msg", "flow", "global"]);
-            initializeTypedInput('smtpRejectUnauthorized', ["bool", "msg", "flow", "global"]);
-        });
-    })();
-</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);
-};