483 lines
13 KiB
JavaScript
483 lines
13 KiB
JavaScript
'use strict';
|
|
|
|
var should = require('chai').should();
|
|
var sinon = require('sinon');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var proxyquire = require('proxyquire');
|
|
|
|
var index = require('../../lib');
|
|
var log = index.log;
|
|
|
|
var httpStub = {
|
|
createServer: sinon.spy()
|
|
};
|
|
var httpsStub = {
|
|
createServer: sinon.spy()
|
|
};
|
|
var fsStub = {
|
|
readFileSync: function(arg1) {
|
|
return arg1 + '-buffer';
|
|
}
|
|
};
|
|
|
|
var fakeSocketListener = new EventEmitter();
|
|
var fakeSocket = new EventEmitter();
|
|
|
|
fakeSocket.on('test/event1', function(data) {
|
|
data.should.equal('testdata');
|
|
});
|
|
|
|
fakeSocketListener.emit('connection', fakeSocket);
|
|
fakeSocket.emit('subscribe', 'test/event1');
|
|
|
|
var WebService = proxyquire('../../lib/services/web', {http: httpStub, https: httpsStub, fs: fsStub});
|
|
|
|
describe('WebService', function() {
|
|
var defaultNode = new EventEmitter();
|
|
|
|
describe('@constructor', function() {
|
|
it('will set socket rpc settings', function() {
|
|
var web = new WebService({node: defaultNode, enableSocketRPC: false});
|
|
web.enableSocketRPC.should.equal(false);
|
|
|
|
var web2 = new WebService({node: defaultNode, enableSocketRPC: true});
|
|
web2.enableSocketRPC.should.equal(true);
|
|
|
|
var web3 = new WebService({node: defaultNode});
|
|
web3.enableSocketRPC.should.equal(WebService.DEFAULT_SOCKET_RPC);
|
|
});
|
|
it('will set configuration options for max payload', function() {
|
|
var web = new WebService({node: defaultNode, jsonRequestLimit: '200kb'});
|
|
web.jsonRequestLimit.should.equal('200kb');
|
|
});
|
|
});
|
|
|
|
describe('#start', function() {
|
|
beforeEach(function() {
|
|
httpStub.createServer.reset();
|
|
httpsStub.createServer.reset();
|
|
});
|
|
it('should create an http server if no options are specified and node is not configured for https', function(done) {
|
|
var web = new WebService({node: defaultNode});
|
|
web.deriveHttpsOptions = sinon.spy();
|
|
web.start(function(err) {
|
|
should.not.exist(err);
|
|
httpStub.createServer.called.should.equal(true);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should create an https server if no options are specified and node is configured for https', function(done) {
|
|
var node = new EventEmitter();
|
|
node.https = true;
|
|
|
|
var web = new WebService({node: node});
|
|
web.transformHttpsOptions = sinon.spy();
|
|
web.start(function(err) {
|
|
should.not.exist(err);
|
|
httpsStub.createServer.called.should.equal(true);
|
|
done();
|
|
});
|
|
});
|
|
it('should pass json request limit to json body parser', function(done) {
|
|
var node = new EventEmitter();
|
|
var jsonStub = sinon.stub();
|
|
var TestWebService = proxyquire('../../lib/services/web', {
|
|
http: {
|
|
createServer: sinon.stub()
|
|
},
|
|
https: {
|
|
createServer: sinon.stub()
|
|
},
|
|
fs: fsStub,
|
|
express: sinon.stub().returns({
|
|
use: sinon.stub()
|
|
}),
|
|
'body-parser': {
|
|
json: jsonStub
|
|
},
|
|
'socket.io': {
|
|
listen: sinon.stub().returns({
|
|
on: sinon.stub()
|
|
})
|
|
}
|
|
});
|
|
var web = new TestWebService({node: node});
|
|
web.start(function(err) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
jsonStub.callCount.should.equal(1);
|
|
jsonStub.args[0][0].limit.should.equal('100kb');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#stop', function() {
|
|
it('should close the server if it exists', function(done) {
|
|
var web = new WebService({node: defaultNode});
|
|
web.server = {
|
|
close: sinon.spy()
|
|
};
|
|
|
|
web.stop(function(err) {
|
|
should.not.exist(err);
|
|
web.server.close.callCount.should.equal(1);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#setupAllRoutes', function() {
|
|
it('should call setupRoutes on each module', function() {
|
|
var node = {
|
|
on: sinon.spy(),
|
|
services: {
|
|
one: {
|
|
setupRoutes: sinon.spy(),
|
|
getRoutePrefix: sinon.stub().returns('one')
|
|
},
|
|
two: {
|
|
setupRoutes: sinon.spy(),
|
|
getRoutePrefix: sinon.stub().returns('two')
|
|
}
|
|
}
|
|
};
|
|
|
|
var web = new WebService({node: node});
|
|
web.app = {
|
|
use: sinon.spy()
|
|
};
|
|
|
|
web.setupAllRoutes();
|
|
node.services.one.setupRoutes.callCount.should.equal(1);
|
|
should.exist(node.services.one.setupRoutes.args[0][0].engine);
|
|
should.exist(node.services.one.setupRoutes.args[0][0].get);
|
|
should.exist(node.services.one.setupRoutes.args[0][0].post);
|
|
should.exist(node.services.one.setupRoutes.args[0][0].set);
|
|
node.services.two.setupRoutes.callCount.should.equal(1);
|
|
});
|
|
});
|
|
|
|
describe('#createMethodsMap', function() {
|
|
it('should create the methodsMap correctly', function(done) {
|
|
var Module1 = function() {};
|
|
Module1.prototype.getAPIMethods = function() {
|
|
return [
|
|
['one', this, this.one, 1],
|
|
['two', this, this.two, 2]
|
|
];
|
|
};
|
|
Module1.prototype.one = function(param1, callback) {
|
|
callback(null, param1);
|
|
};
|
|
Module1.prototype.two = function(param1, param2, callback) {
|
|
callback(null, param1 + param2);
|
|
};
|
|
|
|
var module1 = new Module1();
|
|
|
|
var node = {
|
|
on: sinon.spy(),
|
|
getAllAPIMethods: sinon.stub().returns(module1.getAPIMethods())
|
|
};
|
|
|
|
var web = new WebService({node: node});
|
|
web.createMethodsMap();
|
|
|
|
Object.keys(web.methodsMap).length.should.equal(2);
|
|
web.methodsMap.one.args.should.equal(1);
|
|
web.methodsMap.two.args.should.equal(2);
|
|
web.methodsMap.one.fn(1, function(err, result) {
|
|
should.not.exist(err);
|
|
result.should.equal(1);
|
|
|
|
web.methodsMap.two.fn(1, 2, function(err, result) {
|
|
should.not.exist(err);
|
|
result.should.equal(3);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#getEventNames', function() {
|
|
it('should get event names', function() {
|
|
var Module1 = function() {};
|
|
Module1.prototype.getPublishEvents = function() {
|
|
return [
|
|
{
|
|
name: 'event1',
|
|
extraEvents: ['event2']
|
|
}
|
|
];
|
|
};
|
|
|
|
var module1 = new Module1();
|
|
var node = {
|
|
on: sinon.spy(),
|
|
getAllPublishEvents: sinon.stub().returns(module1.getPublishEvents())
|
|
};
|
|
|
|
var web = new WebService({node: node});
|
|
var events = web.getEventNames();
|
|
|
|
events.should.deep.equal(['event1', 'event2']);
|
|
});
|
|
|
|
it('should throw an error if there is a duplicate event', function() {
|
|
var Module1 = function() {};
|
|
Module1.prototype.getPublishEvents = function() {
|
|
return [
|
|
{
|
|
name: 'event1',
|
|
extraEvents: ['event1']
|
|
}
|
|
];
|
|
};
|
|
|
|
var module1 = new Module1();
|
|
var node = {
|
|
on: sinon.spy(),
|
|
getAllPublishEvents: sinon.stub().returns(module1.getPublishEvents())
|
|
};
|
|
|
|
var web = new WebService({node: node});
|
|
(function() {
|
|
var events = web.getEventNames();
|
|
}).should.throw('Duplicate event event1');
|
|
});
|
|
});
|
|
|
|
describe('#_getRemoteAddress', function() {
|
|
it('will get remote address from cloudflare header', function() {
|
|
var web = new WebService({node: defaultNode});
|
|
var socket = {};
|
|
socket.conn = {};
|
|
socket.client = {};
|
|
socket.client.request = {};
|
|
socket.client.request.headers = {
|
|
'cf-connecting-ip': '127.0.0.1'
|
|
};
|
|
var remoteAddress = web._getRemoteAddress(socket);
|
|
remoteAddress.should.equal('127.0.0.1');
|
|
});
|
|
it('will get remote address from connection', function() {
|
|
var web = new WebService({node: defaultNode});
|
|
var socket = {};
|
|
socket.conn = {};
|
|
socket.conn.remoteAddress = '127.0.0.1';
|
|
socket.client = {};
|
|
socket.client.request = {};
|
|
socket.client.request.headers = {};
|
|
var remoteAddress = web._getRemoteAddress(socket);
|
|
remoteAddress.should.equal('127.0.0.1');
|
|
});
|
|
});
|
|
|
|
describe('#socketHandler', function() {
|
|
var sandbox = sinon.sandbox.create();
|
|
beforeEach(function() {
|
|
sandbox.stub(log, 'info');
|
|
});
|
|
afterEach(function() {
|
|
sandbox.restore();
|
|
});
|
|
|
|
var bus = new EventEmitter();
|
|
bus.remoteAddress = '127.0.0.1';
|
|
|
|
var Module1 = function() {};
|
|
Module1.prototype.getPublishEvents = function() {
|
|
return [
|
|
{
|
|
name: 'event1',
|
|
extraEvents: ['event2']
|
|
}
|
|
];
|
|
};
|
|
|
|
var module1 = new Module1();
|
|
var node = {
|
|
on: sinon.spy(),
|
|
openBus: sinon.stub().returns(bus),
|
|
getAllPublishEvents: sinon.stub().returns(module1.getPublishEvents())
|
|
};
|
|
|
|
var web;
|
|
var socket;
|
|
|
|
it('on message should call socketMessageHandler', function(done) {
|
|
web = new WebService({node: node});
|
|
web.eventNames = web.getEventNames();
|
|
web.socketMessageHandler = function(param1) {
|
|
param1.should.equal('data');
|
|
done();
|
|
};
|
|
socket = new EventEmitter();
|
|
socket.conn = {};
|
|
socket.conn.remoteAddress = '127.0.0.1';
|
|
socket.client = {};
|
|
socket.client.request = {};
|
|
socket.client.request.headers = {};
|
|
web.socketHandler(socket);
|
|
socket.emit('message', 'data');
|
|
});
|
|
|
|
it('on message should NOT call socketMessageHandler if not enabled', function(done) {
|
|
web = new WebService({node: node, enableSocketRPC: false});
|
|
web.eventNames = web.getEventNames();
|
|
web.socketMessageHandler = sinon.stub();
|
|
socket = new EventEmitter();
|
|
socket.conn = {};
|
|
socket.conn.remoteAddress = '127.0.0.1';
|
|
socket.client = {};
|
|
socket.client.request = {};
|
|
socket.client.request.headers = {};
|
|
web.socketHandler(socket);
|
|
socket.on('message', function() {
|
|
web.socketMessageHandler.callCount.should.equal(0);
|
|
done();
|
|
});
|
|
socket.emit('message', 'data');
|
|
});
|
|
|
|
it('on subscribe should call bus.subscribe', function(done) {
|
|
bus.subscribe = function(param1) {
|
|
param1.should.equal('data');
|
|
done();
|
|
};
|
|
|
|
socket.emit('subscribe', 'data');
|
|
});
|
|
|
|
it('on unsubscribe should call bus.unsubscribe', function(done) {
|
|
bus.unsubscribe = function(param1) {
|
|
param1.should.equal('data');
|
|
done();
|
|
};
|
|
|
|
socket.emit('unsubscribe', 'data');
|
|
});
|
|
|
|
it('publish events from bus should be emitted from socket', function(done) {
|
|
socket.once('event2', function(param1, param2) {
|
|
param1.should.equal('param1');
|
|
param2.should.equal('param2');
|
|
done();
|
|
});
|
|
socket.connected = true;
|
|
bus.emit('event2', 'param1', 'param2');
|
|
});
|
|
|
|
it('on disconnect should close bus', function(done) {
|
|
bus.close = function() {
|
|
done();
|
|
};
|
|
|
|
socket.emit('disconnect');
|
|
});
|
|
});
|
|
|
|
describe('#socketMessageHandler', function() {
|
|
var node = {
|
|
on: sinon.spy()
|
|
};
|
|
|
|
var web = new WebService({node: node});
|
|
web.methodsMap = {
|
|
one: {
|
|
fn: function(param1, param2, callback) {
|
|
var result = param1 + param2;
|
|
if(result > 0) {
|
|
return callback(null, result);
|
|
} else {
|
|
return callback(new Error('error'));
|
|
}
|
|
},
|
|
args: 2
|
|
}
|
|
};
|
|
|
|
it('should give a Method Not Found error if method does not exist', function(done) {
|
|
var message = {
|
|
method: 'two',
|
|
params: [1, 2]
|
|
};
|
|
web.socketMessageHandler(message, function(response) {
|
|
should.exist(response.error);
|
|
response.error.message.should.equal('Method Not Found');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should call the method and return the result', function(done) {
|
|
var message = {
|
|
method: 'one',
|
|
params: [1, 2]
|
|
};
|
|
web.socketMessageHandler(message, function(response) {
|
|
should.not.exist(response.error);
|
|
response.result.should.equal(3);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should give an error if there is a param count mismatch', function(done) {
|
|
var message = {
|
|
method: 'one',
|
|
params: [1]
|
|
};
|
|
web.socketMessageHandler(message, function(response) {
|
|
should.exist(response.error);
|
|
response.error.message.should.equal('Expected 2 parameter(s)');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should give an error if the method gave an error', function(done) {
|
|
var message = {
|
|
method: 'one',
|
|
params: [-1, -2]
|
|
};
|
|
web.socketMessageHandler(message, function(response) {
|
|
should.exist(response.error);
|
|
response.error.message.should.equal('Error: error');
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('#deriveHttpsOptions', function() {
|
|
it('should read key and cert from files specified', function() {
|
|
var web = new WebService({
|
|
node: defaultNode,
|
|
https: true,
|
|
httpsOptions: {
|
|
key: 'key',
|
|
cert: 'cert'
|
|
}
|
|
});
|
|
|
|
web.transformHttpsOptions();
|
|
web.httpsOptions.key.should.equal('key-buffer');
|
|
web.httpsOptions.cert.should.equal('cert-buffer');
|
|
});
|
|
it('should throw an error if https is specified but key or cert is not specified', function() {
|
|
var web = new WebService({
|
|
node: defaultNode,
|
|
https: true,
|
|
httpsOptions: {
|
|
key: 'key'
|
|
}
|
|
});
|
|
|
|
(function() {
|
|
web.transformHttpsOptions();
|
|
}).should.throw('Missing https options');
|
|
});
|
|
});
|
|
|
|
});
|