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

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);
+    });
+  });
+});

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

@@ -7,6 +7,10 @@ import {forEach} from 'lodash';
 import MockWebex from '@webex/test-helper-mock-webex';
 
 describe('createMediaConnection', () => {
+  let clock;
+  beforeEach(() => {
+    clock = sinon.useFakeTimers();
+  });
   const webex = MockWebex();
 
   const fakeRoapMediaConnection = {
@@ -45,6 +49,7 @@ describe('createMediaConnection', () => {
   };
   afterEach(() => {
     sinon.restore();
+    clock.uninstall()
   });
 
   it('creates a RoapMediaConnection when multistream is disabled', () => {
@@ -165,37 +170,15 @@ describe('createMediaConnection', () => {
     );
   });
 
-  it('passes empty ICE servers array to MultistreamRoapMediaConnection if turnServerInfo is undefined (multistream enabled)', () => {
-    const multistreamRoapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
-      .returns(fakeRoapMediaConnection);
-
-    Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
-      mediaProperties: {
-        mediaDirection: {
-          sendAudio: true,
-          sendVideo: true,
-          sendShare: false,
-          receiveAudio: true,
-          receiveVideo: true,
-          receiveShare: true,
-        },
-      },
-    });
-    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
-    assert.calledWith(
-      multistreamRoapMediaConnectionConstructorStub,
-      {
-        iceServers: [],
-      },
-      'meeting id'
-    );
-
-    it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
+  [
+    {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
+    {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')
         .returns(fakeRoapMediaConnection);
-
+  
       Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
         mediaProperties: {
           mediaDirection: {
@@ -207,7 +190,7 @@ describe('createMediaConnection', () => {
             receiveShare: true,
           },
         },
-        bundlePolicy: undefined,
+        turnServerInfo,
       });
       assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
       assert.calledWith(
@@ -216,75 +199,108 @@ describe('createMediaConnection', () => {
           iceServers: [],
         },
         'meeting id'
-      );
+        );
     });
   });
-
-  it('passes empty ICE servers array to RoapMediaConnection if turnServerInfo is undefined (multistream disabled)', () => {
-    const roapMediaConnectionConstructorStub = sinon
-      .stub(internalMediaModule, 'RoapMediaConnection')
+      
+  it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
+    const multistreamRoapMediaConnectionConstructorStub = sinon
+      .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
-
-    const ENABLE_EXTMAP = false;
-    const ENABLE_RTX = true;
-
-    Media.createMediaConnection(false, 'some debug id', webex, 'meeting id', 'correlationId', {
+    Media.createMediaConnection(true, 'debug string', webex, 'meeting id', 'correlationId', {
       mediaProperties: {
         mediaDirection: {
           sendAudio: true,
           sendVideo: true,
-          sendShare: true,
+          sendShare: false,
           receiveAudio: true,
           receiveVideo: true,
           receiveShare: true,
         },
-        audioStream: fakeAudioStream,
-        videoStream: null,
-        shareVideoStream: fakeShareVideoStream,
-        shareAudioStream: fakeShareAudioStream,
       },
-      remoteQualityLevel: 'HIGH',
-      enableRtx: ENABLE_RTX,
-      enableExtmap: ENABLE_EXTMAP,
-      turnServerInfo: undefined,
+      bundlePolicy: undefined,
     });
-    assert.calledOnce(roapMediaConnectionConstructorStub);
+    assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
-      roapMediaConnectionConstructorStub,
+      multistreamRoapMediaConnectionConstructorStub,
       {
         iceServers: [],
-        skipInactiveTransceivers: false,
-        requireH264: true,
-        sdpMunging: {
-          convertPort9to0: false,
-          addContentSlides: true,
-          bandwidthLimits: {
-            audio: 123,
-            video: 456,
+      },
+      'meeting id'
+    );
+  });
+
+  [
+    {testCase: 'turnServerInfo is undefined', turnServerInfo: undefined},
+    {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')
+        .returns(fakeRoapMediaConnection);
+
+      StaticConfig.set({bandwidth: {audio: 123, video: 456, startBitrate: 999}});
+
+      const ENABLE_EXTMAP = false;
+      const ENABLE_RTX = true;
+
+      Media.createMediaConnection(false, 'some debug id', webex, 'meeting id', 'correlationId', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: true,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
           },
-          startBitrate: 999,
-          periodicKeyframes: 20,
-          disableExtmap: !ENABLE_EXTMAP,
-          disableRtx: !ENABLE_RTX,
+          audioStream: fakeAudioStream,
+          videoStream: null,
+          shareVideoStream: fakeShareVideoStream,
+          shareAudioStream: fakeShareAudioStream,
         },
-      },
-      {
-        localTracks: {
-          audio: fakeTrack,
-          video: undefined,
-          screenShareVideo: fakeTrack,
-          screenShareAudio: fakeTrack,
+        remoteQualityLevel: 'HIGH',
+        enableRtx: ENABLE_RTX,
+        enableExtmap: ENABLE_EXTMAP,
+        turnServerInfo,
+      });
+      assert.calledOnce(roapMediaConnectionConstructorStub);
+      assert.calledWith(
+        roapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          skipInactiveTransceivers: false,
+          requireH264: true,
+          sdpMunging: {
+            convertPort9to0: false,
+            addContentSlides: true,
+            bandwidthLimits: {
+              audio: 123,
+              video: 456,
+            },
+            startBitrate: 999,
+            periodicKeyframes: 20,
+            disableExtmap: !ENABLE_EXTMAP,
+            disableRtx: !ENABLE_RTX,
+          },
         },
-        direction: {
-          audio: 'sendrecv',
-          video: 'sendrecv',
-          screenShareVideo: 'sendrecv',
+        {
+          localTracks: {
+            audio: fakeTrack,
+            video: undefined,
+            screenShareVideo: fakeTrack,
+            screenShareAudio: fakeTrack,
+          },
+          direction: {
+            audio: 'sendrecv',
+            video: 'sendrecv',
+            screenShareVideo: 'sendrecv',
+          },
+          remoteQualityLevel: 'HIGH',
         },
-        remoteQualityLevel: 'HIGH',
-      },
-      'some debug id'
-    );
+        'some debug id'
+      );
+    });
   });
 });

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

@@ -1,11 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {ConnectionState, Event} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
-import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
-import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import {Defer} from '@webex/common';
+import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
 
 describe('MediaProperties', () => {
   let mediaProperties;
@@ -31,80 +30,27 @@ describe('MediaProperties', () => {
     sinon.restore();
   });
   describe('waitForMediaConnectionConnected', () => {
-    it('resolves immediately if ice state is connected', async () => {
-      await mediaProperties.waitForMediaConnectionConnected();
-    });
-    it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
-
-      let promiseResolved = false;
-      let promiseRejected = false;
-
-      mediaProperties
-        .waitForMediaConnectionConnected()
-        .then(() => {
-          promiseResolved = true;
-        })
-        .catch(() => {
-          promiseRejected = true;
-        });
-
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, false);
-
-      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
-      await testUtils.flushPromises();
+    it('resolves if media connection is connected', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, true);
+      sinon
+        .stub(MediaConnectionAwaiter.prototype, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
-      // check that listener was registered and removed
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      const listener = mockMC.on.getCall(0).args[1];
+      waitForMediaConnectionConnectedResult.resolve();
 
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+      await mediaProperties.waitForMediaConnectionConnected();
     });
+    it('rejects if media connection is not connected', async () => {
+      const waitForMediaConnectionConnectedResult = new Defer();
 
-    it(`resolves when media connection reaches "connected" state`, async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
-
-      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
-
-      let promiseResolved = false;
-      let promiseRejected = false;
-
-      mediaProperties
-        .waitForMediaConnectionConnected()
-        .then(() => {
-          promiseResolved = true;
-        })
-        .catch(() => {
-          promiseRejected = true;
-        });
-
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, false);
-
-      // check the right listener was registered
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_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);
+      sinon
+        .stub(MediaConnectionAwaiter.prototype, 'waitForMediaConnectionConnected')
+        .returns(waitForMediaConnectionConnectedResult.promise);
 
-      // check that listener was removed
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+      waitForMediaConnectionConnectedResult.reject();
 
-      assert.calledOnce(clearTimeoutSpy);
+      await assert.isRejected(mediaProperties.waitForMediaConnectionConnected());
     });
   });