Haraka 3.1.1 → 3.1.2

package/test/fixtures/util_hmailitem.js

@@ -1,9 +1,9 @@
-'use strict';
+'use strict'
 
 const assert = require('node:assert')
 
-const { Address } = require('address-rfc2821');
-const fixtures = require('haraka-test-fixtures');
+const { Address } = require('address-rfc2821')
+const fixtures = require('haraka-test-fixtures')
 
 /**
  * Creates a HMailItem instance, which is passed to callback. Reports error on test param if creation fails.
@@ -13,26 +13,23 @@ const fixtures = require('haraka-test-fixtures');
  * @param callback
  */
 exports.newMockHMailItem = (outbound_context, done, options, callback) => {
-    const opts = options || {};
-    exports.createHMailItem(
-        outbound_context,
-        opts,
-        (err, hmail) => {
-            if (err) {
-                assert.ok(false, `Could not create HMailItem: ${err}`);
-                done()
-                return;
-            }
-            if (!hmail.todo) {
-                hmail.once('ready', () => {
-                    setImmediate(() => {callback(hmail);});
-                });
-            }
-            else {
-                callback(hmail);
-            }
+    const opts = options || {}
+    exports.createHMailItem(outbound_context, opts, (err, hmail) => {
+        if (err) {
+            assert.ok(false, `Could not create HMailItem: ${err}`)
+            done()
+            return
         }
-    );
+        if (!hmail.todo) {
+            hmail.once('ready', () => {
+                setImmediate(() => {
+                    callback(hmail)
+                })
+            })
+        } else {
+            callback(hmail)
+        }
+    })
 }
 
 /**
@@ -43,55 +40,57 @@ exports.newMockHMailItem = (outbound_context, done, options, callback) => {
  * @param callback(err, hmail)
  */
 exports.createHMailItem = (outbound_context, options, callback) => {
+    const mail_from = options.mail_from || 'sender@domain'
+    const delivery_domain = options.delivery_domain || 'domain'
+    const mail_recipients = options.mail_recipients || [new Address('recipient@domain')]
 
-    const mail_from = options.mail_from || 'sender@domain';
-    const delivery_domain = options.delivery_domain || 'domain';
-    const mail_recipients = options.mail_recipients || [new Address('recipient@domain')];
-
-    const conn = fixtures.connection.createConnection();
+    const conn = fixtures.connection.createConnection()
     conn.init_transaction()
-    conn.transaction.mail_from = new Address(mail_from);
+    conn.transaction.mail_from = new Address(mail_from)
 
-    const todo = new outbound_context.TODOItem(delivery_domain, mail_recipients, conn.transaction);
-    todo.uuid = `${todo.uuid}.1`;
+    const todo = new outbound_context.TODOItem(delivery_domain, mail_recipients, conn.transaction)
+    todo.uuid = `${todo.uuid}.1`
 
     let contents = [
         `From: ${mail_from}`,
-        `To: ${mail_recipients.join(", ")}`,
-        "MIME-Version: 1.0",
-        "Content-type: text/plain; charset=us-ascii",
-        "Subject: Some subject here",
-        "",
-        "Some email body here",
-        ""].join("\n");
-    let match;
-    const re = /^([^\n]*\n?)/;
+        `To: ${mail_recipients.join(', ')}`,
+        'MIME-Version: 1.0',
+        'Content-type: text/plain; charset=us-ascii',
+        'Subject: Some subject here',
+        '',
+        'Some email body here',
+        '',
+    ].join('\n')
+    let match
+    const re = /^([^\n]*\n?)/
     while ((match = re.exec(contents))) {
-        let line = match[1];
-        line = line.replace(/\r?\n?$/, '\r\n'); // make sure it ends in \r\n
-        conn.transaction.add_data(Buffer.from(line));
-        contents = contents.substr(match[1].length);
+        let line = match[1]
+        line = line.replace(/\r?\n?$/, '\r\n') // make sure it ends in \r\n
+        conn.transaction.add_data(Buffer.from(line))
+        contents = contents.substr(match[1].length)
         if (contents.length === 0) {
-            break;
+            break
         }
     }
-    conn.transaction.message_stream.add_line_end();
+    conn.transaction.message_stream.add_line_end()
 
-    const hmails = [];
-    const ok_paths = [];
-    outbound_context.exports.process_delivery(ok_paths, todo, hmails).then(() => {
-        if (hmails.length == 0) {
-            callback('No hmail producted');
-            return;
-        }
-        for (const hmail of hmails) {
-            hmail.hostlist = [ delivery_domain ];
-            callback(null, hmail);
-        }
-    })
-    .catch(err => {
-        callback(`process_delivery error: ${err}`);
-    })
+    const hmails = []
+    const ok_paths = []
+    outbound_context.exports
+        .process_delivery(ok_paths, todo, hmails)
+        .then(() => {
+            if (hmails.length == 0) {
+                callback('No hmail producted')
+                return
+            }
+            for (const hmail of hmails) {
+                hmail.hostlist = [delivery_domain]
+                callback(null, hmail)
+            }
+        })
+        .catch((err) => {
+            callback(`process_delivery error: ${err}`)
+        })
 }
 
 /**
@@ -102,52 +101,57 @@ exports.createHMailItem = (outbound_context, options, callback) => {
  */
 exports.playTestSmtpConversation = (hmail, socket, done, playbook, callback) => {
     const testmx = {
-        bind_helo: "haraka.test",
-        exchange: "remote.testhost",
-    };
-    hmail.try_deliver_host_on_socket(testmx, 'testhost', 'testport', socket);
+        bind_helo: 'haraka.test',
+        exchange: 'remote.testhost',
+    }
+    hmail.try_deliver_host_on_socket(testmx, 'testhost', 'testport', socket)
 
-    socket.write = line => {
+    socket.write = (line) => {
         //console.log('MockSocket.write(' + line.replace(/\n/, '\\n').replace(/\r/, '\\r') + ')');
         if (playbook.length == 0) {
-            assert.ok(false, 'missing next playbook entry');
+            assert.ok(false, 'missing next playbook entry')
             done()
-            return;
+            return
         }
-        let expected;
+        let expected
         while (false != (expected = getNextEntryFromPlaybook('haraka', playbook))) {
             if (typeof expected.test === 'function') {
-                assert.ok(expected.test(line), expected.description || `Expected that line works with func: ${expected.test}`);
-            }
-            else {
-                assert.equal(`${expected.test}\r\n`, line, expected.description || `Expected that line equals: ${expected.test}`);
+                assert.ok(
+                    expected.test(line),
+                    expected.description || `Expected that line works with func: ${expected.test}`,
+                )
+            } else {
+                assert.equal(
+                    `${expected.test}\r\n`,
+                    line,
+                    expected.description || `Expected that line equals: ${expected.test}`,
+                )
             }
             if (expected.end_test === true) {
                 setTimeout(() => {
-                    callback();
-                }, 0);
-                return;
+                    callback()
+                }, 0)
+                return
             }
         }
         setTimeout(() => {
-            let nextMessageFromServer;
+            let nextMessageFromServer
             while (false != (nextMessageFromServer = getNextEntryFromPlaybook('remote', playbook))) {
-                socket.emit('line', `${nextMessageFromServer.line}\r\n`);
+                socket.emit('line', `${nextMessageFromServer.line}\r\n`)
             }
-        }, 0);
+        }, 0)
     }
 
-    const welcome = getNextEntryFromPlaybook('remote', playbook);
-    socket.emit('line', welcome.line);
+    const welcome = getNextEntryFromPlaybook('remote', playbook)
+    socket.emit('line', welcome.line)
 }
 
-function getNextEntryFromPlaybook (ofType, playbook) {
+function getNextEntryFromPlaybook(ofType, playbook) {
     if (playbook.length == 0) {
-        return false;
+        return false
     }
     if (playbook[0].from == ofType) {
-        return playbook.shift();
+        return playbook.shift()
     }
-    return false;
+    return false
 }
-

package/test/host_pool.js

@@ -1,58 +1,56 @@
-"use strict";
+'use strict'
 
 const assert = require('node:assert')
 
-const HostPool = require('../host_pool');
+const HostPool = require('../host_pool')
 
 describe('HostPool', () => {
-    it("get a host", (done) => {
+    it('get a host', (done) => {
+        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
+        const host = pool.get_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`);
+        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) => {
-
-        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222');
+    it('uses all the list', (done) => {
+        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();
+        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);
+        assert.notEqual(host1.host, host2.host)
+        assert.notEqual(host3.host, host2.host)
+        assert.equal(host3.host, host1.host)
         done()
     })
 
-    it("default port 25", (done) => {
-        const pool = new HostPool('1.1.1.1, 2.2.2.2');
+    it('default port 25', (done) => {
+        const pool = new HostPool('1.1.1.1, 2.2.2.2')
 
-        const host1 = pool.get_host();
-        const host2 = pool.get_host();
+        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}`);
+        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', (done) => {
+        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222')
 
-        pool.failed('1.1.1.1', '1111');
+        pool.failed('1.1.1.1', '1111')
 
-        let host;
+        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');
+        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')
         done()
     })
 
@@ -60,105 +58,105 @@ describe('HostPool', () => {
     // accidentally DOS'ing ourselves if there's a transient but widespread
     // network outage
     it("they're all dead", (done) => {
+        let host1
+        let host2
 
-        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')
 
-        host1 = pool.get_host();
+        host1 = pool.get_host()
 
-        pool.failed('1.1.1.1', '1111');
-        pool.failed('2.2.2.2', '2222');
+        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");
+        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");
+        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");
+        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) => {
-
-        let num_reqs = 0;
-        const MockSocket = function MockSocket (pool) {
-
+    it('host dead checking timer', (done) => {
+        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.pretendTimeout = () => {}
             this.setTimeout = (ms, cb) => {
-                this.pretendTimeout = cb;
-            };
+                this.pretendTimeout = cb
+            }
             // handle socket.on('error', ....
-            this.listeners = {};
+            this.listeners = {}
             this.on = (eventname, cb) => {
-                this.listeners[eventname] = cb;
-            };
-            this.emit = eventname => {
-                this.listeners[eventname]();
-            };
+                this.listeners[eventname] = cb
+            }
+            this.emit = (eventname) => {
+                this.listeners[eventname]()
+            }
             // handle socket.connect(...
-            this.connected = () => {};
+            this.connected = () => {}
             this.connect = (port, host, cb) => {
                 switch (++num_reqs) {
                     case 1:
                         // the first time through we pretend it timed out
-                        this.pretendTimeout();
-                        break;
+                        this.pretendTimeout()
+                        break
                     case 2:
                         // the second time through, pretend socket error
-                        this.emit('error');
-                        break;
+                        this.emit('error')
+                        break
                     case 3:
                         // the third time around, the socket connected
-                        cb();
-                        break;
+                        cb()
+                        break
                     default:
                         // failsafe
-                        console.log(`num_reqs hit ${num_reqs}, wtf?`);
-                        process.exit(1);
+                        console.log(`num_reqs hit ${num_reqs}, wtf?`)
+                        process.exit(1)
                 }
-            };
-            this.destroy = () => {};
-        };
+            }
+            this.destroy = () => {}
+        }
 
-        const retry_secs = 0.001; // 1ms
-        const pool = new HostPool('1.1.1.1:1111, 2.2.2.2:2222', retry_secs);
+        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);
+        pool.get_socket = () => new MockSocket(pool)
 
         // mark the host as failed and start up the retry timers
-        pool.failed('1.1.1.1', '1111');
+        pool.failed('1.1.1.1', '1111')
 
-        assert.ok(pool.dead_hosts["1.1.1.1:1111"], 'yes it was marked dead');
+        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:
         const timer = setTimeout(() => {
-            clearInterval(interval);
-            assert.ok(false, 'probe_dead_host failed');
+            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 );
+        }, 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,
+        )
     })
 })

package/test/installation/plugins/base_plugin.js

@@ -1,3 +1,3 @@
-"use strict";
+'use strict'
 
-exports.check_the_base = () => "base"
+exports.check_the_base = () => 'base'

package/test/installation/plugins/folder_plugin/index.js

@@ -1,4 +1,3 @@
-"use strict";
+'use strict'
 
-exports.register = () => {
-}
+exports.register = () => {}

package/test/installation/plugins/inherits.js

@@ -1,7 +1,7 @@
-"use strict";
+'use strict'
 
 exports.register = function () {
-    this.inherits('base_plugin');
+    this.inherits('base_plugin')
 }
 
-exports.main_plugin_method = () => "main"
+exports.main_plugin_method = () => 'main'

package/test/installation/plugins/load_first.js

@@ -1,4 +1,3 @@
-exports.register = () => {
-}
+exports.register = () => {}
 
-exports.loaded_first = true;
+exports.loaded_first = true

package/test/installation/plugins/plugin.js

@@ -1,3 +1 @@
-exports.register = () => {
-
-}
+exports.register = () => {}

package/test/installation/plugins/tls.js

@@ -1,5 +1,3 @@
-exports.register = () => {
+exports.register = () => {}
 
-}
-
-exports.core_override = true;
+exports.core_override = true