Haraka 3.2.0 → 3.3.1

package/test/host_pool.js

@@ -1,188 +0,0 @@
-'use strict'
-
-const { describe, it } = require('node:test')
-const assert = require('node:assert/strict')
-
-const HostPool = require('../host_pool')
-
-describe('HostPool', () => {
-    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`)
-    })
-
-    it('uses all the list', () => {
-        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
-
-        const host1 = pool.get_host()
-        const host2 = pool.get_host()
-        const host3 = pool.get_host()
-
-        assert.notEqual(host1.host, host2.host)
-        assert.notEqual(host3.host, host2.host)
-        assert.equal(host3.host, host1.host)
-    })
-
-    it('default port 25', () => {
-        const pool = new HostPool('1.1.1.1, 2.2.2.2')
-
-        const host1 = pool.get_host()
-        const host2 = pool.get_host()
-
-        assert.equal(host1.port, 25, `is port 25: ${host1.port}`)
-        assert.equal(host2.port, 25, `is port 25: ${host2.port}`)
-    })
-
-    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')
-
-        let host
-
-        host = pool.get_host()
-        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')
-        host = pool.get_host()
-        assert.equal(host.host, '2.2.2.2', 'dead host is not returned')
-    })
-
-    // 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", () => {
-        let host1
-        let host2
-
-        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()
-
-        pool.failed('1.1.1.1', '1111')
-        pool.failed('2.2.2.2', '2222')
-
-        host2 = pool.get_host()
-        assert.ok(host2, "if they're all dead, try one anyway")
-        assert.notEqual(host1.host, host2.host, 'rotation continues')
-
-        host1 = pool.get_host()
-        assert.ok(host1, "if they're all dead, try one anyway")
-        assert.notEqual(host1.host, host2.host, 'rotation continues')
-
-        host2 = pool.get_host()
-        assert.ok(host2, "if they're all dead, try one anyway")
-        assert.notEqual(host1.host, host2.host, 'rotation continues')
-    })
-
-    // 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', async () => {
-        let num_reqs = 0
-        const MockSocket = function MockSocket(pool) {
-            // these are the methods called from probe_dead_host
-
-            // setTimeout on the socket
-            this.pretendTimeout = () => {}
-            this.setTimeout = (ms, cb) => {
-                this.pretendTimeout = cb
-            }
-            // handle socket.on('error', ....
-            this.listeners = {}
-            this.on = (eventname, cb) => {
-                this.listeners[eventname] = cb
-            }
-            this.emit = (eventname) => {
-                this.listeners[eventname]()
-            }
-            // handle socket.connect(...
-            this.connected = () => {}
-            this.connect = (port, host, cb) => {
-                switch (++num_reqs) {
-                    case 1:
-                        // the first time through we pretend it timed out
-                        this.pretendTimeout()
-                        break
-                    case 2:
-                        // the second time through, pretend socket error
-                        this.emit('error')
-                        break
-                    case 3:
-                        // the third time around, the socket connected
-                        cb()
-                        break
-                    default:
-                        // failsafe
-                        console.log(`num_reqs hit ${num_reqs}, wtf?`)
-                        process.exit(1)
-                }
-            }
-            this.destroy = () => {}
-        }
-
-        const retry_secs = 0.001 // 1ms
-        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222', retry_secs)
-
-        // override the pool's get_socket method to return our mock
-        pool.get_socket = () => new MockSocket(pool)
-
-        // mark the host as failed and start up the retry timers
-        pool.failed('1.1.1.1', '1111')
-
-        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:
-        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/rfc1869.js

@@ -1,89 +0,0 @@
-'use strict'
-
-const { describe, it } = require('node:test')
-const assert = require('node:assert/strict')
-
-const { parse } = require('../rfc1869')
-
-function _check(line, expected) {
-    const match = /^(MAIL|RCPT)\s+(.*)$/.exec(line)
-    const parsed = parse(match[1].toLowerCase(), match[2])
-    assert.deepEqual(parsed, expected)
-}
-
-describe('rfc1869', () => {
-    describe('valid parse cases', () => {
-        const validCases = [
-            // MAIL FROM variants
-            ['MAIL FROM:<>', ['<>']],
-            ['MAIL FROM:', ['<>']],
-            ['MAIL FROM:<postmaster>', ['<postmaster>']],
-            ['MAIL FROM:user', ['user']],
-            ['MAIL FROM:user size=1234', ['user', 'size=1234']],
-            ['MAIL FROM:user@domain size=1234', ['user@domain', 'size=1234']],
-            ['MAIL FROM:<user@domain> size=1234', ['<user@domain>', 'size=1234']],
-            ['MAIL FROM:<user@domain> somekey', ['<user@domain>', 'somekey']],
-            ['MAIL FROM:<user@domain> somekey other=foo', ['<user@domain>', 'somekey', 'other=foo']],
-            // RFC 1652 BODY extension keyword
-            ['MAIL FROM:<user@domain> BODY=8BITMIME', ['<user@domain>', 'BODY=8BITMIME']],
-            // RFC 6531 SMTPUTF8 keyword (no value)
-            ['MAIL FROM:<user@domain> SMTPUTF8', ['<user@domain>', 'SMTPUTF8']],
-            // RCPT TO variants
-            ['RCPT TO: 0@mailblog.biz 0=9 1=9', ['<0@mailblog.biz>', '0=9', '1=9']],
-            ['RCPT TO:<r86x-ray@emailitin.com> state=1', ['<r86x-ray@emailitin.com>', 'state=1']],
-            ['RCPT TO:<user=name@domain.com> foo=bar', ['<user=name@domain.com>', 'foo=bar']],
-            ['RCPT TO:<postmaster>', ['<postmaster>']],
-            ['RCPT TO:<abuse>', ['<abuse>']],
-        ]
-
-        for (const [line, expected] of validCases) {
-            it(line, () => _check(line, expected))
-        }
-    })
-
-    describe('error cases', () => {
-        const throwCases = [
-            {
-                desc: 'MAIL FROM with space inside angle-bracket address',
-                args: ['mail', 'FROM:<user@dom ain>'],
-            },
-            {
-                desc: 'RCPT TO with syntax error in address (space in address)',
-                args: ['rcpt', 'TO: user @domain bad'],
-            },
-            {
-                desc: 'RCPT TO unknown address (no @ and not postmaster/abuse)',
-                args: ['rcpt', 'TO:unknown'],
-            },
-        ]
-
-        for (const { desc, args } of throwCases) {
-            it(`throws: ${desc}`, () => {
-                assert.throws(() => parse(...args), Error)
-            })
-        }
-    })
-
-    describe('strict mode', () => {
-        const strictValidCases = [
-            ['mail', 'FROM:<user@domain.com>', '<user@domain.com>'],
-            ['rcpt', 'TO:<user@domain.com>', '<user@domain.com>'],
-        ]
-        for (const [type, line, expected] of strictValidCases) {
-            it(`strict ${type.toUpperCase()} with angle brackets accepts address`, () => {
-                const result = parse(type, line, true)
-                assert.equal(result[0], expected)
-            })
-        }
-
-        const strictThrowCases = [
-            ['mail', 'FROM:user@domain.com'],
-            ['rcpt', 'TO:user@domain.com'],
-        ]
-        for (const [type, line] of strictThrowCases) {
-            it(`strict ${type.toUpperCase()} without angle brackets throws`, () => {
-                assert.throws(() => parse(type, line, true), Error)
-            })
-        }
-    })
-})