@bigtyphoon/melo 1.7.6

package/test/service/sessionService.ts

@@ -0,0 +1,464 @@
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let pomelo = require('../../lib/index');
+import { SessionService, Session, FrontendSession } from '../../lib/common/service/sessionService';
+import { SID, FRONTENDID, UID } from '../../lib/util/constants';
+import { ISocket } from '../../lib//interfaces/ISocket';
+
+describe('session service test', function () {
+  describe('#bind', function () {
+    it('should get session by uid after binded', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'changchang';
+      let eventCount = 0;
+
+      let session = service.create(sid, fid, socket);
+
+      should.exist(session);
+
+      session.should.eql(service.get(sid));
+
+      session.on('bind', function (euid: number) {
+        eventCount++;
+        uid.should.equal(euid);
+      });
+
+      service.bind(sid, uid, function (err: Error) {
+        should.not.exist(err);
+        let sessions = service.getByUid(uid);
+        should.exist(sessions);
+        sessions.length.should.equal(1);
+        session.should.eql(sessions[0]);
+        eventCount.should.equal(1);
+        service.bind(sid, uid, function (err: Error) {
+          should.not.exist(err);
+          done();
+        });
+      });
+    });
+    it('should fail if already binded uid', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py', test_uid = 'test';
+
+      let session = service.create(sid, fid, socket);
+
+      service.bind(sid, uid, null);
+
+      service.bind(sid, test_uid, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+    it('should fail if try to bind a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, uid = 'changchang';
+
+      service.bind(sid, uid, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+  });
+
+  describe('#unbind', function () {
+    it('should fail unbind session if session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1;
+      let uid = 'py';
+
+      service.unbind(sid, uid, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+    it('should fail unbind session if session not binded', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py';
+
+      let session = service.create(sid, fid, socket);
+
+      service.unbind(sid, uid, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+    it('should fail to get session after session unbinded', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py';
+
+      let session = service.create(sid, fid, socket);
+      service.bind(sid, uid, null);
+
+      service.unbind(sid, uid, function (err: Error) {
+        should.not.exist(err);
+        let sessions = service.getByUid(uid);
+        should.not.exist(sessions);
+        done();
+      });
+    });
+  });
+
+  describe('#remove', function () {
+    it('should not get the session after remove', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'changchang';
+
+      let session = service.create(sid, fid, socket);
+
+      service.bind(sid, uid, function (err: Error) {
+        service.remove(sid);
+        should.not.exist(service.get(sid));
+        should.not.exist(service.getByUid(uid));
+        done();
+      });
+    });
+  });
+
+  describe('#import', function () {
+    it('should update the session with the key/value pair', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let key = 'key-1', value = 'value-1';
+
+      let session = service.create(sid, fid, socket);
+
+      service.import(sid, key, value, function (err: Error) {
+        should.not.exist(err);
+        value.should.eql(session.get(key));
+        done();
+      });
+    });
+
+    it('should fail if try to update a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1;
+      let key = 'key-1', value = 'value-1';
+
+      service.import(sid, key, value, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+
+    it('should update the session with the key/value pairs', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let key = 'key-1', value = 'value-1', key2 = 'key-2', value2 = {};
+
+      let settings: { [key: string]: any } = {};
+      settings[key] = value;
+      settings[key2] = value2;
+
+      let session = service.create(sid, fid, socket);
+
+      service.importAll(sid, settings, function (err: Error) {
+        should.not.exist(err);
+        value.should.eql(session.get(key));
+        value2.should.eql(session.get(key2));
+        done();
+      });
+    });
+
+    it('should fail if try to update a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1;
+      let key = 'key-1', value = 'value-1';
+
+      service.import(sid, key, value, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+
+    it('should fail if try to update a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1;
+      let key = 'key-1', value = 'value-1', key2 = 'key-2', value2 = {};
+
+      let settings: { [key: string]: any } = {};
+      settings[key] = value;
+      settings[key2] = value2;
+
+      service.importAll(sid, settings, function (err: Error) {
+        should.exist(err);
+        done();
+      });
+    });
+  });
+
+  describe('#kick', function () {
+    it('should kick the sessions', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid1 = 1, fid1 = 'frontend-server-1';
+      let sid2 = 2, fid2 = 'frontend-server-1';
+      let socket: ISocket = <any>{
+        emit: function () { },
+        disconnect: function () { }
+      };
+      let uid = 'changchang';
+      let eventCount = 0;
+
+      let session1 = service.create(sid1, fid1, socket);
+      let session2 = service.create(sid2, fid2, socket);
+      session1.on('closed', function () {
+        eventCount++;
+      });
+
+      session2.on('closed', function () {
+        eventCount++;
+      });
+
+      service.bind(sid1, uid, function (err: Error) {
+        service.bind(sid2, uid, function (err: Error) {
+          service.kick(uid, null, function (err: Error) {
+            should.not.exist(err);
+            should.not.exist(service.get(sid1));
+            should.not.exist(service.get(sid2));
+            should.not.exist(service.getByUid(uid));
+            eventCount.should.equal(2);
+            done();
+          });
+        });
+      });
+    });
+
+    it('should kick the session by sessionId', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid1 = 1, fid1 = 'frontend-server-1';
+      let sid2 = 2, fid2 = 'frontend-server-1';
+
+      let socket: ISocket = <any>{
+        emit: function () { },
+        disconnect: function () { }
+      };
+      let uid = 'changchang';
+      let eventCount = 0;
+
+      let session1 = service.create(sid1, fid1, socket);
+      let session2 = service.create(sid2, fid2, socket);
+      session1.on('closed', function () {
+        eventCount++;
+      });
+
+      session2.on('closed', function () {
+        eventCount++;
+      });
+
+      service.bind(sid1, uid, function (err: Error) {
+        service.bind(sid2, uid, function (err: Error) {
+          service.kickBySessionId(sid1, null, function (err: Error) {
+            should.not.exist(err);
+            should.not.exist(service.get(sid1));
+            should.exist(service.get(sid2));
+            should.exist(service.getByUid(uid));
+            eventCount.should.equal(1);
+            done();
+          });
+        });
+      });
+    });
+
+    it('should ok if kick a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let uid = 'changchang';
+
+      service.kick(uid, null, function (err: Error) {
+        should.not.exist(err);
+        done();
+      });
+    });
+
+    it('should kick session by sid', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1';
+      let socket: ISocket = <any>{
+        emit: function () { },
+        disconnect: function () { }
+      };
+      let eventCount = 0;
+
+      let session = service.create(sid, fid, socket);
+      session.on('closed', function () {
+        eventCount++;
+      });
+
+      service.kickBySessionId(sid, null, function (err: Error) {
+        should.not.exist(err);
+        should.not.exist(service.get(sid));
+        eventCount.should.equal(1);
+        done();
+      });
+    });
+
+    it('should ok if kick a session not exist', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1;
+
+      service.kickBySessionId(sid, null, function (err: Error) {
+        should.not.exist(err);
+        done();
+      });
+    });
+  });
+
+  describe('#forEachSession', function () {
+    it('should iterate all created sessions', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let eventCount = 0;
+
+      let outter_session = service.create(sid, fid, socket);
+
+      service.forEachSession(function (session: any) {
+        should.exist(session);
+        outter_session.id.should.eql(session.id);
+        done();
+      });
+    });
+  });
+
+  describe('#forEachBindedSession', function () {
+    it('should iterate all binded sessions', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py';
+
+      let outter_session = service.create(sid, fid, socket);
+      service.bind(sid, uid, null);
+
+      service.forEachBindedSession(function (session: any) {
+        should.exist(session);
+        outter_session.id.should.eql(session.id);
+        outter_session.uid.should.eql(session.uid);
+        done();
+      });
+    });
+  });
+});
+
+describe('frontend session test', function () {
+  describe('#bind', function () {
+    it('should get session by uid after binded', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'changchang';
+      let eventCount = 0;
+
+      let session = service.create(sid, fid, socket);
+      let fsession = session.toFrontendSession();
+
+      should.exist(fsession);
+
+      fsession.on('bind', function (euid: number) {
+        eventCount++;
+        uid.should.equal(euid);
+      });
+
+      fsession.bind(uid, function (err: Error) {
+        should.not.exist(err);
+        let sessions = service.getByUid(uid);
+        should.exist(sessions);
+        sessions.length.should.equal(1);
+        session.should.eql(sessions[0]);
+        eventCount.should.equal(1);
+        done();
+      });
+    });
+  });
+
+  describe('#unbind', function () {
+    it('should fail to get session after session unbinded', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py';
+
+      let session = service.create(sid, fid, socket);
+      let fsession = session.toFrontendSession();
+
+      fsession.bind(uid, null);
+      fsession.unbind(uid, function (err: Error) {
+        should.not.exist(err);
+        let sessions = service.getByUid(uid);
+        should.not.exist(sessions);
+        done();
+      });
+    });
+  });
+
+  describe('#set/get', function () {
+    it('should update the key/value pair in frontend session but not session',
+      function () {
+        let service = new SessionService();
+        let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+        let key = 'key-1', value = 'value-1';
+
+        let session = service.create(sid, fid, socket);
+        let fsession = session.toFrontendSession();
+
+        fsession.set(key, value);
+
+        should.not.exist(session.get(key));
+        value.should.eql(fsession.get(key));
+      });
+  });
+
+  describe('#push', function () {
+    it('should push the specified key/value pair to session', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let key = 'key-1', value = 'value-1', key2 = 'key-2', value2 = {};
+
+      let session = service.create(sid, fid, socket);
+      let fsession = session.toFrontendSession();
+
+      fsession.set(key, value);
+      fsession.set(key2, value2);
+
+      fsession.push(key, function (err: Error) {
+        should.not.exist(err);
+        value.should.eql(session.get(key));
+        should.not.exist(session.get(key2));
+        done();
+      });
+    });
+
+    it('should push all the key/value pairs to session', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let key = 'key-1', value = 'value-1', key2 = 'key-2', value2 = {};
+
+      let session = service.create(sid, fid, socket);
+      let fsession = session.toFrontendSession();
+
+      fsession.set(key, value);
+      fsession.set(key2, value2);
+
+      fsession.pushAll(function (err: Error) {
+        should.not.exist(err);
+        value.should.eql(session.get(key));
+        value2.should.eql(session.get(key2));
+        done();
+      });
+    });
+  });
+
+  describe('#export', function () {
+    it('should equal frontend session after export', function (done: Mocha.Done) {
+      let service = new SessionService();
+      let sid = 1, fid = 'frontend-server-1', socket: ISocket = <any>{};
+      let uid = 'py';
+
+      let session = service.create(sid, fid, socket);
+      let fsession = session.toFrontendSession();
+      let esession: FrontendSession = <any>fsession.export();
+      esession.id.should.eql(fsession.id);
+      esession.frontendId.should.eql(fsession.frontendId);
+      done();
+    });
+  });
+});

package/test/util/countDownLatch.ts

@@ -0,0 +1,81 @@
+let CountDownLatch = require('../../lib/util/countDownLatch');
+import 'should';
+// import { describe, it } from "mocha-typescript"
+
+let cbCreator = (function () {
+    let count = 0;
+
+    return {
+        callback: function () {
+            count++;
+        },
+        getCount: function () {
+            return count;
+        },
+        count: count
+    };
+})();
+
+describe('countdown latch test', function () {
+    let countDownLatch1;
+    let countDownLatch2;
+
+    describe('#count down', function () {
+        it('should invoke the callback after the done method was invoked the specified times', function (done: Mocha.Done) {
+            let n = 3, doneCount = 0;
+            let cdl = CountDownLatch.createCountDownLatch(n, function () {
+                doneCount.should.equal(n);
+                done();
+            });
+
+            for (let i = 0; i < n; i++) {
+                doneCount++;
+                cdl.done();
+            }
+        });
+
+        it('should throw exception if pass a negative or zero to the create method', function () {
+            (function () {
+                CountDownLatch.createCountDownLatch(-1, function () {
+                });
+            }).should.throw();
+
+            (function () {
+                CountDownLatch.createCountDownLatch(0, function () {
+                });
+            }).should.throw();
+        });
+
+        it('should throw exception if pass illegal cb to the create method', function () {
+            (function () {
+                CountDownLatch.createCountDownLatch(1, null);
+            }).should.throw();
+        });
+
+        it('should throw exception if try to invoke done metho of a latch that has fired cb', function () {
+            let n = 3;
+            let cdl = CountDownLatch.createCountDownLatch(n, function () {
+            });
+
+            for (let i = 0; i < n; i++) {
+                cdl.done();
+            }
+
+            (function () {
+                cdl.done();
+            }).should.throw();
+        });
+
+        it('should invoke the callback if timeout', function () {
+            let n = 3;
+            let cdl = CountDownLatch.createCountDownLatch(n, { timeout: 3000 }, function (isTimeout: boolean) {
+                isTimeout.should.equal(true);
+            });
+
+            for (let i = 0; i < n - 1; i++) {
+                cdl.done();
+            }
+        });
+
+    });
+});

package/test/util/pathUtil.ts

@@ -0,0 +1,122 @@
+let pathUtil = require('../../lib/util/pathUtil');
+let utils = require('../../lib/util/utils');
+import * as should from 'should';
+// import { describe, it } from "mocha-typescript"
+let fs = require('fs');
+
+let mockBase = process.cwd() + '/test/mock-base';
+
+describe('path util test', function () {
+    it('ok', () => {
+
+    })
+    if (process.platform === 'win32') {
+        return
+    }
+    describe('#getSysRemotePath', function () {
+        it('should return the system remote service path for frontend server', function () {
+            let role = 'frontend';
+            let expectSuffix = '/common/remote/frontend';
+            let p = pathUtil.getSysRemotePath(role);
+            should.exist(p);
+            fs.existsSync(p).should.be.true;
+            utils.endsWith(p, expectSuffix).should.be.true;
+        });
+
+        it('should return the system remote service path for backend server', function () {
+            let role = 'backend';
+            let expectSuffix = '/common/remote/backend';
+            let p = pathUtil.getSysRemotePath(role);
+            should.exist(p);
+            fs.existsSync(p).should.be.true;
+            utils.endsWith(p, expectSuffix).should.be.true;
+        });
+
+    });
+
+    describe('#getUserRemotePath', function () {
+        it('should return user remote service path for the associated server type', function () {
+            let serverType = 'connector';
+            let expectSuffix = '/app/servers/connector/remote';
+            let p = pathUtil.getUserRemotePath(mockBase, serverType);
+            should.exist(p);
+            fs.existsSync(p).should.be.true;
+            utils.endsWith(p, expectSuffix).should.be.true;
+        });
+
+        it('should return null if the directory not exist', function () {
+            let serverType = 'area';
+            let p = pathUtil.getUserRemotePath(mockBase, serverType);
+            should.not.exist(p);
+
+            serverType = 'some-dir-not-exist';
+            p = pathUtil.getUserRemotePath(mockBase, serverType);
+            should.not.exist(p);
+        });
+    });
+
+    describe('#listUserRemoteDir', function () {
+        it('should return sub-direcotry name list of servers/ directory', function () {
+            let expectNames = ['connector', 'area'];
+            let p = pathUtil.listUserRemoteDir(mockBase);
+            should.exist(p);
+            expectNames.length.should.equal(p.length);
+            for (let i = 0, l = expectNames.length; i < l; i++) {
+                p.should.containEql(expectNames[i]);
+            }
+        });
+
+        it('should throw err if the servers/ illegal', function () {
+            (function () {
+                pathUtil.listUserRemoteDir('some illegal base');
+            }).should.throw();
+        });
+    });
+
+    describe('#remotePathRecord', function () {
+        let namespace = 'user';
+        let serverType = 'connector';
+        let path = '/some/path/to/remote';
+        let r = pathUtil.remotePathRecord(namespace, serverType, path);
+        should.exist(r);
+        namespace.should.equal(r.namespace);
+        serverType.should.equal(r.serverType);
+        path.should.equal(r.path);
+    });
+
+    describe('#getHandlerPath', function () {
+        it('should return user handler path for the associated server type', function () {
+            let serverType = 'connector';
+            let expectSuffix = '/app/servers/connector/handler';
+            let p = pathUtil.getHandlerPath(mockBase, serverType);
+            should.exist(p);
+            fs.existsSync(p).should.be.true;
+            utils.endsWith(p, expectSuffix).should.be.true;
+        });
+
+        it('should return null if the directory not exist', function () {
+            let serverType = 'area';
+            let p = pathUtil.getHandlerPath(mockBase, serverType);
+            should.not.exist(p);
+
+            serverType = 'some-dir-not-exist';
+            p = pathUtil.getHandlerPath(mockBase, serverType);
+            should.not.exist(p);
+        });
+    });
+
+    describe('#getScriptPath', function () {
+        let p = pathUtil.getScriptPath(mockBase);
+        let expectSuffix = '/scripts';
+        should.exist(p);
+        utils.endsWith(p, expectSuffix).should.be.true;
+    });
+
+    describe('#getLogPath', function () {
+        let p = pathUtil.getLogPath(mockBase);
+        let expectSuffix = '/logs';
+        should.exist(p);
+        utils.endsWith(p, expectSuffix).should.be.true;
+    });
+
+});