add test for messageQueue

replace setTimeout to Promised wait

dist/src/index.js

@@ -36,7 +36,6 @@ const init = ({ app, server, options }) => {
         const messageQueue = realm.getMessageQueueById(client.getId());
         if (messageQueue) {
             let message;
-            // tslint:disable
             while (message = messageQueue.readMessage()) {
                 messageHandler.handle(client, message);
             }

dist/src/models/messageQueue.js

@@ -16,7 +16,7 @@ class MessageQueue {
             this.lastReadAt = new Date().getTime();
             return this.messages.shift();
         }
-        return null;
+        return undefined;
     }
     getMessages() {
         return this.messages;

src/index.ts

@@ -46,9 +46,8 @@ const init = ({ app, server, options }: {
     const messageQueue = realm.getMessageQueueById(client.getId());
 
     if (messageQueue) {
-      let message: IMessage | null;
+      let message: IMessage | undefined;
 
-      // tslint:disable
       while (message = messageQueue.readMessage()) {
         messageHandler.handle(client, message);
       }

src/models/messageQueue.ts

@@ -5,7 +5,7 @@ export interface IMessageQueue {
 
   addMessage(message: IMessage): void;
 
-  readMessage(): IMessage | null;
+  readMessage(): IMessage | undefined;
 
   getMessages(): IMessage[];
 }
@@ -22,13 +22,13 @@ export class MessageQueue implements IMessageQueue {
     this.messages.push(message);
   }
 
-  public readMessage(): IMessage | null {
+  public readMessage(): IMessage | undefined {
     if (this.messages.length > 0) {
       this.lastReadAt = new Date().getTime();
       return this.messages.shift()!;
     }
 
-    return null;
+    return undefined;
   }
 
   public getMessages(): IMessage[] {

test/models/messageQueue.ts

@@ -0,0 +1,62 @@
+import { expect } from 'chai';
+import { MessageQueue } from '../../src/models/messageQueue';
+import { MessageType } from '../../src/enums';
+import { IMessage } from '../../src/models/message';
+import { wait } from '../utils';
+
+describe('MessageQueue', () => {
+  const createTestMessage = (): IMessage => {
+    return {
+      type: MessageType.OPEN,
+      src: 'src',
+      dst: 'dst'
+    };
+  };
+
+  describe('#addMessage', () => {
+    it('should add message to queue', () => {
+      const queue = new MessageQueue();
+      queue.addMessage(createTestMessage());
+      expect(queue.getMessages().length).to.eq(1);
+    });
+  });
+
+  describe('#readMessage', () => {
+    it('should return undefined for empty queue', () => {
+      const queue = new MessageQueue();
+      expect(queue.readMessage()).to.be.undefined;
+    });
+
+    it('should return message if any exists in queue', () => {
+      const queue = new MessageQueue();
+      const message = createTestMessage();
+      queue.addMessage(message);
+
+      expect(queue.readMessage()).to.deep.eq(message);
+      expect(queue.readMessage()).to.be.undefined;
+    });
+  });
+
+  describe('#getLastReadAt', () => {
+    it('should not be changed if no messages when read', () => {
+      const queue = new MessageQueue();
+      const lastReadAt = queue.getLastReadAt();
+      queue.readMessage();
+      expect(queue.getLastReadAt()).to.be.eq(lastReadAt);
+    });
+
+    it('should be changed when read message', async () => {
+      const queue = new MessageQueue();
+      const lastReadAt = queue.getLastReadAt();
+      queue.addMessage(createTestMessage());
+
+      await wait(10);
+
+      expect(queue.getLastReadAt()).to.be.eq(lastReadAt);
+
+      queue.readMessage();
+
+      expect(queue.getLastReadAt()).to.be.greaterThan(lastReadAt + 10);
+    });
+  });
+});

test/services/checkBrokenConnections/index.ts

@@ -2,9 +2,10 @@ import { expect } from 'chai';
 import { Client } from '../../../src/models/client';
 import { Realm } from '../../../src/models/realm';
 import { CheckBrokenConnections } from '../../../src/services/checkBrokenConnections';
+import { wait } from '../../utils';
 
 describe('checkBrokenConnections service', () => {
-    it('should remove client after 2 checks', (done) => {
+    it('should remove client after 2 checks', async () => {
         const realm = new Realm();
         const doubleCheckTime = 55;//~ equals to checkBrokenConnections.checkInterval * 2
         const checkBrokenConnections = new CheckBrokenConnections({ realm, config: { alive_timeout: doubleCheckTime }, checkInterval: 30 });
@@ -13,14 +14,14 @@ describe('checkBrokenConnections service', () => {
 
         checkBrokenConnections.start();
 
-        setTimeout(() => {
+        await wait(checkBrokenConnections.checkInterval * 2 + 30);
+
         expect(realm.getClientById('id')).to.be.undefined;
+
         checkBrokenConnections.stop();
-            done();
-        }, checkBrokenConnections.checkInterval * 2 + 30);
     });
 
-    it('should remove client after 1 ping', (done) => {
+    it('should remove client after 1 ping', async () => {
         const realm = new Realm();
         const doubleCheckTime = 55;//~ equals to checkBrokenConnections.checkInterval * 2
         const checkBrokenConnections = new CheckBrokenConnections({ realm, config: { alive_timeout: doubleCheckTime }, checkInterval: 30 });
@@ -30,14 +31,14 @@ describe('checkBrokenConnections service', () => {
         checkBrokenConnections.start();
 
         //set ping after first check
-        setTimeout(() => {
+        await wait(checkBrokenConnections.checkInterval);
+
         client.setLastPing(new Date().getTime());
 
-            setTimeout(() => {
+        await wait(checkBrokenConnections.checkInterval * 2 + 10);
+
         expect(realm.getClientById('id')).to.be.undefined;
+
         checkBrokenConnections.stop();
-                done();
-            }, checkBrokenConnections.checkInterval * 2 + 10);
-        }, checkBrokenConnections.checkInterval);
     });
 });

test/utils.ts

@@ -0,0 +1 @@
+export const wait = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms));