Haraka 3.1.1 → 3.1.2

package/test/.eslintrc.yaml

@@ -1,4 +1,3 @@
-
 globals:
   test: true
   OK: true

package/test/connection.js

@@ -1,34 +1,34 @@
-
 const assert = require('node:assert/strict')
 
-const constants    = require('haraka-constants');
-const DSN          = require('haraka-dsn')
+const constants = require('haraka-constants')
+const DSN = require('haraka-dsn')
 
-const connection   = require('../connection');
-const Server       = require('../server');
+const connection = require('../connection')
+const Server = require('../server')
 
 // hack alert, but plugin tests need constants
-constants.import(global);
+constants.import(global)
 
 const _set_up = (done) => {
-    this.backup = {};
+    this.backup = {}
     const client = {
         remotePort: null,
         remoteAddress: null,
-        destroy: () => { true; },
-    };
+        destroy: () => {
+            true
+        },
+    }
     const server = {
         ip_address: null,
-        address () {
-            return this.ip_address;
-        }
+        address() {
+            return this.ip_address
+        },
     }
-    this.connection = connection.createConnection(client, server, Server.cfg);
+    this.connection = connection.createConnection(client, server, Server.cfg)
     done()
 }
 
 describe('connection', () => {
-
     describe('connectionRaw', () => {
         beforeEach(_set_up)
 
@@ -40,14 +40,14 @@ describe('connection', () => {
                 info: null,
                 closed: false,
                 is_private: false,
-                is_local: false
-            });
+                is_local: false,
+            })
         })
 
         it('has local object', () => {
-            assert.equal(this.connection.local.ip, null);
-            assert.equal(this.connection.local.port, null);
-            assert.ok(this.connection.local.host, this.connection.local.host);
+            assert.equal(this.connection.local.ip, null)
+            assert.equal(this.connection.local.port, null)
+            assert.ok(this.connection.local.host, this.connection.local.host)
         })
 
         it('has tls object', () => {
@@ -56,111 +56,101 @@ describe('connection', () => {
                 advertised: false,
                 verified: false,
                 cipher: {},
-            });
+            })
         })
 
         it('get_capabilities', () => {
-            assert.deepEqual([], this.connection.get_capabilities());
+            assert.deepEqual([], this.connection.get_capabilities())
         })
 
         it('queue_msg, defined', () => {
-            assert.equal(
-                'test message',
-                this.connection.queue_msg(1, 'test message')
-            );
+            assert.equal('test message', this.connection.queue_msg(1, 'test message'))
         })
 
         it('queue_msg, default deny', () => {
-            assert.equal(
-                'Message denied',
-                this.connection.queue_msg(DENY)
-            );
-            assert.equal(
-                'Message denied',
-                this.connection.queue_msg(DENYDISCONNECT)
-            );
+            assert.equal('Message denied', this.connection.queue_msg(DENY))
+            assert.equal('Message denied', this.connection.queue_msg(DENYDISCONNECT))
         })
 
         it('queue_msg, default denysoft', () => {
-            assert.equal(
-                'Message denied temporarily',
-                this.connection.queue_msg(DENYSOFT)
-            );
-            assert.equal(
-                'Message denied temporarily',
-                this.connection.queue_msg(DENYSOFTDISCONNECT)
-            );
+            assert.equal('Message denied temporarily', this.connection.queue_msg(DENYSOFT))
+            assert.equal('Message denied temporarily', this.connection.queue_msg(DENYSOFTDISCONNECT))
         })
 
         it('queue_msg, default else', () => {
-            assert.equal('', this.connection.queue_msg('hello'));
+            assert.equal('', this.connection.queue_msg('hello'))
         })
 
         it('has normalized connection properties', () => {
-            this.connection.set('remote', 'ip', '172.16.15.1');
-            this.connection.set('hello', 'verb', 'EHLO');
-            this.connection.set('tls', 'enabled', true);
-
-            assert.equal('172.16.15.1', this.connection.remote.ip);
-            assert.equal(null, this.connection.remote.port);
-            assert.equal('EHLO', this.connection.hello.verb);
-            assert.equal(null, this.connection.hello.host);
-            assert.equal(true, this.connection.tls.enabled);
+            this.connection.set('remote', 'ip', '172.16.15.1')
+            this.connection.set('hello', 'verb', 'EHLO')
+            this.connection.set('tls', 'enabled', true)
+
+            assert.equal('172.16.15.1', this.connection.remote.ip)
+            assert.equal(null, this.connection.remote.port)
+            assert.equal('EHLO', this.connection.hello.verb)
+            assert.equal(null, this.connection.hello.host)
+            assert.equal(true, this.connection.tls.enabled)
         })
 
         it('sets remote.is_private and remote.is_local', () => {
-            assert.equal(false, this.connection.remote.is_private);
-            assert.equal(false, this.connection.remote.is_local);
+            assert.equal(false, this.connection.remote.is_private)
+            assert.equal(false, this.connection.remote.is_local)
         })
 
         it('has normalized proxy properties, default', () => {
-            assert.equal(false, this.connection.proxy.allowed);
-            assert.equal(null, this.connection.proxy.ip);
-            assert.equal(null, this.connection.proxy.type);
-            assert.equal(null, this.connection.proxy.timer);
+            assert.equal(false, this.connection.proxy.allowed)
+            assert.equal(null, this.connection.proxy.ip)
+            assert.equal(null, this.connection.proxy.type)
+            assert.equal(null, this.connection.proxy.timer)
         })
 
         it('has normalized proxy properties, set', () => {
-            this.connection.set('proxy', 'ip', '172.16.15.1');
-            this.connection.set('proxy', 'type', 'haproxy');
-            this.connection.set('proxy', 'timer', setTimeout(() => {}, 1000));
-            this.connection.set('proxy', 'allowed', true);
-
-            assert.equal(true, this.connection.proxy.allowed);
-            assert.equal('172.16.15.1', this.connection.proxy.ip);
-            assert.ok(this.connection.proxy.timer);
-            assert.equal(this.connection.proxy.type, 'haproxy');
+            this.connection.set('proxy', 'ip', '172.16.15.1')
+            this.connection.set('proxy', 'type', 'haproxy')
+            this.connection.set(
+                'proxy',
+                'timer',
+                setTimeout(() => {}, 1000),
+            )
+            this.connection.set('proxy', 'allowed', true)
+
+            assert.equal(true, this.connection.proxy.allowed)
+            assert.equal('172.16.15.1', this.connection.proxy.ip)
+            assert.ok(this.connection.proxy.timer)
+            assert.equal(this.connection.proxy.type, 'haproxy')
         })
     })
 
     describe('connectionPrivate', () => {
         beforeEach((done) => {
-            this.backup = {};
+            this.backup = {}
             const client = {
                 remotePort: 2525,
                 remoteAddress: '172.16.15.1',
                 localPort: 25,
                 localAddress: '172.16.15.254',
-                destroy: () => { true; },
-            };
+                destroy: () => {
+                    true
+                },
+            }
             const server = {
                 ip_address: '172.16.15.254',
-                address () {
-                    return this.ip_address;
-                }
+                address() {
+                    return this.ip_address
+                },
             }
-            this.connection = connection.createConnection(client, server, Server.cfg);
+            this.connection = connection.createConnection(client, server, Server.cfg)
             done()
         })
 
         it('sets remote.is_private and remote.is_local', () => {
-            assert.equal(true, this.connection.remote.is_private);
-            assert.equal(false, this.connection.remote.is_local);
-            assert.equal(2525, this.connection.remote.port);
+            assert.equal(true, this.connection.remote.is_private)
+            assert.equal(false, this.connection.remote.is_local)
+            assert.equal(2525, this.connection.remote.port)
         })
     })
 
-
     describe('connectionLocal', () => {
         beforeEach((done) => {
             const client = {
@@ -168,59 +158,59 @@ describe('connection', () => {
                 remoteAddress: '127.0.0.2',
                 localPort: 25,
                 localAddress: '172.0.0.1',
-                destroy: () => { true; },
-            };
+                destroy: () => {
+                    true
+                },
+            }
             const server = {
                 ip_address: '127.0.0.1',
-                address () {
-                    return this.ip_address;
-                }
-            };
-            this.connection = connection.createConnection(client, server, Server.cfg);
-            done();
+                address() {
+                    return this.ip_address
+                },
+            }
+            this.connection = connection.createConnection(client, server, Server.cfg)
+            done()
         })
 
         it('sets remote.is_private and remote.is_local', () => {
-            assert.equal(true, this.connection.remote.is_private);
-            assert.equal(true, this.connection.remote.is_local);
-            assert.equal(2525, this.connection.remote.port);
+            assert.equal(true, this.connection.remote.is_private)
+            assert.equal(true, this.connection.remote.is_local)
+            assert.equal(2525, this.connection.remote.port)
         })
     })
 
-
     describe('get_remote', () => {
         beforeEach(_set_up)
 
         it('valid hostname', () => {
-            this.connection.remote.host='a.host.tld'
-            this.connection.remote.ip='172.16.199.198'
-            assert.equal(this.connection.get_remote('host'), 'a.host.tld [172.16.199.198]');
+            this.connection.remote.host = 'a.host.tld'
+            this.connection.remote.ip = '172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), 'a.host.tld [172.16.199.198]')
         })
 
         it('no hostname', () => {
-            this.connection.remote.ip='172.16.199.198'
-            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+            this.connection.remote.ip = '172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]')
         })
 
         it('DNSERROR', () => {
-            this.connection.remote.host='DNSERROR'
-            this.connection.remote.ip='172.16.199.198'
-            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+            this.connection.remote.host = 'DNSERROR'
+            this.connection.remote.ip = '172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]')
         })
 
         it('NXDOMAIN', () => {
-            this.connection.remote.host='NXDOMAIN'
-            this.connection.remote.ip='172.16.199.198'
-            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]');
+            this.connection.remote.host = 'NXDOMAIN'
+            this.connection.remote.ip = '172.16.199.198'
+            assert.equal(this.connection.get_remote('host'), '[172.16.199.198]')
         })
-
     })
 
     describe('local.info', () => {
         beforeEach(_set_up)
 
         it('is Haraka/version', () => {
-            assert.ok(/Haraka\/\d.\d/.test(this.connection.local.info), this.connection.local.info);
+            assert.ok(/Haraka\/\d.\d/.test(this.connection.local.info), this.connection.local.info)
         })
     })
 
@@ -228,28 +218,28 @@ describe('connection', () => {
         beforeEach(_set_up)
 
         it('sets and gets', () => {
-            assert.equal(this.connection.relaying, false);
+            assert.equal(this.connection.relaying, false)
 
-            this.connection.set('relaying', 'crocodiles');
-            assert.equal(this.connection.get('relaying'), 'crocodiles');
-            assert.equal(this.connection.relaying, 'crocodiles');
-            assert.equal(this.connection._relaying, 'crocodiles');
+            this.connection.set('relaying', 'crocodiles')
+            assert.equal(this.connection.get('relaying'), 'crocodiles')
+            assert.equal(this.connection.relaying, 'crocodiles')
+            assert.equal(this.connection._relaying, 'crocodiles')
 
-            this.connection.relaying = 'alligators';
-            assert.equal(this.connection.get('relaying'), 'alligators');
-            assert.equal(this.connection.relaying, 'alligators');
-            assert.equal(this.connection._relaying, 'alligators');
+            this.connection.relaying = 'alligators'
+            assert.equal(this.connection.get('relaying'), 'alligators')
+            assert.equal(this.connection.relaying, 'alligators')
+            assert.equal(this.connection._relaying, 'alligators')
         })
 
         it('sets and gets in a transaction', () => {
-            assert.equal(this.connection.relaying, false);
+            assert.equal(this.connection.relaying, false)
 
             this.connection.transaction = {}
-            this.connection.set('relaying', 'txn-only'); // sets txn.relaying
+            this.connection.set('relaying', 'txn-only') // sets txn.relaying
 
             assert.equal(this.connection.get('relaying'), 'txn-only')
-            assert.equal(this.connection._relaying, false);
-            assert.equal(this.connection.transaction._relaying, 'txn-only');
+            assert.equal(this.connection._relaying, false)
+            assert.equal(this.connection.transaction._relaying, 'txn-only')
         })
     })
 
@@ -257,21 +247,21 @@ describe('connection', () => {
         beforeEach(_set_up)
 
         it('sets single level properties', () => {
-            this.connection.set('encoding', true);
-            assert.ok(this.connection.encoding);
-            assert.ok(this.connection.get('encoding'));
+            this.connection.set('encoding', true)
+            assert.ok(this.connection.encoding)
+            assert.ok(this.connection.get('encoding'))
         })
 
         it('sets two level deep properties', () => {
-            this.connection.set('local.host', 'test');
-            assert.equal(this.connection.local.host, 'test');
-            assert.equal(this.connection.get('local.host'), 'test');
+            this.connection.set('local.host', 'test')
+            assert.equal(this.connection.local.host, 'test')
+            assert.equal(this.connection.get('local.host'), 'test')
         })
 
         it('sets three level deep properties', () => {
-            this.connection.set('some.fine.example', true);
-            assert.ok(this.connection.some.fine.example);
-            assert.ok(this.connection.get('some.fine.example'));
+            this.connection.set('some.fine.example', true)
+            assert.ok(this.connection.some.fine.example)
+            assert.ok(this.connection.get('some.fine.example'))
         })
     })
 
@@ -280,34 +270,37 @@ describe('connection', () => {
 
         it('disconnected returns undefined', () => {
             this.connection.state = constants.connection.state.DISCONNECTED
-            assert.equal(this.connection.respond(200, 'your lucky day'), undefined);
-            assert.equal(this.connection.respond(550, 'you are jacked'), undefined);
+            assert.equal(this.connection.respond(200, 'your lucky day'), undefined)
+            assert.equal(this.connection.respond(550, 'you are jacked'), undefined)
         })
 
         it('state=command, 200', () => {
-            assert.equal(this.connection.respond(200, 'you may pass Go'), '200 you may pass Go\r\n');
+            assert.equal(this.connection.respond(200, 'you may pass Go'), '200 you may pass Go\r\n')
         })
 
         it('DSN 200', () => {
             assert.equal(
                 this.connection.respond(200, DSN.create(200, 'you may pass Go')),
-                '200 2.0.0 you may pass Go\r\n'
-            );
+                '200 2.0.0 you may pass Go\r\n',
+            )
         })
 
         it('DSN 550 create', () => {
             // note, the DSN code overrides the response code
             assert.equal(
                 this.connection.respond(450, DSN.create(550, 'This domain is not in use and does not accept mail')),
-                '550 5.0.0 This domain is not in use and does not accept mail\r\n'
-            );
+                '550 5.0.0 This domain is not in use and does not accept mail\r\n',
+            )
         })
 
         it('DSN 550 addr_bad_dest_system', () => {
             assert.equal(
-                this.connection.respond(550, DSN.addr_bad_dest_system('This domain is not in use and does not accept mail', 550)),
-                '550 5.1.2 This domain is not in use and does not accept mail\r\n'
-            );
+                this.connection.respond(
+                    550,
+                    DSN.addr_bad_dest_system('This domain is not in use and does not accept mail', 550),
+                ),
+                '550 5.1.2 This domain is not in use and does not accept mail\r\n',
+            )
         })
     })
 })

package/test/endpoint.js

@@ -1,94 +1,100 @@
 const assert = require('node:assert')
 
-const mock = require('mock-require');
-const endpoint = require('../endpoint');
+const mock = require('mock-require')
+const endpoint = require('../endpoint')
 
 describe('endpoint', () => {
-
     it('toString()', () => {
-        assert.equal( endpoint(25),                         '[::0]:25' );
-        assert.equal( endpoint('10.0.0.3', 42),             '10.0.0.3:42' );
-        assert.equal( endpoint('/foo/bar.sock'),            '/foo/bar.sock' );
-        assert.equal( endpoint('/foo/bar.sock:770'),        '/foo/bar.sock:770' );
-        assert.equal( endpoint({address: '::0', port: 80}), '[::0]:80' );
+        assert.equal(endpoint(25), '[::0]:25')
+        assert.equal(endpoint('10.0.0.3', 42), '10.0.0.3:42')
+        assert.equal(endpoint('/foo/bar.sock'), '/foo/bar.sock')
+        assert.equal(endpoint('/foo/bar.sock:770'), '/foo/bar.sock:770')
+        assert.equal(endpoint({ address: '::0', port: 80 }), '[::0]:80')
     })
 
     describe('parse', () => {
         it('Number as port', () => {
-            assert.deepEqual( endpoint(25), {host:'::0', port:25} );
+            assert.deepEqual(endpoint(25), { host: '::0', port: 25 })
         })
 
         it('Default port if only host', () => {
-            assert.deepEqual( endpoint('10.0.0.3', 42), {host:'10.0.0.3', port:42} );
+            assert.deepEqual(endpoint('10.0.0.3', 42), {
+                host: '10.0.0.3',
+                port: 42,
+            })
         })
 
         it('Unix socket', () => {
-            assert.deepEqual( endpoint('/foo/bar.sock'), {path:'/foo/bar.sock'} );
+            assert.deepEqual(endpoint('/foo/bar.sock'), {
+                path: '/foo/bar.sock',
+            })
         })
 
         it('Unix socket w/mode', () => {
-            assert.deepEqual( endpoint('/foo/bar.sock:770'), {path:'/foo/bar.sock', mode:'770'} );
+            assert.deepEqual(endpoint('/foo/bar.sock:770'), {
+                path: '/foo/bar.sock',
+                mode: '770',
+            })
         })
     })
 
     describe('bind()', () => {
         beforeEach((done) => {
             // Mock filesystem and log server + fs method calls
-            const modes = this.modes = {}
-            const log = this.log = []
+            const modes = (this.modes = {})
+            const log = (this.log = [])
 
             this.server = {
-                listen (opts, cb) {
-                    log.push(['listen', opts]);
-                    if (cb) cb();
-                }
+                listen(opts, cb) {
+                    log.push(['listen', opts])
+                    if (cb) cb()
+                },
             }
 
             this.mockfs = {
-                chmod (path, mode, ...args) {
-                    log.push(['chmod', path, mode, ...args]);
-                    modes[path] = mode;
+                chmod(path, mode, ...args) {
+                    log.push(['chmod', path, mode, ...args])
+                    modes[path] = mode
                 },
-                rm (path, ...args) {
-                    log.push(['rm', path, ...args]);
+                rm(path, ...args) {
+                    log.push(['rm', path, ...args])
                 },
-            };
+            }
 
-            mock('node:fs/promises', this.mockfs);
-            this.endpoint = mock.reRequire('../endpoint');
-            done();
+            mock('node:fs/promises', this.mockfs)
+            this.endpoint = mock.reRequire('../endpoint')
+            done()
         })
 
         afterEach((done) => {
-            mock.stop('node:fs/promises');
-            done();
+            mock.stop('node:fs/promises')
+            done()
         })
 
         it('IP socket', async () => {
-            await this.endpoint('10.0.0.3:42').bind(this.server, {backlog:19});
-            assert.deepEqual(
-                this.log, [
-                    ['listen', {host: '10.0.0.3', port: 42, backlog: 19}],
-                ]);
+            await this.endpoint('10.0.0.3:42').bind(this.server, {
+                backlog: 19,
+            })
+            assert.deepEqual(this.log, [['listen', { host: '10.0.0.3', port: 42, backlog: 19 }]])
         })
 
         it('Unix socket', async () => {
-            await this.endpoint('/foo/bar.sock').bind(this.server, {readableAll:true});
-            assert.deepEqual(
-                this.log, [
-                    ['rm', '/foo/bar.sock', {force:true}],
-                    ['listen', {path: '/foo/bar.sock', readableAll: true}],
-                ]);
+            await this.endpoint('/foo/bar.sock').bind(this.server, {
+                readableAll: true,
+            })
+            assert.deepEqual(this.log, [
+                ['rm', '/foo/bar.sock', { force: true }],
+                ['listen', { path: '/foo/bar.sock', readableAll: true }],
+            ])
         })
 
         it('Unix socket w/mode', async () => {
-            await this.endpoint('/foo/bar.sock:764').bind(this.server);
-            assert.deepEqual(
-                this.log, [
-                    ['rm', '/foo/bar.sock', {force:true}],
-                    ['listen', {path: '/foo/bar.sock'}],
-                    ['chmod', '/foo/bar.sock', 0o764],
-                ]);
+            await this.endpoint('/foo/bar.sock:764').bind(this.server)
+            assert.deepEqual(this.log, [
+                ['rm', '/foo/bar.sock', { force: true }],
+                ['listen', { path: '/foo/bar.sock' }],
+                ['chmod', '/foo/bar.sock', 0o764],
+            ])
         })
     })
 })

package/test/fixtures/line_socket.js

@@ -1,20 +1,20 @@
-'use strict';
+'use strict'
 
-const events   = require('node:events');
-const fixtures = require('haraka-test-fixtures');
-const { stub } = fixtures.stub;
+const events = require('node:events')
+const fixtures = require('haraka-test-fixtures')
+const { stub } = fixtures.stub
 
 class Socket extends events.EventEmitter {
-    constructor (port, host) {
-        super();
-        this.port = port;
-        this.host = host;
-        this.setTimeout = stub();
-        this.setKeepAlive = stub();
-        this.destroy = stub();
+    constructor(port, host) {
+        super()
+        this.port = port
+        this.host = host
+        this.setTimeout = stub()
+        this.setKeepAlive = stub()
+        this.destroy = stub()
     }
 }
 
-exports.Socket = Socket;
+exports.Socket = Socket
 
 exports.connect = (port, host, cb) => new Socket(port, host)