@bigtyphoon/melo 1.7.6

package/test/remote/channelRemote.ts

@@ -0,0 +1,176 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+import { UID, SID } from '../../lib/util/constants';
+import { ScheduleOptions } from '../../lib/interfaces/IPushScheduler';
+
+let melo = require('../../lib/index').melo;
+let remote = require('../../lib/common/remote/frontend/channelRemote').default;
+let SessionService = require('../../lib/common/service/sessionService').SessionService;
+let ChannelService = require('../../lib/common/service/channelService').ChannelService;
+let countDownLatch = require('../../lib/util/countDownLatch').CountDownLatch;
+let MockChannelManager = require('../manager/mockChannelManager').MockManager;
+
+
+let mockBase = process.cwd() + '/test';
+
+let WAIT_TIME = 200;
+
+describe('channel remote test', function () {
+    describe('#pushMessage', function () {
+        it('should push message the the specified clients', function (done: Mocha.Done) {
+            this.timeout(5555)
+            let sids = [1, 2, 3, 4, 5, 6];
+            let uids = [11, 12, 13];
+            let frontendId = 'frontend-server-id';
+            let mockRoute = 'mock-route-string';
+            let mockMsg = { msg: 'some test msg' };
+            let invokeCount = 0;
+            let invokeUids: Array<number> = [];
+
+            let sessionService = new SessionService();
+            sessionService.sendMessageByUid = function (uid: number, msg: string) {
+                mockMsg.should.eql(msg);
+                invokeCount++;
+                invokeUids.push(uid);
+            };
+
+            let session;
+            for (let i = 0, l = sids.length, j = 0; i < l; i++) {
+                session = sessionService.create(sids[i], frontendId);
+                if (i % 2) {
+                    sessionService.bind(session.id, uids[j]);
+                    j++;
+                }
+            }
+
+            let app = melo.createApp({ base: mockBase });
+            app.components.__connector__ = {
+                send: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    app.components.__pushScheduler__.schedule(reqId, route, msg, recvs, opts, cb);
+                }
+            };
+            app.components.__connector__.connector = {};
+            app.components.__pushScheduler__ = {
+                schedule: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    mockMsg.should.eql(msg);
+                    invokeCount += recvs.length;
+                    let sess;
+                    for (let i = 0; i < recvs.length; i++) {
+                        sess = sessionService.get(recvs[i]);
+                        if (sess) {
+                            invokeUids.push(sess.uid);
+                        }
+                    }
+                    cb();
+                }
+            };
+            app.set('sessionService', sessionService);
+            let channelRemote = remote(app);
+            channelRemote.pushMessage(mockRoute, mockMsg, uids, { isPush: true }).then(() => {
+                invokeCount.should.equal(uids.length);
+                invokeUids.length.should.equal(uids.length);
+                for (let i = 0, l = uids.length; i < l; i++) {
+                    invokeUids.should.containEql(uids[i]);
+                }
+                done();
+            });
+
+        });
+    });
+
+    describe('#broadcast', function () {
+        it('should broadcast to all the client connected', function (done: Mocha.Done) {
+            let sids = [1, 2, 3, 4, 5];
+            let uids = [11, 12, 13, 14, 15];
+            let frontendId = 'frontend-server-id';
+            let mockRoute = 'mock-route-string';
+            let mockMsg = { msg: 'some test msg' };
+            let invokeCount = 0;
+
+            let sessionService = new SessionService();
+            let channelService = new ChannelService();
+
+            let session;
+            for (let i = 0, l = sids.length; i < l; i++) {
+                session = sessionService.create(sids[i], frontendId);
+                if (i % 2) {
+                    session.bind(uids[i]);
+                }
+            }
+
+            let app = melo.createApp({ base: mockBase });
+            app.components.__connector__ = {
+                send: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    app.components.__pushScheduler__.schedule(reqId, route, msg, recvs, opts, cb);
+                }
+            };
+            app.components.__connector__.connector = {};
+            app.components.__pushScheduler__ = {
+                schedule: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    invokeCount++;
+                    mockMsg.should.eql(msg);
+                    should.exist(opts);
+                    should.equal(opts.type, 'broadcast');
+                    cb();
+                }
+            };
+            app.set('sessionService', sessionService);
+            app.set('channelService', channelService);
+            let channelRemote = remote(app);
+            channelRemote.broadcast(mockRoute, mockMsg, { type: 'broadcast' }).then(() => {
+                invokeCount.should.equal(1);
+                done();
+            });
+        });
+
+        it('should broadcast to all the binded client connected', function (done: Mocha.Done) {
+            let sids = [1, 2, 3, 4, 5, 6];
+            let uids = [11, 12, 13];
+            let frontendId = 'frontend-server-id';
+            let mockRoute = 'mock-route-string';
+            let mockMsg = { msg: 'some test msg' };
+            let invokeCount = 0;
+            let invokeUids = [];
+
+            let sessionService = new SessionService();
+            let channelService = new ChannelService();
+
+            let session;
+            for (let i = 0, l = sids.length, j = 0; i < l; i++) {
+                session = sessionService.create(sids[i], frontendId);
+                if (i % 2) {
+                    session.bind(uids[j]);
+                    j++;
+                }
+            }
+
+            let app = melo.createApp({ base: mockBase });
+            app.components.__connector__ = {
+                send: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    app.components.__pushScheduler__.schedule(reqId, route, msg, recvs, opts, cb);
+                }
+            };
+            app.components.__connector__.connector = {};
+            app.components.__pushScheduler__ = {
+                schedule: function (reqId: number, route: string, msg: any, recvs: Array<SID>, opts: ScheduleOptions, cb: (err?: Error, resp?: any) => void) {
+                    invokeCount++;
+                    mockMsg.should.eql(msg);
+                    should.exist(opts);
+                    should.equal(opts.type, 'broadcast');
+                    true.should.equal(opts.userOptions.binded);
+                    cb();
+                }
+            };
+            app.set('sessionService', sessionService);
+            app.set('channelService', channelService);
+            let channelRemote = remote(app);
+            channelRemote.broadcast(mockRoute, mockMsg, {
+                type: 'broadcast',
+                userOptions: { binded: true }
+            }).then(() => {
+                invokeCount.should.equal(1);
+                done();
+            });
+        });
+    });
+});

package/test/service/channel.ts

@@ -0,0 +1,161 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let melo = require('../../lib/index').melo;
+let ChannelService = require('../../lib/common/service/channelService').ChannelService;
+
+let mockBase = process.cwd() + '/test';
+let channelName = 'test_channel';
+let mockApp = { serverId: 'test-server-1' };
+
+describe('channel test', function () {
+  describe('#add', function () {
+    it('should add a member into channel and could fetch it later', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      let uid = 'uid1', sid = 'sid1';
+      channel.add(uid, sid).should.be.true;
+
+      let member = channel.getMember(uid);
+      should.exist(member);
+      uid.should.equal(member.uid);
+      sid.should.equal(member.sid);
+    });
+
+    it('should fail if the sid not specified', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      let uid = 'uid1';
+      channel.add(uid, null).should.be.false;
+    });
+
+    it('should fail after the channel has been destroied', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      channel.destroy();
+
+      let uid = 'uid1', sid = 'sid1';
+      channel.add(uid, sid).should.be.false;
+    });
+  });
+
+  describe('#leave', function () {
+    it('should remove the member from channel when leave', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      let uid = 'uid1', sid = 'sid1';
+      channel.add(uid, sid).should.be.true;
+
+      let member = channel.getMember(uid);
+      should.exist(member);
+
+      channel.leave(uid, sid);
+      member = channel.getMember(uid);
+      should.not.exist(member);
+    });
+
+    it('should fail if uid or sid not specified', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      let uid = 'uid1', sid = 'sid1';
+      channel.add(uid, sid).should.be.true;
+
+      channel.leave(uid, null).should.be.false;
+      channel.leave(null, sid).should.be.false;
+    });
+  });
+
+  describe('#getMembers', function () {
+    it('should return all the members of channel', function () {
+      let uinfos = [
+        { uid: 'uid1', sid: 'sid1' },
+        { uid: 'uid2', sid: 'sid2' },
+        { uid: 'uid3', sid: 'sid3' }
+      ];
+
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+
+      let i, l, item;
+      for (i = 0, l = uinfos.length; i < l; i++) {
+        item = uinfos[i];
+        channel.add(item.uid, item.sid);
+      }
+
+      let members = channel.getMembers();
+      should.exist(members);
+      members.length.should.equal(uinfos.length);
+      for (i = 0, l = uinfos.length; i < l; i++) {
+        item = uinfos[i];
+        members.should.containEql(item.uid);
+      }
+    });
+  });
+
+  describe('#pushMessage', function () {
+    it('should push message to the right frontend server by sid', function (done: Mocha.Done) {
+      let sid1 = 'sid1', sid2 = 'sid2';
+      let uid1 = 'uid1', uid2 = 'uid2', uid3 = 'uid3';
+      let mockUids = [{ sid: sid1, uid: uid1 }, { sid: sid2, uid: uid2 }, { sid: sid2, uid: uid3 }];
+      let mockMsg = { key: 'some remote message' };
+      let uidMap: { [key: string]: any } = {};
+      for (let i in mockUids) {
+        uidMap[mockUids[i].uid] = mockUids[i];
+      }
+
+      let invokeCount = 0;
+
+      let mockRpcInvoke = function (sid: string, rmsg: { [key: string]: any }, cb: Function) {
+        invokeCount++;
+        let args = rmsg.args;
+        let route = args[0];
+        let msg = args[1];
+        let uids = args[2];
+        mockMsg.should.eql(msg);
+
+        for (let j = 0, l = uids.length; j < l; j++) {
+          let uid = uids[j];
+          let r2 = uidMap[uid];
+          r2.sid.should.equal(sid);
+        }
+
+        cb();
+      };
+
+      let app = melo.createApp({ base: mockBase });
+      app.rpcInvoke = mockRpcInvoke;
+      let channelService = new ChannelService(app);
+
+      let channel = channelService.createChannel(channelName);
+      for (let i = 0, l = mockUids.length; i < l; i++) {
+        channel.add(mockUids[i].uid, mockUids[i].sid);
+      }
+
+      channel.pushMessage(mockMsg, function () {
+        invokeCount.should.equal(2);
+        done();
+      });
+    });
+    it('should fail if channel has destroied', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+
+      channel.destroy();
+
+      channel.pushMessage({}, function (err: Error) {
+        should.exist(err);
+        err.message.should.equal('channel is not running now');
+      });
+    });
+  });
+});

package/test/service/channelService.ts

@@ -0,0 +1,243 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let melo = require('../../lib/index').melo;
+let ChannelService = require('../../lib/common/service/channelService').ChannelService;
+
+let channelName = 'test_channel';
+let mockBase = process.cwd() + '/test';
+let mockApp = { serverId: 'test-server-1' };
+
+describe('channel manager test', function () {
+  describe('#createChannel', function () {
+    it('should create and return a channel with the specified name', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+      channelName.should.equal(channel.name);
+    });
+
+    it('should return the same channel if the name has already existed', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+      channelName.should.equal(channel.name);
+      let channel2 = channelService.createChannel(channelName);
+      channel.should.equal(channel2);
+    });
+  });
+
+  describe('#destroyChannel', function () {
+    it('should delete the channel instance', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.createChannel(channelName);
+      should.exist(channel);
+      channelName.should.equal(channel.name);
+      channelService.destroyChannel(channelName);
+      let channel2 = channelService.createChannel(channelName);
+      channel.should.not.equal(channel2);
+    });
+  });
+
+  describe('#getChannel', function () {
+    it('should return the channel with the specified name if it exists', function () {
+      let channelService = new ChannelService(mockApp);
+      channelService.createChannel(channelName);
+      let channel = channelService.getChannel(channelName);
+      should.exist(channel);
+      channelName.should.equal(channel.name);
+    });
+
+    it('should return undefined if the channel dose not exist', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.getChannel(channelName);
+      should.not.exist(channel);
+    });
+
+    it('should create and return a new channel if create parameter is set', function () {
+      let channelService = new ChannelService(mockApp);
+      let channel = channelService.getChannel(channelName, true);
+      should.exist(channel);
+      channelName.should.equal(channel.name);
+    });
+  });
+
+  describe('#pushMessageByUids', function () {
+    it('should push message to the right frontend server', function (done: Mocha.Done) {
+      let sid1 = 'sid1', sid2 = 'sid2';
+      let uid1 = 'uid1', uid2 = 'uid2', uid3 = 'uid3';
+      let orgRoute = 'test.route.string';
+      let mockUids = [
+        { sid: sid1, uid: uid1 },
+        { sid: sid2, uid: uid2 },
+        { sid: sid2, uid: uid3 }
+      ];
+      let mockMsg = { key: 'some remote message' };
+      let uidMap: { [key: string]: any } = {};
+      for (let i in mockUids) {
+        uidMap[mockUids[i].uid] = mockUids[i];
+      }
+
+      let invokeCount = 0;
+
+      let mockRpcInvoke = function (sid: string, rmsg: { [key: string]: any }, cb: Function) {
+        invokeCount++;
+        let args = rmsg.args;
+        let route = args[0];
+        let msg = args[1];
+        let uids = args[2];
+        mockMsg.should.eql(msg);
+
+        for (let j = 0, l = uids.length; j < l; j++) {
+          let uid = uids[j];
+          let r2 = uidMap[uid];
+          r2.sid.should.equal(sid);
+        }
+
+        cb();
+      };
+
+      let app = melo.createApp({ base: mockBase });
+      app.rpcInvoke = mockRpcInvoke;
+      let channelService = new ChannelService(app);
+
+      channelService.pushMessageByUids(orgRoute, mockMsg, mockUids, function () {
+        invokeCount.should.equal(2);
+        done();
+      });
+    });
+
+    it('should return an err if uids is empty', function (done: Mocha.Done) {
+      let mockMsg = { key: 'some remote message' };
+      let app = melo.createApp({ base: mockBase });
+      let channelService = new ChannelService(app);
+
+      channelService.pushMessageByUids(mockMsg, null, function (err: Error) {
+        should.exist(err);
+        err.message.should.equal('uids should not be empty');
+        done();
+      });
+    });
+
+    it('should return err if all message fail to push', function (done: Mocha.Done) {
+      let sid1 = 'sid1', sid2 = 'sid2';
+      let uid1 = 'uid1', uid2 = 'uid2', uid3 = 'uid3';
+      let mockUids = [
+        { sid: sid1, uid: uid1 },
+        { sid: sid2, uid: uid2 },
+        { sid: sid2, uid: uid3 }
+      ];
+      let mockMsg = { key: 'some remote message' };
+      let uidMap: { [key: string]: any } = {};
+      for (let i in mockUids) {
+        uidMap[mockUids[i].uid] = mockUids[i];
+      }
+
+      let invokeCount = 0;
+
+      let mockRpcInvoke = function (sid: string, rmsg: { [key: string]: any }, cb: (parameter: Error) => void) {
+        invokeCount++;
+        cb(new Error('[TestMockError] mock rpc error'));
+      };
+
+      let app = melo.createApp({ base: mockBase });
+      app.rpcInvoke = mockRpcInvoke;
+      let channelService = new ChannelService(app);
+
+      channelService.pushMessageByUids(mockMsg, mockUids, function (err: Error) {
+        invokeCount.should.equal(2);
+        should.exist(err);
+        err.message.should.equal('all uids push message fail');
+        done();
+      });
+    });
+
+    it('should return fail uid list if fail to push messge to some of the uids', function (done: Mocha.Done) {
+      let sid1 = 'sid1', sid2 = 'sid2';
+      let uid1 = 'uid1', uid2 = 'uid2', uid3 = 'uid3';
+      let mockUids = [{ sid: sid1, uid: uid1 }, { sid: sid2, uid: uid2 }, { sid: sid2, uid: uid3 }];
+      let mockMsg = { key: 'some remote message' };
+      let uidMap: { [key: string]: any } = {};
+      for (let i in mockUids) {
+        uidMap[mockUids[i].uid] = mockUids[i];
+      }
+
+      let invokeCount = 0;
+
+      let mockRpcInvoke = function (sid: string, rmsg: { [key: string]: any }, cb: Function) {
+        invokeCount++;
+        if (rmsg.args[2].indexOf(uid1) >= 0) {
+          cb(null, [uid1]);
+        } else if (rmsg.args[2].indexOf(uid3) >= 0) {
+          cb(null, [uid3]);
+        } else {
+          cb();
+        }
+      };
+
+      let app = melo.createApp({ base: mockBase });
+      app.rpcInvoke = mockRpcInvoke;
+      let channelService = new ChannelService(app);
+
+      channelService.pushMessageByUids(mockMsg, mockUids, function (err: Error, fails: Array<any>) {
+        invokeCount.should.equal(2);
+        should.not.exist(err);
+        should.exist(fails);
+        fails.length.should.equal(2);
+        fails.should.containEql(uid1);
+        fails.should.containEql(uid3);
+        done();
+      });
+    });
+  });
+
+  describe('#broadcast', function () {
+    it('should push message to all specified frontend servers', function (done: Mocha.Done) {
+      let mockServers = [
+        { id: 'connector-1', serverType: 'connector', other: 'xxx1' },
+        { id: 'connector-2', serverType: 'connector', other: 'xxx2' },
+        { id: 'area-1', serverType: 'area', other: 'yyy1' },
+        { id: 'gate-1', serverType: 'gate', other: 'zzz1' },
+        { id: 'gate-2', serverType: 'gate', other: 'xxx1' },
+        { id: 'gate-3', serverType: 'gate', other: 'yyy1' }
+      ];
+      let connectorIds = ['connector-1', 'connector-2'];
+      let mockSType = 'connector';
+      let mockRoute = 'test.route.string';
+      let mockBinded = true;
+      let opts = { binded: mockBinded };
+      let mockMsg = { key: 'some remote message' };
+
+      let invokeCount = 0;
+      let sids: Array<number> = [];
+
+      let mockRpcInvoke = function (sid: number, rmsg: { [key: string]: any }, cb: Function) {
+        invokeCount++;
+        let args = rmsg.args;
+        let route = args[0];
+        let msg = args[1];
+        let opts = args[2];
+        mockMsg.should.eql(msg);
+        mockRoute.should.equal(route);
+        should.exist(opts);
+        mockBinded.should.equal(opts.userOptions.binded);
+        sids.push(sid);
+        cb();
+      };
+
+      let app = melo.createApp({ base: mockBase });
+      app.rpcInvoke = mockRpcInvoke;
+      app.addServers(mockServers);
+      let channelService = new ChannelService(app);
+
+      channelService.broadcast(mockSType, mockRoute, mockMsg,
+        opts, function () {
+          invokeCount.should.equal(2);
+          sids.length.should.equal(connectorIds.length);
+          for (let i = 0, l = connectorIds.length; i < l; i++) {
+            sids.should.containEql(connectorIds[i]);
+          }
+          done();
+        });
+    });
+  });
+});