378 lines
11 KiB
JavaScript
378 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
var should = require('chai').should();
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var path = require('path');
|
|
var sinon = require('sinon');
|
|
var proxyquire = require('proxyquire');
|
|
var start = require('../../lib/scaffold/start');
|
|
|
|
describe('#start', function() {
|
|
describe('#setupServices', function() {
|
|
var cwd = process.cwd();
|
|
var setupServices = proxyquire('../../lib/scaffold/start', {}).setupServices;
|
|
it('will require an internal module', function() {
|
|
function InternalService() {}
|
|
InternalService.dependencies = [];
|
|
InternalService.prototype.start = sinon.stub();
|
|
InternalService.prototype.stop = sinon.stub();
|
|
var expectedPath = path.resolve(__dirname, '../../lib/services/internal');
|
|
var testRequire = function(p) {
|
|
p.should.equal(expectedPath);
|
|
return InternalService;
|
|
};
|
|
var config = {
|
|
services: ['internal'],
|
|
servicesConfig: {
|
|
internal: {
|
|
param: 'value'
|
|
}
|
|
}
|
|
};
|
|
var services = setupServices(testRequire, cwd, config);
|
|
services[0].name.should.equal('internal');
|
|
services[0].config.should.deep.equal({param: 'value'});
|
|
services[0].module.should.equal(InternalService);
|
|
});
|
|
it('will require a local module', function() {
|
|
function LocalService() {}
|
|
LocalService.dependencies = [];
|
|
LocalService.prototype.start = sinon.stub();
|
|
LocalService.prototype.stop = sinon.stub();
|
|
var notfoundPath = path.resolve(__dirname, '../../lib/services/local');
|
|
var testRequire = function(p) {
|
|
if (p === notfoundPath) {
|
|
throw new Error();
|
|
} else if (p === 'local') {
|
|
return LocalService;
|
|
} else if (p === 'local/package.json') {
|
|
return {
|
|
name: 'local'
|
|
};
|
|
}
|
|
};
|
|
var config = {
|
|
services: ['local']
|
|
};
|
|
var services = setupServices(testRequire, cwd, config);
|
|
services[0].name.should.equal('local');
|
|
services[0].module.should.equal(LocalService);
|
|
});
|
|
it('will require a local module with "bitcoreNode" in package.json', function() {
|
|
function LocalService() {}
|
|
LocalService.dependencies = [];
|
|
LocalService.prototype.start = sinon.stub();
|
|
LocalService.prototype.stop = sinon.stub();
|
|
var notfoundPath = path.resolve(__dirname, '../../lib/services/local');
|
|
var testRequire = function(p) {
|
|
if (p === notfoundPath) {
|
|
throw new Error();
|
|
} else if (p === 'local/package.json') {
|
|
return {
|
|
name: 'local',
|
|
bitcoreNode: 'lib/bitcoreNode.js'
|
|
};
|
|
} else if (p === 'local/lib/bitcoreNode.js') {
|
|
return LocalService;
|
|
}
|
|
};
|
|
var config = {
|
|
services: ['local']
|
|
};
|
|
var services = setupServices(testRequire, cwd, config);
|
|
services[0].name.should.equal('local');
|
|
services[0].module.should.equal(LocalService);
|
|
});
|
|
it('will throw error if module is incompatible', function() {
|
|
var internal = {};
|
|
var testRequire = function() {
|
|
return internal;
|
|
};
|
|
var config = {
|
|
services: ['bitcoind']
|
|
};
|
|
(function() {
|
|
setupServices(testRequire, cwd, config);
|
|
}).should.throw('Could not load service');
|
|
});
|
|
});
|
|
describe('#registerSyncHandlers', function() {
|
|
it('will log the sync status at an interval', function(done) {
|
|
var log = {
|
|
info: sinon.stub()
|
|
};
|
|
var registerSyncHandlers = proxyquire('../../lib/scaffold/start', {
|
|
'../': {
|
|
log: log
|
|
}
|
|
}).registerSyncHandlers;
|
|
var node = new EventEmitter();
|
|
node.services = {
|
|
db: new EventEmitter()
|
|
};
|
|
node.services.db.tip = {
|
|
hash: 'hash',
|
|
__height: 10
|
|
};
|
|
registerSyncHandlers(node, 10);
|
|
node.emit('ready');
|
|
node.services.db.emit('addblock');
|
|
setTimeout(function() {
|
|
node.emit('synced');
|
|
log.info.callCount.should.be.within(3, 4);
|
|
done();
|
|
}, 35);
|
|
});
|
|
});
|
|
describe('#cleanShutdown', function() {
|
|
it('will call node stop and process exit', function() {
|
|
var log = {
|
|
info: sinon.stub(),
|
|
error: sinon.stub()
|
|
};
|
|
var cleanShutdown = proxyquire('../../lib/scaffold/start', {
|
|
'../': {
|
|
log: log
|
|
}
|
|
}).cleanShutdown;
|
|
var node = {
|
|
stop: sinon.stub().callsArg(0)
|
|
};
|
|
var _process = {
|
|
exit: sinon.stub()
|
|
};
|
|
cleanShutdown(_process, node);
|
|
setImmediate(function() {
|
|
node.stop.callCount.should.equal(1);
|
|
_process.exit.callCount.should.equal(1);
|
|
_process.exit.args[0][0].should.equal(0);
|
|
});
|
|
});
|
|
it('will log error during shutdown and exit with status 1', function() {
|
|
var log = {
|
|
info: sinon.stub(),
|
|
error: sinon.stub()
|
|
};
|
|
var cleanShutdown = proxyquire('../../lib/scaffold/start', {
|
|
'../': {
|
|
log: log
|
|
}
|
|
}).cleanShutdown;
|
|
var node = {
|
|
stop: sinon.stub().callsArgWith(0, new Error('test'))
|
|
};
|
|
var _process = {
|
|
exit: sinon.stub()
|
|
};
|
|
cleanShutdown(_process, node);
|
|
setImmediate(function() {
|
|
node.stop.callCount.should.equal(1);
|
|
log.error.callCount.should.equal(1);
|
|
_process.exit.callCount.should.equal(1);
|
|
_process.exit.args[0][0].should.equal(1);
|
|
});
|
|
});
|
|
});
|
|
describe('#registerExitHandlers', function() {
|
|
var log = {
|
|
info: sinon.stub(),
|
|
error: sinon.stub()
|
|
};
|
|
var registerExitHandlers = proxyquire('../../lib/scaffold/start', {
|
|
'../': {
|
|
log: log
|
|
}
|
|
}).registerExitHandlers;
|
|
it('log, stop and exit with an `uncaughtException`', function(done) {
|
|
var proc = new EventEmitter();
|
|
proc.exit = sinon.stub();
|
|
var node = {
|
|
stop: sinon.stub().callsArg(0)
|
|
};
|
|
registerExitHandlers(proc, node);
|
|
proc.emit('uncaughtException', new Error('test'));
|
|
setImmediate(function() {
|
|
node.stop.callCount.should.equal(1);
|
|
proc.exit.callCount.should.equal(1);
|
|
done();
|
|
});
|
|
});
|
|
it('stop and exit on `SIGINT`', function(done) {
|
|
var proc = new EventEmitter();
|
|
proc.exit = sinon.stub();
|
|
var node = {
|
|
stop: sinon.stub().callsArg(0)
|
|
};
|
|
registerExitHandlers(proc, node);
|
|
proc.emit('SIGINT');
|
|
setImmediate(function() {
|
|
node.stop.callCount.should.equal(1);
|
|
proc.exit.callCount.should.equal(1);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
describe('#spawnChildProcess', function() {
|
|
|
|
it('should build the appropriate arguments to spawn a child process', function() {
|
|
var child = {
|
|
unref: function() {}
|
|
};
|
|
var _process = {
|
|
exit: function() {},
|
|
env: {
|
|
__bitcore_node: false
|
|
},
|
|
argv: [
|
|
'node',
|
|
'bitcore-node'
|
|
],
|
|
cwd: function(){return ''},
|
|
pid: 999,
|
|
execPath: '/tmp'
|
|
};
|
|
var fd = {};
|
|
var spawn = sinon.stub().returns(child);
|
|
var openSync = sinon.stub().returns(fd);
|
|
var spawnChildProcess = proxyquire('../../lib/scaffold/start', {
|
|
fs: {
|
|
openSync: openSync
|
|
},
|
|
child_process: {
|
|
spawn: spawn
|
|
}
|
|
}).spawnChildProcess;
|
|
|
|
spawnChildProcess('/tmp', _process);
|
|
|
|
spawn.callCount.should.equal(1);
|
|
spawn.args[0][0].should.equal(_process.execPath);
|
|
var expected = [].concat(_process.argv);
|
|
expected.shift();
|
|
spawn.args[0][1].should.deep.equal(expected);
|
|
var cp_opt = {
|
|
stdio: ['ignore', fd, fd],
|
|
env: _process.env,
|
|
cwd: '',
|
|
detached: true
|
|
};
|
|
spawn.args[0][2].should.deep.equal(cp_opt);
|
|
openSync.callCount.should.equal(1);
|
|
openSync.args[0][0].should.equal('/tmp/bitcore-node.log');
|
|
openSync.args[0][1].should.equal('a+');
|
|
});
|
|
it('should not spawn a new child process if there is already a daemon running', function() {
|
|
var _process = {
|
|
exit: function() {},
|
|
env: {
|
|
__bitcore_node: true
|
|
},
|
|
argv: [
|
|
'node',
|
|
'bitcore-node'
|
|
],
|
|
cwd: 'cwd',
|
|
pid: 999,
|
|
execPath: '/tmp'
|
|
};
|
|
var spawnChildProcess = proxyquire('../../lib/scaffold/start', {}).spawnChildProcess;
|
|
spawnChildProcess('/tmp', _process).should.equal(999);
|
|
});
|
|
});
|
|
describe('daemon', function() {
|
|
var sandbox;
|
|
var spawn;
|
|
var setup;
|
|
var registerSync;
|
|
var registerExit;
|
|
var start = require('../../lib/scaffold/start');
|
|
var options = {
|
|
config: {
|
|
datadir: '/tmp',
|
|
daemon: true
|
|
}
|
|
}
|
|
beforeEach(function() {
|
|
sandbox = sinon.sandbox.create();
|
|
spawn = sandbox.stub(start, 'spawnChildProcess', function() {});
|
|
setup = sandbox.stub(start, 'setupServices', function() {});
|
|
registerSync = sandbox.stub(start, 'registerSyncHandlers', function() {});
|
|
registerExit = sandbox.stub(start, 'registerExitHandlers', function() {});
|
|
});
|
|
afterEach(function() {
|
|
sandbox.restore();
|
|
});
|
|
it('call spawnChildProcess if there is a config option to do so', function() {
|
|
start(options);
|
|
registerSync.callCount.should.equal(1);
|
|
registerExit.callCount.should.equal(1);
|
|
spawn.callCount.should.equal(1);
|
|
});
|
|
it('not call spawnChildProcess if there is not an option to do so', function() {
|
|
options.config.daemon = false;
|
|
start(options);
|
|
registerSync.callCount.should.equal(1);
|
|
registerExit.callCount.should.equal(1);
|
|
spawn.callCount.should.equal(0);
|
|
});
|
|
});
|
|
describe('#registerExitHandlers', function() {
|
|
var stub;
|
|
var registerExitHandlers = require('../../lib/scaffold/start').registerExitHandlers;
|
|
|
|
before(function() {
|
|
stub = sinon.stub(process, 'on');
|
|
});
|
|
|
|
after(function() {
|
|
stub.restore();
|
|
});
|
|
|
|
it('should setup two listeners on process when registering exit handlers', function() {
|
|
registerExitHandlers(process, {});
|
|
stub.callCount.should.equal(2);
|
|
});
|
|
|
|
describe('#exitHandler', function() {
|
|
var sandbox;
|
|
var cleanShutdown;
|
|
var exitHandler;
|
|
var logStub;
|
|
|
|
before(function() {
|
|
sandbox = sinon.sandbox.create();
|
|
var start = require('../../lib/scaffold/start');
|
|
var log = require('../../lib').log;
|
|
logStub = sandbox.stub(log, 'error');
|
|
cleanShutdown = sandbox.stub(start, 'cleanShutdown', function() {});
|
|
exitHandler = require('../../lib/scaffold/start').exitHandler;
|
|
});
|
|
|
|
after(function() {
|
|
sandbox.restore();
|
|
});
|
|
|
|
it('should replace the listener for SIGINT after the first SIGINT is handled', function() {
|
|
var options = { sigint: true };
|
|
var node = {};
|
|
exitHandler(options, process, node);
|
|
cleanShutdown.callCount.should.equal(1);
|
|
exitHandler(options, process, node);
|
|
cleanShutdown.callCount.should.equal(1);
|
|
});
|
|
|
|
it('should log all errors and stops the services nonetheless', function() {
|
|
var options = { sigint: true };
|
|
var stop = sinon.stub();
|
|
var node = {
|
|
stop: stop
|
|
};
|
|
exitHandler(options, process, node, new Error('some error'));
|
|
logStub.callCount.should.equal(2);
|
|
stop.callCount.should.equal(1);
|
|
});
|
|
|
|
});
|
|
});
|
|
});
|