Haraka 3.1.3 → 3.1.5

package/test/host_pool.js

@@ -1,20 +1,20 @@
 'use strict'
 
-const assert = require('node:assert')
+const { describe, it } = require('node:test')
+const assert = require('node:assert/strict')
 
 const HostPool = require('../host_pool')
 
 describe('HostPool', () => {
-    it('get a host', (done) => {
+    it('get a host', () => {
         const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
         const host = pool.get_host()
 
         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()
     })
 
-    it('uses all the list', (done) => {
+    it('uses all the list', () => {
         const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
 
         const host1 = pool.get_host()
@@ -24,10 +24,9 @@ describe('HostPool', () => {
         assert.notEqual(host1.host, host2.host)
         assert.notEqual(host3.host, host2.host)
         assert.equal(host3.host, host1.host)
-        done()
     })
 
-    it('default port 25', (done) => {
+    it('default port 25', () => {
         const pool = new HostPool('1.1.1.1, 2.2.2.2')
 
         const host1 = pool.get_host()
@@ -35,11 +34,24 @@ describe('HostPool', () => {
 
         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')
+    it('dead host', () => {
+        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222', 0.001)
+        pool.get_socket = () => ({
+            pretendTimeout: () => {},
+            setTimeout(ms, cb) {
+                this.pretendTimeout = cb
+            },
+            listeners: {},
+            on(ev, cb) {
+                this.listeners[ev] = cb
+            },
+            connect(port, host, cb) {
+                cb()
+            }, // immediately "connects" to stop retry loop
+            destroy() {},
+        })
 
         pool.failed('1.1.1.1', '1111')
 
@@ -51,17 +63,30 @@ describe('HostPool', () => {
         assert.equal(host.host, '2.2.2.2', 'dead host is not returned')
         host = pool.get_host()
         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
-    it("they're all dead", (done) => {
+    it("they're all dead", () => {
         let host1
         let host2
 
-        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
+        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222', 0.001)
+        pool.get_socket = () => ({
+            pretendTimeout: () => {},
+            setTimeout(ms, cb) {
+                this.pretendTimeout = cb
+            },
+            listeners: {},
+            on(ev, cb) {
+                this.listeners[ev] = cb
+            },
+            connect(port, host, cb) {
+                cb()
+            }, // immediately "connects" to stop retry loop
+            destroy() {},
+        })
 
         host1 = pool.get_host()
 
@@ -79,13 +104,12 @@ describe('HostPool', () => {
         host2 = pool.get_host()
         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
-    it('host dead checking timer', (done) => {
+    it('host dead checking timer', async () => {
         let num_reqs = 0
         const MockSocket = function MockSocket(pool) {
             // these are the methods called from probe_dead_host
@@ -141,22 +165,24 @@ describe('HostPool', () => {
 
         // 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)
-            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)
-                    assert.ok(true, 'timer un-deaded it')
-                    done()
-                }
-            },
-            retry_secs * 1000 * 3,
-        )
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                clearInterval(interval)
+                reject(new Error('probe_dead_host failed'))
+            }, 10 * 1000)
+
+            const interval = setInterval(
+                () => {
+                    if (!pool.dead_hosts['1.1.1.1:1111']) {
+                        clearTimeout(timer)
+                        clearInterval(interval)
+                        resolve()
+                    }
+                },
+                retry_secs * 1000 * 3,
+            )
+        })
+
+        assert.ok(true, 'timer un-deaded it')
     })
 })

package/test/logger.js

@@ -1,9 +1,11 @@
-const assert = require('node:assert')
+'use strict'
+
+const { describe, it, beforeEach } = require('node:test')
+const assert = require('node:assert/strict')
 const util = require('node:util')
 
-const _set_up = (done) => {
+const _set_up = () => {
     this.logger = require('../logger')
-    done()
 }
 
 describe('logger', () => {
@@ -16,55 +18,23 @@ describe('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',
+        const formats = ['DEFAULT', 'LOGFMT', 'JSON']
+
+        for (const fmt of formats) {
+            it(`log in ${fmt} format`, () => {
+                this.logger.deferred_logs = []
+                this.logger.format = this.logger.formats[fmt]
+                assert.ok(this.logger.log('WARN', 'test warning'))
+                assert.equal(this.logger.deferred_logs.length, 1)
             })
-            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',
+            it(`log in ${fmt} format w/deferred`, () => {
+                this.logger.format = this.logger.formats[fmt]
+                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'))
             })
-            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', () => {
@@ -75,68 +45,40 @@ describe('logger', () => {
     })
 
     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)
-        })
+        // [input, expected format key]
+        const cases = [
+            ['DEFAULT', 'DEFAULT'],
+            ['LOGFMT', 'LOGFMT'],
+            ['JSON', 'JSON'],
+            ['', 'DEFAULT'], // empty → DEFAULT
+            ['default', 'DEFAULT'], // case-insensitive → DEFAULT
+            ['invalid', 'DEFAULT'], // unknown → DEFAULT
+        ]
+        for (const [input, expectedKey] of cases) {
+            it(`set_format(${JSON.stringify(input)}) → ${expectedKey}`, () => {
+                this.logger.format = ''
+                this.logger.set_format(input)
+                assert.equal(this.logger.format, this.logger.formats[expectedKey])
+            })
+        }
     })
 
     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)
-        })
+        // [input, expected level key or null for numeric assertion]
+        const cases = [
+            ['LOGINFO', 'LOGINFO'],
+            ['INFO', 'INFO'],
+            ['emerg', 'EMERG'], // case-insensitive
+            [6, null], // numeric passthrough
+            ['invalid', 'WARN'], // unknown → WARN
+        ]
+        for (const [input, expectedKey] of cases) {
+            it(`set_loglevel(${JSON.stringify(input)}) → ${expectedKey ?? input}`, () => {
+                this.logger.set_loglevel(input)
+                const expected = expectedKey ? this.logger.levels[expectedKey] : input
+                assert.equal(this.logger.loglevel, expected)
+            })
+        }
     })
 
     describe('set_timestamps', () => {
@@ -219,40 +161,38 @@ describe('logger', () => {
     })
 
     describe('log_if_level', () => {
-        it('log_if_level is a function', () => {
-            assert.ok('function' === typeof this.logger.log_if_level)
+        it('is a function', () => {
+            assert.equal(typeof this.logger.log_if_level, 'function')
         })
 
-        it('log_if_level test log entry', () => {
+        it('returns a logging function', () => {
             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)
-        })
+            assert.equal(typeof f, 'function')
+        })
+
+        // Each of these runs independently with a fresh deferred_logs
+        for (const [label, msg] of [
+            ['string', 'test info message'],
+            ['null', null],
+            ['false', false],
+            ['0 (falsy number)', 0],
+        ]) {
+            it(`logs ${label} value and appends to deferred_logs`, () => {
+                this.logger.loglevel = 9
+                this.logger.deferred_logs = []
+                const f = this.logger.log_if_level('INFO', 'LOGINFO')
+                assert.ok(f(msg))
+                assert.equal(this.logger.deferred_logs.length, 1)
+            })
+        }
 
-        it('log_if_level 0', () => {
+        it('records correct level in deferred log entry', () => {
             this.logger.loglevel = 9
+            this.logger.deferred_logs = []
             const f = this.logger.log_if_level('INFO', 'LOGINFO')
-            assert.ok(f(0))
-            assert.equal(4, this.logger.deferred_logs.length)
+            f('test info message')
+            assert.equal(this.logger.deferred_logs[0].level, 'INFO')
         })
     })
 

package/test/outbound/bounce_net_errors.js

@@ -0,0 +1,132 @@
+'use strict'
+
+// Testing bounce email contents related to errors occurring during SMTP dialog.
+// Strategy: create an HMailItem via fixtures, invoke an outbound method, then
+// verify that the correct bounce/temp_fail handler is called.
+
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert')
+const dns = require('node:dns')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const constants = require('haraka-constants')
+
+// Load outbound/index FIRST to avoid the circular-dependency boot-order issue:
+// hmail.js → require('./index') while index.js is still loading causes queue.js
+// to capture a stale (empty) module.exports for hmail.js.
+const outbound = require('../../outbound')
+const HMailItem = outbound.HMailItem
+const TODOItem = require('../../outbound/todo')
+
+const util_hmailitem = require('../fixtures/util_hmailitem')
+
+const outbound_context = { TODOItem, exports: outbound }
+const queue_dir = path.resolve(__dirname, '../test-queue')
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+const ensureQueueDir = () => fs.promises.mkdir(queue_dir, { recursive: true })
+
+const cleanQueueDir = async () => {
+    if (!fs.existsSync(queue_dir)) return
+    for (const file of fs.readdirSync(queue_dir)) {
+        const full = path.resolve(queue_dir, file)
+        if (fs.lstatSync(full).isDirectory()) throw new Error(`unexpected subdirectory: ${full}`)
+        fs.unlinkSync(full)
+    }
+}
+
+/** Creates a mock HMailItem, resolving with it or rejecting on error. */
+const mockHMailItem = (ctx, opts = {}) =>
+    new Promise((resolve, reject) => {
+        util_hmailitem.newMockHMailItem(ctx, reject, opts, resolve)
+    })
+
+/**
+ * Intercepts `HMailItem.prototype[method]`, calls `assertion(this)` when invoked,
+ * then triggers the action under test via `trigger()`.
+ */
+const interceptAndAssert = (method, assertion, trigger) =>
+    new Promise((resolve, reject) => {
+        const orig = HMailItem.prototype[method]
+        HMailItem.prototype[method] = function () {
+            try {
+                assertion(this)
+                resolve()
+            } catch (e) {
+                reject(e)
+            } finally {
+                HMailItem.prototype[method] = orig
+            }
+        }
+        trigger()
+    })
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+// [method, dsn_status, optional setup fn, trigger fn, test name]
+const testCases = [
+    {
+        name: 'get_mx=DENY triggers bounce with dsn_status 5.1.2',
+        method: 'bounce',
+        status: '5.1.2',
+        setup: (h) => {
+            h.domain = h.todo.domain
+        },
+        trigger: (h) => HMailItem.prototype.get_mx_respond.apply(h, [constants.deny, {}]),
+    },
+    {
+        name: 'get_mx=DENYSOFT triggers temp_fail with dsn_status 4.1.2',
+        method: 'temp_fail',
+        status: '4.1.2',
+        setup: (h) => {
+            h.domain = h.todo.domain
+        },
+        trigger: (h) => HMailItem.prototype.get_mx_respond.apply(h, [constants.denysoft, {}]),
+    },
+    {
+        name: 'get_mx_error({code:NXDOMAIN}) triggers bounce with dsn_status 5.1.2',
+        method: 'bounce',
+        status: '5.1.2',
+        trigger: (h) => HMailItem.prototype.get_mx_error.apply(h, [{ code: dns.NXDOMAIN }]),
+    },
+    {
+        name: "get_mx_error({code:'SOME-OTHER-ERR'}) triggers temp_fail with dsn_status 4.1.0",
+        method: 'temp_fail',
+        status: '4.1.0',
+        trigger: (h) => HMailItem.prototype.get_mx_error.apply(h, [{ code: 'SOME-OTHER-ERR' }, {}]),
+    },
+    {
+        name: 'found_mx with empty exchange triggers bounce with dsn_status 5.1.2',
+        method: 'bounce',
+        status: '5.1.2',
+        trigger: (h) => HMailItem.prototype.found_mx.apply(h, [[{ priority: 0, exchange: '' }]]),
+    },
+    {
+        name: 'try_deliver with empty mxlist triggers temp_fail with dsn_status 5.1.2',
+        method: 'temp_fail',
+        status: '5.1.2',
+        setup: (h) => {
+            h.mxlist = []
+        },
+        trigger: (h) => HMailItem.prototype.try_deliver.apply(h, []),
+    },
+]
+
+describe('outbound_bounce_net_errors', () => {
+    beforeEach(ensureQueueDir)
+    afterEach(cleanQueueDir)
+
+    for (const { name, method, status, setup, trigger } of testCases) {
+        it(name, async () => {
+            const mock_hmail = await mockHMailItem(outbound_context)
+            if (setup) setup(mock_hmail)
+            await interceptAndAssert(
+                method,
+                (h) => assert.equal(h.todo.rcpt_to[0].dsn_status, status, 'dsn_status'),
+                () => trigger(mock_hmail),
+            )
+        })
+    }
+})