Haraka 3.0.2 → 3.0.4

package/test/plugins/relay.js

@@ -0,0 +1,303 @@
+'use strict';
+const assert = require('node:assert')
+
+const fixtures = require('haraka-test-fixtures');
+
+const _set_up = (done) => {
+    this.plugin = new fixtures.plugin('relay');
+    this.plugin.cfg = {};
+    this.connection = fixtures.connection.createConnection();
+    done();
+}
+
+describe('relay', () => {
+    describe('plugin', () => {
+        beforeEach(_set_up)
+
+        it('should have register function', () => {
+            assert.ok(this.plugin);
+            assert.equal('function', typeof this.plugin.register);
+        })
+
+        it('register function should call register_hook()', () => {
+            this.plugin.register();
+            assert.ok(this.plugin.register_hook.called);
+        })
+    })
+
+    describe('load_config_files', () => {
+        beforeEach(_set_up)
+
+        it('relay.ini', () => {
+            this.plugin.load_relay_ini();
+            assert.ok(typeof this.plugin.cfg === 'object');
+            assert.ok(this.plugin.cfg);
+            assert.ok(this.plugin.cfg.relay);
+        })
+
+        it('relay_dest_domains.ini', () => {
+            this.plugin.load_dest_domains();
+            assert.ok(typeof this.plugin.dest === 'object');
+        })
+    })
+
+    describe('is_acl_allowed', () => {
+        beforeEach(_set_up)
+
+        it('bare IP', () => {
+            this.plugin.acl_allow=['127.0.0.6'];
+            this.connection.remote.ip='127.0.0.6';
+            assert.equal(true, this.plugin.is_acl_allowed(this.connection));
+            this.connection.remote.ip='127.0.0.5';
+            assert.equal(false, this.plugin.is_acl_allowed(this.connection));
+            this.connection.remote.ip='127.0.1.5';
+            assert.equal(false, this.plugin.is_acl_allowed(this.connection));
+        })
+
+        it('netmask', () => {
+            this.plugin.acl_allow=['127.0.0.6/24'];
+            this.connection.remote.ip='127.0.0.6';
+            assert.equal(true, this.plugin.is_acl_allowed(this.connection));
+            this.connection.remote.ip='127.0.0.5';
+            assert.equal(true, this.plugin.is_acl_allowed(this.connection));
+            this.connection.remote.ip='127.0.1.5';
+            assert.equal(false, this.plugin.is_acl_allowed(this.connection));
+        })
+
+        it('mixed (ipv4 & ipv6 (Issue #428))', () => {
+            this.connection.remote.ip='2607:f060:b008:feed::2';
+            assert.equal(false, this.plugin.is_acl_allowed(this.connection));
+
+            this.plugin.acl_allow=['2607:f060:b008:feed::2/64'];
+            this.connection.remote.ip='2607:f060:b008:feed::2';
+            assert.equal(true, this.plugin.is_acl_allowed(this.connection));
+
+            this.plugin.acl_allow=['127.0.0.6/24'];
+            this.connection.remote.ip='2607:f060:b008:feed::2';
+            assert.equal(false, this.plugin.is_acl_allowed(this.connection));
+        })
+    })
+
+    describe('acl', () => {
+        beforeEach((done) => {
+            this.plugin = new fixtures.plugin('relay');
+            this.plugin.cfg = { relay: { dest_domains: true } };
+            this.connection = fixtures.connection.createConnection();
+            done();
+        })
+
+        it('relay.acl=false', (done) => {
+            this.plugin.cfg.relay.acl=false;
+            this.plugin.acl(() => {}, this.connection);
+            this.plugin.pass_relaying((rc) => {
+                assert.equal(undefined, rc);
+                done();
+            }, this.connection);
+        })
+
+        it('relay.acl=true, miss', (done) => {
+            this.plugin.cfg.relay.acl=true;
+            this.plugin.acl(() => {}, this.connection);
+            this.plugin.pass_relaying((rc) => {
+                assert.equal(undefined, rc);
+                assert.equal(false, this.connection.relaying);
+                done();
+            }, this.connection);
+        })
+
+        it('relay.acl=true, hit', (done) => {
+            this.plugin.cfg.relay.acl=true;
+            this.connection.remote.ip='1.1.1.1';
+            this.plugin.acl_allow=['1.1.1.1/32'];
+            this.plugin.acl(() => {}, this.connection);
+            this.plugin.pass_relaying((rc) => {
+                assert.equal(OK, rc);
+                assert.equal(true, this.connection.relaying);
+                done();
+            }, this.connection);
+        })
+
+        it('relay.acl=true, hit, missing mask', (done) => {
+            this.plugin.cfg.relay.acl=true;
+            this.connection.remote.ip='1.1.1.1';
+            this.plugin.acl_allow=['1.1.1.1'];
+            this.plugin.acl(() => {}, this.connection);
+            this.plugin.pass_relaying((rc) => {
+                assert.equal(OK, rc);
+                assert.equal(true, this.connection.relaying);
+                done();
+            }, this.connection);
+        })
+
+        it('relay.acl=true, hit, net', (done) => {
+            this.plugin.cfg.relay.acl=true;
+            this.connection.remote.ip='1.1.1.1';
+            this.plugin.acl_allow=['1.1.1.1/24'];
+            this.plugin.acl(() => {}, this.connection);
+            this.plugin.pass_relaying((rc) => {
+                assert.equal(OK, rc);
+                assert.equal(true, this.connection.relaying);
+                done();
+            }, this.connection);
+        })
+    })
+
+    describe('dest_domains', () => {
+        beforeEach((done) => {
+            this.plugin = new fixtures.plugin('relay');
+            this.plugin.cfg = { relay: { dest_domains: true } };
+
+            this.connection = fixtures.connection.createConnection();
+            this.connection.init_transaction();
+
+            done();
+        })
+
+        it('relay.dest_domains=false', (done) => {
+            this.plugin.cfg.relay.dest_domains=false;
+            this.plugin.dest_domains((rc) => {
+                assert.equal(undefined, rc);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('relaying', (done) => {
+            this.connection.relaying=true;
+            this.plugin.dest_domains((rc) => {
+                assert.equal(undefined, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').skip.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('no config', (done) => {
+            this.plugin.dest_domains((rc) => {
+                assert.equal(undefined, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').err.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('action=undef', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"dunno"}' } };
+            this.plugin.dest_domains((rc) => {
+                assert.equal(DENY, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').fail.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('action=deny', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"deny"}' } };
+            this.plugin.dest_domains((rc) => {
+                assert.equal(DENY, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').fail.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('action=continue', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"continue"}' } };
+            this.plugin.dest_domains((rc) => {
+                assert.equal(CONT, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').pass.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+
+        it('action=accept', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"continue"}' } };
+            this.plugin.dest_domains((rc) => {
+                assert.equal(CONT, rc);
+                assert.equal(1, this.connection.transaction.results.get('relay').pass.length);
+                done();
+            }, this.connection, [{host:'foo'}]);
+        })
+    })
+
+    describe('force_routing', () => {
+        beforeEach((done) => {
+            this.plugin = new fixtures.plugin('relay');
+            this.plugin.cfg = { relay: { force_routing: true } };
+            this.plugin.dest = {};
+
+            this.connection = fixtures.connection.createConnection();
+            this.connection.init_transaction()
+
+            done();
+        })
+
+        it('relay.force_routing=false', (done) => {
+            this.plugin.cfg.relay.force_routing=false;
+            this.plugin.force_routing((rc) => {
+                assert.equal(undefined, rc);
+                done();
+            }, this.connection, 'foo');
+        })
+
+        it('dest_domains empty', (done) => {
+            this.plugin.force_routing((rc) => {
+                assert.equal(undefined, rc);
+                done();
+            }, this.connection, 'foo');
+        })
+
+        it('dest_domains, no route', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"blah blah"}' } };
+            this.plugin.force_routing((rc, nexthop) => {
+                assert.equal(undefined, rc);
+                assert.equal(undefined, nexthop);
+                done();
+            }, this.connection, 'foo');
+        })
+
+        it('dest_domains, route', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"blah blah","nexthop":"other-server"}' } };
+            this.plugin.force_routing((rc, nexthop) => {
+                assert.equal(OK, rc);
+                assert.equal('other-server', nexthop);
+                done();
+            }, this.connection, 'foo');
+        })
+
+        it('dest-domains, any', (done) => {
+            this.plugin.dest = { domains: { foo: '{"action":"blah blah","nexthop":"other-server"}',
+                any: '{"action":"blah blah","nexthop":"any-server"}'} };
+            this.plugin.force_routing((rc, nexthop) => {
+                assert.equal(OK, rc);
+                assert.equal('any-server', nexthop);
+                done();
+            }, this.connection, 'not');
+        })
+    })
+
+    describe('all', () => {
+        beforeEach(_set_up)
+
+        it('register_hook() should register available function', () => {
+            assert.ok(this.plugin.all);
+            assert.equal('function', typeof this.plugin.all);
+            this.plugin.register();
+            this.plugin.cfg.relay.all = true;
+            this.plugin.register_hook('rcpt', 'all');  // register() doesn't b/c config is disabled
+            // console.log(this.plugin.register_hook.args);
+            assert.equal(this.plugin.register_hook.args[3][1], 'all');
+        })
+
+        it('all hook always returns OK', (done) => {
+            this.plugin.cfg.relay = { all: true };
+            this.plugin.all((action) => {
+                assert.equal(action, OK);
+                done();
+            }, this.connection, ['foo@bar.com']);
+        })
+
+        it('all hook always sets connection.relaying to 1', (done) => {
+            this.plugin.cfg.relay = { all: true };
+            this.plugin.all((action) => {
+                assert.equal(this.connection.relaying, 1);
+                done();
+            }, this.connection, ['foo@bar.com']);
+        })
+    })
+})

package/test/plugins/status.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const assert = require('node:assert')
+
+const fixtures = require('haraka-test-fixtures');
+const outbound = require('../../outbound');
+const TimerQueue = require('../../outbound/timer_queue');
+
+const Connection = fixtures.connection;
+
+const _set_up = (done) => {
+    this.plugin = new fixtures.plugin('status');
+    this.plugin.outbound = outbound;
+
+    this.connection = Connection.createConnection();
+    this.connection.remote.is_local = true;
+    done();
+}
+
+describe('status', () => {
+
+    describe('register', () => {
+        beforeEach(_set_up)
+
+        it('loads the status plugin', () => {
+            assert.equal('status', this.plugin.name);
+        })
+    })
+
+    describe('access', () => {
+        beforeEach(_set_up)
+
+        it('remote', (done) => {
+            this.connection.remote.is_local = false;
+            this.plugin.hook_unrecognized_command((code) => {
+                assert.equal(DENY, code);
+                done();
+            }, this.connection, ['STATUS', 'POOL LIST']);
+        })
+    })
+
+    describe('pools', () => {
+        beforeEach(_set_up)
+
+        it('list_pools', (done) => {
+            this.connection.respond = (code, message) => {
+                const data = JSON.parse(message);
+                assert.equal('object', typeof data); // there should be one pools array for noncluster and more for cluster
+                done();
+            };
+            this.plugin.hook_unrecognized_command(() => {}, this.connection, ['STATUS', 'POOL LIST']);
+        })
+    })
+
+    describe('queues', () => {
+        beforeEach(_set_up)
+
+        it('inspect_queue', (done) => {
+            // should list delivery_queue and temp_fail_queue per cluster children
+            outbound.temp_fail_queue = new TimerQueue(10);
+            outbound.temp_fail_queue.add('file1', 100, () => {});
+            outbound.temp_fail_queue.add('file2', 100, () => {});
+
+            this.connection.respond = (code, message) => {
+                const data = JSON.parse(message);
+                assert.equal(0, data.delivery_queue.length);
+                assert.equal(2, data.temp_fail_queue.length);
+                done();
+            };
+            this.plugin.hook_unrecognized_command(() => {}, this.connection, ['STATUS', 'QUEUE INSPECT']);
+        })
+
+        it('stat_queue', (done) => {
+            // should list files only
+            this.connection.respond = (code, message) => {
+                const data = JSON.parse(message);
+                assert.ok(/^\d+\/\d+\/\d+$/.test(data));
+                done();
+            };
+            this.plugin.hook_unrecognized_command(() => {}, this.connection, ['STATUS', 'QUEUE STATS']);
+        })
+
+        it('list_queue', (done) => {
+            // should list files only
+            this.connection.respond = (code, message) => {
+                const data = JSON.parse(message);
+                assert.equal(0, data.length);
+                done();
+            };
+            this.plugin.hook_unrecognized_command(() => {}, this.connection, ['STATUS', 'QUEUE LIST']);
+        })
+
+        it('discard_from_queue', (done) => {
+            const self = this;
+
+            outbound.temp_fail_queue = new TimerQueue(10);
+            outbound.temp_fail_queue.add('file1', 10, () => {
+                assert.ok(false, 'This callback should not be called');
+                done();
+            })
+
+            outbound.temp_fail_queue.add('file2', 2000, () => {});
+
+            this.plugin.hook_unrecognized_command(() => {
+                self.connection.respond = (code, message) => {
+                    const data = JSON.parse(message);
+                    assert.equal(1, data.temp_fail_queue.length);
+                    done();
+                }
+                self.plugin.hook_unrecognized_command(() => {}, self.connection, ['STATUS', 'QUEUE INSPECT']);
+            }, this.connection, ['STATUS', 'QUEUE DISCARD file1']);
+        })
+
+        it('push_email_at_queue', (done) => {
+            const timeout = setTimeout(() => {
+                assert.ok(false, 'Timeout');
+                done();
+            }, 1000);
+
+            outbound.temp_fail_queue.add('file', 1500, () => {
+                clearTimeout(timeout);
+
+                assert.ok(true);
+                done();
+            });
+
+            this.plugin.hook_unrecognized_command(() => {}, this.connection, ['STATUS', 'QUEUE PUSH file']);
+        })
+    })
+})

package/test/plugins/tls.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const assert = require('node:assert')
+const path = require('node:path');
+
+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();
+
+    // 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 = {};
+    done();
+}
+
+describe('tls', ()=> {
+    beforeEach(_set_up)
+
+    it('has function 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);
+    })
+
+    it('has function 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);
+    })
+
+    describe('register', ()=> {
+        it('with certs, should call register_hook()', () => {
+            this.plugin.register();
+            assert.ok(this.plugin.register_hook.called);
+        })
+    })
+
+    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"');
+        })
+
+        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"');
+        })
+    })
+})