@webex/plugin-meetings 3.3.1 → 3.4.0

package/test/unit/spec/media/MediaConnectionAwaiter.ts

@@ -1,6 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {ConnectionState, Event} from '@webex/internal-media-core';
+import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
 import testUtils from '../../../utils/testUtils';
 import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
@@ -19,6 +19,8 @@ describe('MediaConnectionAwaiter', () => {
       off: sinon.stub(),
       getConnectionState: sinon.stub().returns(ConnectionState.New),
       getIceGatheringState: sinon.stub().returns('new'),
+      getIceConnectionState: sinon.stub().returns('new'),
+      getPeerConnectionState: sinon.stub().returns('new'),
     };
 
     mediaConnectionAwaiter = new MediaConnectionAwaiter({
@@ -52,8 +54,11 @@ describe('MediaConnectionAwaiter', () => {
         .then(() => {
           promiseResolved = true;
         })
-        .catch(() => {
+        .catch((error) => {
           promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
         });
 
       await testUtils.flushPromises();
@@ -61,21 +66,109 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
+
+      mockMC.getIceGatheringState.returns('complete');
+      iceGatheringListener();
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledThrice(mockMC.off);
+    });
+
+    it('rejects immediately if ice state is FAILED', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch((error) => {
+          promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      // check the right listener was registered
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
+
+      mockMC.getConnectionState.returns(ConnectionState.Failed);
+      iceConnectionListener();
+
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledThrice(mockMC.off);
+    });
+
+    it('rejects after timeout if dtls state is not connected', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch((error) => {
+          promiseRejected = true;
+
+          const {iceConnected} = error;
+          assert.equal(iceConnected, false);
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      // check the right listener was registered
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(1).args[1];
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
 
       mockMC.getIceGatheringState.returns('complete');
       listener();
 
+      mockMC.getIceConnectionState.returns('connected');
+      iceConnectionListener();
+
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
       await testUtils.flushPromises();
 
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, true);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it('resolves after timeout if connection state reach connected/completed', async () => {
@@ -99,9 +192,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
 
       mockMC.getConnectionState.returns(ConnectionState.Connected);
 
@@ -111,7 +205,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseResolved, true);
       assert.equal(promiseRejected, false);
 
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`resolves when media connection reaches "connected" state`, async () => {
@@ -137,9 +231,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       // call the listener and pretend we are now connected
@@ -151,7 +246,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
     });
@@ -179,9 +274,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const listener = mockMC.on.getCall(1).args[1];
 
       // call the listener and pretend we are now connected
@@ -197,7 +293,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.neverCalledWith(clearTimeoutSpy);
     });
@@ -228,10 +324,11 @@ describe('MediaConnectionAwaiter', () => {
       assert.calledOnce(setTimeoutSpy);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
-      const listener = mockMC.on.getCall(1).args[1];
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
+      const listener = mockMC.on.getCall(2).args[1];
 
       // call the listener and pretend we are now connected
       mockMC.getIceGatheringState.returns('complete');
@@ -249,7 +346,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
     });
 
     it(`reject with restart timer once if gathering state is not complete`, async () => {
@@ -276,9 +373,10 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
 
       await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT * 2);
       await testUtils.flushPromises();
@@ -287,7 +385,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, true);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledOnce(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);
@@ -317,11 +415,12 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check the right listener was registered
-      assert.calledTwice(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      assert.equal(mockMC.on.getCall(1).args[0], Event.ICE_GATHERING_STATE_CHANGED);
+      assert.calledThrice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(2).args[0], MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED);
       const connectionStateListener = mockMC.on.getCall(0).args[1];
-      const iceGatheringListener = mockMC.on.getCall(1).args[1];
+      const iceGatheringListener = mockMC.on.getCall(2).args[1];
 
       mockMC.getIceGatheringState.returns('complete');
       iceGatheringListener();
@@ -335,7 +434,7 @@ describe('MediaConnectionAwaiter', () => {
       assert.equal(promiseRejected, false);
 
       // check that listener was removed
-      assert.calledTwice(mockMC.off);
+      assert.calledThrice(mockMC.off);
 
       assert.calledTwice(clearTimeoutSpy);
       assert.calledTwice(setTimeoutSpy);

package/test/unit/spec/media/index.ts

@@ -1,9 +1,8 @@
-import * as internalMediaModule from '@webex/internal-media-core';
+import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import Media from '@webex/plugin-meetings/src/media/index';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
-import {forEach} from 'lodash';
 import MockWebex from '@webex/test-helper-mock-webex';
 
 describe('createMediaConnection', () => {
@@ -17,44 +16,44 @@ describe('createMediaConnection', () => {
     id: 'roap media connection',
   };
   const fakeTrack = {
-    id: 'any fake track'
-  }
+    id: 'any fake track',
+  };
   const fakeAudioStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeVideoStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeShareVideoStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   const fakeShareAudioStream = {
     outputStream: {
       getTracks: () => {
         return [fakeTrack];
-      }
-    }
+      },
+    },
   };
   afterEach(() => {
     sinon.restore();
-    clock.uninstall()
+    clock.uninstall();
   });
 
   it('creates a RoapMediaConnection when multistream is disabled', () => {
     const roapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'RoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'RoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
     StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
@@ -81,7 +80,7 @@ describe('createMediaConnection', () => {
       enableRtx: ENABLE_RTX,
       enableExtmap: ENABLE_EXTMAP,
       turnServerInfo: {
-        url: 'turn server url',
+        url: 'turns:turn-server-url:443?transport=tcp',
         username: 'turn username',
         password: 'turn password',
       },
@@ -92,7 +91,12 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn server url',
+            urls: 'turn:turn-server-url:5004?transport=tcp',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+          {
+            urls: 'turns:turn-server-url:443?transport=tcp',
             username: 'turn username',
             credential: 'turn password',
           },
@@ -132,7 +136,7 @@ describe('createMediaConnection', () => {
 
   it('creates a MultistreamRoapMediaConnection when multistream is enabled', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
     Media.createMediaConnection(true, 'some debug id', webex, 'meeting id', 'correlationId', {
@@ -147,7 +151,7 @@ describe('createMediaConnection', () => {
         },
       },
       turnServerInfo: {
-        url: 'turn server url',
+        url: 'turns:turn-server-url:443?transport=tcp',
         username: 'turn username',
         password: 'turn password',
       },
@@ -159,7 +163,12 @@ describe('createMediaConnection', () => {
       {
         iceServers: [
           {
-            urls: 'turn server url',
+            urls: 'turn:turn-server-url:5004?transport=tcp',
+            username: 'turn username',
+            credential: 'turn password',
+          },
+          {
+            urls: 'turns:turn-server-url:443?transport=tcp',
             username: 'turn username',
             credential: 'turn password',
           },
@@ -172,13 +181,16 @@ describe('createMediaConnection', () => {
 
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
-    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+    {
+      testCase: 'turnServerInfo.url is empty string',
+      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+    },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to MultistreamRoapMediaConnection if ${testCase} (multistream enabled)`, () => {
       const multistreamRoapMediaConnectionConstructorStub = sinon
-        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
         .returns(fakeRoapMediaConnection);
-  
+
       Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
         mediaProperties: {
           mediaDirection: {
@@ -199,13 +211,13 @@ describe('createMediaConnection', () => {
           iceServers: [],
         },
         'meeting id'
-        );
+      );
     });
   });
-      
+
   it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+      .stub(InternalMediaCoreModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
     Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
@@ -233,11 +245,14 @@ describe('createMediaConnection', () => {
 
   [
     {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
-    {testCase: 'turnServerInfo.url is empty string', turnServerInfo: {url: '', username: 'turn username', password: 'turn password'}},
+    {
+      testCase: 'turnServerInfo.url is empty string',
+      turnServerInfo: {url: '', username: 'turn username', password: 'turn password'},
+    },
   ].forEach(({testCase, turnServerInfo}) => {
     it(`passes empty ICE servers array to RoapMediaConnection if ${testCase} (multistream disabled)`, () => {
       const roapMediaConnectionConstructorStub = sinon
-        .stub(internalMediaModule, 'RoapMediaConnection')
+        .stub(InternalMediaCoreModule, 'RoapMediaConnection')
         .returns(fakeRoapMediaConnection);
 
       StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});

package/test/unit/spec/meeting/connectionStateHandler.ts

@@ -0,0 +1,102 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {
+  ConnectionStateHandler,
+  ConnectionStateEvent,
+} from '@webex/plugin-meetings/src/meeting/connectionStateHandler';
+import {ConnectionState, MediaConnectionEventNames} from '@webex/internal-media-core';
+
+describe('ConnectionStateHandler', () => {
+  let connectionStateHandler: ConnectionStateHandler;
+  let mockMC;
+
+  beforeEach(() => {
+    mockMC = {
+      on: sinon.stub(),
+      off: sinon.stub(),
+      getConnectionState: sinon.stub().returns(ConnectionState.Connecting),
+    };
+
+    connectionStateHandler = new ConnectionStateHandler(mockMC);
+  });
+
+  describe('ConnectionStateChangedEvent', () => {
+    it('should emit a stateChanged event when the peer connection state changes', () => {
+      const spy = sinon.spy(connectionStateHandler, 'emit');
+
+      // check the right listener was registered
+      assert.calledTwice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      const listener = mockMC.on.getCall(0).args[1];
+
+      listener();
+
+      assert.calledOnce(spy);
+      assert.calledOnceWithExactly(
+        connectionStateHandler.emit,
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {
+          state: ConnectionState.Connecting,
+        }
+      );
+    });
+
+    it('should emit a stateChanged event when the ice connection state changes', () => {
+      const spy = sinon.spy(connectionStateHandler, 'emit');
+
+      // check the right listener was registered
+      assert.calledTwice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      const listener = mockMC.on.getCall(1).args[1];
+
+      listener();
+
+      assert.calledOnce(spy);
+      assert.calledOnceWithExactly(
+        connectionStateHandler.emit,
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {
+          state: ConnectionState.Connecting,
+        }
+      );
+    });
+
+    it('should emit a stateChanged event only once when overall connection state does not change', () => {
+      const spy = sinon.spy(connectionStateHandler, 'emit');
+
+      // check the right listener was registered
+      assert.calledTwice(mockMC.on);
+      assert.equal(mockMC.on.getCall(0).args[0], MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED);
+      const peerConnectionListener = mockMC.on.getCall(0).args[1];
+      const iceConnectionListener = mockMC.on.getCall(1).args[1];
+
+      peerConnectionListener();
+
+      iceConnectionListener();
+
+      assert.calledOnce(spy);
+      assert.calledOnceWithExactly(
+        connectionStateHandler.emit,
+        {
+          file: 'connectionStateHandler',
+          function: 'handleConnectionStateChange',
+        },
+        ConnectionStateEvent.stateChanged,
+        {
+          state: ConnectionState.Connecting,
+        }
+      );
+    });
+  });
+});