@5minds/node-red-contrib-processcube-tools 1.2.0-feature-37541f-mg92jkdw → 1.2.0-feature-8f3d72-mg9cplxi

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

@@ -0,0 +1,570 @@
+const { expect } = require('chai');
+const {
+    createMockNodeRED,
+    setupModuleMocks,
+    emailSenderConfigs,
+    createMockNodemailer,
+} = require('../helpers/email-sender.mocks.js');
+
+describe('E-Mail Sender Node - Unit Tests', function () {
+    this.timeout(10000);
+
+    let emailSenderNode;
+    let cleanupMocks;
+
+    before(function () {
+        // Set up module mocks using helper
+        cleanupMocks = setupModuleMocks();
+
+        // Load the node with mocked dependencies
+        emailSenderNode = require('../../email-sender/email-sender.js');
+    });
+
+    after(function () {
+        // Clean up mocks
+        if (cleanupMocks) {
+            cleanupMocks();
+        }
+    });
+
+    // A separate describe block for module export
+    describe('Module Export', function () {
+        it('should export a function', function () {
+            expect(emailSenderNode).to.be.a('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
+            emailSenderNode(mockRED);
+
+            // ASSERT: Verify registration
+            expect(mockRED.nodes.lastRegisteredType).to.equal('email-sender');
+            expect(mockRED.nodes.lastRegisteredConstructor).to.be.a('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
+            emailSenderNode(mockRED);
+            new mockRED.nodes.lastRegisteredConstructor(emailSenderConfigs.valid);
+
+            // ASSERT: Verify node was created with correct properties
+            expect(createdNode).to.exist;
+            expect(createdNode).to.have.property('name', emailSenderConfigs.valid.name);
+            expect(createdNode).to.have.property('id', emailSenderConfigs.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
+            emailSenderNode(mockRED);
+            new mockRED.nodes.lastRegisteredConstructor(emailSenderConfigs.minimal);
+
+            // ASSERT: Verify node creation
+            expect(createdNode).to.exist;
+            expect(createdNode).to.have.property('id', emailSenderConfigs.minimal.id);
+        });
+    });
+
+    describe('Node Functionality', function () {
+        beforeEach(function () {
+            // Clear the module cache BEFORE requiring anything
+            delete require.cache[require.resolve('nodemailer')];
+        });
+
+        afterEach(function () {
+            delete require.cache[require.resolve('nodemailer')];
+        });
+
+        it('should send email successfully and set status to "sent"', function (done) {
+            let statusSet = false;
+
+            // ARRANGE: Initialize mockNodemailer
+            const mockNodemailer = createMockNodemailer();
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            // ARRANGE: Create mock Node-RED environment
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'green') {
+                        expect(status.text).to.include('sent');
+                        expect(status.shape).to.equal('dot');
+                        statusSet = true;
+                        done();
+                    }
+                },
+                errorHandler: function (err) {
+                    done(err || new Error('Unexpected error handler called'));
+                },
+            });
+
+            // ACT: Initialize the email sender node
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(emailSenderConfigs.valid);
+
+            nodeInstance.inputCallback({
+                payload: 'test',
+                topic: 'test message',
+            });
+        });
+
+        it('should handle sendMail error and set status to "error sending"', function (done) {
+            let errorHandlerCalled = false;
+            let redStatusSet = false;
+
+            function checkDone() {
+                if (errorHandlerCalled && redStatusSet) {
+                    done();
+                }
+            }
+
+            // Explicitly set shouldFail to true
+            const mockOptions = { shouldFail: true };
+            const mockNodemailer = createMockNodemailer(mockOptions);
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'red' && status.text === 'error sending') {
+                        redStatusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    expect(err.message).to.equal('Mock sendMail error');
+                    errorHandlerCalled = true;
+                    checkDone();
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(emailSenderConfigs.valid);
+
+            nodeInstance.inputCallback({
+                payload: 'test',
+                topic: 'test message',
+            });
+        });
+
+        it('should handle an array of attachments correctly', function (done) {
+            let attachmentsChecked = false;
+            let statusSet = false;
+
+            function checkDone() {
+                if (attachmentsChecked && statusSet) {
+                    done();
+                }
+            }
+
+            // ARRANGE: Configure test attachments
+            const attachments = [
+                {
+                    filename: 'test1.txt',
+                    content: 'This is the first test file.',
+                },
+                {
+                    filename: 'test2.txt',
+                    content: 'This is the second test file.',
+                },
+            ];
+
+            const mockNodemailer = createMockNodemailer({
+                onSendMail: (mailOptions) => {
+                    expect(mailOptions.attachments).to.be.an('array').with.lengthOf(2);
+                    expect(mailOptions.attachments[0].filename).to.equal('test1.txt');
+                    expect(mailOptions.attachments[1].content).to.equal('This is the second test file.');
+                    attachmentsChecked = true;
+                    checkDone();
+                },
+            });
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'green') {
+                        expect(status.text).to.include('sent');
+                        expect(status.shape).to.equal('dot');
+                        statusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    done(err || new Error('Unexpected error handler called'));
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const config = { ...emailSenderConfigs.valid };
+            config.attachments = JSON.stringify(attachments);
+            config.attachmentsType = 'json';
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(config);
+
+            setTimeout(() => {
+                nodeInstance.inputCallback({
+                    payload: 'test',
+                    topic: 'test message',
+                });
+            }, 100);
+        });
+
+        it('should throw error for malformed attachments', function (done) {
+            let errorHandlerCalled = false;
+            let redStatusSet = false;
+
+            function checkDone() {
+                if (errorHandlerCalled && redStatusSet) {
+                    done();
+                }
+            }
+
+            // ARRANGE: Configure the node with a JSON string containing a malformed attachment
+            const malformedAttachments = [
+                {
+                    filename: 'test.txt',
+                    content: 'This is a test file.',
+                },
+                {
+                    // Malformed attachment with missing content
+                    filename: 'invalid.txt',
+                },
+            ];
+
+            const mockNodemailer = createMockNodemailer();
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'red') {
+                        redStatusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    expect(err).to.equal("Attachment object is missing 'filename' or 'content' property.");
+                    errorHandlerCalled = true;
+                    checkDone();
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const config = { ...emailSenderConfigs.valid };
+            config.attachments = JSON.stringify(malformedAttachments);
+            config.attachmentsType = 'json';
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(config);
+
+            nodeInstance.inputCallback({
+                payload: 'test',
+                topic: 'test message',
+            });
+        });
+
+        it('should handle rejected emails and set status to rejected', function (done) {
+            let errorHandlerCalled = false;
+            let redStatusSet = false;
+
+            function checkDone() {
+                if (errorHandlerCalled && redStatusSet) {
+                    done();
+                }
+            }
+
+            // ARRANGE: Configure mock to simulate rejected emails
+            const mockOptions = {
+                rejectedEmails: ['recipient@example.com'],
+                acceptedEmails: [], // Ensure no emails are accepted
+            };
+
+            const mockNodemailer = createMockNodemailer(mockOptions);
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'red' && status.text === 'rejected') {
+                        redStatusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    expect(err.message).to.include('Email rejected: recipient@example.com');
+                    errorHandlerCalled = true;
+                    checkDone();
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(emailSenderConfigs.valid);
+
+            nodeInstance.inputCallback({
+                payload: 'test',
+                topic: 'test message',
+            });
+        });
+
+        it('should handle pending emails and set status to pending', function (done) {
+            let errorHandlerCalled = false;
+            let yellowStatusSet = false;
+
+            function checkDone() {
+                if (errorHandlerCalled && yellowStatusSet) {
+                    done();
+                }
+            }
+
+            // ARRANGE: Configure mock to simulate pending emails
+            const mockOptions = {
+                pendingEmails: ['recipient@example.com'],
+                acceptedEmails: [], // Ensure no emails are accepted
+            };
+
+            const mockNodemailer = createMockNodemailer(mockOptions);
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'yellow' && status.text === 'pending') {
+                        yellowStatusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    expect(err.message).to.include('Email pending: recipient@example.com');
+                    errorHandlerCalled = true;
+                    checkDone();
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(emailSenderConfigs.valid);
+
+            nodeInstance.inputCallback({
+                payload: 'test',
+                topic: 'test message',
+            });
+        });
+
+        it('should handle a single attachment object correctly', function (done) {
+            let attachmentChecked = false;
+            let statusSet = false;
+
+            function checkDone() {
+                if (attachmentChecked && statusSet) {
+                    done();
+                }
+            }
+
+            // ARRANGE: Configure test with single attachment object
+            const singleAttachment = {
+                filename: 'single-test.txt',
+                content: 'This is a single test file.',
+            };
+
+            const mockNodemailer = createMockNodemailer({
+                onSendMail: (mailOptions) => {
+                    expect(mailOptions.attachments).to.be.an('array').with.lengthOf(1);
+                    expect(mailOptions.attachments[0].filename).to.equal('single-test.txt');
+                    expect(mailOptions.attachments[0].content).to.equal('This is a single test file.');
+                    attachmentChecked = true;
+                    checkDone();
+                },
+            });
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'green') {
+                        expect(status.text).to.include('sent');
+                        expect(status.shape).to.equal('dot');
+                        statusSet = true;
+                        checkDone();
+                    }
+                },
+                errorHandler: function (err) {
+                    done(err || new Error('Unexpected error handler called'));
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const config = { ...emailSenderConfigs.valid };
+            config.attachments = JSON.stringify(singleAttachment);
+            config.attachmentsType = 'json';
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(config);
+
+            setTimeout(() => {
+                nodeInstance.inputCallback({
+                    payload: 'test',
+                    topic: 'test message',
+                });
+            }, 100);
+        });
+
+        it('should handle an empty attachments string without error', function (done) {
+            let statusSet = false;
+
+            // ARRANGE: Create mock nodemailer to verify no attachments are processed
+            const mockNodemailer = createMockNodemailer({
+                onSendMail: (mailOptions) => {
+                    // Should be an empty array when no attachments are provided
+                    expect(mailOptions.attachments).to.be.an('array').with.lengthOf(0);
+                },
+            });
+
+            // Mock the nodemailer module
+            delete require.cache[require.resolve('nodemailer')];
+            require.cache[require.resolve('nodemailer')] = {
+                exports: mockNodemailer,
+            };
+
+            const mockRED = createMockNodeRED({
+                onHandler: function (event, callback) {
+                    if (event === 'input') {
+                        this.inputCallback = callback;
+                    }
+                },
+                statusHandler: function (status) {
+                    if (status.fill === 'green') {
+                        expect(status.text).to.include('sent');
+                        expect(status.shape).to.equal('dot');
+                        statusSet = true;
+                        done();
+                    }
+                },
+                errorHandler: function (err) {
+                    done(err || new Error('Unexpected error handler called'));
+                },
+            });
+
+            const emailSenderNode = require('../../email-sender/email-sender.js');
+            emailSenderNode(mockRED);
+
+            const config = { ...emailSenderConfigs.valid };
+            // Set attachments to empty string to test this scenario
+            config.attachments = '';
+            config.attachmentsType = 'str';
+
+            const nodeConstructor = mockRED.nodes.lastRegisteredConstructor;
+            const nodeInstance = new nodeConstructor(config);
+
+            setTimeout(() => {
+                nodeInstance.inputCallback({
+                    payload: 'test',
+                    topic: 'test message',
+                });
+            }, 100);
+        });
+    });
+});

package/.mocharc.json

@@ -1,5 +0,0 @@
-{
-  "require": ["ts-node/register"],
-  "spec": "src/test/**/*.test.ts",
-  "timeout": 5000
-}

package/src/custom-node-template/custom-node-template.html.template

@@ -1,45 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('my-new-node-name', {
-        category: 'ProcessCube Tools',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            // Füge hier deine Konfigurations-Eigenschaften hinzu
-            // Beispiel:
-            // myProperty: { value: 'standardwert', required: true, validate: RED.validators.typedInput('myPropertyType') },
-            // myPropertyType: { value: 'str' }
-        },
-        inputs: 1, // Anzahl der Eingangsports
-        outputs: 1, // Anzahl der Ausgangsports
-        icon: 'font-awesome/fa-tag', // Symbol für die Node
-        label: function () {
-            return this.name || 'Meine Neue Node';
-        },
-        oneditprepare: function () {
-            // Hier konfigurierst du die TypedInput-Felder, die du im defaults-Block definiert hast.
-            // $('#node-input-myProperty').typedInput({
-            //     default: 'str',
-            //     types: ['str', 'msg', 'flow', 'global', 'env'],
-            //     typeField: '#node-input-myPropertyType',
-            // });
-        },
-    });
-</script>
-
-<script type="text/html" data-template-name="my-new-node-name">
-    <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>
-
-    </script>
-
-<script type="text/html" data-help-name="my-new-node-name">
-    <p>Eine einfache Node-RED-Node-Vorlage, die eine grundlegende Struktur für neue Nodes bietet.</p>
-
-    <h3>Konfiguration</h3>
-    <dl class="message-properties">
-        <dt>Name</dt>
-        <dd>Der Name deiner Node, wie er im Flow angezeigt wird.</dd>
-        </dl>
-</script>

package/src/custom-node-template/custom-node-template.ts.template

@@ -1,69 +0,0 @@
-import { NodeInitializer, Node, NodeDef, NodeMessage } from 'node-red';
-// Wenn du eine externe Bibliothek benötigst, importiere sie hier.
-// const myExternalLibrary = require('my-external-library');
-
-// Definiere ein Interface für die Konfigurations-Eigenschaften deines Nodes.
-// Ersetze 'MyNewNode' durch den Namen deiner Node.
-interface MyNewNodeProperties extends NodeDef {
-  // Füge hier deine benutzerdefinierten Konfigurationseigenschaften hinzu.
-  // Zum Beispiel:
-  // myConfigProperty: string;
-}
-
-// Definiere ein Interface für die Nachrichten-Payload, falls sie einen bestimmten Typ haben muss.
-// Ersetze 'MyNewNode' durch den Namen deiner Node.
-interface MyNewNodeMessage extends NodeMessage {
-  payload: any; // Ändere 'any' in den erwarteten Typ (z.B. 'string', 'number').
-}
-
-// Die Initialisierungsfunktion, die von Node-RED geladen wird.
-// Ersetze 'MyNewNode' durch den Namen deiner Node.
-const MyNewNode: NodeInitializer = function(RED) {
-  // Die Hauptfunktion für deine Node.
-  // Ersetze 'MyNewNode' durch den Namen deiner Node.
-  function MyNewNode(this: Node, config: MyNewNodeProperties) {
-    RED.nodes.createNode(this, config);
-    const node = this;
-
-    // Speichere die Konfiguration in der Node-Instanz.
-    // node.myConfigProperty = config.myConfigProperty;
-
-    // Registriere einen Listener für eingehende Nachrichten.
-    (node as any).on("input", (msg: MyNewNodeMessage, send?: Function, done?: Function) => {
-      // Stelle sicher, dass 'send' und 'done' verfügbar sind.
-      send = send || function(m: NodeMessage | NodeMessage[]) { node.send(m); };
-      done = done || function(err?: Error) { if (err) node.error(err, msg); };
-
-      try {
-        // --- Hier kommt deine eigentliche Node-Logik rein ---
-        // Beispiel:
-        // if (typeof msg.payload === 'string') {
-        //   msg.payload = "Hallo, das ist eine neue Node!";
-        // }
-        // --------------------------------------------------
-
-        // Sende die Nachricht weiter an die nächste Node.
-        send(msg);
-
-        // Signalisiere, dass die Verarbeitung abgeschlossen ist.
-        done();
-
-      } catch (error) {
-        // Bei einem Fehler, rufe `done` mit dem Fehlerobjekt auf.
-        done(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-
-    // Optional: Füge hier einen 'close'-Handler hinzu, um Ressourcen freizugeben.
-    // (node as any).on("close", (done) => {
-    //   // Aufräumarbeiten (z.B. Verbindung schließen)
-    //   done();
-    // });
-  }
-
-  // Registriere den Node-Typ bei Node-RED.
-  // Der String hier muss dem Namen in deiner .html-Datei entsprechen.
-  RED.nodes.registerType('my-new-node-name', MyNewNode);
-};
-
-export = MyNewNode;