@webex/plugin-meetings 3.3.1-next.16 → 3.3.1-next.17

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 {Event, ConnectionState} 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], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.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], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.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], Event.PEER_CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(1).args[0], Event.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,
+        }
+      );
+    });
+  });
+});

package/test/unit/spec/meeting/index.js

@@ -2216,7 +2216,7 @@ describe('plugin-meetings', () => {
               turnDiscoverySkippedReason: undefined,
             });
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
+          meeting.mediaProperties.waitForMediaConnectionConnected.rejects({iceConnected: false});
 
           const forceRtcMetricsSend = sinon.stub().resolves();
           const closeMediaConnectionStub = sinon.stub();
@@ -2240,12 +2240,12 @@ describe('plugin-meetings', () => {
           assert.calledTwice(generateClientErrorCodeForIceFailureStub);
           assert.calledWith(generateClientErrorCodeForIceFailureStub, {
             signalingState: 'unknown',
-            iceConnectionState: 'unknown',
+            iceConnected: false,
             turnServerUsed: false,
           });
           assert.calledWith(generateClientErrorCodeForIceFailureStub, {
             signalingState: 'unknown',
-            iceConnectionState: 'unknown',
+            iceConnected: false,
             turnServerUsed: true,
           });
 
@@ -2440,7 +2440,7 @@ describe('plugin-meetings', () => {
           assert.calledOnce(generateClientErrorCodeForIceFailureStub);
           assert.calledWith(generateClientErrorCodeForIceFailureStub, {
             signalingState: 'unknown',
-            iceConnectionState: 'unknown',
+            iceConnected: undefined,
             turnServerUsed: false,
           });
 
@@ -2715,7 +2715,7 @@ describe('plugin-meetings', () => {
             turnDiscoverySkippedReason: undefined,
           });
           meeting.meetingState = 'ACTIVE';
-          meeting.mediaProperties.waitForMediaConnectionConnected.rejects(new Error('fake error'));
+          meeting.mediaProperties.waitForMediaConnectionConnected.rejects({iceConnected: false});
 
           const forceRtcMetricsSend = sinon.stub().resolves();
           const closeMediaConnectionStub = sinon.stub();
@@ -3058,7 +3058,7 @@ describe('plugin-meetings', () => {
 
               meeting.meetingState = 'ACTIVE';
               meeting.mediaProperties.waitForMediaConnectionConnected.rejects(
-                new Error('fake error')
+                {iceConnected: false}
               );
 
               let errorThrown = false;
@@ -3073,7 +3073,7 @@ describe('plugin-meetings', () => {
 
               assert.calledOnceWithExactly(generateClientErrorCodeForIceFailureStub, {
                 signalingState: 'unknown',
-                iceConnectionState: 'unknown',
+                iceConnected: false,
                 turnServerUsed: true,
               });
 
@@ -7079,6 +7079,10 @@ describe('plugin-meetings', () => {
           id: 'stream',
           getTracks: () => [{id: 'track', addEventListener: sinon.stub()}],
         };
+        const simulateConnectionStateChange = (newState) => {
+          meeting.mediaProperties.webrtcMediaConnection.getConnectionState = sinon.stub().returns(newState);
+          eventListeners[Event.PEER_CONNECTION_STATE_CHANGED]();
+        }
 
         beforeEach(() => {
           eventListeners = {};
@@ -7088,6 +7092,7 @@ describe('plugin-meetings', () => {
             on: sinon.stub().callsFake((event, listener) => {
               eventListeners[event] = listener;
             }),
+            getConnectionState: sinon.stub().returns(ConnectionState.New),
           };
           MediaUtil.createMediaStream.returns(fakeStream);
         });
@@ -7099,7 +7104,8 @@ describe('plugin-meetings', () => {
           assert.isFunction(eventListeners[Event.ROAP_FAILURE]);
           assert.isFunction(eventListeners[Event.ROAP_MESSAGE_TO_SEND]);
           assert.isFunction(eventListeners[Event.REMOTE_TRACK_ADDED]);
-          assert.isFunction(eventListeners[Event.CONNECTION_STATE_CHANGED]);
+          assert.isFunction(eventListeners[Event.PEER_CONNECTION_STATE_CHANGED]);
+          assert.isFunction(eventListeners[Event.ICE_CONNECTION_STATE_CHANGED]);
         });
 
         it('should trigger a media:ready event when REMOTE_TRACK_ADDED is fired', () => {
@@ -7139,9 +7145,8 @@ describe('plugin-meetings', () => {
           it('sends client.ice.start correctly when hasMediaConnectionConnectedAtLeastOnce = true', () => {
             meeting.hasMediaConnectionConnectedAtLeastOnce = true;
             meeting.setupMediaConnectionListeners();
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Connecting',
-            });
+
+            simulateConnectionStateChange(ConnectionState.Connecting);
 
             assert.notCalled(webex.internal.newMetrics.submitClientEvent);
           });
@@ -7149,9 +7154,8 @@ describe('plugin-meetings', () => {
           it('sends client.ice.start correctly when hasMediaConnectionConnectedAtLeastOnce = false', () => {
             meeting.hasMediaConnectionConnectedAtLeastOnce = false;
             meeting.setupMediaConnectionListeners();
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Connecting',
-            });
+
+            simulateConnectionStateChange(ConnectionState.Connecting);
 
             assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
             assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
@@ -7177,6 +7181,7 @@ describe('plugin-meetings', () => {
               on: sinon.stub().callsFake((event, listener) => {
                 eventListeners[event] = listener;
               }),
+              getConnectionState: sinon.stub().returns(ConnectionState.Connected),
             };
           };
 
@@ -7230,9 +7235,7 @@ describe('plugin-meetings', () => {
             assert.equal(meeting.hasMediaConnectionConnectedAtLeastOnce, false);
 
             // simulate first connection success
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Connected',
-            });
+            simulateConnectionStateChange(ConnectionState.Connected);
             checkExpectedSpies({
               icePhase: 'JOIN_MEETING_FINAL',
               setNetworkStatusCallParams: [NETWORK_STATUS.CONNECTED],
@@ -7242,12 +7245,9 @@ describe('plugin-meetings', () => {
             // now simulate short connection loss, client.ice.end is not sent a second time as hasMediaConnectionConnectedAtLeastOnce = true
             resetSpies();
 
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Disconnected',
-            });
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Connected',
-            });
+            simulateConnectionStateChange(ConnectionState.Disconnected);
+
+            simulateConnectionStateChange(ConnectionState.Connected);
 
             checkExpectedSpies({
               setNetworkStatusCallParams: [NETWORK_STATUS.DISCONNECTED, NETWORK_STATUS.CONNECTED],
@@ -7255,12 +7255,9 @@ describe('plugin-meetings', () => {
 
             resetSpies();
 
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Disconnected',
-            });
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Connected',
-            });
+            simulateConnectionStateChange(ConnectionState.Disconnected);
+
+            simulateConnectionStateChange(ConnectionState.Connected);
           });
         });
 
@@ -7282,9 +7279,8 @@ describe('plugin-meetings', () => {
 
           const mockDisconnectedEvent = () => {
             meeting.setupMediaConnectionListeners();
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Disconnected',
-            });
+
+            simulateConnectionStateChange(ConnectionState.Disconnected);
           };
 
           const checkBehavioralMetricSent = (hasMediaConnectionConnectedAtLeastOnce = false) => {
@@ -7348,9 +7344,8 @@ describe('plugin-meetings', () => {
         describe('CONNECTION_STATE_CHANGED event when state = "Failed"', () => {
           const mockFailedEvent = () => {
             meeting.setupMediaConnectionListeners();
-            eventListeners[Event.CONNECTION_STATE_CHANGED]({
-              state: 'Failed',
-            });
+
+            simulateConnectionStateChange(ConnectionState.Failed);
           };
 
           const checkBehavioralMetricSent = (hasMediaConnectionConnectedAtLeastOnce = false) => {