Haraka 3.2.0 → 3.3.1

package/test/plugins/rcpt_to.host_list_base.js

@@ -2,16 +2,15 @@
 const assert = require('node:assert/strict')
 const { describe, it, beforeEach } = require('node:test')
 
-const { Address } = require('../../address')
-const fixtures = require('haraka-test-fixtures')
+const { Address } = require('@haraka/email-address')
+const { assertResult, makeConnection, makePlugin } = require('haraka-test-fixtures')
 
 const _set_up = () => {
-    this.plugin = new fixtures.plugin('rcpt_to.host_list_base')
+    this.plugin = makePlugin('rcpt_to.host_list_base', { register: false })
     this.plugin.cfg = {}
     this.plugin.host_list = {}
 
-    this.connection = fixtures.connection.createConnection()
-    this.connection.init_transaction()
+    this.connection = makeConnection({ withTxn: true })
 }
 
 describe('rcpt_to.host_list_base', () => {
@@ -78,8 +77,7 @@ describe('rcpt_to.host_list_base', () => {
             const { rc, msg } = await callMailHook('<user@example.com>')
             assert.equal(rc, undefined)
             assert.equal(msg, undefined)
-            const res = this.connection.transaction.results.get('rcpt_to.host_list_base')
-            assert.ok(res.msg.includes('mail_from!local'))
+            assertResult(this.connection.transaction, 'rcpt_to.host_list_base', 'msg', /^mail_from!local$/)
         })
 
         for (const [desc, setup] of [
@@ -97,8 +95,7 @@ describe('rcpt_to.host_list_base', () => {
                 const { rc, msg } = await callMailHook('<user@example.com>')
                 assert.equal(rc, undefined)
                 assert.equal(msg, undefined)
-                const res = this.connection.transaction.results.get('rcpt_to.host_list_base')
-                assert.ok(res.pass.includes('mail_from'))
+                assertResult(this.connection.transaction, 'rcpt_to.host_list_base', 'pass', /^mail_from$/)
             })
         }
     })

package/test/plugins/rcpt_to.in_host_list.js

@@ -2,21 +2,18 @@
 const assert = require('node:assert/strict')
 const { describe, it, beforeEach } = require('node:test')
 
-const { Address } = require('../../address')
+const { Address } = require('@haraka/email-address')
 const fixtures = require('haraka-test-fixtures')
+const { assertResult, makeConnection, makePlugin } = fixtures
 require('haraka-constants').import(global)
 
 const _set_up = () => {
-    this.plugin = new fixtures.plugin('rcpt_to.in_host_list')
+    this.plugin = makePlugin('rcpt_to.in_host_list', { register: false })
     this.plugin.inherits('rcpt_to.host_list_base')
     this.plugin.cfg = {}
     this.plugin.host_list = {}
 
-    this.connection = fixtures.connection.createConnection()
-    this.connection.transaction = {
-        results: new fixtures.results(this.connection),
-        notes: {},
-    }
+    this.connection = makeConnection({ withTxn: true })
 }
 
 describe('in_host_list', () => {
@@ -81,8 +78,7 @@ describe('in_host_list', () => {
             const { rc, msg } = await callMailHook('<user@example.com>')
             assert.equal(rc, undefined)
             assert.equal(msg, undefined)
-            const res = this.connection.transaction.results.get('rcpt_to.in_host_list')
-            assert.ok(res.msg.includes('mail_from!local'))
+            assertResult(this.connection.transaction, 'rcpt_to.in_host_list', 'msg', /^mail_from!local$/)
         })
 
         for (const [desc, setup] of [
@@ -100,8 +96,7 @@ describe('in_host_list', () => {
                 const { rc, msg } = await callMailHook('<user@example.com>')
                 assert.equal(rc, undefined)
                 assert.equal(msg, undefined)
-                const res = this.connection.transaction.results.get('rcpt_to.in_host_list')
-                assert.ok(res.pass.includes('mail_from'))
+                assertResult(this.connection.transaction, 'rcpt_to.in_host_list', 'pass', /^mail_from$/)
             })
         }
     })

package/test/plugins/record_envelope_addresses.js

@@ -3,13 +3,11 @@
 const assert = require('node:assert')
 const { describe, it, beforeEach } = require('node:test')
 
-const { Address } = require('../../address')
-const fixtures = require('haraka-test-fixtures')
+const { callMail, callRcpt, makeConnection, makePlugin } = require('haraka-test-fixtures')
 
 const _set_up = () => {
-    this.plugin = new fixtures.plugin('record_envelope_addresses')
-    this.connection = fixtures.connection.createConnection()
-    this.connection.init_transaction()
+    this.plugin = makePlugin('record_envelope_addresses')
+    this.connection = makeConnection({ withTxn: true })
 }
 
 describe('record_envelope_addresses', () => {
@@ -17,77 +15,52 @@ describe('record_envelope_addresses', () => {
 
     describe('hook_mail', () => {
         it('adds X-Envelope-From header from MAIL FROM address', (t, done) => {
-            const addr = new Address('<sender@example.com>')
-            this.plugin.hook_mail(
-                () => {
-                    const vals = this.connection.transaction.header.get_all('X-Envelope-From')
-                    assert.equal(vals.length, 1, 'header was added')
-                    assert.equal(vals[0], 'sender@example.com')
-                    done()
-                },
-                this.connection,
-                [addr],
-            )
+            callMail(this.plugin, this.connection, 'sender@example.com').then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-From')
+                assert.equal(vals.length, 1, 'header was added')
+                assert.equal(vals[0], 'sender@example.com')
+                done()
+            })
         })
 
         it('does not throw when connection has no transaction', (t, done) => {
             this.connection.transaction = null
-            const addr = new Address('<sender@example.com>')
-            this.plugin.hook_mail(
-                () => {
-                    assert.ok(true, 'next was called without error')
-                    done()
-                },
-                this.connection,
-                [addr],
-            )
+            callMail(this.plugin, this.connection, 'sender@example.com').then(() => {
+                assert.ok(true, 'next was called without error')
+                done()
+            })
         })
     })
 
     describe('hook_rcpt', () => {
         it('adds X-Envelope-To header from RCPT TO address', (t, done) => {
-            const addr = new Address('<rcpt@example.com>')
-            this.plugin.hook_rcpt(
-                () => {
-                    const vals = this.connection.transaction.header.get_all('X-Envelope-To')
-                    assert.equal(vals.length, 1, 'header was added')
-                    assert.equal(vals[0], 'rcpt@example.com')
-                    done()
-                },
-                this.connection,
-                [addr],
-            )
+            callRcpt(this.plugin, this.connection, 'rcpt@example.com').then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                assert.equal(vals.length, 1, 'header was added')
+                assert.equal(vals[0], 'rcpt@example.com')
+                done()
+            })
         })
 
         it('adds X-Envelope-To header for each recipient', (t, done) => {
-            const addr1 = new Address('<one@example.com>')
-            const addr2 = new Address('<two@example.com>')
-            let calls = 0
-            const next = () => {
-                calls++
-                if (calls === 2) {
-                    const vals = this.connection.transaction.header.get_all('X-Envelope-To')
-                    assert.equal(vals.length, 2, 'two headers added')
-                    assert.equal(vals[0], 'one@example.com')
-                    assert.equal(vals[1], 'two@example.com')
-                    done()
-                }
-            }
-            this.plugin.hook_rcpt(next, this.connection, [addr1])
-            this.plugin.hook_rcpt(next, this.connection, [addr2])
+            Promise.all([
+                callRcpt(this.plugin, this.connection, 'one@example.com'),
+                callRcpt(this.plugin, this.connection, 'two@example.com'),
+            ]).then(() => {
+                const vals = this.connection.transaction.header.get_all('X-Envelope-To')
+                assert.equal(vals.length, 2, 'two headers added')
+                assert.equal(vals[0], 'one@example.com')
+                assert.equal(vals[1], 'two@example.com')
+                done()
+            })
         })
 
         it('does not throw when connection has no transaction', (t, done) => {
             this.connection.transaction = null
-            const addr = new Address('<rcpt@example.com>')
-            this.plugin.hook_rcpt(
-                () => {
-                    assert.ok(true, 'next was called without error')
-                    done()
-                },
-                this.connection,
-                [addr],
-            )
+            callRcpt(this.plugin, this.connection, 'rcpt@example.com').then(() => {
+                assert.ok(true, 'next was called without error')
+                done()
+            })
         })
     })
 })

package/test/plugins/reseed_rng.js

@@ -3,12 +3,12 @@
 const assert = require('node:assert/strict')
 const { describe, it } = require('node:test')
 
-const fixtures = require('haraka-test-fixtures')
+const { makePlugin } = require('haraka-test-fixtures')
 
 describe('reseed_rng', () => {
     describe('hook_init_child', () => {
         it('calls Math.seedrandom with a hex string and calls next', (t, done) => {
-            const plugin = new fixtures.plugin('reseed_rng')
+            const plugin = makePlugin('reseed_rng', { register: false })
             let called = false
             let calledArg
             Math.seedrandom = (arg) => {
@@ -26,7 +26,7 @@ describe('reseed_rng', () => {
         })
 
         it('throws when Math.seedrandom is not defined', () => {
-            const plugin = new fixtures.plugin('reseed_rng')
+            const plugin = makePlugin('reseed_rng', { register: false })
             delete Math.seedrandom
             assert.throws(() => plugin.hook_init_child(() => {}), /Math\.seedrandom is not a function/)
         })

package/test/plugins/status.js

@@ -4,16 +4,15 @@ const assert = require('node:assert/strict')
 const { describe, it, beforeEach } = require('node:test')
 
 const fixtures = require('haraka-test-fixtures')
+const { makeConnection, makePlugin } = fixtures
 const outbound = require('../../outbound')
-const TimerQueue = require('../../outbound/timer_queue')
-
-const Connection = fixtures.connection
+const { TimerQueue } = require('haraka-utils')
 
 const _set_up = () => {
-    this.plugin = new fixtures.plugin('status')
+    this.plugin = makePlugin('status', { register: false })
     this.plugin.outbound = outbound
 
-    this.connection = Connection.createConnection()
+    this.connection = makeConnection()
     this.connection.remote.is_local = true
 }
 

package/test/plugins/tarpit.js

@@ -3,13 +3,13 @@
 const assert = require('node:assert/strict')
 const { describe, it, beforeEach } = require('node:test')
 
-const fixtures = require('haraka-test-fixtures')
+const { makeConnection, makePlugin } = require('haraka-test-fixtures')
 
 describe('tarpit', () => {
     let plugin
 
     beforeEach(() => {
-        plugin = new fixtures.plugin('tarpit')
+        plugin = makePlugin('tarpit', { register: false })
         plugin.config.get = () => ({ main: {} })
     })
 
@@ -40,8 +40,7 @@ describe('tarpit', () => {
         let conn
 
         beforeEach(() => {
-            conn = fixtures.connection.createConnection()
-            conn.init_transaction()
+            conn = makeConnection({ withTxn: true })
         })
 
         it('calls next immediately when no transaction', (t, done) => {

package/test/plugins/tls.js

@@ -4,15 +4,13 @@ const assert = require('node:assert/strict')
 const path = require('node:path')
 const { describe, it, beforeEach } = require('node:test')
 
-const fixtures = require('haraka-test-fixtures')
-const Plugin = fixtures.plugin
+const { makeConnection, makePlugin } = require('haraka-test-fixtures')
 
 const _set_up = () => {
-    this.plugin = new Plugin('tls')
-    this.connection = new fixtures.connection.createConnection()
+    this.plugin = makePlugin('tls', { register: false, configDir: 'test' })
+    this.connection = makeConnection()
 
     // use test/config instead of ./config
-    this.plugin.config = this.plugin.config.module_config(path.resolve('test'))
     this.plugin.net_utils.config = this.plugin.net_utils.config.module_config(path.resolve('test'))
 
     this.plugin.tls_opts = {}

package/test/plugins/toobusy.js

@@ -1,21 +1,198 @@
 'use strict'
 
 const assert = require('node:assert/strict')
-const { describe, it } = require('node:test')
+const { beforeEach, describe, it } = require('node:test')
 
-const fixtures = require('haraka-test-fixtures')
+const { makeConnection, makePlugin } = require('haraka-test-fixtures')
+require('haraka-constants').import(global)
 
 describe('toobusy', () => {
+    let plugin
+
+    beforeEach(() => {
+        plugin = makePlugin('toobusy', { register: false })
+    })
+
     describe('register', () => {
-        it('handles missing toobusy-js gracefully (does not throw)', () => {
-            const plugin = new fixtures.plugin('toobusy')
-            // toobusy-js is not installed; register should catch the error and return
-            let registered = false
-            plugin.register_hook = () => {
-                registered = true
+        it('registers connect hook with correct priority', () => {
+            const hooks = []
+            plugin.register_hook = function (hook, name, priority) {
+                hooks.push({ hook, name, priority })
             }
+
+            plugin.register()
+
+            assert.equal(hooks.length, 1, 'should register one hook')
+            assert.equal(hooks[0].hook, 'connect')
+            assert.equal(hooks[0].name, 'check_busy')
+            assert.equal(hooks[0].priority, -100)
+        })
+
+        it('loads config on register', () => {
+            let loadConfigCalled = false
+            const originalLoadConfig = plugin.loadConfig
+            plugin.loadConfig = function () {
+                loadConfigCalled = true
+                return originalLoadConfig.call(this)
+            }
+
+            plugin.register()
+
+            assert.equal(loadConfigCalled, true, 'loadConfig should be called')
+        })
+
+        it('handles missing toobusy-js gracefully', () => {
             assert.doesNotThrow(() => plugin.register())
-            assert.equal(registered, false, 'hook should not be registered without toobusy-js')
+        })
+    })
+
+    describe('loadConfig', () => {
+        beforeEach(() => {
+            plugin.register()
+        })
+
+        it('gets toobusy.maxlag config value', () => {
+            let configArgs = []
+
+            plugin.config.get = function (key, type, callback) {
+                configArgs = [key, type]
+                return '70'
+            }
+
+            plugin.loadConfig()
+
+            assert.equal(configArgs[0], 'toobusy.maxlag')
+            assert.equal(configArgs[1], 'value')
+        })
+
+        it('passes callback to config.get for hot reload', () => {
+            let callbackProvided = false
+
+            plugin.config.get = function (key, type, callback) {
+                callbackProvided = typeof callback === 'function'
+                return '70'
+            }
+
+            plugin.loadConfig()
+
+            assert.equal(callbackProvided, true, 'callback should be provided for hot reload')
+        })
+
+        it('handles zero maxLag value', () => {
+            plugin.config.get = () => '0'
+
+            assert.doesNotThrow(() => {
+                plugin.loadConfig()
+            })
+        })
+
+        it('handles non-numeric maxLag value', () => {
+            plugin.config.get = () => 'notanumber'
+
+            assert.doesNotThrow(() => {
+                plugin.loadConfig()
+            })
+        })
+
+        it('handles empty string maxLag value', () => {
+            plugin.config.get = () => ''
+
+            assert.doesNotThrow(() => {
+                plugin.loadConfig()
+            })
+        })
+
+        it('parses numeric maxLag as integer', () => {
+            plugin.config.get = () => '100'
+
+            assert.doesNotThrow(() => {
+                plugin.loadConfig()
+            })
+        })
+
+        it('supports reload via callback', () => {
+            let callbackFn = null
+
+            plugin.config.get = function (key, type, callback) {
+                callbackFn = callback
+                return '70'
+            }
+
+            plugin.loadConfig()
+
+            assert.equal(typeof callbackFn, 'function', 'callback should be provided')
+            assert.doesNotThrow(() => {
+                if (callbackFn) callbackFn()
+            })
+        })
+    })
+
+    describe('check_busy', () => {
+        beforeEach(() => {
+            plugin.register()
+        })
+
+        it('calls next without args when not busy', (t, done) => {
+            plugin.config.get = () => '70'
+            plugin.loadConfig()
+
+            plugin.check_busy(function (...args) {
+                assert.equal(args.length, 0, 'should call next with no arguments')
+                done()
+            })
+        })
+
+        it('initializes was_busy state', (t, done) => {
+            plugin.config.get = () => '70'
+            plugin.loadConfig()
+
+            plugin.check_busy(function () {
+                done()
+            })
+        })
+
+        it('is a callable function', () => {
+            assert.equal(typeof plugin.check_busy, 'function')
+        })
+
+        it('does not log when not busy', (t, done) => {
+            plugin.config.get = () => '70'
+            plugin.loadConfig()
+
+            let logCount = 0
+            plugin.logcrit = function () {
+                logCount++
+            }
+
+            plugin.check_busy(function () {
+                plugin.check_busy(function () {
+                    assert.equal(logCount, 0, 'should not log when not busy')
+                    done()
+                })
+            })
+        })
+
+        it('accepts next callback', (t, done) => {
+            plugin.config.get = () => '70'
+            plugin.loadConfig()
+
+            const nextFn = function () {
+                done()
+            }
+
+            assert.doesNotThrow(() => {
+                plugin.check_busy(nextFn)
+            })
+        })
+
+        it('works with connection context', (t, done) => {
+            plugin.config.get = () => '70'
+            plugin.loadConfig()
+
+            const conn = makeConnection()
+            plugin.check_busy.call(conn, function () {
+                done()
+            })
         })
     })
 })

package/test/plugins/xclient.js

@@ -3,11 +3,11 @@
 const assert = require('node:assert/strict')
 const { describe, it, beforeEach } = require('node:test')
 
-const fixtures = require('haraka-test-fixtures')
+const { makeConnection, makePlugin } = require('haraka-test-fixtures')
 
 const _set_up = () => {
-    this.plugin = new fixtures.plugin('xclient')
-    this.connection = fixtures.connection.createConnection()
+    this.plugin = makePlugin('xclient', { register: false })
+    this.connection = makeConnection()
     this.connection.capabilities = []
 }
 
@@ -45,7 +45,10 @@ describe('xclient', () => {
             },
             {
                 desc: 'denies XCLIENT when transaction is in progress',
-                setup: () => this.connection.init_transaction(),
+                setup: () => {
+                    this.connection = makeConnection({ withTxn: true })
+                    this.connection.capabilities = []
+                },
                 params: ['XCLIENT', 'ADDR=127.0.0.1'],
                 check: (code) => assert.equal(code, DENY),
             },