@webex/plugin-meetings 3.0.0-test.1 → 3.1.0-next.1

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

@@ -381,7 +381,7 @@ describe('plugin-meetings', () => {
             id: 'meeting-id'
           })
         };
-        breakoutEvent.onBreakoutJoinResponse = sinon.stub();
+        const onBreakoutJoinResponseSpy = sinon.stub(breakoutEvent,'onBreakoutJoinResponse')
         breakouts.currentBreakoutSession.sessionId = "sessionId-old";
         breakouts.updateBreakout({
           sessionId: 'sessionId-new',
@@ -398,7 +398,9 @@ describe('plugin-meetings', () => {
           breakoutMoveId: 'breakoutMoveId',
         });
 
-        assert.calledOnce(breakoutEvent.onBreakoutJoinResponse);
+        assert.calledOnce(onBreakoutJoinResponseSpy);
+
+        onBreakoutJoinResponseSpy.restore()
 
       });
 
@@ -408,7 +410,7 @@ describe('plugin-meetings', () => {
             id: 'meeting-id'
           })
         };
-        breakoutEvent.onBreakoutJoinResponse = sinon.stub();
+        const onBreakoutJoinResponseSpy = sinon.stub(breakoutEvent, 'onBreakoutJoinResponse');
         breakouts.currentBreakoutSession.sessionId = "sessionId";
         breakouts.currentBreakoutSession.groupId = "groupId";
         breakouts.updateBreakout({
@@ -426,7 +428,8 @@ describe('plugin-meetings', () => {
           breakoutMoveId: 'breakoutMoveId',
         });
 
-        assert.notCalled(breakoutEvent.onBreakoutJoinResponse);
+        assert.notCalled(onBreakoutJoinResponseSpy);
+        onBreakoutJoinResponseSpy.restore()
 
       });
     });

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

@@ -131,6 +131,7 @@ describe('plugin-meetings', () => {
         assert.equal(interpretation.receiveLanguage, 'en');
         assert.equal(interpretation.isActive, true);
         assert.equal(interpretation.order, 0);
+        assert.equal(interpretation.selfIsInterpreter, true);
 
         sampleData.interpretation = {
           originalLanguage: 'en',
@@ -141,13 +142,15 @@ describe('plugin-meetings', () => {
         assert.equal(interpretation.sourceLanguage, undefined);
         assert.equal(interpretation.targetLanguage, 'zh');
         assert.equal(interpretation.receiveLanguage, undefined);
+        assert.equal(interpretation.selfIsInterpreter, true);
 
         sampleData.interpretation = {
           order: 0,
         };
-        assert.equal(interpretation.updateSelfInterpretation(sampleData), false);
+        assert.equal(interpretation.updateSelfInterpretation(sampleData), true);
         assert.equal(interpretation.originalLanguage, undefined);
         assert.equal(interpretation.targetLanguage, undefined);
+        assert.equal(interpretation.selfIsInterpreter, false);
       });
     });
 

package/test/unit/spec/locus-info/index.js

@@ -1385,7 +1385,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
-          payload
+          payload,
         ];
 
         if (expected) {
@@ -1404,7 +1404,7 @@ describe('plugin-meetings', () => {
             function: 'updateMeetingInfo',
           },
           LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
-          payload
+          payload,
         ];
 
         if (expected) {
@@ -1426,8 +1426,7 @@ describe('plugin-meetings', () => {
         */
         sinon.stub(locusInfo, 'emitScoped').callsFake(() => {
           assert.deepEqual(mockMeeting, expectedMeeting);
-        })
-
+        });
 
         // set the info initially as locusInfo.info starts as undefined
         expectedMeeting = {
@@ -1907,7 +1906,7 @@ describe('plugin-meetings', () => {
         locusInfo.locusParser.workingCopy = {
           syncUrl: 'current sync url',
         };
-  
+
         locusInfo.applyLocusDeltaData(LOCUS_URL_CHANGED, fakeLocus, meeting);
         assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'current sync url'});
       });
@@ -1970,8 +1969,12 @@ describe('plugin-meetings', () => {
           }).then(() => {
             assert.calledTwice(meeting.meetingRequest.getLocusDTO);
 
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [
+              {url: 'deltaSyncUrl'},
+            ]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [
+              {url: 'fullSyncUrl'},
+            ]);
 
             assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
               correlationId: meeting.correlationId,
@@ -1999,8 +2002,12 @@ describe('plugin-meetings', () => {
           }).then(() => {
             assert.calledTwice(meeting.meetingRequest.getLocusDTO);
 
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [{url: 'deltaSyncUrl'}]);
-            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [{url: 'fullSyncUrl'}]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[0].args, [
+              {url: 'deltaSyncUrl'},
+            ]);
+            assert.deepEqual(meeting.meetingRequest.getLocusDTO.getCalls()[1].args, [
+              {url: 'fullSyncUrl'},
+            ]);
 
             assert.calledWith(sendBehavioralMetricStub, 'js_sdk_locus_delta_sync_failed', {
               correlationId: meeting.correlationId,
@@ -2084,7 +2091,7 @@ describe('plugin-meetings', () => {
 
         locusInfo.clearMainSessionLocusCache = sinon.stub();
         locusInfo.getTheLocusToUpdate(newLocus);
-        assert.notCalled(locusInfo.clearMainSessionLocusCache)
+        assert.notCalled(locusInfo.clearMainSessionLocusCache);
       });
 
       it('return the new locus if return to main session but no cache and do not clear main session cache', () => {
@@ -2106,7 +2113,7 @@ describe('plugin-meetings', () => {
 
         locusInfo.clearMainSessionLocusCache = sinon.stub();
         locusInfo.getTheLocusToUpdate(newLocus);
-        assert.notCalled(locusInfo.clearMainSessionLocusCache)
+        assert.notCalled(locusInfo.clearMainSessionLocusCache);
       });
 
       it('return the new locus if not return to main session and clear main session cache', () => {
@@ -2116,9 +2123,9 @@ describe('plugin-meetings', () => {
               sessionType: 'MAIN',
             },
           },
-          self: {removed: true}
+          self: {removed: true},
         };
-        locusInfo.fullState = {state: 'ACTIVE'}
+        locusInfo.fullState = {state: 'ACTIVE'};
         locusInfo.controls = {
           breakout: {
             sessionType: 'MAIN',
@@ -2134,7 +2141,7 @@ describe('plugin-meetings', () => {
 
         locusInfo.clearMainSessionLocusCache = sinon.stub();
         const result = locusInfo.getTheLocusToUpdate(newLocus);
-        assert.calledOnce(locusInfo.clearMainSessionLocusCache)
+        assert.calledOnce(locusInfo.clearMainSessionLocusCache);
 
         assert.deepEqual(result, newLocus);
       });
@@ -2146,9 +2153,9 @@ describe('plugin-meetings', () => {
               sessionType: 'MAIN',
             },
           },
-          self: {removed: undefined}
+          self: {removed: undefined},
         };
-        locusInfo.fullState = {state: 'ACTIVE'}
+        locusInfo.fullState = {state: 'ACTIVE'};
         locusInfo.controls = {
           breakout: {
             sessionType: 'MAIN',
@@ -2164,7 +2171,7 @@ describe('plugin-meetings', () => {
 
         locusInfo.clearMainSessionLocusCache = sinon.stub();
         locusInfo.getTheLocusToUpdate(newLocus);
-        assert.notCalled(locusInfo.clearMainSessionLocusCache)
+        assert.notCalled(locusInfo.clearMainSessionLocusCache);
       });
     });
 
@@ -2611,7 +2618,9 @@ describe('plugin-meetings', () => {
         // send an out-of-order delta
         locusInfo.handleLocusDelta(oooDelta, mockMeeting);
 
-        assert.calledOnceWithExactly(sendBehavioralMetricStub, 'js_sdk_locus_delta_ooo', { stack: sinon.match.any})
+        assert.calledOnceWithExactly(sendBehavioralMetricStub, 'js_sdk_locus_delta_ooo', {
+          stack: sinon.match.any,
+        });
 
         await clock.tickAsync(12499);
         await testUtils.flushPromises();

package/test/unit/spec/locus-info/mediaSharesUtils.ts

@@ -20,6 +20,15 @@ describe('getContentUrl', () => {
   });
 });
 
+describe('getContentResourceType', () => {
+  it('getContentResourceType return correct resourceType value', () => {
+    const stub = Sinon.stub(MediaSharesUtils, 'extractContent').returns({resourceType:'resourceType'});
+    const resourceType = MediaSharesUtils.getContentResourceType();
+    assert.equal(resourceType,'resourceType');
+    stub.restore();
+  });
+});
+
 describe('getContentBeneficiaryDeviceUrl', () => {
   it('getContentBeneficiaryDeviceUrl return correct deviceUrl value', () => {
     const mockContentBeneficiaryDeviceUrl = "https://wdm-a.wbx2.com/wdm/api/v1/devices/e9ffd8a1-1fae-42d1-afbe-013e951f93ab"

package/test/unit/spec/locus-info/selfUtils.js

@@ -150,8 +150,7 @@ describe('plugin-meetings', () => {
 
       it('should return false if no breakouts in current', () => {
         const current = {
-          breakoutSessions: {
-          },
+          breakoutSessions: {},
         };
         const previous = {
           breakoutSessions: {
@@ -293,7 +292,7 @@ describe('plugin-meetings', () => {
           const clonedSelf = cloneDeep(self);
 
           clonedSelf.controls.audio.requestedToUnmute = true;
-          clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z'
+          clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
 
           const {updates} = SelfUtils.getSelves(self, clonedSelf);
 
@@ -345,6 +344,41 @@ describe('plugin-meetings', () => {
     });
   });
 
+  describe('mutedByOthersChanged', () => {
+    it('throws an error if changedSelf is not provided', function() {
+      assert.throws(() => SelfUtils.mutedByOthersChanged({}, null), 'New self must be defined to determine if self was muted by others.');
+    });
+
+    it('return false when oldSelf is not defined', function() {
+      assert.equal(SelfUtils.mutedByOthersChanged(null, { remoteMuted: false }), false);
+    });
+
+    it('should return true when remoteMuted is true on entry', function() {
+      assert.equal(SelfUtils.mutedByOthersChanged(null, { remoteMuted: true }), true);
+    });
+
+    it('should return false when selfIdentity and modifiedBy are the same', function() {
+      assert.equal(SelfUtils.mutedByOthersChanged(
+        { remoteMuted: false },
+        { remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user1' }
+      ), false);
+    });
+
+    it('should return true when remoteMuted values are different', function() {
+      assert.equal(SelfUtils.mutedByOthersChanged(
+        { remoteMuted: false },
+        { remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user2' }
+      ), true);
+    });
+
+    it('should return true when remoteMuted is true and unmuteAllowed has changed', function() {
+      assert.equal(SelfUtils.mutedByOthersChanged(
+        { remoteMuted: true, unmuteAllowed: false },
+        { remoteMuted: true, unmuteAllowed: true, selfIdentity: 'user1', modifiedBy: 'user2' }
+      ), true);
+    });
+  });
+
   describe('videoMutedByOthersChanged', () => {
     it('returns true if changed', () => {
       assert.equal(
@@ -371,23 +405,18 @@ describe('plugin-meetings', () => {
     const clonedSelf = cloneDeep(self);
 
     it('get breakoutMoveId works', () => {
-
       assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(self, deviceId), breakoutMoveId);
-
     });
 
     it('replaces is empty', () => {
-
       clonedSelf.devices[0].replaces = undefined;
       assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(clonedSelf, deviceId), null);
-
     });
 
     it('no self or self.devices is not array', () => {
-
       assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(undefined, deviceId), null);
 
-      clonedSelf.devices =     {
+      clonedSelf.devices = {
         url: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/20eabde3-4254-48da-9a24',
         deviceType: 'WEB',
         mediaSessionsExternal: false,
@@ -395,10 +424,11 @@ describe('plugin-meetings', () => {
           {
             breakoutMoveId: 'e5caeb2c-ffcc-4e06-a08a-1122e7710398',
             lastActive: '2023-05-04T07:14:32.068Z',
-            locusUrl: 'https://locus-alpha-apdx.prod.meetapi.webex.com/locus/api/v1/loci/495061ca-7b3c-3b77-85ff-4e1bd58600d1',
+            locusUrl:
+              'https://locus-alpha-apdx.prod.meetapi.webex.com/locus/api/v1/loci/495061ca-7b3c-3b77-85ff-4e1bd58600d1',
             replacedAt: '2023-05-04T07:16:04.905Z',
             sessionId: 'be3147d4-c318-86d8-7611-8d24beaaca8d',
-          }
+          },
         ],
         state: 'JOINED',
       };

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

@@ -0,0 +1,344 @@
+import {assert} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+import {ConnectionState, Event} 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';
+
+describe('MediaConnectionAwaiter', () => {
+  let mediaConnectionAwaiter;
+  let mockMC;
+  let clock;
+
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+
+    mockMC = {
+      getStats: sinon.stub().resolves([]),
+      on: sinon.stub(),
+      off: sinon.stub(),
+      getConnectionState: sinon.stub().returns(ConnectionState.New),
+      getIceGatheringState: sinon.stub().returns('new'),
+    };
+
+    mediaConnectionAwaiter = new MediaConnectionAwaiter({
+      webrtcMediaConnection: mockMC,
+    });
+  });
+
+  afterEach(() => {
+    clock.restore();
+    sinon.restore();
+  });
+
+  describe('waitForMediaConnectionConnected', () => {
+    it('resolves immediately if connection state is connected', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+
+      await mediaConnectionAwaiter.waitForMediaConnectionConnected();
+
+      assert.neverCalledWith(mockMC.on);
+    });
+
+    it('rejects after timeout if ice 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(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+      const listener = mockMC.on.getCall(1).args[1];
+
+      mockMC.getIceGatheringState.returns('complete');
+      listener();
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      assert.calledTwice(mockMC.off);
+    });
+
+    it('resolves after timeout if connection state reach connected/completed', async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
+
+      assert.calledTwice(mockMC.off);
+    });
+
+    it(`resolves when media connection reaches "connected" state`, async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('gathering');
+
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+      const listener = mockMC.on.getCall(0).args[1];
+
+      // call the listener and pretend we are now connected
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+      listener();
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
+
+      // check that listener was removed
+      assert.calledTwice(mockMC.off);
+
+      assert.calledOnce(clearTimeoutSpy);
+    });
+
+    it(`ice gathering state update to "gathering" state does not update timer`, async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('new');
+
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+      const listener = mockMC.on.getCall(1).args[1];
+
+      // call the listener and pretend we are now connected
+      mockMC.getIceGatheringState.returns('gathering');
+      listener();
+
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
+
+      // check that listener was removed
+      assert.calledTwice(mockMC.off);
+
+      assert.neverCalledWith(clearTimeoutSpy);
+    });
+
+    it(`ice gathering update to 'complete' state restarts the timer`, async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('new');
+
+      const setTimeoutSpy = sinon.spy(clock, 'setTimeout');
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, false);
+
+      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];
+
+      // call the listener and pretend we are now connected
+      mockMC.getIceGatheringState.returns('complete');
+      listener();
+
+      assert.calledOnce(clearTimeoutSpy);
+      assert.calledTwice(setTimeoutSpy);
+
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
+
+      // check that listener was removed
+      assert.calledTwice(mockMC.off);
+    });
+
+    it(`reject with restart timer once if gathering state is not complete`, async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('new');
+
+      const setTimeoutSpy = sinon.spy(clock, 'setTimeout');
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+
+      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT * 2);
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, false);
+      assert.equal(promiseRejected, true);
+
+      // check that listener was removed
+      assert.calledTwice(mockMC.off);
+
+      assert.calledOnce(clearTimeoutSpy);
+      assert.calledTwice(setTimeoutSpy);
+    });
+
+    it(`resolves gathering and connection state complete right after`, async () => {
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockMC.getIceGatheringState.returns('new');
+
+      const setTimeoutSpy = sinon.spy(clock, 'setTimeout');
+      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
+      let promiseResolved = false;
+      let promiseRejected = false;
+
+      mediaConnectionAwaiter
+        .waitForMediaConnectionConnected()
+        .then(() => {
+          promiseResolved = true;
+        })
+        .catch(() => {
+          promiseRejected = true;
+        });
+
+      await testUtils.flushPromises();
+      assert.equal(promiseResolved, false);
+      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);
+      const connectionStateListener = mockMC.on.getCall(0).args[1];
+      const iceGatheringListener = mockMC.on.getCall(1).args[1];
+
+      mockMC.getIceGatheringState.returns('complete');
+      iceGatheringListener();
+
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
+      connectionStateListener();
+
+      await testUtils.flushPromises();
+
+      assert.equal(promiseResolved, true);
+      assert.equal(promiseRejected, false);
+
+      // check that listener was removed
+      assert.calledTwice(mockMC.off);
+
+      assert.calledTwice(clearTimeoutSpy);
+      assert.calledTwice(setTimeoutSpy);
+    });
+  });
+});