boomcatch
Version:
A standalone, node.js-based beacon receiver for boomerang.
1,392 lines (1,323 loc) • 125 kB
JavaScript
// Copyright © 2014, 2015, 2016 Springer Nature
//
// This file is part of boomcatch.
//
// Boomcatch is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Boomcatch is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with boomcatch. If not, see <http://www.gnu.org/licenses/>.
'use strict';
var assert, mockery, spooks, modulePath, nop;
assert = require('chai').assert;
mockery = require('mockery');
spooks = require('spooks');
modulePath = '../src';
nop = function () {};
mockery.registerAllowable(modulePath);
mockery.registerAllowable('check-types');
mockery.registerAllowable('url');
mockery.registerAllowable('qs');
mockery.registerAllowable('./lib/');
mockery.registerAllowable('./stringify');
mockery.registerAllowable('./utils');
mockery.registerAllowable('./parse');
mockery.registerAllowable('./v1');
mockery.registerAllowable('./v4');
mockery.registerAllowable('./lib/rng');
mockery.registerAllowable('./lib/bytesToUuid');
mockery.registerAllowable('./formats');
process.setMaxListeners(500);
suite('index:', function () {
var log, results, restrict, cluster, isTooBusy;
setup(function () {
log = {};
results = {
existsSync: [],
statSync: [],
readFileSync: []
};
cluster = spooks.obj({
archetype: { fork: nop, on: nop },
log: log
});
mockery.enable({ useCleanCache: true });
mockery.registerMock('http', spooks.obj({
archetype: { createServer: nop, listen: nop },
log: log,
chains: { createServer: true }
}));
mockery.registerMock('https', spooks.obj({
archetype: { options: {}, createServer: nop, listen: nop },
log: log,
chains: { createServer: true }
}));
mockery.registerMock('fs', spooks.obj({
archetype: { existsSync: nop, statSync: nop, readFileSync: nop },
log: log,
results: results
}));
mockery.registerMock('./validators/permissive', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'validator',
log: log,
results: [ true ]
})
]
}
}));
mockery.registerMock('./filters/unfiltered', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
function (data) {
log.counts.filter += 1;
log.args.filter.push(arguments);
log.these.filter.push(this);
return data;
}
]
}
}));
mockery.registerMock('./mappers/statsd', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'mapper',
log: log,
results: [ 'default mapped data' ]
})
]
}
}));
mockery.registerMock('./forwarders/udp', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'forwarder',
log: log
})
]
}
}));
mockery.registerMock('./validators/restrictive', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
function () {
log.counts.validator += 1;
log.these.validator.push(this);
log.args.validator.push(arguments);
return !restrict;
}
]
}
}));
mockery.registerMock('./filters/filtered', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'filter',
log: log,
results: [ {} ]
})
]
}
}));
mockery.registerMock('./mappers/mapper', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'mapper',
log: log,
results: [ 'alternative mapped data' ]
})
]
}
}));
mockery.registerMock('./forwarders/forwarder', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'forwarder',
log: log
})
]
}
}));
mockery.registerMock('./mappers/failing', spooks.obj({
archetype: { initialise: nop },
log: log,
results: {
initialise: [
spooks.fn({
name: 'mapper',
log: log,
results: [ '' ]
})
]
}
}));
mockery.registerMock('toobusy-js', function () {
log.counts.toobusy += 1;
log.these.toobusy.push(this);
log.args.toobusy.push(arguments);
});
log.counts.toobusy = 0;
log.these.toobusy = [];
log.args.toobusy = [];
mockery.registerMock('cluster', cluster);
});
teardown(function () {
mockery.deregisterMock('cluster');
mockery.deregisterMock('toobusy-js');
mockery.deregisterMock('./mappers/failing');
mockery.deregisterMock('./forwarders/forwarder');
mockery.deregisterMock('./mappers/mapper');
mockery.deregisterMock('./filters/filtered');
mockery.deregisterMock('./validators/restrictive');
mockery.deregisterMock('./forwarders/udp');
mockery.deregisterMock('./mappers/statsd');
mockery.deregisterMock('./filters/unfiltered');
mockery.deregisterMock('./validators/permissive');
mockery.deregisterMock('fs');
mockery.deregisterMock('https');
mockery.deregisterMock('http');
mockery.disable();
log = undefined;
});
test('require does not throw', function () {
assert.doesNotThrow(function () {
require(modulePath);
});
});
test('require returns object', function () {
assert.isObject(require(modulePath));
});
suite('require:', function () {
var boomcatch;
setup(function () {
boomcatch = require(modulePath);
});
teardown(function () {
boomcatch = undefined;
});
test('listen function is exported', function () {
assert.isFunction(boomcatch.listen);
});
test('listen does not throw without options', function () {
assert.doesNotThrow(function () {
boomcatch.listen();
});
});
test('listen throws if host is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if port is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: '80',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if path is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if referer is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: 'bar',
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if origin is not a URL', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'baz',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if limit is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: '100',
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if maxSize is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: '1024',
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if log.info is not function', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if log.warn is not function', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if log.error is not function', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if validator is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: '',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if filter is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: '',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if mapper is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: '',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if prefix is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: '',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if forwarder is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: '',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if fwdHost is empty string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if fwdPort is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: '8125',
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if fwdSize is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if workers is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: '4',
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if workers is negative number', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: -1,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if delayRespawn is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: '200',
maxRespawn: -1
});
});
});
test('listen throws if delayRespawn is negative number', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: -1,
maxRespawn: -1
});
});
});
test('listen throws if maxRespawn is string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: '256',
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: '-1'
});
});
});
test('listen does not throw if options are valid', function () {
assert.doesNotThrow(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen does not throw if options are null', function () {
assert.doesNotThrow(function () {
boomcatch.listen({
host: null,
port: null,
path: null,
referer: null,
origin: null,
limit: null,
maxSize: null,
log: null,
validator: null,
filter: null,
mapper: null,
prefix: null,
forwarder: null,
fwdHost: null,
fwdPort: null,
fwdSize: null,
fwdUrl: null,
fwdMethod: null,
workers: null,
delayRespawn: null,
maxRespawn: null
});
});
});
test('listen throws if HTTPS PFX is not a string', function () {
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsPfx: { toString: function () { return 'wibble' } },
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen does not throw if HTTPS PFX is string', function () {
assert.doesNotThrow(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsPfx: 'wibble',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if HTTPS private key path is not a string', function () {
results.existsSync[0] = true;
results.statSync[0] = { isFile: function () { return true; } };
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsKey: { toString: function () { return 'wibble' } },
httpsCert: 'wobble',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if HTTPS certificate path is not a string', function () {
results.existsSync[0] = true;
results.statSync[0] = { isFile: function () { return true; } };
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsKey: 'wibble',
httpsCert: { toString: function () { return 'wobble' } },
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if HTTPS private key path is not found', function () {
results.existsSync[0] = false;
results.existsSync[1] = true;
results.statSync[0] = { isFile: function () { return true; } };
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsKey: 'wibble',
httpsCert: 'wobble',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen throws if HTTPS certificate path is not found', function () {
results.existsSync[0] = true;
results.statSync[0] = { isFile: function () { return true; } };
results.statSync[1] = { isFile: function () { return false; } };
assert.throws(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsKey: 'wibble',
httpsCert: 'wobble',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
test('listen does not throw if HTTPS private key and certificate paths are found', function () {
results.existsSync[0] = true;
results.statSync[0] = { isFile: function () { return true; } };
assert.doesNotThrow(function () {
boomcatch.listen({
host: '127.0.0.1',
port: 80,
https: true,
httpsKey: 'wibble',
httpsCert: 'wobble',
path: '/foo',
referer: /bar/,
origin: 'http://example.com/',
limit: 100,
maxSize: 1024,
log: {
info: function () {},
warn: function () {},
error: function () {}
},
validator: 'restrictive',
filter: 'filtered',
mapper: 'mapper',
prefix: 'prefix',
forwarder: 'forwarder',
fwdHost: '192.168.50.4',
fwdPort: 8125,
fwdSize: 256,
fwdUrl: 'http://example.com/',
fwdMethod: 'POST',
workers: 2,
delayRespawn: 100,
maxRespawn: -1
});
});
});
suite('call listen with default options:', function () {
setup(function () {
boomcatch.listen();
});
test('?.initialise was called four times', function () {
assert.strictEqual(log.counts.initialise, 4);
});
test('validator.initialise was called correctly', function () {
assert.strictEqual(log.these.initialise[0], require('./validators/permissive'));
assert.lengthOf(log.args.initialise[0], 1);
assert.isObject(log.args.initialise[0][0]);
});
test('filter.initialise was called correctly', function () {
assert.strictEqual(log.these.initialise[1], require('./filters/unfiltered'));
assert.lengthOf(log.args.initialise[1], 1);
assert.isObject(log.args.initialise[1][0]);
});
test('mapper.initialise was called correctly', function () {
assert.strictEqual(log.these.initialise[2], require('./mappers/statsd'));
assert.lengthOf(log.args.initialise[2], 1);
assert.isObject(log.args.initialise[2][0]);
assert.isUndefined(log.args.initialise[2][0].prefix);
});
test('forwarder.initialise was called correctly', function () {
assert.strictEqual(log.these.initialise[3], require('./forwarders/udp'));
assert.lengthOf(log.args.initialise[3], 1);
assert.isObject(log.args.initialise[3][0]);
assert.isUndefined(log.args.initialise[3][0].fwdHost);
assert.isUndefined(log.args.initialise[3][0].fwdPort);
});
test('http.createServer was called once', function () {
assert.strictEqual(log.counts.createServer, 1);
});
test('http.createServer was called correctly', function () {
assert.strictEqual(log.these.createServer[0], require('http'));
assert.lengthOf(log.args.createServer[0], 1);
assert.isFunction(log.args.createServer[0][0]);
});
test('http.listen was called once', function () {
assert.strictEqual(log.counts.listen, 1);
});
test('http.listen was called correctly', function () {
assert.strictEqual(log.these.listen[0], require('http').createServer());
assert.lengthOf(log.args.listen[0], 2);
assert.strictEqual(log.args.listen[0][0], 80);
assert.strictEqual(log.args.listen[0][1], '0.0.0.0');
});
test('cluster.fork was not called', function () {
assert.strictEqual(log.counts.fork, 0);
});
test('cluster.on was not called', function () {
assert.strictEqual(log.counts.on, 0);
});
suite('invalid path:', function () {
var request, response;
setup(function () {
request = {
url: '/foo?rt.tstart=1&t_resp=2&t_page=3&t_done=4&r=wibble',
method: 'GET',
headers: {},
socket: {
destroy: spooks.fn({
name: 'destroy',
log: log
})
}
};
response = spooks.obj({
archetype: { setHeader: nop, end: nop },