Haraka 3.1.1 → 3.1.2

package/test/plugins/tls.js

@@ -1,70 +1,73 @@
-'use strict';
+'use strict'
 
 const assert = require('node:assert')
-const path = require('node:path');
+const path = require('node:path')
 
-const fixtures = require('haraka-test-fixtures');
-const Plugin = fixtures.plugin;
+const fixtures = require('haraka-test-fixtures')
+const Plugin = fixtures.plugin
 
 const _set_up = (done) => {
     this.plugin = new Plugin('tls')
-    this.connection = new fixtures.connection.createConnection();
+    this.connection = new fixtures.connection.createConnection()
 
     // 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.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 = {};
-    done();
+    this.plugin.tls_opts = {}
+    done()
 }
 
-describe('tls', ()=> {
+describe('tls', () => {
     beforeEach(_set_up)
 
     it('has function register', () => {
-        assert.ok(this.plugin);
-        assert.equal('function', typeof this.plugin.register);
+        assert.ok(this.plugin)
+        assert.equal('function', typeof this.plugin.register)
     })
 
     it('has function upgrade_connection', () => {
-        assert.equal('function', typeof this.plugin.upgrade_connection);
+        assert.equal('function', typeof this.plugin.upgrade_connection)
     })
 
     it('has function advertise_starttls', () => {
-        assert.equal('function', typeof this.plugin.advertise_starttls);
+        assert.equal('function', typeof this.plugin.advertise_starttls)
     })
 
     it('has function emit_upgrade_msg', () => {
-        assert.equal('function', typeof this.plugin.emit_upgrade_msg);
+        assert.equal('function', typeof this.plugin.emit_upgrade_msg)
     })
 
-    describe('register', ()=> {
+    describe('register', () => {
         it('with certs, should call register_hook()', () => {
-            this.plugin.register();
-            assert.ok(this.plugin.register_hook.called);
+            this.plugin.register()
+            assert.ok(this.plugin.register_hook.called)
         })
     })
 
-    describe('emit_upgrade_msg', ()=> {
-
+    describe('emit_upgrade_msg', () => {
         it('should emit a log message', () => {
-            assert.equal(this.plugin.emit_upgrade_msg(this.connection, true, '', {
-                subject: {
-                    CN: 'TLS.subject',
-                    O: 'TLS.org'
-                },
-            }),
-            'secured: verified=true cn="TLS.subject" organization="TLS.org"');
+            assert.equal(
+                this.plugin.emit_upgrade_msg(this.connection, true, '', {
+                    subject: {
+                        CN: 'TLS.subject',
+                        O: 'TLS.org',
+                    },
+                }),
+                'secured: verified=true cn="TLS.subject" organization="TLS.org"',
+            )
         })
 
         it('should emit a log message with error', () => {
-            assert.equal(this.plugin.emit_upgrade_msg(this.connection, true, 'oops', {
-                subject: {
-                    CN: 'TLS.subject',
-                    O: 'TLS.org'
-                },
-            }),
-            'secured: verified=true error="oops" cn="TLS.subject" organization="TLS.org"');
+            assert.equal(
+                this.plugin.emit_upgrade_msg(this.connection, true, 'oops', {
+                    subject: {
+                        CN: 'TLS.subject',
+                        O: 'TLS.org',
+                    },
+                }),
+                'secured: verified=true error="oops" cn="TLS.subject" organization="TLS.org"',
+            )
         })
     })
 })

package/test/plugins.js

@@ -1,14 +1,14 @@
-'use strict';
+'use strict'
 
-process.env.WITHOUT_CONFIG_CACHE=true;
+process.env.WITHOUT_CONFIG_CACHE = true
 
 const assert = require('node:assert')
-const fs     = require('node:fs');
-const path   = require('node:path');
+const fs = require('node:fs')
+const path = require('node:path')
 
-const plugin = require('../plugins');
+const plugin = require('../plugins')
 
-const piName = 'testPlugin';
+const piName = 'testPlugin'
 
 /*
 
@@ -42,187 +42,192 @@ From: https://github.com/haraka/Haraka/pull/1278#issuecomment-172134064
 */
 
 describe('plugin', () => {
-
     it('new Plugin() object', () => {
-        const pi = new plugin.Plugin(piName);
-        assert.ok(pi);
+        const pi = new plugin.Plugin(piName)
+        assert.ok(pi)
     })
 
     describe('get_timeout', () => {
-        const toPath = path.resolve('config', `${piName}.timeout`);
+        const toPath = path.resolve('config', `${piName}.timeout`)
         it('0s', (done) => {
             fs.writeFile(toPath, '0', () => {
-                this.plugin = new plugin.Plugin(piName);
-                assert.equal(this.plugin.timeout, 0);
-                fs.unlink(toPath, done);
+                this.plugin = new plugin.Plugin(piName)
+                assert.equal(this.plugin.timeout, 0)
+                fs.unlink(toPath, done)
             })
         })
 
         it('3s', (done) => {
             fs.writeFile(toPath, '3', () => {
-                this.plugin = new plugin.Plugin(piName);
-                assert.equal(this.plugin.timeout, 3);
-                fs.unlink(toPath, done);
+                this.plugin = new plugin.Plugin(piName)
+                assert.equal(this.plugin.timeout, 3)
+                fs.unlink(toPath, done)
             })
         })
 
         it('60s', (done) => {
             fs.writeFile(toPath, '60', () => {
-                this.plugin = new plugin.Plugin(piName);
-                assert.equal(this.plugin.timeout, 60);
-                fs.unlink(toPath, done);
+                this.plugin = new plugin.Plugin(piName)
+                assert.equal(this.plugin.timeout, 60)
+                fs.unlink(toPath, done)
             })
         })
 
         it('30s default (overrides NaN)', (done) => {
             fs.writeFile(toPath, 'apple', () => {
-                this.plugin = new plugin.Plugin(piName);
-                assert.equal(this.plugin.timeout, 30);
-                fs.unlink(toPath, done);
+                this.plugin = new plugin.Plugin(piName)
+                assert.equal(this.plugin.timeout, 30)
+                fs.unlink(toPath, done)
             })
         })
     })
 
     describe('plugin_paths', () => {
         beforeEach((done) => {
-            delete process.env.HARAKA;
+            delete process.env.HARAKA
             done()
         })
 
         afterEach((done) => {
-            delete process.env.HARAKA;
+            delete process.env.HARAKA
             done()
         })
 
         it('CORE plugin: (tls)', () => {
-            const p = new plugin.Plugin('tls');
+            const p = new plugin.Plugin('tls')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, '..', 'plugins', 'tls.js'));
+            assert.equal(p.plugin_path, path.resolve(__dirname, '..', 'plugins', 'tls.js'))
         })
 
         it('INSTALLED override: (tls)', () => {
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            const p = new plugin.Plugin('tls');
+            const p = new plugin.Plugin('tls')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'tls.js'));
+            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'tls.js'))
         })
 
         it('INSTALLED node_modules package plugin: (test-plugin)', () => {
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            const p = new plugin.Plugin('test-plugin');
+            const p = new plugin.Plugin('test-plugin')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'node_modules', 'test-plugin', 'package.json'));
-            assert.ok(p.hasPackageJson);
+            assert.equal(
+                p.plugin_path,
+                path.resolve(__dirname, 'installation', 'node_modules', 'test-plugin', 'package.json'),
+            )
+            assert.ok(p.hasPackageJson)
             try {
-                p._compile();
-                assert.ok(true, "compiles OK");
-            }
-            catch (e) {
-                console.error(e.stack);
-                assert.ok(false, "compiles OK");
+                p._compile()
+                assert.ok(true, 'compiles OK')
+            } catch (e) {
+                console.error(e.stack)
+                assert.ok(false, 'compiles OK')
             }
         })
 
         it('CORE package plugin: redis', () => {
-            const p = new plugin.Plugin('haraka-plugin-redis');
+            const p = new plugin.Plugin('haraka-plugin-redis')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, '..', 'node_modules', 'haraka-plugin-redis', 'package.json'));
-            assert.ok(p.hasPackageJson);
+            assert.equal(
+                p.plugin_path,
+                path.resolve(__dirname, '..', 'node_modules', 'haraka-plugin-redis', 'package.json'),
+            )
+            assert.ok(p.hasPackageJson)
         })
 
         it('plugins overrides node_modules', () => {
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            const p = new plugin.Plugin('load_first');
+            const p = new plugin.Plugin('load_first')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'load_first.js'));
+            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'load_first.js'))
             try {
-                p._compile();
-                assert.ok(true, "compiles OK");
-            }
-            catch (e) {
-                console.error(e.stack);
-                assert.ok(false, "compiles OK");
+                p._compile()
+                assert.ok(true, 'compiles OK')
+            } catch (e) {
+                console.error(e.stack)
+                assert.ok(false, 'compiles OK')
             }
-            assert.ok(p.loaded_first);
+            assert.ok(p.loaded_first)
         })
 
         it('INSTALLED plugins folder plugin: (folder_plugin)', () => {
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            const p = new plugin.Plugin('folder_plugin');
+            const p = new plugin.Plugin('folder_plugin')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'folder_plugin', 'package.json'));
-            assert.ok(p.hasPackageJson);
+            assert.equal(
+                p.plugin_path,
+                path.resolve(__dirname, 'installation', 'plugins', 'folder_plugin', 'package.json'),
+            )
+            assert.ok(p.hasPackageJson)
             try {
-                p._compile();
-                assert.ok(true, "compiles OK");
-            }
-            catch (e) {
-                console.error(e.stack);
-                assert.ok(false, "compiles OK");
+                p._compile()
+                assert.ok(true, 'compiles OK')
+            } catch (e) {
+                console.error(e.stack)
+                assert.ok(false, 'compiles OK')
             }
         })
 
         it('Inheritance: (inherits)', () => {
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            const p = new plugin.Plugin('inherits');
+            const p = new plugin.Plugin('inherits')
 
-            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'inherits.js'));
+            assert.equal(p.plugin_path, path.resolve(__dirname, 'installation', 'plugins', 'inherits.js'))
             try {
-                p._compile();
-                assert.ok(true, "compiles OK");
-            }
-            catch (e) {
-                console.error(e.stack);
-                assert.ok(false, "compiles OK");
+                p._compile()
+                assert.ok(true, 'compiles OK')
+            } catch (e) {
+                console.error(e.stack)
+                assert.ok(false, 'compiles OK')
             }
-            p.register();
-            assert.ok(p.base.base_plugin);
+            p.register()
+            assert.ok(p.base.base_plugin)
         })
     })
 
     describe('plugin_config', () => {
         beforeEach((done) => {
-            delete process.env.HARAKA;
-            done();
+            delete process.env.HARAKA
+            done()
         })
 
         afterEach((done) => {
-            delete process.env.HARAKA;
-            done();
+            delete process.env.HARAKA
+            done()
         })
 
         it('CORE plugin: (tls)', () => {
-            const p = new plugin.Plugin('tls');
+            const p = new plugin.Plugin('tls')
 
-            assert.equal(p.config.root_path, path.resolve(__dirname, '..', 'config'));
-            assert.equal(p.config.overrides_path, undefined);
+            assert.equal(p.config.root_path, path.resolve(__dirname, '..', 'config'))
+            assert.equal(p.config.overrides_path, undefined)
         })
 
         it('INSTALLED override: (tls)', () => {
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
+            const p = new plugin.Plugin('tls')
 
-            const p = new plugin.Plugin('tls');
-
-            assert.equal(p.config.root_path, path.resolve(__dirname, '..', 'config'));
-            assert.equal(p.config.overrides_path, path.resolve(__dirname, 'installation', 'config'));
-            const tls_ini = p.config.get('tls.ini');
-            assert.equal(tls_ini.main.ciphers, 'test');
+            assert.equal(p.config.root_path, path.resolve(__dirname, '..', 'config'))
+            assert.equal(p.config.overrides_path, path.resolve(__dirname, 'installation', 'config'))
+            const tls_ini = p.config.get('tls.ini')
+            assert.equal(tls_ini.main.ciphers, 'test')
         })
 
         it('INSTALLED node_modules package plugin: (test-plugin)', () => {
+            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation')
 
-            process.env.HARAKA = path.resolve(__dirname, '..', 'test', 'installation');
-
-            const p = new plugin.Plugin('test-plugin');
+            const p = new plugin.Plugin('test-plugin')
 
-            assert.equal(p.config.root_path, path.resolve(__dirname, 'installation', 'node_modules', 'test-plugin', 'config'));
-            assert.equal(p.config.overrides_path, path.resolve(__dirname, 'installation', 'config'));
+            assert.equal(
+                p.config.root_path,
+                path.resolve(__dirname, 'installation', 'node_modules', 'test-plugin', 'config'),
+            )
+            assert.equal(p.config.overrides_path, path.resolve(__dirname, 'installation', 'config'))
         })
     })
 })

package/test/rfc1869.js

@@ -1,73 +1,66 @@
 const assert = require('node:assert')
 
-const { parse } = require('../rfc1869');
+const { parse } = require('../rfc1869')
 
-function _check (line, expected) {
-    const match = /^(MAIL|RCPT)\s+(.*)$/.exec(line);
-    const parsed = parse(match[1].toLowerCase(), match[2]);
-    assert.equal(parsed.length, expected.length);
+function _check(line, expected) {
+    const match = /^(MAIL|RCPT)\s+(.*)$/.exec(line)
+    const parsed = parse(match[1].toLowerCase(), match[2])
+    assert.equal(parsed.length, expected.length)
     for (let x = 0; x < expected.length; x++) {
-        assert.equal(parsed[x], expected[x]);
+        assert.equal(parsed[x], expected[x])
     }
 }
 
 describe('rfc1869', () => {
     it('MAIL FROM:<>', () => {
-        _check('MAIL FROM:<>', ['<>']);
+        _check('MAIL FROM:<>', ['<>'])
     })
 
     it('MAIL FROM:', () => {
-        _check('MAIL FROM:', ['<>']);
+        _check('MAIL FROM:', ['<>'])
     })
 
     it('MAIL FROM:<postmaster>', () => {
-        _check('MAIL FROM:<postmaster>', ['<postmaster>']);
+        _check('MAIL FROM:<postmaster>', ['<postmaster>'])
     })
 
     it('MAIL FROM:user', () => {
-        _check('MAIL FROM:user', ['user']);
+        _check('MAIL FROM:user', ['user'])
     })
 
     it('MAIL FROM:user size=1234', () => {
-        _check('MAIL FROM:user size=1234', ['user', 'size=1234']);
+        _check('MAIL FROM:user size=1234', ['user', 'size=1234'])
     })
 
     it('MAIL FROM:user@domain size=1234', () => {
-        _check('MAIL FROM:user@domain size=1234',
-            ['user@domain', 'size=1234']);
+        _check('MAIL FROM:user@domain size=1234', ['user@domain', 'size=1234'])
     })
 
     it('MAIL FROM:<user@domain> size=1234', () => {
-        _check('MAIL FROM:<user@domain> size=1234',
-            ['<user@domain>', 'size=1234']);
+        _check('MAIL FROM:<user@domain> size=1234', ['<user@domain>', 'size=1234'])
     })
 
     it('MAIL FROM:<user@domain> somekey', () => {
-        _check('MAIL FROM:<user@domain> somekey',
-            ['<user@domain>', 'somekey']);
+        _check('MAIL FROM:<user@domain> somekey', ['<user@domain>', 'somekey'])
     })
 
     it('MAIL FROM:<user@domain> somekey other=foo', () => {
-        _check('MAIL FROM:<user@domain> somekey other=foo',
-            ['<user@domain>', 'somekey', 'other=foo']);
+        _check('MAIL FROM:<user@domain> somekey other=foo', ['<user@domain>', 'somekey', 'other=foo'])
     })
 
     it('RCPT TO ugly', () => {
-        _check('RCPT TO: 0@mailblog.biz 0=9 1=9',
-            ['<0@mailblog.biz>', '0=9', '1=9']);
+        _check('RCPT TO: 0@mailblog.biz 0=9 1=9', ['<0@mailblog.biz>', '0=9', '1=9'])
     })
 
     it('RCPT TO:<r86x-ray@emailitin.com> state=1', () => {
-        _check('RCPT TO:<r86x-ray@emailitin.com> state=1',
-            ['<r86x-ray@emailitin.com>', 'state=1']);
+        _check('RCPT TO:<r86x-ray@emailitin.com> state=1', ['<r86x-ray@emailitin.com>', 'state=1'])
     })
 
     it('RCPT TO:<user=name@domain.com> foo=bar', () => {
-        _check('RCPT TO:<user=name@domain.com> foo=bar',
-            ['<user=name@domain.com>', 'foo=bar']);
+        _check('RCPT TO:<user=name@domain.com> foo=bar', ['<user=name@domain.com>', 'foo=bar'])
     })
 
     it('RCPT TO:<postmaster>', () => {
-        _check('RCPT TO:<postmaster>', ['<postmaster>']);
+        _check('RCPT TO:<postmaster>', ['<postmaster>'])
     })
 })