@5minds/node-red-contrib-processcube-tools 1.0.1-feature-607796-mfdmqdc3 → 1.0.1-feature-e7a81a-mfdq8poq

package/email-receiver/email-receiver.html

@@ -123,56 +123,65 @@
   <script type="text/html" data-help-name="email-receiver">
     <p>A Node-RED node that fetches unseen emails from a specified IMAP server. Each fetched email is sent as a separate message on the output.</p>
 
-<p>All fields can be configured as a <strong>string</strong>, from a <strong>message property (msg)</strong>, <strong>flow</strong> or <strong>global</strong> context, or an <strong>environment variable</strong>.</p>
-
-<p><strong>Security Tip:</strong> It's a best practice to avoid storing sensitive information like passwords directly in your Node-RED flow. This prevents them from being exposed in your flow file. Instead, use an <strong>environment variable</strong>. You can define these variables in a <code>.env</code> file, which is especially useful when deploying your application.</p>
-
-<p>A <code>.env</code> file should look like this:</p>
-<pre>
-EMAIL_SEND_PORT=123
-EMAIL_SEND_HOST=smtp.gmail.com
-EMAIL_SEND_USER=myTestMail@company.com
-EMAIL_SEND_PASSWORD=mySecretPassword
-</pre>
-
-<p>In your flow, you can then access the password using the environment variable <code>EMAIL_SEND_PASSWORD</code>.</p>
-
-Inputs
-<dl class="message-properties">
-<dt>payload</dt>
-<dd>The node is triggered by any incoming message. The node's configuration can be overridden by properties of the incoming <code>msg</code> object.</dd>
-</dl>
-
-Outputs
-<dl class="message-properties">
-<dt>payload
-<span class="property-type">string</span>
-</dt>
-<dd>The text body of the email.</dd>
-</dl>
-
-Optional Message Properties
-<p>You can override default settings by passing the following properties in the incoming <code>msg</code> object:</p>
-<dl class="message-properties">
-<dt>msg.imap_connTimeout
-<span class="property-type">number</span>
-</dt>
-<dd>The connection timeout in milliseconds (default: 10000).</dd>
-<dt>msg.imap_authTimeout
-<span class="property-type">number</span>
-</dt>
-<dd>The authentication timeout in milliseconds (default: 5000).</dd>
-<dt>msg.imap_keepalive
-<span class="property-type">boolean</span>
-</dt>
-<dd>If set to true, a periodic NOOP command is sent to keep the connection alive (default: true).</dd>
-<dt>msg.imap_autotls
-<span class="property-type">string</span>
-</dt>
-<dd>Controls STARTTLS behavior. Set to never to disable it (default: never).</dd>
-<dt>msg.imap_tlsOptions
-<span class="property-type">object</span>
-</dt>
-<dd>An object containing TLS options for the connection.</dd>
-</dl>
+    <p>All fields can be configured as a <strong>string</strong>, from a <strong>message property (msg)</strong>, <strong>flow</strong> or <strong>global</strong> context, or an <strong>environment variable</strong>.</p>
+
+    <p><strong>Security Tip:</strong> It's a best practice to avoid storing sensitive information like passwords directly in your Node-RED flow. This prevents them from being exposed in your flow file. Instead, use an <strong>environment variable</strong>. You can define these variables in a <code>.env</code> file, which is especially useful when deploying your application with Docker.</p>
+
+    <p>A <code>.env</code> file should look like this:</p>
+    <pre>
+    EMAIL_SEND_PORT=123
+    EMAIL_SEND_HOST=smtp.gmail.com
+    EMAIL_SEND_USER=myTestMail@company.com
+    EMAIL_SEND_PASSWORD=mySecretPassword
+    </pre>
+
+    <p>To ensure Docker loads these variables from the <code>.env</code> file, you need to add the following line to your <code>docker-compose.yaml</code> file:</p>
+    <pre>
+    services:
+    your_service_name:
+    ...
+    env_file:
+    - .env
+    </pre>
+
+    <p>In your flow, you can then access the password using the environment variable <code>EMAIL_SEND_PASSWORD</code>.</p>
+
+    Inputs
+    <dl class="message-properties">
+    <dt>payload</dt>
+    <dd>The node is triggered by any incoming message. The node's configuration can be overridden by properties of the incoming <code>msg</code> object.</dd>
+    </dl>
+
+    Outputs
+    <dl class="message-properties">
+    <dt>payload
+    <span class="property-type">string</span>
+    </dt>
+    <dd>The text body of the email.</dd>
+    </dl>
+
+    Optional Message Properties
+    <p>You can override default settings by passing the following properties in the incoming <code>msg</code> object:</p>
+    <dl class="message-properties">
+    <dt>msg.imap_connTimeout
+    <span class="property-type">number</span>
+    </dt>
+    <dd>The connection timeout in milliseconds (default: 10000).</dd>
+    <dt>msg.imap_authTimeout
+    <span class="property-type">number</span>
+    </dt>
+    <dd>The authentication timeout in milliseconds (default: 5000).</dd>
+    <dt>msg.imap_keepalive
+    <span class="property-type">boolean</span>
+    </dt>
+    <dd>If set to <code>true</code>, a periodic NOOP command is sent to keep the connection alive (default: <code>true</code>).</dd>
+    <dt>msg.imap_autotls
+    <span class="property-type">string</span>
+    </dt>
+    <dd>Controls STARTTLS behavior. Set to <code>never</code> to disable it (default: <code>never</code>).</dd>
+    <dt>msg.imap_tlsOptions
+    <span class="property-type">object</span>
+    </dt>
+    <dd>An object containing TLS options for the connection.</dd>
+    </dl>
 </script>

package/package.json

@@ -1,12 +1,14 @@
 {
     "name": "@5minds/node-red-contrib-processcube-tools",
-    "version": "1.0.1-feature-607796-mfdmqdc3",
+    "version": "1.0.1-feature-e7a81a-mfdq8poq",
     "license": "MIT",
     "description": "Node-RED tools nodes for ProcessCube",
     "scripts": {
         "lint": "prettier --write --config ./.prettierrc.json \"**/*.{html,js}\"",
-        "test": "mocha test/**/*_spec.js --timeout 10000",
-        "test:debug": "mocha test/**/*_spec.js --timeout 0 --reporter spec"
+        "test:unit": "mocha test/unit/**/*.test.js --timeout 10000",
+        "test:integration": "mocha test/integration/**/*.test.js --timeout 10000",
+        "test": "npm run test:unit && npm run test:integration",
+        "test:debug": "mocha test/unit/**/*.test.js test/integration/**/*.test.js --timeout 0 --reporter spec"
     },
     "authors": [
         {

package/test/helpers/email-receiver.mocks.js

@@ -0,0 +1,379 @@
+/**
+ * Shared mock objects and utilities for Email Receiver Node tests
+ */
+
+/**
+ * Mock IMAP implementation for testing
+ */
+function createMockImap() {
+  return function MockImap(config) {
+    this.config = config;
+    this.events = {};
+
+    // Simulate connection behavior
+    this.connect = () => {
+      // Simulate successful connection by emitting 'ready' event
+      if (this.events && this.events.ready) {
+        // Use setTimeout to simulate async behavior
+        setTimeout(() => this.events.ready(), 10);
+      }
+    };
+
+    // Simulate opening a mailbox
+    this.openBox = (folder, readOnly, callback) => {
+      setTimeout(() => {
+        callback(null, {
+          messages: { total: 1 },
+          name: folder,
+          readOnly: readOnly
+        });
+      }, 10);
+    };
+
+    // Simulate searching for emails
+    this.search = (criteria, callback) => {
+      setTimeout(() => {
+        // Return mock message IDs
+        callback(null, [123, 456, 789]);
+      }, 10);
+    };
+
+    // Simulate fetching email messages
+    this.fetch = (results, options) => {
+      return {
+        on: (event, callback) => {
+          if (event === 'message') {
+            setTimeout(() => {
+              const mockMessage = {
+                on: (messageEvent, messageCallback) => {
+                  if (messageEvent === 'body') {
+                    setTimeout(() => {
+                      messageCallback(Buffer.from('mock email body'));
+                    }, 5);
+                  } else if (messageEvent === 'attributes') {
+                    setTimeout(() => {
+                      messageCallback({
+                        uid: 123,
+                        flags: ['\\Seen'],
+                        date: new Date(),
+                        size: 1024
+                      });
+                    }, 5);
+                  }
+                },
+                once: (messageEvent, messageCallback) => {
+                  if (messageEvent === 'end') {
+                    setTimeout(() => messageCallback(), 15);
+                  }
+                }
+              };
+              callback(mockMessage);
+            }, 10);
+          }
+        },
+        once: (event, callback) => {
+          if (event === 'end') {
+            setTimeout(() => callback(), 20);
+          } else if (event === 'error') {
+            // Store error callback for potential use
+            this.errorCallback = callback;
+          }
+        }
+      };
+    };
+
+    // Simulate closing connection
+    this.end = () => {
+      if (this.events && this.events.end) {
+        setTimeout(() => this.events.end(), 5);
+      }
+    };
+
+    // Event listener setup
+    this.once = (event, callback) => {
+      if (!this.events) this.events = {};
+      this.events[event] = callback;
+    };
+
+    // Additional IMAP methods that might be used
+    this.addFlags = (source, flags, callback) => {
+      setTimeout(() => callback(null), 5);
+    };
+
+    this.removeFlags = (source, flags, callback) => {
+      setTimeout(() => callback(null), 5);
+    };
+
+    return this;
+  };
+}
+
+/**
+ * Mock Mailparser implementation for testing
+ */
+function createMockMailparser() {
+  return {
+    simpleParser: function(source, options = {}) {
+      return Promise.resolve({
+        subject: options.subject || 'Mock Email Subject',
+        text: options.text || 'This is a mock email body for testing purposes.',
+        html: options.html || '<p>This is a mock email body for testing purposes.</p>',
+        from: {
+          text: options.from || 'sender@test.com',
+          value: [{ address: options.from || 'sender@test.com', name: 'Test Sender' }]
+        },
+        to: {
+          text: options.to || 'recipient@test.com',
+          value: [{ address: options.to || 'recipient@test.com', name: 'Test Recipient' }]
+        },
+        date: options.date || new Date(),
+        messageId: options.messageId || '<mock-message-id@test.com>',
+        headers: new Map([
+          ['message-id', '<mock-message-id@test.com>'],
+          ['subject', options.subject || 'Mock Email Subject'],
+          ['from', options.from || 'sender@test.com'],
+          ['to', options.to || 'recipient@test.com']
+        ]),
+        attachments: options.attachments || []
+      });
+    }
+  };
+}
+
+/**
+ * Create mock Node-RED object for unit testing
+ */
+function createMockNodeRED(options = {}) {
+  return {
+    nodes: {
+      createNode: function(node, config) {
+        // Apply config properties to node
+        Object.assign(node, {
+          id: config.id || 'mock-node-id',
+          type: config.type || 'email-receiver',
+          name: config.name || 'Mock Node',
+          on: options.onHandler || function() {},
+          status: options.statusHandler || function() {},
+          error: options.errorHandler || function() {},
+          send: options.sendHandler || function() {},
+          log: options.logHandler || function() {},
+          warn: options.warnHandler || function() {},
+          debug: options.debugHandler || function() {}
+        });
+        return node;
+      },
+      registerType: function(type, constructor) {
+        // Store registration for verification in tests
+        this.lastRegisteredType = type;
+        this.lastRegisteredConstructor = constructor;
+      }
+    },
+    util: {
+      evaluateNodeProperty: function(value, type, node, msg, callback) {
+        if (type === 'json') {
+          try {
+            // Simulate parsing a JSON string into an object
+            return JSON.parse(JSON.stringify(value));
+          } catch (e) {
+            if (callback) {
+              callback(e, null);
+            }
+            return null;
+          }
+        }
+        
+        // Simple mock implementation
+        if (callback) {
+          callback(null, value);
+        }
+        return value;
+      },
+      encrypt: function(value) {
+        return 'encrypted:' + value;
+      },
+      decrypt: function(value) {
+        return value.replace('encrypted:', '');
+      }
+    },
+    log: {
+      info: options.logInfo || function() {},
+      warn: options.logWarn || function() {},
+      error: options.logError || function() {},
+      debug: options.logDebug || function() {}
+    }
+  };
+}
+
+/**
+ * Set up module mocks for require() calls
+ */
+function setupModuleMocks() {
+  const mockModules = {
+    'node-imap': createMockImap(),
+    'mailparser': createMockMailparser()
+  };
+
+  const Module = require('module');
+  const originalLoad = Module._load;
+
+  Module._load = function(request, parent) {
+    if (mockModules[request]) {
+      return mockModules[request];
+    }
+    return originalLoad.apply(this, arguments);
+  };
+
+  // Return cleanup function
+  return function cleanup() {
+    Module._load = originalLoad;
+  };
+}
+
+/**
+ * Create test configurations for different scenarios
+ */
+const testConfigs = {
+  valid: {
+    id: 'test-node-1',
+    type: 'email-receiver',
+    name: 'Test Email Receiver',
+    host: 'imap.test.com',
+    hostType: 'str',
+    port: 993,
+    portType: 'num',
+    tls: true,
+    tlsType: 'bool',
+    user: 'test@test.com',
+    userType: 'str',
+    password: 'testpass',
+    passwordType: 'str',
+    folder: 'INBOX',
+    folderType: 'str',
+    markseen: true,
+    markseenType: 'bool'
+  },
+
+  arrayFolders: {
+    id: 'test-node-3',
+    type: 'email-receiver',
+    name: 'Array Folders Test',
+    host: 'imap.test.com',
+    hostType: 'str',
+    port: 993,
+    portType: 'num',
+    user: 'test@test.com',
+    userType: 'str',
+    password: 'testpass',
+    passwordType: 'str',
+    folder: ['INBOX', 'Junk', 'Drafts'],
+    folderType: 'json',
+    markseen: false,
+    markseenType: 'bool'
+  },
+
+  invalidConfig: {
+    id: 'test-node-4',
+    type: 'email-receiver',
+    name: 'Invalid Config Test',
+    host: '',  // Missing host
+    hostType: 'str',
+    port: 993,
+    portType: 'num',
+    user: 'test@test.com',
+    userType: 'str',
+    password: '',  // Missing password
+    passwordType: 'str',
+    folder: 123,  // Wrong type
+    folderType: 'num'
+  },
+
+  minimal: {
+    id: 'test-node-5',
+    type: 'email-receiver',
+    host: 'imap.minimal.com',
+    hostType: 'str',
+    port: 993,
+    portType: 'num',
+    user: 'minimal@test.com',
+    userType: 'str',
+    password: 'minimalpass',
+    passwordType: 'str',
+    folder: 'INBOX',
+    folderType: 'str'
+  }
+};
+
+/**
+ * Create test flows for Node-RED integration tests
+ */
+const testFlows = {
+  single: [
+    testConfigs.valid
+  ],
+
+  withHelper: [
+    testConfigs.valid,
+    { id: 'h1', type: 'helper' }
+  ],
+
+  connected: [
+    { ...testConfigs.valid, wires: [['h1']] },
+    { id: 'h1', type: 'helper' }
+  ],
+
+  multiOutput: [
+    { ...testConfigs.valid, wires: [['h1', 'h2']] },
+    { id: 'h1', type: 'helper' },
+    { id: 'h2', type: 'helper' }
+  ]
+};
+
+/**
+ * Utility functions for test assertions
+ */
+const testUtils = {
+  /**
+   * Wait for a specified amount of time
+   */
+  wait: (ms = 100) => new Promise(resolve => setTimeout(resolve, ms)),
+
+  /**
+   * Create a promise that resolves when a node receives a message
+   */
+  waitForMessage: (node, timeout = 1000) => {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error('Timeout waiting for message'));
+      }, timeout);
+
+      node.on('input', (msg) => {
+        clearTimeout(timer);
+        resolve(msg);
+      });
+    });
+  },
+
+  /**
+   * Verify that a message has expected properties
+   */
+  verifyMessage: (msg, expectedProps = {}) => {
+    const should = require('should');
+    should.exist(msg);
+
+    Object.keys(expectedProps).forEach(prop => {
+      if (expectedProps[prop] !== undefined) {
+        msg.should.have.property(prop, expectedProps[prop]);
+      }
+    });
+  }
+};
+
+module.exports = {
+  createMockImap,
+  createMockMailparser,
+  createMockNodeRED,
+  setupModuleMocks,
+  testConfigs,
+  testFlows,
+  testUtils
+};

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

@@ -0,0 +1,492 @@
+const should = require('should');
+const helper = require('node-red-node-test-helper');
+
+describe('Email Receiver Node - Integration Tests', function() {
+  // Set a reasonable timeout for integration tests
+  this.timeout(10000);
+
+  let emailReceiverNode;
+  let originalLoad;
+
+  before(function(done) {
+    // Set up mocks for dependencies before loading the node
+    setupMocks();
+
+    // Load the node with mocked dependencies
+    emailReceiverNode = require('../../email-receiver/email-receiver.js');
+
+    // CRITICAL: Initialize the helper with Node-RED
+    helper.init(require.resolve('node-red'));
+    done();
+  });
+
+  after(function() {
+    // Restore original module loading
+    if (originalLoad) {
+      const Module = require('module');
+      Module._load = originalLoad;
+    }
+  });
+
+  beforeEach(function(done) {
+    helper.startServer(done);
+  });
+
+  afterEach(function(done) {
+    helper.unload();
+    helper.stopServer(done);
+  });
+
+  function setupMocks() {
+    // Create mock IMAP module
+    const 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;
+    };
+
+    // Create mock mailparser module
+    const mockMailparser = {
+      simpleParser: function() {
+        return Promise.resolve({
+          subject: 'test integration email',
+          text: 'test integration body',
+          html: '<p>test integration</p>',
+          from: { text: 'integration@test.com' },
+          date: new Date(),
+          headers: new Map(),
+          attachments: []
+        });
+      }
+    };
+
+    const mockModules = {
+      'node-imap': mockImap,
+      'mailparser': mockMailparser
+    };
+
+    // Override require to use mocks
+    const Module = require('module');
+    originalLoad = Module._load;
+    Module._load = function(request, parent) {
+      if (mockModules[request]) {
+        return mockModules[request];
+      }
+      return originalLoad.apply(this, arguments);
+    };
+  }
+
+  describe('Node Loading', function() {
+    it('should load in Node-RED test environment', function(done) {
+      // ARRANGE: Set up Node-RED flow with proper configuration
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "test node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          tls: true,
+          tlsType: "bool",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str",
+          markseen: true,
+          markseenType: "bool"
+        }
+      ];
+
+      // ACT: Load the node in the test helper environment
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          // ASSERT: Verify the node loaded correctly
+          const n1 = helper.getNode("n1");
+          should.exist(n1);
+          n1.should.have.property('name', 'test node');
+          n1.should.have.property('type', 'email-receiver');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+
+    it('should load with minimal configuration', function(done) {
+      // ARRANGE: Set up minimal flow configuration
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          host: "imap.minimal.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "minimal@test.com",
+          userType: "str",
+          password: "minimalpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str"
+        }
+      ];
+
+      // ACT: Load the node
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          // ASSERT: Verify the node loaded with minimal config
+          const n1 = helper.getNode("n1");
+          should.exist(n1);
+          n1.should.have.property('type', 'email-receiver');
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  describe('Node Connections', function() {
+    it('should create wired connections correctly', function(done) {
+      // ARRANGE: Set up flow with helper node to catch output
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "test node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          tls: true,
+          tlsType: "bool",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str",
+          markseen: true,
+          markseenType: "bool",
+          wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+      ];
+
+      // ACT: Load nodes and verify connections
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          const n2 = helper.getNode("n2");
+
+          // ASSERT: Both nodes should exist and be connected
+          should.exist(n1);
+          should.exist(n2);
+          n1.should.have.property('name', 'test node');
+          n2.should.have.property('type', 'helper');
+
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+
+    it('should handle multiple output connections', function(done) {
+      // ARRANGE: Set up flow with multiple helper nodes
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "multi-output node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str",
+          markseen: true,
+          markseenType: "bool",
+          wires: [["n2", "n3"]]
+        },
+        { id: "n2", type: "helper" },
+        { id: "n3", type: "helper" }
+      ];
+
+      // ACT: Load nodes
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          const n2 = helper.getNode("n2");
+          const n3 = helper.getNode("n3");
+
+          // ASSERT: All nodes should exist
+          should.exist(n1);
+          should.exist(n2);
+          should.exist(n3);
+          n1.should.have.property('name', 'multi-output node');
+
+          done();
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  describe('Message Flow', function() {
+    it('should handle input without crashing', function(done) {
+      // ARRANGE: Set up minimal flow
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "test node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          tls: true,
+          tlsType: "bool",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str",
+          markseen: true,
+          markseenType: "bool"
+        }
+      ];
+
+      // ACT: Load node and send input
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          should.exist(n1);
+
+          // Send input - this should not crash due to mocked IMAP
+          n1.receive({ payload: "test input" });
+
+          // ASSERT: If we reach here, the node handled input gracefully
+          setTimeout(() => {
+            done(); // Success if no errors thrown
+          }, 500);
+
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+
+    it('should process messages through connected nodes', function(done) {
+      // ARRANGE: Set up flow with helper to capture output
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "sender node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str",
+          markseen: true,
+          markseenType: "bool",
+          wires: [["n2"]]
+        },
+        { id: "n2", type: "helper" }
+      ];
+
+      // ACT: Load nodes and set up message listener
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          const n2 = helper.getNode("n2");
+
+          // Set up listener for messages from email receiver
+          n2.on("input", function(msg) {
+            try {
+              // ASSERT: Should receive a message with expected properties
+              should.exist(msg);
+              should.exist(msg.payload);
+              msg.payload.should.equal('test integration body');
+              done();
+            } catch (err) {
+              done(err);
+            }
+          });
+
+          // Trigger the email receiver
+          n1.receive({ payload: "trigger" });
+
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  describe('Configuration Validation', function() {
+    it('should handle invalid configuration gracefully', function(done) {
+      // ARRANGE: Set up flow with missing required config
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "invalid config node",
+          host: "", // Missing host
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str"
+        }
+      ];
+
+      // ACT: Load node with invalid config
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          should.exist(n1);
+
+          // ASSERT: Node should exist but handle invalid config appropriately
+          // Send input to trigger validation
+          n1.receive({ payload: "test" });
+
+          // If we get here without crashing, the validation worked
+          setTimeout(() => {
+            done();
+          }, 300);
+
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+
+    it('should load with different folder configurations', function(done) {
+      // ARRANGE: Set up flow with array folder config
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "array folder node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: ["INBOX", "Sent", "Drafts"],
+          folderType: "json",
+          markseen: true,
+          markseenType: "bool"
+        }
+      ];
+
+      // ACT: Load node with array folder config
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+
+          // ASSERT: Node should load successfully with array config
+          should.exist(n1);
+          n1.should.have.property('name', 'array folder node');
+          done();
+
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+
+  describe('Node Lifecycle', function() {
+    it('should clean up properly on unload', function(done) {
+      // ARRANGE: Set up flow
+      const flow = [
+        {
+          id: "n1",
+          type: "email-receiver",
+          name: "cleanup test node",
+          host: "imap.test.com",
+          hostType: "str",
+          port: "993",
+          portType: "str",
+          user: "test@example.com",
+          userType: "str",
+          password: "testpass",
+          passwordType: "str",
+          folder: "INBOX",
+          folderType: "str"
+        }
+      ];
+
+      // ACT: Load and then unload the node
+      helper.load(emailReceiverNode, flow, function() {
+        try {
+          const n1 = helper.getNode("n1");
+          should.exist(n1);
+
+          // Simulate some activity
+          n1.receive({ payload: "test" });
+
+          // ASSERT: Unloading should not throw errors
+          helper.unload();
+          done();
+
+        } catch (err) {
+          done(err);
+        }
+      });
+    });
+  });
+});

package/test/{email-receiver_spec.js → unit/email-receiver.unit.test.js}

@@ -1,6 +1,6 @@
 const should = require('should');
 
-describe('Email Receiver Node', function() {
+describe('Email Receiver Node - Unit Tests', function() {
   // Set a reasonable timeout
   this.timeout(10000);
 
@@ -72,7 +72,7 @@ describe('Email Receiver Node', function() {
     };
 
     // Load the node with mocked dependencies
-    emailReceiverNode = require('../email-receiver/email-receiver.js');
+    emailReceiverNode = require('../../email-receiver/email-receiver.js');
   });
 
   after(function() {
@@ -83,7 +83,7 @@ describe('Email Receiver Node', function() {
     }
   });
 
-  describe('Unit Tests', function() {
+  describe('Module Export', function() {
     it('should export a function', function() {
       // ARRANGE: Node module is already loaded
 
@@ -92,7 +92,9 @@ describe('Email Receiver Node', function() {
       // 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;
@@ -132,8 +134,10 @@ describe('Email Receiver Node', function() {
       registeredType.should.equal('email-receiver');
       registeredConstructor.should.be.type('function');
     });
+  });
 
-    it('should handle node instantiation', 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;
 
@@ -190,46 +194,11 @@ describe('Email Receiver Node', function() {
       should.exist(nodeInstance);
       nodeInstance.should.have.property('name', 'Test Email Receiver');
     });
+  });
 
-    it('should handle comma-separated folder string', function(done) {
-      // ARRANGE: Mock the Node-RED and IMAP environment
-      let nodeInstance;
-      let inputCallback;
-      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');
-              done();
-            };
-            return node;
-          },
-          registerType: (type, constructor) => {
-            new constructor({
-              host: "imap.test.com", hostType: "str",
-              port: 993, portType: "num",
-              user: "test@test.com", userType: "str",
-              password: "testpass", passwordType: "str",
-              folder: "INBOX, Spam, Sent", folderType: 'str',
-              markseen: true, markseenType: 'bool'
-            });
-          }
-        },
-        util: { evaluateNodeProperty: (value) => value },
-      };
-
-      // ACT: Register the node, then simulate input
-      emailReceiverNode(mockRED);
-      inputCallback({});
-    });
-
+  describe('Folder Configuration', function() {
     it('should handle an array of folders', function(done) {
-      // ARRANGE: Mock the Node-RED and IMAP environment
+      // ARRANGE: Mock the Node-RED environment
       let nodeInstance;
       let inputCallback;
       const mockRED = {
@@ -264,7 +233,9 @@ describe('Email Receiver Node', function() {
       emailReceiverNode(mockRED);
       inputCallback({});
     });
+  });
 
+  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;
@@ -301,7 +272,7 @@ describe('Email Receiver Node', function() {
           host: "imap.test.com", hostType: "str",
           port: 993, portType: "num",
           user: "test@test.com", userType: "str",
-          password: "", passwordType: "str",
+          password: "", passwordType: "str", // Empty password should trigger error
           folder: "INBOX", folderType: "str"
         },
         on: (event, callback) => { if (event === 'input') nodeInstance.inputCallback = callback; },
@@ -326,152 +297,4 @@ describe('Email Receiver Node', function() {
       nodeInstance.inputCallback({});
     });
   });
-
-  describe('Integration Tests with Node-RED Helper', function() {
-    const helper = require('node-red-node-test-helper');
-
-    // CRITICAL: Initialize the helper with Node-RED
-    before(function(done) {
-      // This is the missing piece that was causing the clearRegistry error
-      helper.init(require.resolve('node-red'));
-      done();
-    });
-
-    beforeEach(function(done) {
-      helper.startServer(done);
-    });
-
-    afterEach(function(done) {
-      helper.unload();
-      helper.stopServer(done);
-    });
-
-    it('should load in Node-RED test environment', function(done) {
-      // ARRANGE: Set up Node-RED flow with proper configuration
-      const flow = [
-        {
-          id: "n1",
-          type: "email-receiver",
-          name: "test node",
-          host: "imap.test.com",
-          hostType: "str",
-          port: "993",
-          portType: "str",
-          tls: true,
-          tlsType: "bool",
-          user: "test@example.com",
-          userType: "str",
-          password: "testpass",
-          passwordType: "str",
-          folder: "INBOX",
-          folderType: "str",
-          markseen: true,
-          markseenType: "bool"
-        }
-      ];
-
-      // ACT: Load the node in the test helper environment
-      helper.load(emailReceiverNode, flow, function() {
-        try {
-          // ASSERT: Verify the node loaded correctly
-          const n1 = helper.getNode("n1");
-          should.exist(n1);
-          n1.should.have.property('name', 'test node');
-          n1.should.have.property('type', 'email-receiver');
-          done();
-        } catch (err) {
-          done(err);
-        }
-      });
-    });
-
-    it('should create wired connections correctly', function(done) {
-      // ARRANGE: Set up flow with helper node to catch output
-      const flow = [
-        {
-          id: "n1",
-          type: "email-receiver",
-          name: "test node",
-          host: "imap.test.com",
-          hostType: "str",
-          port: "993",
-          portType: "str",
-          tls: true,
-          tlsType: "bool",
-          user: "test@example.com",
-          userType: "str",
-          password: "testpass",
-          passwordType: "str",
-          folder: "INBOX",
-          folderType: "str",
-          markseen: true,
-          markseenType: "bool",
-          wires: [["n2"]]
-        },
-        { id: "n2", type: "helper" }
-      ];
-
-      // ACT: Load nodes and verify connections
-      helper.load(emailReceiverNode, flow, function() {
-        try {
-          const n1 = helper.getNode("n1");
-          const n2 = helper.getNode("n2");
-
-          // ASSERT: Both nodes should exist and be connected
-          should.exist(n1);
-          should.exist(n2);
-          n1.should.have.property('name', 'test node');
-          n2.should.have.property('type', 'helper');
-
-          done();
-        } catch (err) {
-          done(err);
-        }
-      });
-    });
-
-    it('should handle input without crashing', function(done) {
-      // ARRANGE: Set up minimal flow
-      const flow = [
-        {
-          id: "n1",
-          type: "email-receiver",
-          name: "test node",
-          host: "imap.test.com",
-          hostType: "str",
-          port: "993",
-          portType: "str",
-          tls: true,
-          tlsType: "bool",
-          user: "test@example.com",
-          userType: "str",
-          password: "testpass",
-          passwordType: "str",
-          folder: "INBOX",
-          folderType: "str",
-          markseen: true,
-          markseenType: "bool"
-        }
-      ];
-
-      // ACT: Load node and send input
-      helper.load(emailReceiverNode, flow, function() {
-        try {
-          const n1 = helper.getNode("n1");
-          should.exist(n1);
-
-          // Send input - this should not crash due to mocked IMAP
-          n1.receive({ payload: "test input" });
-
-          // ASSERT: If we reach here, the node handled input gracefully
-          setTimeout(() => {
-            done(); // Success if no errors thrown
-          }, 500);
-
-        } catch (err) {
-          done(err);
-        }
-      });
-    });
-  });
-});
+});