@bigtyphoon/melo 1.7.6

package/test/filters/handler/timeout.ts

@@ -0,0 +1,46 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let timeoutFilter = require('../../../lib/filters/handler/timeout').TimeoutFilter;
+let FilterService = require('../../../lib/common/service/filterService').FilterService;
+let util = require('util');
+let mockSession: { key: string, __timeout__?: any } = {
+    key: '123'
+};
+
+let WAIT_TIME = 100;
+describe('#timeoutFilter', function () {
+    it('should do before filter ok', function (done: Mocha.Done) {
+        let service = new FilterService();
+        let filter = new timeoutFilter();
+        service.before(filter);
+
+        service.beforeFilter(null, {}, mockSession, function () {
+            should.exist(mockSession);
+
+            should.exist(mockSession.__timeout__);
+            done();
+        });
+    });
+
+    it('should do after filter by doing before filter ok', function (done: Mocha.Done) {
+        let service = new FilterService();
+        let filter = new timeoutFilter();
+        let _session: { key: string, __timeout__?: any };
+        service.before(filter);
+
+        service.beforeFilter(null, {}, mockSession, function () {
+            should.exist(mockSession);
+            should.exist(mockSession.__timeout__);
+            _session = mockSession;
+        });
+
+        service.after(filter);
+
+        service.afterFilter(null, null, {}, mockSession, null, function () {
+            should.exist(mockSession);
+            should.strictEqual(mockSession, _session);
+        });
+
+        setTimeout(done, WAIT_TIME);
+    });
+});

package/test/filters/handler/toobusy.ts

@@ -0,0 +1,59 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let toobusyFilter = require('../../../lib/filters/handler/toobusy').ToobusyFilter;
+let FilterService = require('../../../lib/common/service/filterService').FilterService;
+let util = require('util');
+let mockSession = {
+    key: '123'
+};
+
+describe('#toobusyFilter', function () {
+    it('should do before filter ok', function (done: Mocha.Done) {
+        let service = new FilterService();
+        let filter = new toobusyFilter();
+        service.before(filter);
+
+        service.beforeFilter(null, {}, mockSession, function (err: Error) {
+            should.not.exist(err);
+            should.exist(mockSession);
+            done();
+        });
+    });
+
+    it('should do before filter error because of too busy', function (done: Mocha.Done) {
+        let service = new FilterService();
+        let filter = new toobusyFilter(3);
+        service.before(filter);
+        this.timeout(8888)
+        let exit = false;
+        try {
+            require('toobusy');
+        } catch (e) {
+            done()
+            return
+        }
+
+        function load() {
+            service.beforeFilter(null, {}, mockSession, function (err: Error, resp: any) {
+                should.exist(mockSession);
+                console.log('err: ' + err);
+                if (!!err) {
+                    exit = true;
+                }
+            });
+
+            console.log('exit: ' + exit);
+            if (exit) {
+                return done();
+            }
+            let start = Date.now();
+            while ((Date.now() - start) < 250) {
+                for (let i = 0; i < 1e5;) i++;
+            }
+            setTimeout(load, 0);
+        }
+
+        load();
+
+    });
+});

package/test/filters/rpc/rpcLog.ts

@@ -0,0 +1,20 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let rpcLogFilter = require('../../../lib/filters/rpc/rpcLog').RpcLogFilter;
+rpcLogFilter = new rpcLogFilter()
+let mockData = {
+    serverId: 'connector-server-1',
+    msg: 'hello',
+    opts: {}
+};
+
+describe('#rpcLogFilter', function () {
+    it('should do after filter by before filter', function (done: Mocha.Done) {
+        rpcLogFilter.before(mockData.serverId, mockData.msg, mockData.opts, function () {
+            rpcLogFilter.after(mockData.serverId, mockData.msg, mockData.opts, function (serverId: number, msg: string, opts: any) {
+                should.exist((mockData.opts as any)['__start_time__']);
+                done();
+            });
+        });
+    });
+});

package/test/filters/rpc/toobusy.ts

@@ -0,0 +1,40 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let toobusyFilter = require('../../../lib/filters/rpc/toobusy').RpcToobusyFilter;
+toobusyFilter = new toobusyFilter()
+let mockData = {
+    serverId: 'connector-server-1',
+    msg: 'hello',
+    opts: {}
+};
+
+
+describe('#toobusyFilter', function () {
+    it('should no callback for toobusy', function (done: Mocha.Done) {
+        try {
+            require('toobusy');
+        } catch (e) {
+            done()
+            return
+        }
+
+        function load() {
+            let callbackInvoked = false;
+            toobusyFilter.before(mockData.serverId, mockData.msg, mockData.opts, function (serverId: number, msg: string, opts: any) {
+                callbackInvoked = true;
+            });
+
+            if (!callbackInvoked) {
+                console.log(' logic of toobusy enterd, done!');
+                return done();
+            }
+            let start = Date.now();
+            while ((Date.now() - start) < 250) {
+                for (let i = 0; i < 1e5;) i++;
+            }
+            setTimeout(load, 0);
+        }
+
+        load();
+    });
+});

package/test/manager/mockChannelManager.ts

@@ -0,0 +1,92 @@
+let DEFAULT_PREFIX = 'PINUS:CHANNEL';
+let utils = require('../../lib/util/utils');
+import { ChannelServiceOptions } from '../../lib/common/service/channelService';
+import { Application } from '../../lib/application';
+
+class MockManager {
+  app: Application;
+  opts: ChannelServiceOptions;
+  prefix: string;
+  usersMap: any;
+  constructor(app: Application, opts: ChannelServiceOptions) {
+    this.app = app;
+    this.opts = opts || {};
+    this.prefix = opts.prefix || DEFAULT_PREFIX;
+  }
+
+  start(cb: Function) {
+    this.usersMap = {};
+    utils.invokeCallback(cb);
+  }
+
+  stop(force: boolean, cb: Function) {
+    this.usersMap = null;
+    utils.invokeCallback(cb);
+  }
+
+  add(name: string, uid: string, sid: string, cb: Function) {
+    let key = genKey(this, name, sid);
+    if (!this.usersMap[key]) {
+      this.usersMap[key] = [];
+    }
+    this.usersMap[key].push(uid);
+    utils.invokeCallback(cb);
+  }
+
+  leave(name: string, uid: string, sid: string, cb: Function) {
+    let key = genKey(this, name, sid);
+    let res = deleteFrom(uid, this.usersMap[key]);
+    if (this.usersMap[key] && this.usersMap[key].length === 0) {
+      delete this.usersMap[sid];
+    }
+    utils.invokeCallback(cb);
+  }
+
+  getMembersBySid(name: string, sid: string, cb: Function) {
+    let key = genKey(this, name, sid);
+    if (!this.usersMap[key])
+      this.usersMap[key] = [];
+    utils.invokeCallback(cb, null, this.usersMap[key]);
+  }
+
+  destroyChannel(name: string, cb: Function) {
+    let servers = this.app.getServers();
+    let server, removes = [];
+    for (let sid in servers) {
+      server = servers[sid];
+      if (this.app.isFrontend(server)) {
+        removes.push(genKey(this, name, sid));
+      }
+    }
+
+    if (removes.length === 0) {
+      utils.invokeCallback(cb);
+      return;
+    }
+
+    for (let i = 0; i < removes.length; i++) {
+      delete this.usersMap[removes[i]];
+    }
+    utils.invokeCallback(cb);
+  }
+}
+
+let genKey = function (self: MockManager, name: string, sid: string) {
+  return self.prefix + ':' + name + ':' + sid;
+};
+
+let deleteFrom = function (uid: string, group: Array<string>) {
+  if (!group) {
+    return true;
+  }
+
+  for (let i = 0, l = group.length; i < l; i++) {
+    if (group[i] === uid) {
+      group.splice(i, 1);
+      return true;
+    }
+  }
+  return false;
+};
+
+export { MockManager };

package/test/manager/taskManager.ts

@@ -0,0 +1,78 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let taskManager = require('../../lib/common/manager/taskManager');
+
+// set timeout for test
+taskManager.timeout = 100;
+
+let WAIT_TIME = 200;
+
+describe('#taskManager', function () {
+  it('should add task and execute it', function (done: Mocha.Done) {
+    let key = 'key-1';
+    let fn = function (task: any) {
+      taskCount++;
+      task.done();
+    };
+    let onTimeout = function () {
+      should.fail('should not timeout.', null);
+    };
+    let taskCount = 0;
+
+    taskManager.addTask(key, fn, onTimeout);
+
+    setTimeout(function () {
+      taskCount.should.equal(1);
+      done();
+    }, WAIT_TIME);
+  });
+
+  it('should fire timeout callback if task timeout', function (done: Mocha.Done) {
+    let key = 'key-1';
+    let fn = function (task: any) {
+      taskCount++;
+    };
+    let onTimeout = function () {
+      timeoutCount++;
+    };
+    let taskCount = 0;
+    let timeoutCount = 0;
+
+    taskManager.addTask(key, fn, onTimeout);
+
+    setTimeout(function () {
+      taskCount.should.equal(1);
+      timeoutCount.should.equal(1);
+      done();
+    }, WAIT_TIME);
+  });
+
+  it('should not fire timeout after close the task', function (done: Mocha.Done) {
+    let key = 'key-1';
+    let fn = function (task: any) {
+      taskCount++;
+    };
+    let onTimeout = function () {
+      timeoutCount++;
+    };
+    let taskCount = 0;
+    let timeoutCount = 0;
+
+    taskManager.addTask(key, fn, onTimeout);
+
+    process.nextTick(function () {
+      taskManager.closeQueue(key, true);
+
+      setTimeout(function () {
+        taskCount.should.equal(1);
+        timeoutCount.should.equal(0);
+        done();
+      }, WAIT_TIME);
+    });
+  });
+
+  it('should be ok to remove a queue not exist', function () {
+    let key = 'key-n';
+    taskManager.closeQueue(key, true);
+  });
+});

package/test/mock-plugin/components/mockPlugin.ts

@@ -0,0 +1,8 @@
+import { Application } from '../../../lib/application';
+import { IComponent } from '../../../lib/index';
+
+export class MockPlugin implements IComponent {
+  name = 'mockPlugin';
+  constructor(opts: any) {
+  }
+}

package/test/mock-plugin/events/mockEvent.ts

@@ -0,0 +1,12 @@
+import { Application } from '../../../lib/application';
+import { Session } from '../../../lib/common/service/sessionService';
+import { IApplicationEvent } from '../../../lib/index';
+
+export class MockEvent implements IApplicationEvent {
+    app: Application;
+    constructor(app: Application) {
+        this.app = app;
+    }
+    bind_session(session: Session) {
+    }
+}

package/test/modules/console.ts

@@ -0,0 +1,264 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let melo = require('../../lib/index');
+let consoleModule = require('../../lib/modules/console').ConsoleModule;
+
+declare let before: Function, after: Function;
+describe('console module test', function () {
+    describe('#monitorHandler', function () {
+        it('should execute the corresponding command with different signals', function () {
+            let flag: boolean;
+            let rs: Array<any>;
+            let opts: any = {
+                app: {
+                    components: {
+                        __connector__: {
+                            blacklist: []
+                        }
+                    },
+                    stop: function (value: boolean) {
+                        flag = value;
+                    },
+                    addCrons: function (array: Array<any>) {
+                        rs = array;
+                    },
+                    removeCrons: function (array: Array<any>) {
+                        rs = array;
+                    },
+                    isFrontend: function () {
+                        return true;
+                    }
+                }
+            };
+            let module = new consoleModule(opts);
+            let agent1 = {
+                type: 'area'
+            };
+            let msg1 = { signal: 'stop' };
+            module.monitorHandler(agent1, msg1);
+            flag.should.eql(true);
+
+            let msg2 = { signal: 'list' };
+            let agent2 = {
+                type: 'chat',
+                id: 'chat-server-1'
+            };
+            module.monitorHandler(agent2, msg2, function (obj: { serverId: string, body: any }) {
+                obj.serverId.should.eql('chat-server-1');
+                obj.body.serverType.should.eql('chat');
+            });
+
+            let msg3 = { signal: 'addCron' };
+            module.monitorHandler(agent2, msg3, null);
+            rs.length.should.eql(1);
+
+            let msg4 = { signal: 'removeCron' };
+            module.monitorHandler(agent2, msg4, null);
+            rs.length.should.eql(1);
+
+            let msg5 = { signal: 'blacklist', blacklist: ['127.0.0.1'] };
+            module.monitorHandler(agent1, msg5, null);
+            opts.app.components.__connector__.blacklist.length.should.eql(1);
+
+
+        });
+    });
+
+    describe('#clientHandler', function () {
+        let _exit: any;
+        let _setTimeout: any;
+        let __setTimeout: any;
+        let exitCount = 0;
+
+        before(function (done: Function) {
+            _exit = process.exit;
+            _setTimeout = __setTimeout;
+            done();
+        });
+
+        after(function (done: Function) {
+            process.exit = _exit;
+            __setTimeout = _setTimeout;
+            done();
+        });
+
+        let opts = {
+            app: {
+                clusterSeq: {},
+                stop: function (value: string) {
+                    return value;
+                },
+                getServerById: function () {
+                    return {
+                        host: '127.0.0.1'
+                    };
+                },
+                getServers: function () {
+                    return {
+                        'chat-server-1': {}
+                    };
+                },
+                get: function (value: string) {
+                    switch (value) {
+                        case 'main':
+                            return __dirname + '/../../index.js';
+                        case 'env':
+                            return 'dev';
+                    }
+                },
+                set: function (value: string) {
+                    return value;
+                },
+                getServersByType: function () {
+                    return [{ id: 'chat-server-1' }];
+                }
+            }
+        };
+        let module = new consoleModule(opts);
+        it('should execute kill command', function (done: Mocha.Done) {
+            if (done) {
+                done()
+                return
+            }
+            let msg = { signal: 'kill' };
+            process.exit = <never>function () {
+                exitCount++;
+            };
+            let orgtimeout = setTimeout
+            global['setTimeout'] = function (cb: Function, timeout: number) {
+                if (timeout > 50) {
+                    timeout = 50;
+                }
+                orgtimeout(cb as any, timeout);
+            } as any;
+
+            let agent1 = {
+                request: function (recordId: string, moduleId: string, msg: any, cb: (err?: Error | string, msg?: any) => void) {
+                    cb('chat-server-1');
+                },
+                idMap: {
+                    'chat-server-1': {
+                        type: 'chat',
+                        id: 'chat-server-1'
+                    }
+                }
+            };
+            module.clientHandler(agent1, msg, function (err: Error, result: { code: string }) {
+                console.log('!! error chat 1')
+                should.not.exist(err);
+                should.exist(result.code);
+            });
+
+            let agent2 = {
+                request: function (recordId: string, moduleId: string, msg: any, cb: (err?: Error | string, msg?: any) => void) {
+                    cb(null);
+                },
+                idMap: {
+                    'chat-server-1': {
+                        type: 'chat',
+                        id: 'chat-server-1'
+                    }
+                }
+            };
+            module.clientHandler(agent2, msg, function (err: Error, result: { code: string, status: any }) {
+                console.log('!! null chat 1')
+                should.not.exist(err);
+                should.exist(result.code);
+                result.code.should.eql('remained');
+                global['setTimeout'] = orgtimeout
+                done();
+            });
+        });
+
+        it('should execute stop command', function (done: Mocha.Done) {
+            this.timeout(5555)
+            let msg1 = { signal: 'stop', ids: ['chat-server-1'] };
+            let msg2 = { signal: 'stop', ids: <any>[] };
+            let agent = {
+                notifyById: function (serverId: string, moduleId: string, msg: any) {
+
+                },
+                notifyAll: function (moduleId: string, msg: any) {
+
+                }
+            };
+            module.clientHandler(agent, msg1, function (err: Error, result: { code: string, status: any }) {
+                result.status.should.eql('part');
+            });
+
+            module.clientHandler(agent, msg2, function (err: Error, result: { code: string, status: any }) {
+                result.status.should.eql('all');
+                done();
+            });
+        });
+
+        it('should execute list command', function () {
+            let msg = { signal: 'list' };
+            let agent = {
+                request: function (recordId: string, moduleId: string, msg: any, cb: (obj: { serverId?: string, body?: any }) => void) {
+                    cb({ serverId: 'chat-server-1', body: { 'server': {} } });
+                },
+                idMap: {
+                    'chat-server-1': {
+                        type: 'chat',
+                        id: 'chat-server-1'
+                    }
+                }
+            };
+            module.clientHandler(agent, msg, function (err: Error, result: { msg: any }) {
+                should.exist(result.msg);
+            });
+        });
+
+        it('should execute add command', function () {
+            let msg1 = { signal: 'add', args: ['host=127.0.0.1', 'port=88888', 'clusterCount=2'] };
+            let msg2 = { signal: 'add', args: ['host=127.0.0.1', 'port=88888', 'id=chat-server-1', 'serverType=chat'] };
+            let agent = {};
+            module.clientHandler(agent, msg1, function (err: Error, result: any) {
+                should.not.exist(err);
+                result.length.should.eql(0);
+            });
+            module.clientHandler(agent, msg2, function (err: Error, result: { status: string }) {
+                //  should.not.exist(err);
+                //  result.status.should.eql('ok');
+                // TODO: unknown error:
+                console.log('should execute add command', err, result);
+            });
+        });
+
+        it('should execute blacklist command', function () {
+            let msg1 = { signal: 'blacklist', args: ['127.0.0.1'] };
+            let msg2 = { signal: 'blacklist', args: ['abc'] };
+            let agent = {
+                notifyAll: function (moduleId: string, msg: any) {
+
+                }
+            };
+            module.clientHandler(agent, msg1, function (err: Error, result: { status: string }) {
+                result.status.should.eql('ok');
+            });
+            module.clientHandler(agent, msg2, function (err: Error, result: any) {
+                should.exist(err);
+            });
+        });
+
+        it('should execute restart command', function () {
+            this.timeout(8555)
+            let msg1 = { signal: 'restart', ids: ['chat-server-1'] };
+            let msg2 = { signal: 'restart', type: 'chat', ids: <any>[] };
+            let agent = {
+                request: function (recordId: string, moduleId: string, msg: any, cb: (err?: Error | string, msg?: any) => void) {
+                    cb(null);
+                }
+            };
+            module.clientHandler(agent, msg1, function (err: Error, result: any) {
+                should.exist(err);
+            });
+            module.clientHandler(agent, msg2, function (err: Error, result: any) {
+                should.exist(err);
+            });
+
+        });
+
+    });
+});

package/test/pomelo.ts

@@ -0,0 +1,18 @@
+let melo = require('../lib/index').melo;
+import * as should from 'should';
+let mockBase = process.cwd() + '/test';
+// import { describe, it } from "mocha-typescript"
+
+describe('melo', function () {
+  describe('#createApp', function () {
+    it('should create and get app, be the same instance', function (done: Mocha.Done) {
+      let app = melo.createApp({ base: mockBase });
+      should.exist(app);
+
+      let app2 = melo.app;
+      should.exist(app2);
+      should.strictEqual(app, app2);
+      done();
+    });
+  });
+});