Haraka 3.0.2 → 3.0.4

package/{tests → test}/fixtures/util_hmailitem.js

@@ -1,29 +1,26 @@
 'use strict';
 
-const { Address }     = require('address-rfc2821');
-const fixtures        = require('haraka-test-fixtures');
-const stub_connection = fixtures.connection;
-// const transaction     = fixtures.transaction;  // not yet sufficient
-const transaction     = require('../../transaction');
+const assert = require('node:assert')
 
+const { Address } = require('address-rfc2821');
+const fixtures = require('haraka-test-fixtures');
 
 /**
  * Creates a HMailItem instance, which is passed to callback. Reports error on test param if creation fails.
  *
  * @param outbound_context
- * @param test
  * @param options
  * @param callback
  */
-exports.newMockHMailItem = (outbound_context, test, options, callback) => {
+exports.newMockHMailItem = (outbound_context, done, options, callback) => {
     const opts = options || {};
     exports.createHMailItem(
         outbound_context,
         opts,
         (err, hmail) => {
             if (err) {
-                test.ok(false, `Could not create HMailItem: ${err}`);
-                test.done();
+                assert.ok(false, `Could not create HMailItem: ${err}`);
+                done()
                 return;
             }
             if (!hmail.todo) {
@@ -41,7 +38,7 @@ exports.newMockHMailItem = (outbound_context, test, options, callback) => {
 /**
  * Creates a HMailItem instance for testing purpose
  *
- * @param outbound_context: The context of the outbound.js, e.g. from require('nodeunit').utils.sandbox("outbound.js")
+ * @param outbound_context: The context of outbound, e.g. from require('outbound/index.js')
  * @param options
  * @param callback(err, hmail)
  */
@@ -51,8 +48,8 @@ exports.createHMailItem = (outbound_context, options, callback) => {
     const delivery_domain = options.delivery_domain || 'domain';
     const mail_recipients = options.mail_recipients || [new Address('recipient@domain')];
 
-    const conn = stub_connection.createConnection();
-    conn.transaction = transaction.createTransaction('someuuid');
+    const conn = fixtures.connection.createConnection();
+    conn.init_transaction()
     conn.transaction.mail_from = new Address(mail_from);
 
     const todo = new outbound_context.TODOItem(delivery_domain, mail_recipients, conn.transaction);
@@ -82,11 +79,7 @@ exports.createHMailItem = (outbound_context, options, callback) => {
 
     const hmails = [];
     const ok_paths = [];
-    outbound_context.exports.process_delivery(ok_paths, todo, hmails, err => {
-        if (err) {
-            callback(`process_delivery error: ${err}`);
-            return;
-        }
+    outbound_context.exports.process_delivery(ok_paths, todo, hmails).then(() => {
         if (hmails.length == 0) {
             callback('No hmail producted');
             return;
@@ -95,8 +88,10 @@ exports.createHMailItem = (outbound_context, options, callback) => {
             hmail.hostlist = [ delivery_domain ];
             callback(null, hmail);
         }
-    });
-
+    })
+    .catch(err => {
+        callback(`process_delivery error: ${err}`);
+    })
 }
 
 /**
@@ -105,7 +100,7 @@ exports.createHMailItem = (outbound_context, options, callback) => {
  * @param test
  * @param playbook
  */
-exports.playTestSmtpConversation = (hmail, socket, test, playbook, callback) => {
+exports.playTestSmtpConversation = (hmail, socket, done, playbook, callback) => {
     const testmx = {
         bind_helo: "haraka.test",
         exchange: "remote.testhost",
@@ -115,17 +110,17 @@ exports.playTestSmtpConversation = (hmail, socket, test, playbook, callback) =>
     socket.write = line => {
         //console.log('MockSocket.write(' + line.replace(/\n/, '\\n').replace(/\r/, '\\r') + ')');
         if (playbook.length == 0) {
-            test.ok(false, 'missing next playbook entry');
-            test.done();
+            assert.ok(false, 'missing next playbook entry');
+            done()
             return;
         }
         let expected;
         while (false != (expected = getNextEntryFromPlaybook('haraka', playbook))) {
             if (typeof expected.test === 'function') {
-                test.ok(expected.test(line), expected.description || `Expected that line works with func: ${expected.test}`);
+                assert.ok(expected.test(line), expected.description || `Expected that line works with func: ${expected.test}`);
             }
             else {
-                test.equals(`${expected.test}\r\n`, line, expected.description || `Expected that line equals: ${expected.test}`);
+                assert.equal(`${expected.test}\r\n`, line, expected.description || `Expected that line equals: ${expected.test}`);
             }
             if (expected.end_test === true) {
                 setTimeout(() => {
@@ -144,7 +139,6 @@ exports.playTestSmtpConversation = (hmail, socket, test, playbook, callback) =>
 
     const welcome = getNextEntryFromPlaybook('remote', playbook);
     socket.emit('line', welcome.line);
-
 }
 
 function getNextEntryFromPlaybook (ofType, playbook) {

package/{tests → test}/host_pool.js

@@ -1,24 +1,21 @@
 "use strict";
 
+const assert = require('node:assert')
+
 const HostPool = require('../host_pool');
 
-exports.HostPool = {
-    "get a host": test => {
-        test.expect(2);
+describe('HostPool', () => {
+    it("get a host", (done) => {
 
         const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222');
-
         const host = pool.get_host();
 
-        test.ok( /\d\.\d\.\d\.\d/.test(host.host),
-            `'${host.host}' looks like a IP`);
-        test.ok( /\d\d\d\d/.test(host.port),
-            `'${host.port}' looks like a port`);
+        assert.ok( /\d\.\d\.\d\.\d/.test(host.host), `'${host.host}' looks like a IP`);
+        assert.ok( /\d\d\d\d/.test(host.port), `'${host.port}' looks like a port`);
+        done()
+    })
 
-        test.done();
-    },
-    "uses all the list": test => {
-        test.expect(3);
+    it("uses all the list", (done) => {
 
         const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222');
 
@@ -26,29 +23,24 @@ exports.HostPool = {
         const host2 = pool.get_host();
         const host3 = pool.get_host();
 
-        test.notEqual(host1.host, host2.host);
-        test.notEqual(host3.host, host2.host);
-        test.equal(host3.host, host1.host);
-
-        test.done();
-    },
-    "default port 25": test => {
-        test.expect(2);
+        assert.notEqual(host1.host, host2.host);
+        assert.notEqual(host3.host, host2.host);
+        assert.equal(host3.host, host1.host);
+        done()
+    })
 
+    it("default port 25", (done) => {
         const pool = new HostPool('1.1.1.1, 2.2.2.2');
 
         const host1 = pool.get_host();
         const host2 = pool.get_host();
 
-        test.equal(host1.port, 25, `is port 25: ${host1.port}`);
-        test.equal(host2.port, 25, `is port 25: ${host2.port}`);
-
-        test.done();
-    },
-
-    "dead host": test => {
-        test.expect(3);
+        assert.equal(host1.port, 25, `is port 25: ${host1.port}`);
+        assert.equal(host2.port, 25, `is port 25: ${host2.port}`);
+        done()
+    })
 
+    it("dead host", (done) => {
         const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222');
 
         pool.failed('1.1.1.1', '1111');
@@ -56,20 +48,18 @@ exports.HostPool = {
         let host;
 
         host = pool.get_host();
-        test.equal(host.host, '2.2.2.2', 'dead host is not returned');
+        assert.equal(host.host, '2.2.2.2', 'dead host is not returned');
         host = pool.get_host();
-        test.equal(host.host, '2.2.2.2', 'dead host is not returned');
+        assert.equal(host.host, '2.2.2.2', 'dead host is not returned');
         host = pool.get_host();
-        test.equal(host.host, '2.2.2.2', 'dead host is not returned');
-
-        test.done();
-    },
+        assert.equal(host.host, '2.2.2.2', 'dead host is not returned');
+        done()
+    })
 
     // if they're *all* dead, we return a host to try anyway, to keep from
     // accidentally DOS'ing ourselves if there's a transient but widespread
     // network outage
-    "they're all dead": test => {
-        test.expect(6);
+    it("they're all dead", (done) => {
 
         let host1;
         let host2;
@@ -82,26 +72,23 @@ exports.HostPool = {
         pool.failed('2.2.2.2', '2222');
 
         host2 = pool.get_host();
-        test.ok (host2, "if they're all dead, try one anyway");
-        test.notEqual(host1.host, host2.host, "rotation continues");
+        assert.ok (host2, "if they're all dead, try one anyway");
+        assert.notEqual(host1.host, host2.host, "rotation continues");
 
         host1 = pool.get_host();
-        test.ok (host1, "if they're all dead, try one anyway");
-        test.notEqual(host1.host, host2.host, "rotation continues");
+        assert.ok (host1, "if they're all dead, try one anyway");
+        assert.notEqual(host1.host, host2.host, "rotation continues");
 
         host2 = pool.get_host();
-        test.ok (host2, "if they're all dead, try one anyway");
-        test.notEqual(host1.host, host2.host, "rotation continues");
-
-        test.done();
-    },
-
+        assert.ok (host2, "if they're all dead, try one anyway");
+        assert.notEqual(host1.host, host2.host, "rotation continues");
+        done()
+    })
 
     // after .01 secs the timer to retry the dead host will fire, and then
     // we connect using this mock socket, whose "connect" always succeeds
     // so the code brings the dead host back to life
-    "host dead checking timer": test => {
-        test.expect(2);
+    it("host dead checking timer", (done) => {
 
         let num_reqs = 0;
         const MockSocket = function MockSocket (pool) {
@@ -144,7 +131,6 @@ exports.HostPool = {
                 }
             };
             this.destroy = () => {};
-
         };
 
         const retry_secs = 0.001; // 1ms
@@ -156,24 +142,23 @@ exports.HostPool = {
         // mark the host as failed and start up the retry timers
         pool.failed('1.1.1.1', '1111');
 
-        test.ok(pool.dead_hosts["1.1.1.1:1111"], 'yes it was marked dead');
+        assert.ok(pool.dead_hosts["1.1.1.1:1111"], 'yes it was marked dead');
 
         // probe_dead_host() will hit two failures and one success (based on
         // num_reqs above). So we wait at least 10s for that to happen:
         const timer = setTimeout(() => {
             clearInterval(interval);
-            test.ok(false, 'probe_dead_host failed');
-            test.done();
+            assert.ok(false, 'probe_dead_host failed');
+            done()
         }, 10 * 1000);
 
         const interval = setInterval(() => {
             if (!pool.dead_hosts["1.1.1.1:1111"]) {
                 clearTimeout(timer);
                 clearInterval(interval);
-                test.ok(true, 'timer un-deaded it');
-                test.done();
+                assert.ok(true, 'timer un-deaded it');
+                done()
             }
         }, retry_secs * 1000 * 3 );
-
-    }
-}
+    })
+})

package/test/logger.js

@@ -0,0 +1,258 @@
+const assert = require('node:assert')
+const util = require('node:util');
+
+const _set_up = (done) => {
+    this.logger = require('../logger');
+    done();
+}
+
+describe('logger', () => {
+    beforeEach(_set_up)
+
+    describe('init', () => {
+        it('logger', () => {
+            assert.ok(this.logger);
+        })
+    })
+
+    describe('log', () => {
+        it('log', () => {
+            this.logger.deferred_logs = [];
+            assert.equal(0, this.logger.deferred_logs.length);
+            assert.ok(this.logger.log('WARN','test warning'));
+            assert.equal(1, this.logger.deferred_logs.length);
+        })
+
+        it('log, w/deferred', () => {
+            this.logger.plugins = { plugin_list: true };
+            this.logger.deferred_logs.push( { level: 'INFO', data: 'log test info'} );
+            assert.ok(this.logger.log('INFO', 'another test info'));
+        })
+
+        it('log in logfmt', () => {
+            this.logger.deferred_logs = [];
+            this.logger.format = this.logger.formats.LOGFMT;
+            assert.equal(0, this.logger.deferred_logs.length);
+            assert.ok(this.logger.log('WARN','test warning'));
+            assert.equal(1, this.logger.deferred_logs.length);
+        })
+
+        it('log in logfmt w/deferred', () => {
+            this.logger.plugins = { plugin_list: true };
+            this.logger.deferred_logs.push( { level: 'INFO', data: 'log test info'} );
+            assert.ok(this.logger.log('INFO', 'another test info'));
+        })
+
+        it('log in json', () => {
+            this.logger.deferred_logs = [];
+            this.logger.format = this.logger.formats.JSON;
+            assert.equal(0, this.logger.deferred_logs.length);
+            assert.ok(this.logger.log('WARN','test warning'));
+            assert.equal(1, this.logger.deferred_logs.length);
+        })
+
+        it('log in json w/deferred', () => {
+            this.logger.plugins = { plugin_list: true };
+            this.logger.deferred_logs.push( { level: 'INFO', data: 'log test info'} );
+            assert.ok(this.logger.log('INFO', 'another test info'));
+        })
+    })
+
+    describe('level', () => {
+        it('both INFO and LOGINFO are log levels', () => {
+            assert.equal(this.logger.levels.INFO, 6);
+            assert.equal(this.logger.levels.LOGINFO, 6);
+        })
+
+    })
+
+    describe('set_format', () => {
+        it('set format to DEFAULT', () => {
+            this.logger.format = '';
+            this.logger.set_format('DEFAULT');
+            assert.equal(this.logger.format, this.logger.formats.DEFAULT);
+        })
+
+        it('set format to LOGFMT', () => {
+            this.logger.format = '';
+            this.logger.set_format('LOGFMT');
+            assert.equal(this.logger.format, this.logger.formats.LOGFMT);
+        })
+
+        it('set format to JSON', () => {
+            this.logger.format = '';
+            this.logger.set_format('JSON');
+            assert.equal(this.logger.format, this.logger.formats.JSON);
+        })
+
+        it('set format to DEFAULT if empty', () => {
+            this.logger.format = '';
+            this.logger.set_format('');
+            assert.equal(this.logger.format, this.logger.formats.DEFAULT);
+        })
+
+        it('set format to DEFAULT if lowercase', () => {
+            this.logger.format = '';
+            this.logger.set_format('default');
+            assert.equal(this.logger.format, this.logger.formats.DEFAULT);
+        })
+
+        it('set format to DEFAULT if invalid', () => {
+            this.logger.format = '';
+            this.logger.set_format('invalid');
+            assert.equal(this.logger.format, this.logger.formats.DEFAULT);
+        })
+
+    })
+
+    describe('set_loglevel', () => {
+        it('set loglevel to LOGINFO', () => {
+            this.logger.set_loglevel('LOGINFO');
+            assert.equal(this.logger.loglevel, this.logger.levels.LOGINFO);
+        })
+
+        it('set loglevel to INFO', () => {
+            this.logger.set_loglevel('INFO');
+            assert.equal(this.logger.loglevel, this.logger.levels.INFO);
+        })
+
+        it('set loglevel to EMERG', () => {
+            this.logger.set_loglevel('emerg');
+            assert.equal(this.logger.loglevel, this.logger.levels.EMERG);
+        })
+
+        it('set loglevel to 6', () => {
+            this.logger.set_loglevel(6);
+            assert.equal(this.logger.loglevel, 6);
+        })
+
+        it('set loglevel to WARN if invalid', () => {
+            this.logger.set_loglevel('invalid');
+            assert.equal(this.logger.loglevel, this.logger.levels.WARN);
+        })
+    })
+
+    describe('set_timestamps', () => {
+        it('set timestamps to false', () => {
+            this.logger.timestamps = undefined;
+            this.logger.set_timestamps(false);
+            assert.equal(this.logger.timestamps, false);
+        })
+
+        it('set timestamps to true', () => {
+            this.logger.timestamps = undefined;
+            this.logger.set_timestamps(true);
+            assert.equal(this.logger.timestamps, true);
+        })
+    })
+
+    describe('would_log', () => {
+        it('should', () => {
+            this.logger.loglevel = 4;
+            assert.equal(false, this.logger.would_log(7));
+            assert.equal(false, this.logger.would_log(6));
+            assert.equal(false, this.logger.would_log(5));
+        })
+
+        it('should not', () => {
+            this.logger.loglevel = 4;
+            assert.equal(true, this.logger.would_log(4));
+            assert.equal(true, this.logger.would_log(3));
+            assert.equal(true, this.logger.would_log(2));
+            assert.equal(true, this.logger.would_log(1));
+        })
+    })
+
+    describe('log_respond', () => {
+        it('invalid retval', () => {
+            assert.equal(false, this.logger.log_respond(901));
+        })
+
+        it('valid retval', () => {
+            const data = { level: 'INFO', data: "test data" };
+            assert.equal(true, this.logger.log_respond(900, 'test msg', data));
+        })
+    })
+
+    describe('dump_logs', () => {
+        it('empty', () => {
+            assert.ok(this.logger.dump_logs(0));
+        })
+
+        it('with deferred', () => {
+            this.logger.deferred_logs.push( { level: 'info', data: 'test info'} );
+            this.logger.deferred_logs.push( { level: 'INFO', data: 'test info, color'} );
+            this.logger.deferred_logs.push( { level: 'WARN', data: 'test warn, color'} );
+            assert.ok(this.logger.dump_logs(0));
+            assert.ok(this.logger.deferred_logs.length === 0);
+        })
+    })
+
+    describe('colors', () => {
+        it('colors', () => {
+            assert.ok(this.logger.colors);
+        })
+
+        it('colorize', () => {
+            assert.ok(this.logger.colorize);
+            assert.equal('function', typeof this.logger.colorize);
+            assert.equal('error', this.logger.colorize('bad-color', 'error'));
+            const expected = util.inspect.colors ? '\u001b[34mgood\u001b[39m' : 'good';
+            assert.equal(expected, this.logger.colorize('blue', 'good'));
+        })
+    })
+
+    describe('log_if_level', () => {
+        it('log_if_level is a function', () => {
+            assert.ok('function' === typeof this.logger.log_if_level);
+        })
+
+        it('log_if_level test log entry', () => {
+            this.logger.loglevel = 9;
+            const f = this.logger.log_if_level('INFO', 'LOGINFO');
+            assert.ok(f);
+            assert.ok('function' === typeof f);
+            assert.ok(f('test info message'));
+            assert.equal(1, this.logger.deferred_logs.length);
+            // console.log(this.logger.deferred_logs[0]);
+            assert.equal('INFO', this.logger.deferred_logs[0].level);
+        })
+
+        it('log_if_level null case', () => {
+            this.logger.loglevel = 9;
+            const f = this.logger.log_if_level('INFO', 'LOGINFO');
+            assert.ok(f(null));
+            assert.equal(2, this.logger.deferred_logs.length);
+        })
+
+        it('log_if_level false', () => {
+            this.logger.loglevel = 9;
+            const f = this.logger.log_if_level('INFO', 'LOGINFO');
+            assert.ok(f(false));
+            assert.equal(3, this.logger.deferred_logs.length);
+        })
+
+        it('log_if_level 0', () => {
+            this.logger.loglevel = 9;
+            const f = this.logger.log_if_level('INFO', 'LOGINFO');
+            assert.ok(f(0));
+            assert.equal(4, this.logger.deferred_logs.length);
+        })
+    })
+
+    describe('add_log_methods', () => {
+        it('ignores non-objects', () => {
+            assert.equal(undefined, this.logger.add_log_methods(''));
+            assert.equal(undefined, this.logger.add_log_methods(function foo (){}));
+        })
+
+        it('adds functions to an object', () => {
+            const testObj = {};
+            this.logger.add_log_methods(testObj);
+            const levels = ['DATA','PROTOCOL','DEBUG','INFO','NOTICE','WARN','ERROR','CRIT','ALERT','EMERG'];
+            for (const level of levels) {
+                assert.ok('function' === typeof(testObj[`log${level.toLowerCase()}`]));
+            }
+        })
+    })
+})