Haraka 3.1.4 → 3.1.6

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

@@ -26,151 +26,107 @@ const queue_dir = path.resolve(__dirname, '../test-queue')
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-const ensureQueueDir = () =>
+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) => {
-        fs.exists(queue_dir, (exists) => {
-            if (exists) return resolve()
-            fs.mkdir(queue_dir, (err) => (err ? reject(err) : resolve()))
-        })
+        util_hmailitem.newMockHMailItem(ctx, reject, opts, resolve)
     })
 
-const cleanQueueDir = () =>
+/**
+ * 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) => {
-        fs.exists(queue_dir, (exists) => {
-            if (!exists) return resolve()
+        const orig = HMailItem.prototype[method]
+        HMailItem.prototype[method] = function () {
             try {
-                for (const file of fs.readdirSync(queue_dir)) {
-                    const full = path.resolve(queue_dir, file)
-                    if (fs.lstatSync(full).isDirectory()) return reject(new Error(`unexpected subdirectory: ${full}`))
-                    fs.unlinkSync(full)
-                }
+                assertion(this)
                 resolve()
-            } catch (err) {
-                reject(err)
+            } catch (e) {
+                reject(e)
+            } finally {
+                HMailItem.prototype[method] = orig
             }
-        })
-    })
-
-/** 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)
+        }
+        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)
 
-    it('get_mx=DENY triggers bounce with dsn_status 5.1.2', async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.bounce
-            HMailItem.prototype.bounce = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '5.1.2', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.bounce = orig
-                }
-            }
-            mock_hmail.domain = mock_hmail.todo.domain
-            HMailItem.prototype.get_mx_respond.apply(mock_hmail, [constants.deny, {}])
-        })
-    })
-
-    it('get_mx=DENYSOFT triggers temp_fail with dsn_status 4.1.2', async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.temp_fail
-            HMailItem.prototype.temp_fail = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '4.1.2', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.temp_fail = orig
-                }
-            }
-            mock_hmail.domain = mock_hmail.todo.domain
-            HMailItem.prototype.get_mx_respond.apply(mock_hmail, [constants.denysoft, {}])
-        })
-    })
-
-    it('get_mx_error({code:NXDOMAIN}) triggers bounce with dsn_status 5.1.2', async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.bounce
-            HMailItem.prototype.bounce = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '5.1.2', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.bounce = orig
-                }
-            }
-            HMailItem.prototype.get_mx_error.apply(mock_hmail, [{ code: dns.NXDOMAIN }])
-        })
-    })
-
-    it("get_mx_error({code:'SOME-OTHER-ERR'}) triggers temp_fail with dsn_status 4.1.0", async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.temp_fail
-            HMailItem.prototype.temp_fail = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '4.1.0', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.temp_fail = orig
-                }
-            }
-            HMailItem.prototype.get_mx_error.apply(mock_hmail, [{ code: 'SOME-OTHER-ERR' }, {}])
+    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),
+            )
         })
-    })
-
-    it("found_mx(null, [{priority:0,exchange:''}]) triggers bounce with dsn_status 5.1.2", async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.bounce
-            HMailItem.prototype.bounce = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '5.1.2', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.bounce = orig
-                }
-            }
-            HMailItem.prototype.found_mx.apply(mock_hmail, [[{ priority: 0, exchange: '' }]])
-        })
-    })
-
-    it('try_deliver with empty mxlist triggers temp_fail with dsn_status 5.1.2', async () => {
-        const mock_hmail = await mockHMailItem(outbound_context)
-        mock_hmail.mxlist = []
-        await new Promise((resolve, reject) => {
-            const orig = HMailItem.prototype.temp_fail
-            HMailItem.prototype.temp_fail = function (err, opts) {
-                try {
-                    assert.equal(this.todo.rcpt_to[0].dsn_status, '5.1.2', 'dsn status')
-                    resolve()
-                } catch (e) {
-                    reject(e)
-                } finally {
-                    HMailItem.prototype.temp_fail = orig
-                }
-            }
-            HMailItem.prototype.try_deliver.apply(mock_hmail, [])
-        })
-    })
+    }
 })