@bigtyphoon/melo 1.7.6

package/test/service/connectionService.ts

@@ -0,0 +1,142 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let ConnectionService = require('../../lib/common/service/connectionService').ConnectionService;
+
+let mockApp = {
+    settings: {
+        serverId: 'connector-server-1'
+    },
+
+    get: function (key: 'serverId') {
+        return this.settings[key];
+    },
+
+    getServerId: function () {
+        return this.get('serverId');
+    }
+};
+
+describe('connection service test', function () {
+    describe('#addLoginedUser', function () {
+        it('should add logined user and could fetch it later', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+            service.loginedCount.should.equal(0);
+
+            let uid = 'uid1';
+            let info = { msg: 'some other message' };
+            service.addLoginedUser(uid, info);
+
+            service.loginedCount.should.equal(1);
+            let record = service.logined[uid];
+            should.exist(record);
+            record.should.eql(info);
+        });
+    });
+
+    describe('#increaseConnectionCount', function () {
+        it('should increate connection count and could fetch it later', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+            service.connCount.should.equal(0);
+
+            service.increaseConnectionCount();
+            service.connCount.should.equal(1);
+        });
+    });
+
+    describe('#removeLoginedUser', function () {
+        it('should remove logined user info with the uid', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+            service.loginedCount.should.equal(0);
+
+            let uid = 'uid1';
+            let info = { msg: 'some other message' };
+            service.addLoginedUser(uid, info);
+
+            service.loginedCount.should.equal(1);
+            let record = service.logined[uid];
+            should.exist(record);
+
+            let uid2 = 'uid2';
+            service.removeLoginedUser(uid2);
+            service.loginedCount.should.equal(1);
+            record = service.logined[uid];
+            should.exist(record);
+
+            service.removeLoginedUser(uid);
+            service.loginedCount.should.equal(0);
+            record = service.logined[uid];
+            should.not.exist(record);
+        });
+    });
+
+    describe('#decreaseConnectionCount', function () {
+        it('should decrease connection count only if uid is empty', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+
+            service.increaseConnectionCount();
+            service.connCount.should.equal(1);
+            service.decreaseConnectionCount();
+            service.connCount.should.equal(0);
+        });
+
+        it('should keep zero if connection count become zero', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+
+            service.connCount.should.equal(0);
+            service.decreaseConnectionCount();
+            service.connCount.should.equal(0);
+        });
+
+        it('should remove the logined info if uid is specified', function () {
+            let service = new ConnectionService(mockApp);
+            should.exist(service);
+
+            service.increaseConnectionCount();
+
+            let uid = 'uid1';
+            let info = { msg: 'some other message' };
+            service.addLoginedUser(uid, info);
+
+            service.connCount.should.equal(1);
+            service.logined[uid].should.eql(info);
+
+            service.decreaseConnectionCount(uid);
+
+            service.connCount.should.equal(0);
+            should.not.exist(service.logined[uid]);
+        });
+    });
+
+    it('should getStatisticsInfo', function (done: Mocha.Done) {
+        let service = new ConnectionService(mockApp);
+        let uid1 = 'uid1', uid2 = 'uid2';
+        let info1 = { msg: 'msg1' }, info2 = { msg: 'msg2' };
+
+        service.increaseConnectionCount();
+        service.increaseConnectionCount();
+        service.increaseConnectionCount();
+
+        service.addLoginedUser(uid1, info1);
+        service.addLoginedUser(uid2, info2);
+
+
+        let sinfo = service.getStatisticsInfo();
+
+        sinfo.should.have.property('serverId', 'connector-server-1');
+        sinfo.should.have.property('totalConnCount', 3);
+        sinfo.should.have.property('loginedCount', 2);
+
+        let infos = sinfo.loginedList;
+        should.exist(infos);
+        infos.length.should.equal(2);
+        infos.should.containEql(info1);
+        infos.should.containEql(info2);
+
+        done();
+    });
+});

package/test/service/filterService.ts

@@ -0,0 +1,165 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let FilterService = require('../../lib/common/service/filterService').FilterService;
+import { FrontendOrBackendSession } from '../../lib/server/server';
+
+let WAIT_TIME = 50;
+
+let mockFilter1 = {
+    before: function (record: any, msg: any, session: FrontendOrBackendSession & { beforeCount1: number }, cb: Function) {
+        session.beforeCount1++;
+        cb();
+    },
+
+    after: function (err: Error, record: any, msg: any, session: FrontendOrBackendSession & { afterCount1: number }, resp: any, cb: Function) {
+        session.afterCount1++;
+        cb();
+    }
+};
+
+let mockFilter2 = {
+    before: function (record: any, msg: any, session: FrontendOrBackendSession & { beforeCount2: number }, cb: Function) {
+        session.beforeCount2++;
+        cb();
+    },
+
+    after: function (err: Error, record: any, msg: any, session: FrontendOrBackendSession & { afterCount2: number }, resp: any, cb: Function) {
+        session.afterCount2++;
+        cb();
+    }
+};
+
+let blackholdFilter = {
+    before: function () {
+    },
+    after: function () {
+    }
+};
+
+class MockSession {
+    beforeCount1: number = 0;
+    afterCount1: number = 0;
+    beforeCount2: number = 0;
+    afterCount2: number = 0;
+
+    constructor() {
+
+    }
+}
+
+describe('filter service test', function () {
+    describe('#filter', function () {
+        it('should register before filter by calling before method and fire filter chain by calling beforeFilter', function (done: Mocha.Done) {
+            let session = new MockSession();
+            let service = new FilterService();
+            service.before(mockFilter1);
+            service.before(mockFilter2);
+            service.beforeFilter(null, {}, session, function () {
+                should.exist(session);
+                session.beforeCount1.should.equal(1);
+                session.beforeCount2.should.equal(1);
+                session.afterCount1.should.equal(0);
+                session.afterCount2.should.equal(0);
+                done();
+            });
+        });
+
+        it('should register after filter by calling after method and fire filter chain by calling afterFilter', function (done: Mocha.Done) {
+            let session = new MockSession();
+            let service = new FilterService();
+            service.after(mockFilter1);
+            service.after(mockFilter2);
+            service.afterFilter(null, null, {}, session, null, function () {
+                should.exist(session);
+                session.beforeCount1.should.equal(0);
+                session.beforeCount2.should.equal(0);
+                session.afterCount1.should.equal(1);
+                session.afterCount2.should.equal(1);
+                done();
+            });
+        });
+
+        it('should be ok if filter is a function', function (done: Mocha.Done) {
+            let session = { beforeCount: 0, afterCount: 0 };
+            let service = new FilterService();
+            let beforeCount = 0, afterCount = 0;
+
+            service.before(function (record: any, msg: any, session: FrontendOrBackendSession & { beforeCount: number }, cb: Function) {
+                session.beforeCount++;
+                cb();
+            });
+            service.after(function (err: Error, record: any, msg: any, session: FrontendOrBackendSession & { afterCount: number }, resp: any, cb: Function) {
+                session.afterCount++;
+                cb();
+            });
+            service.beforeFilter(null, {}, session, function () {
+                beforeCount++;
+            });
+            service.afterFilter(null, null, {}, session, null, function () {
+                afterCount++;
+            });
+
+            session.beforeCount.should.equal(1);
+            session.afterCount.should.equal(1);
+            beforeCount.should.equal(1);
+            afterCount.should.equal(1);
+
+            done();
+        });
+
+        it('should not invoke the callback if filter not invoke callback', function (done: Mocha.Done) {
+            let session = new MockSession();
+            let service = new FilterService();
+            let beforeCount = 0, afterCount = 0;
+
+            service.before(blackholdFilter);
+            service.after(blackholdFilter);
+            service.beforeFilter(null, {}, session, function () {
+                beforeCount++;
+            });
+            service.afterFilter(null, null, {}, session, null, function () {
+                afterCount++;
+            });
+
+            setTimeout(function () {
+                session.beforeCount1.should.equal(0);
+                session.beforeCount2.should.equal(0);
+                session.afterCount1.should.equal(0);
+                session.afterCount2.should.equal(0);
+                beforeCount.should.equal(0);
+                afterCount.should.equal(0);
+
+                done();
+            }, WAIT_TIME);
+        });
+
+        it('should pass the err and resp parameters to callback and ignore the filters behind if them specified in before filter', function (done: Mocha.Done) {
+            let session = new MockSession();
+            let service = new FilterService();
+            let error = 'some error message';
+            let response = { key: 'some value' };
+            let respFilter = {
+                before: function (record: any, msg: any, session: FrontendOrBackendSession, cb: Function) {
+                    cb(error, response);
+                }
+            };
+
+            service.before(mockFilter1);
+            service.before(respFilter);
+            service.before(mockFilter2);
+            service.beforeFilter(null, {}, session, function (err: Error, resp: any) {
+                should.exist(err);
+                err.should.equal(error);
+                should.exist(resp);
+                resp.should.equal(response);
+
+                session.beforeCount1.should.equal(1);
+                session.beforeCount2.should.equal(0);
+                session.afterCount1.should.equal(0);
+                session.afterCount2.should.equal(0);
+
+                done();
+            });
+        });
+    });
+});

package/test/service/handlerService.ts

@@ -0,0 +1,77 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let HandlerService = require('../../lib/common/service/handlerService').HandlerService;
+import { Session } from '../../lib/common/service/sessionService';
+
+class MockApp {
+    serverType: string = 'connector';
+
+    constructor() {
+    }
+
+    usedPlugins: any = [];
+
+    get(this: any, key: string) {
+        return this[key];
+    }
+
+    getCurrentServer() {
+        return {}
+    }
+}
+
+let mockApp = new MockApp();
+
+let mockSession = {
+    exportSession: function () {
+        return this;
+    }
+};
+
+let mockMsg = { key: 'some request message' };
+let mockRouteRecord = { serverType: 'connector', handler: 'testHandler', method: 'testMethod' };
+
+describe('handler service test', function () {
+    describe('handle', function () {
+        it('should dispatch the request to the handler if the route match current server type', function (done: Mocha.Done) {
+            let invoke1Count = 0, invoke2Count = 0;
+            // mock datas
+            let mockHandlers = {
+                testHandler: {
+                    testMethod: async function (msg: any, session: Session, next: Function) {
+                        invoke1Count++;
+                        msg.should.eql(mockMsg);
+                    }
+                },
+                test2Handler: {
+                    testMethod: async function (msg: any, session: Session, next: Function) {
+                        invoke2Count++;
+                    }
+                }
+            };
+
+            let mockOpts = {};
+
+            let service = new HandlerService(mockApp, mockOpts);
+            service.handlerMap = { connector: mockHandlers };
+
+            service.handle(mockRouteRecord, mockMsg, mockSession, function () {
+                invoke1Count.should.equal(1);
+                invoke2Count.should.equal(0);
+                done();
+            });
+        });
+
+        it('should return an error if can not find the appropriate handler locally', function (done: Mocha.Done) {
+            let mockHandlers = {};
+            let mockOpts = {};
+            let service = new HandlerService(mockApp, mockOpts);
+            service.handlerMap = { connector: mockHandlers };
+
+            service.handle(mockRouteRecord, mockMsg, mockSession, function (err: Error) {
+                should.exist(err);
+                done();
+            });
+        });
+    });
+});