@5minds/node-red-contrib-processcube-tools 1.0.1-develop-8bf22b-mffg2ve3 → 1.0.1-develop-4412ca-mfm8hzs3

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

@@ -3,450 +3,445 @@
  */
 
 /**
- * Mock IMAP implementation for testing
+ * Create mock Node-RED object for unit testing
  */
-function createMockImap() {
-  return function MockImap(config) {
-    this.config = config;
-    this.events = {};
-
-    // Simulate connection behavior
-    this.connect = () => {
-      // Check if we should simulate a connection error
-      if (this.config.host && this.config.host.includes('invalid')) {
-        // Simulate connection error
-        if (this.events && this.events.error) {
-          setTimeout(() => {
-            const error = new Error('Connection failed');
-            error.code = 'ENOTFOUND';
-            this.events.error(error);
-          }, 10);
-        }
-      } else {
-        // Simulate successful connection by emitting 'ready' event
-        if (this.events && this.events.ready) {
-          setTimeout(() => this.events.ready(), 10);
-        }
-      }
-    };
+function createMockNodeRED(options = {}) {
+    // Store input callback in the mock RED context
+    let storedInputCallback = null;
+    let nodeInstance = null;
+
+    const mockRED = {
+        nodes: {
+            createNode: function (node, config) {
+                nodeInstance = node; // Capture the node instance
+
+                // 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: function (event, callback) {
+                        if (event === 'input') {
+                            storedInputCallback = callback;
+                            // Store the callback on the node instance for easy access
+                            node.inputCallback = callback;
+                        }
+                        // Call the original onHandler if provided
+                        if (options.onHandler) {
+                            options.onHandler.call(node, event, callback);
+                        }
+                    },
+                    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;
+            },
+            // Helper method to get the stored input callback
+            getInputCallback: function () {
+                return storedInputCallback;
+            },
+            // Helper method to get the node instance
+            getNodeInstance: function () {
+                return nodeInstance;
+            },
+        },
+        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;
+                    }
+                }
 
-    // Simulate opening a mailbox
-    this.openBox = (folder, readOnly, callback) => {
-      setTimeout(() => {
-        callback(null, {
-          messages: { total: 1 },
-          name: folder,
-          readOnly: readOnly
-        });
-      }, 10);
+                // 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 () {},
+        },
     };
 
-    // Simulate searching for emails
-    this.search = (criteria, callback) => {
-      setTimeout(() => {
-        // Return mock message IDs
-        callback(null, [123, 456, 789]);
-      }, 10);
-    };
+    return mockRED;
+}
 
-    // Simulate fetching email messages
-    this.fetch = (results, options) => {
-      const fetchEmitter = {
-        on: (event, callback) => {
-          if (event === 'message') {
-            setTimeout(() => {
-              const mockMessage = {
-                on: (messageEvent, messageCallback) => {
-                  if (messageEvent === 'body') {
-                    setTimeout(() => {
-                      // Return a mock email body that will be parsed
-                      const mockEmailContent = `From: sender@test.com\r\nTo: recipient@test.com\r\nSubject: Mock Email Subject\r\n\r\nThis is a mock email body for testing purposes.`;
-                      messageCallback(Buffer.from(mockEmailContent));
-                    }, 5);
-                  } else if (messageEvent === 'attributes') {
+/**
+ * Mock IMAP implementation for testing
+ */
+function createMockImap() {
+    return function MockImap(config) {
+        this.config = config;
+        this.events = {};
+
+        // Simulate connection behavior
+        this.connect = () => {
+            // Check if we should simulate a connection error
+            if (this.config.host && this.config.host.includes('invalid')) {
+                // Simulate connection error
+                if (this.events && this.events.error) {
                     setTimeout(() => {
-                      messageCallback({
-                        uid: 123,
-                        flags: ['\\Seen'],
-                        date: new Date(),
-                        size: 1024
-                      });
-                    }, 5);
-                  }
-                },
-                once: (messageEvent, messageCallback) => {
-                  if (messageEvent === 'end') {
-                    setTimeout(() => messageCallback(), 15);
-                  }
+                        const error = new Error('Connection failed');
+                        error.code = 'ENOTFOUND';
+                        this.events.error(error);
+                    }, 10);
                 }
-              };
-              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;
-          }
-        }
-      };
-
-      // Store the fetch emitter so we can trigger events manually in tests
-      this.lastFetchEmitter = fetchEmitter;
-      return fetchEmitter;
-    };
-
-    // Simulate closing connection
-    this.end = () => {
-      if (this.events && this.events.end) {
-        setTimeout(() => this.events.end(), 5);
-      }
-    };
+            } else {
+                // Simulate successful connection by emitting 'ready' event
+                if (this.events && this.events.ready) {
+                    setTimeout(() => this.events.ready(), 10);
+                }
+            }
+        };
 
-    // Event listener setup
-    this.once = (event, callback) => {
-      if (!this.events) this.events = {};
-      this.events[event] = callback;
-    };
+        // Simulate opening a mailbox
+        this.openBox = (folder, readOnly, callback) => {
+            setTimeout(() => {
+                callback(null, {
+                    messages: { total: 1 },
+                    name: folder,
+                    readOnly: readOnly,
+                });
+            }, 10);
+        };
 
-    this.on = (event, callback) => {
-      if (!this.events) this.events = {};
-      this.events[event] = callback;
-    };
+        // 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) => {
+            const fetchEmitter = {
+                on: (event, callback) => {
+                    if (event === 'message') {
+                        setTimeout(() => {
+                            const mockMessage = {
+                                on: (messageEvent, messageCallback) => {
+                                    if (messageEvent === 'body') {
+                                        setTimeout(() => {
+                                            // Return a mock email body that will be parsed
+                                            const mockEmailContent = `From: sender@test.com\r\nTo: recipient@test.com\r\nSubject: Mock Email Subject\r\n\r\nThis is a mock email body for testing purposes.`;
+                                            messageCallback(Buffer.from(mockEmailContent));
+                                        }, 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;
+                    }
+                },
+            };
 
-    // Additional IMAP methods that might be used
-    this.addFlags = (source, flags, callback) => {
-      setTimeout(() => callback(null), 5);
-    };
+            // Store the fetch emitter so we can trigger events manually in tests
+            this.lastFetchEmitter = fetchEmitter;
+            return fetchEmitter;
+        };
 
-    this.removeFlags = (source, flags, callback) => {
-      setTimeout(() => callback(null), 5);
-    };
+        // 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;
+        };
+
+        this.on = (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);
+        };
+
+        // Helper method to trigger the email processing flow
+        this.simulateNewEmail = (emailData = {}) => {
+            if (this.events && this.events.mail) {
+                setTimeout(() => {
+                    this.events.mail(1); // Simulate 1 new email
+                }, 10);
+            }
+        };
 
-    // Helper method to trigger the email processing flow
-    this.simulateNewEmail = (emailData = {}) => {
-      if (this.events && this.events.mail) {
-        setTimeout(() => {
-          this.events.mail(1); // Simulate 1 new email
-        }, 10);
-      }
+        return this;
     };
-
-    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' }]
+    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 || [],
+            });
         },
-        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
+ * Enhanced module mocks setup with better email simulation
  */
-function createMockNodeRED(options = {}) {
-  // Store input callback in the mock RED context
-  let storedInputCallback = null;
-  let nodeInstance = null;
-
-  const mockRED = {
-    nodes: {
-      createNode: function(node, config) {
-        nodeInstance = node; // Capture the node instance
-
-        // 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: function(event, callback) {
-            if (event === 'input') {
-              storedInputCallback = callback;
-              // Store the callback on the node instance for easy access
-              node.inputCallback = callback;
-            }
-            // Call the original onHandler if provided
-            if (options.onHandler) {
-              options.onHandler.call(node, event, callback);
-            }
-          },
-          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;
-      },
-      // Helper method to get the stored input callback
-      getInputCallback: function() {
-        return storedInputCallback;
-      },
-      // Helper method to get the node instance
-      getNodeInstance: function() {
-        return nodeInstance;
-      }
-    },
-    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;
-          }
-        }
+function setupModuleMocks() {
+    const mockModules = {
+        'node-imap': createMockImap(),
+        mailparser: createMockMailparser(),
+    };
+
+    const Module = require('module');
+    const originalLoad = Module._load;
 
-        // Simple mock implementation
-        if (callback) {
-          callback(null, value);
+    Module._load = function (request, parent) {
+        if (mockModules[request]) {
+            return mockModules[request];
         }
-        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() {}
-    }
-  };
-
-  return mockRED;
-}
+        return originalLoad.apply(this, arguments);
+    };
 
-/**
- * Enhanced module mocks setup with better email simulation
- */
-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;
-  };
+    // 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'
-  },
-
-  invalidFolderType: {
-    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,
-    folderType: 'num'
-  },
-
-  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: ["Inbox"],
-    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'
-  }
+    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',
+    },
+
+    invalidFolderType: {
+        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,
+        folderType: 'num',
+    },
+
+    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: ['Inbox'],
+        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' }
-  ]
+    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 and email simulation
  */
 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]);
-      }
-    });
-  }
+    /**
+     * 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
-};
+    createMockNodeRED,
+    createMockImap,
+    createMockMailparser,
+    setupModuleMocks,
+    testConfigs,
+    testFlows,
+    testUtils,
+};