test: adding limbo state tests

dist/test/mocks.d.ts

@@ -35,6 +35,7 @@ export declare const getServicesMock: () => {
     getHandle: () => Function | null;
     simulateConnectionLost: () => void;
     simulateConnectionReestablished: () => void;
+    simulateExitLimbo: () => void;
     storage: {
         get: () => void;
         set: () => void;

test/connection/connectionSpec.ts

@@ -39,14 +39,16 @@ describe('connection', () => {
   const reconnectIntervalIncrement = 10
   const maxReconnectAttempts = 3
   const maxReconnectInterval = 30
+  const offlineBufferTimeout = 10
 
   beforeEach(() => {
     services = getServicesMock()
     options = Object.assign(DefaultOptions, {
       heartbeatInterval,
       reconnectIntervalIncrement,
       maxReconnectAttempts,
-      maxReconnectInterval
+      maxReconnectInterval,
+      offlineBufferTimeout
     })
     emitter = new Emitter()
     emitterMock = mock(emitter)
@@ -313,6 +315,20 @@ describe('connection', () => {
     assert.calledOnce(authCallback)
   })
 
+  it('goes into limbo on connection lost', async () => {
+    await openConnection()
+    const limboSpy = spy()
+
+    connection.onExitLimbo(limboSpy)
+
+    await loseConnection()
+    expect(connection.isInLimbo).to.equal(true)
+
+    await BBPromise.delay(1000)
+    assert.calledOnce(limboSpy)
+    expect(connection.isInLimbo).to.equal(false)
+  })
+
   async function openConnection () {
     socket.simulateOpen()
     await BBPromise.delay(0)
@@ -577,6 +593,7 @@ describe('connection', () => {
 
     socket.close()
     await BBPromise.delay(0)
+    expect(connection.isConnected).to.equal(false)
   }
 
   async function reconnectToInitialServer () {

test/event/event-handlerSpec.ts

@@ -4,7 +4,7 @@ import { getServicesMock, getListenerMock } from '../mocks'
 import { EVENT } from '../../src/constants'
 import { TOPIC, EVENT_ACTIONS as EVENT_ACTION } from '../../binary-protocol/src/message-constants'
 import * as Emitter from 'component-emitter2'
-
+import { Promise as BBPromise } from 'bluebird'
 import { DefaultOptions } from '../../src/client-options'
 import { EventHandler } from '../../src/event/event-handler'
 
@@ -364,4 +364,25 @@ describe('event handler', () => {
     })
   })
 
+  describe('limbo', () => {
+
+    beforeEach(() => {
+      services.connection.isConnected = false
+      services.connection.isInLimbo = true
+    })
+
+    it('sends messages once re-established if in limbo', async () => {
+      eventHandler.emit(name, 6)
+
+      services.connectionMock
+        .expects('sendMessage')
+        .once()
+        .withExactArgs({ topic: TOPIC.EVENT, action: EVENT_ACTION.EMIT, parsedData: 6, name })
+
+      services.simulateConnectionReestablished()
+      await BBPromise.delay(1)
+    })
+
+  })
+
 })

test/mocks.ts

@@ -109,6 +109,7 @@ export const getServicesMock = () => {
     getHandle: (): Function | null => handle,
     simulateConnectionLost: (): void => onLost(),
     simulateConnectionReestablished: (): void => onReestablished(),
+    simulateExitLimbo: (): void => onExitLimbo(),
     storage,
     storageMock,
     verify: () => {

test/presence/presence-handlerSpec.ts

@@ -549,6 +549,38 @@ describe('Presence handler', () => {
     })
   })
 
+  describe('limbo', () => {
+
+    beforeEach(() => {
+      services.connection.isConnected = false
+      services.connection.isInLimbo = true
+    })
+
+    it('returns client offline error once limbo state over', async () => {
+      presenceHandler.getAll(callbackSpy)
+      services.simulateExitLimbo()
+
+      await BBPromise.delay(1)
+
+      assert.calledOnce(callbackSpy)
+      assert.calledWithExactly(callbackSpy, EVENT.CLIENT_OFFLINE)
+    })
+
+    it('sends messages once re-established if in limbo', async () => {
+      presenceHandler.getAll(callbackSpy)
+
+      services.connectionMock
+        .expects('sendMessage')
+        .once()
+      services.timeoutRegistryMock
+        .expects('add')
+        .once()
+
+      services.simulateConnectionReestablished()
+      await BBPromise.delay(1)
+    })
+  })
+
 })
 
 function message (action: PRESENCE_ACTIONS, user?: string): Message {

test/rpc/rpc-handlerSpec.ts

@@ -16,6 +16,7 @@ describe('RPC handler', () => {
   let rpcHandler: RPCHandler
   let handle: Function
   let rpcProviderSpy: sinon.SinonSpy
+  let rpcMakeSpy: sinon.SinonSpy
   let data: any
   const name = 'myRpc'
   const rpcAcceptTimeout = 3
@@ -27,6 +28,7 @@ describe('RPC handler', () => {
     rpcHandler = new RPCHandler(services, options)
     handle = services.getHandle()
     rpcProviderSpy = sinon.spy()
+    rpcMakeSpy = sinon.spy()
     data = { foo: 'bar' }
   })
 
@@ -551,6 +553,38 @@ describe('RPC handler', () => {
       sinon.assert.calledOnce(rpcPromiseResponseFail)
       sinon.assert.calledWithExactly(rpcPromiseResponseFail, EVENT.CLIENT_OFFLINE)
     })
+  })
+
+  describe('limbo', () => {
+
+    beforeEach(() => {
+      services.connection.isConnected = false
+      services.connection.isInLimbo = true
+    })
+
+    it('returns client offline error once limbo state over', async () => {
+      rpcHandler.make(name, data, rpcMakeSpy)
+      services.simulateExitLimbo()
+
+      await BBPromise.delay(1)
+
+      sinon.assert.calledOnce(rpcMakeSpy)
+      sinon.assert.calledWithExactly(rpcMakeSpy, EVENT.CLIENT_OFFLINE)
+    })
+
+    it('sends messages once re-established if in limbo', async () => {
+      rpcHandler.make(name, data, rpcMakeSpy)
+
+      services.connectionMock
+        .expects('sendMessage')
+        .once()
+      services.timeoutRegistryMock
+        .expects('add')
+        .twice()
+
+      services.simulateConnectionReestablished()
+      await BBPromise.delay(1)
+    })
 
   })