@webex/plugin-meetings 3.0.0-stream-classes.4 → 3.0.0-test.1

package/test/unit/spec/multistream/remoteMediaManager.ts

@@ -18,6 +18,7 @@ import testUtils from '../../../utils/testUtils';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import { expect } from 'chai';
+import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;
@@ -299,6 +300,204 @@ describe('RemoteMediaManager', () => {
       );
     });
 
+    it('creates a RemoteMediaGroup for named media group audio correctly', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 20},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+      });
+
+      remoteMediaManager.start();
+
+      await testUtils.flushPromises();
+
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+      assert.alwaysCalledWith(fakeReceiveSlotManager.allocateSlot, MediaType.AudioMain);
+
+      assert.isNotNull(createdInterpretationAudioGroup);
+      if (createdInterpretationAudioGroup) {
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia().length, 1);
+        assert.isTrue(
+          createdInterpretationAudioGroup
+            .getRemoteMedia()
+            .every((remoteMedia) => remoteMedia.mediaType === MediaType.AudioMain)
+        );
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia('pinned').length, 0);
+        assert.calledTwice(fakeMediaRequestManagers.audio.addRequest);
+        assert.calledWith(
+          fakeMediaRequestManagers.audio.addRequest,
+          sinon.match({
+            policyInfo: sinon.match({
+              policy: 'active-speaker',
+              priority: 255,
+              namedMediaGroups: sinon.match([{type: 1, value: 20}]),
+            }),
+            receiveSlots: Array(1).fill(fakeAudioSlot),
+            codecInfo: undefined,
+          }),
+          false,
+        );
+      }
+    });
+
+    it('creates new media request when call setReceiveNamedMediaGroup', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+        createdInterpretationAudioGroup.setNamedMediaGroup = sinon.stub();
+      });
+
+      await remoteMediaManager.start();
+
+      // requires 3 main audio slots and one interpretation audio slot
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 28);
+
+      // check that setNamedMediaGroup has been called
+      assert.calledOnce(createdInterpretationAudioGroup.setNamedMediaGroup);
+      assert.calledWith(
+        createdInterpretationAudioGroup.setNamedMediaGroup,
+        {type: 1, value: 28},
+        true,
+      );
+
+    });
+
+    it('ignore duplicated group when call setReceiveNamedMediaGroup', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.AudioCreated, (audio: RemoteMediaGroup) => {
+        audioStopStub = sinon.stub(audio, 'stop');
+      });
+
+      await remoteMediaManager.start();
+
+      // we're using the default config that requires 3 main audio slots
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 24);
+
+      assert.notCalled(audioStopStub);
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 0);
+
+      await testUtils.flushPromises();
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 0);
+      assert.notCalled(fakeReceiveSlotManager.allocateSlot);
+
+    });
+
+
+    it('should throw error if set receive named media group which type is not audio', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      // Assuming setReceiveNamedMediaGroup returns a promise
+      it('should throw error when media type is not audio-main', async () => {
+        try {
+          await remoteMediaManager.setReceiveNamedMediaGroup(MediaType.VideoMain, 0);
+          // If the promise resolves successfully, we should fail the test
+          throw new Error('Expected an error but none was thrown');
+        } catch (error) {
+          // Check if the error message matches the expected one
+          expect(error.message).to.equal('cannot set receive named media group which media type is not audio-main');
+        }
+      });
+    });
+
     it('pre-allocates receive slots based on the biggest layout', async () => {
       const config = cloneDeep(DefaultTestConfiguration);
 
@@ -693,7 +892,7 @@ describe('RemoteMediaManager', () => {
       });
 
       expect(config.video.preferLiveVideo).to.equal(true);
-      
+
       assert.calledOnce(fakeMediaRequestManagers.video.commit);
     });
   });
@@ -747,7 +946,11 @@ describe('RemoteMediaManager', () => {
 
       assert.calledWith(
         logger.log,
-        'RemoteMediaManager#updateVideoReceiveSlots --> receive slots updated: unused=0, activeSpeaker=6, receiverSelected=4\ngroup: thumbnails\nfake video slot fake video slot fake video slot fake video slot fake video slot fake video slot\nreceiverSelected:\n stage-1: fake video slot\n stage-2: fake video slot\n stage-3: fake video slot\n stage-4: fake video slot\n'
+        'RemoteMediaManager#setLayout --> new layout selected: Stage'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=6, receiverSelected=4\ngroup: thumbnails\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n stage-1: fake video slot\n stage-2: fake video slot\n stage-3: fake video slot\n stage-4: fake video slot\n'
       );
     });
 
@@ -769,7 +972,11 @@ describe('RemoteMediaManager', () => {
 
       assert.calledWith(
         logger.log,
-        'RemoteMediaManager#updateVideoReceiveSlots --> receive slots updated: unused=0, activeSpeaker=9, receiverSelected=0\ngroup: main\nfake video slot fake video slot fake video slot fake video slot fake video slot fake video slot fake video slot fake video slot fake video slot\nreceiverSelected:\n'
+        'RemoteMediaManager#setLayout --> new layout selected: AllEqual'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=9, receiverSelected=0\ngroup: main\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n'
       );
     });
 

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -10,11 +10,11 @@ describe('SendSlotsManager', () => {
             info: sinon.stub(),
         },
     };
-    
+
     beforeEach(() => {
         sendSlotsManager = new SendSlotManager(LoggerProxy);
     });
-    
+
     describe('createSlot', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -27,19 +27,19 @@ describe('SendSlotsManager', () => {
 
         it('should create a slot for the given mediaType', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             expect(mediaConnection.createSendSlot.calledWith(mediaType, true));
         });
 
         it('should create a slot for the given mediaType & active state', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType, false);
-        
+
             expect(mediaConnection.createSendSlot.calledWith(mediaType, false));
         });
-    
+
         it('should throw an error if a slot for the given mediaType already exists', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             expect(() => sendSlotsManager.createSlot(mediaConnection, mediaType)).to.throw(`Slot for ${mediaType} already exists`);
         });
     });
@@ -56,7 +56,7 @@ describe('SendSlotsManager', () => {
 
         it('should return the slot for the given mediaType', () => {
             const slot = sendSlotsManager.createSlot(mediaConnection,mediaType);
-        
+
             expect(sendSlotsManager.getSlot(mediaType)).to.equal(slot);
         });
 
@@ -64,7 +64,7 @@ describe('SendSlotsManager', () => {
             expect(() => sendSlotsManager.getSlot(mediaType)).to.throw(`Slot for ${mediaType} does not exist`);
         });
     });
-    
+
     describe('publishStream', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -82,9 +82,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.publishStream(mediaType, stream);
-        
+
             expect(slot.publishStream.calledWith(stream));
         });
 
@@ -112,9 +112,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.unpublishStream(mediaType);
-        
+
             expect(slot.unpublishStream.called);
         });
 
@@ -126,6 +126,38 @@ describe('SendSlotsManager', () => {
         });
     });
 
+  describe('setNamedMediaGroups', () => {
+    let mediaConnection;
+    const mediaType = MediaType.AudioMain;
+    const groups = [{type: 1, value: 20}];
+
+    beforeEach(() => {
+      mediaConnection = {
+        createSendSlot: sinon.stub(),
+      } as MultistreamRoapMediaConnection;
+    });
+
+    it('should publish the given stream to the sendSlot for the given mediaType', async () => {
+      const slot = {
+        setNamedMediaGroups: sinon.stub().resolves(),
+      };
+      mediaConnection.createSendSlot.returns(slot);
+      sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+      await sendSlotsManager.setNamedMediaGroups(mediaType, groups);
+
+      expect(slot.setNamedMediaGroups.calledWith(groups));
+    });
+
+    it('should throw an error if the given mediaType is not audio', () => {
+      expect(() => sendSlotsManager.setNamedMediaGroups(MediaType.VideoMain, groups)).to.throw(`sendSlotManager cannot set named media group which media type is ${MediaType.VideoMain}`)
+    });
+
+    it('should throw an error if a slot for the given mediaType does not exist', () => {
+      expect(() => sendSlotsManager.setNamedMediaGroups(mediaType, groups)).to.throw(`Slot for ${mediaType} does not exist`)
+    });
+  });
+
     describe('setActive', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -142,9 +174,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.setActive(mediaType,true);
-        
+
             expect(slot.setActive.called);
         });
 
@@ -170,9 +202,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
-        
+
             expect(slot.setCodecParameters.calledWith(codecParameters));
         });
 
@@ -200,9 +232,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.deleteCodecParameters(mediaType,[]);
-        
+
             expect(slot.deleteCodecParameters.called);
         });
 

package/test/unit/spec/reachability/clusterReachability.ts

@@ -0,0 +1,279 @@
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+import testUtils from '../../../utils/testUtils';
+
+// packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
+import { ClusterReachability } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+
+describe('ClusterReachability', () => {
+  let previousRTCPeerConnection;
+  let clusterReachability;
+  let fakePeerConnection;
+
+  const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
+
+  beforeEach(() => {
+    fakePeerConnection = {
+      createOffer: sinon.stub().resolves(FAKE_OFFER),
+      setLocalDescription: sinon.stub().resolves(),
+      close: sinon.stub(),
+      iceGatheringState: 'new',
+    };
+
+    previousRTCPeerConnection = global.RTCPeerConnection;
+    global.RTCPeerConnection = sinon.stub().returns(fakePeerConnection);
+
+    clusterReachability = new ClusterReachability('testName', {
+      isVideoMesh: false,
+      udp: ['stun:udp1', 'stun:udp2'],
+      tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
+      xtls: ['xtls1', 'xtls2'],
+    });
+
+  });
+
+  afterEach(() => {
+    global.RTCPeerConnection = previousRTCPeerConnection;
+  });
+
+  it('should create an instance correctly', () => {
+    assert.instanceOf(clusterReachability, ClusterReachability);
+    assert.equal(clusterReachability.name, 'testName');
+    assert.equal(clusterReachability.isVideoMesh, false);
+    assert.equal(clusterReachability.numUdpUrls, 2);
+    assert.equal(clusterReachability.numTcpUrls, 2);
+  });
+
+  it('should create a peer connection with the right config', () => {
+    assert.calledOnceWithExactly(global.RTCPeerConnection, {
+      iceServers: [
+        {username: '', credential: '', urls: ['stun:udp1']},
+        {username: '', credential: '', urls: ['stun:udp2']},
+        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp1.webex.com?transport=tcp']},
+        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp2.webex.com:5004?transport=tcp']}
+      ],
+      iceCandidatePoolSize: 0,
+      iceTransportPolicy: 'all',
+    });
+  });
+
+  it('should create a peer connection with the right config even if lists of urls are empty', () => {
+    (global.RTCPeerConnection as any).resetHistory();
+
+    clusterReachability = new ClusterReachability('testName', {
+      isVideoMesh: false,
+      udp: [],
+      tcp: [],
+      xtls: [],
+    });
+
+    assert.calledOnceWithExactly(global.RTCPeerConnection, {
+      iceServers: [],
+      iceCandidatePoolSize: 0,
+      iceTransportPolicy: 'all',
+    });
+  });
+
+  it('returns correct results before start() is called', () => {
+    assert.deepEqual(clusterReachability.getResult(), {
+      udp: {result: 'untested'},
+      tcp: {result: 'untested'},
+      xtls: {result: 'untested'}
+    });
+  });
+
+  describe('#start', () => {
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+    })
+
+    it('should initiate the ICE gathering process', async () => {
+      const promise = clusterReachability.start();
+
+      await testUtils.flushPromises();
+
+      // check that the right listeners are setup
+      assert.isFunction(fakePeerConnection.onicecandidate);
+      assert.isFunction(fakePeerConnection.onicegatheringstatechange);
+
+      // check that the right webrtc APIs are called
+      assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
+      assert.calledOnce(fakePeerConnection.setLocalDescription);
+
+      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await promise;
+    });
+
+    it('resolves and has correct result as soon as it finds that both udp and tcp is reachable', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
+
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
+        tcp: {result: 'reachable', latencyInMilliseconds: 200},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('times out correctly', async () => {
+      const promise = clusterReachability.start();
+
+      // progress time without any candidates
+      await clock.tickAsync(3000);
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('times out correctly for video mesh nodes', async () => {
+      clusterReachability = new ClusterReachability('testName', {
+        isVideoMesh: true,
+        udp: ['stun:udp1', 'stun:udp2'],
+        tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
+        xtls: ['xtls1', 'xtls2'],
+      });
+
+      const promise = clusterReachability.start();
+
+      // video mesh nodes have shorter timeout of just 1s
+      await clock.tickAsync(1000);
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('resolves when ICE gathering is completed', async () => {
+      const promise = clusterReachability.start();
+
+      await testUtils.flushPromises();
+
+      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('resolves with the right result when ICE gathering is completed', async () => {
+      const promise = clusterReachability.start();
+
+      // send 1 candidate
+      await clock.tickAsync(30);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('should store latency only for the first srflx candidate, but IPs from all of them', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      // generate more candidates
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
+
+      await clock.tickAsync(3000);// move the clock so that reachability times out
+
+      await promise;
+
+      // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3']},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('should store latency only for the first relay candidate', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp1'}});
+
+      // generate more candidates
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp2'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
+
+      await clock.tickAsync(3000);// move the clock so that reachability times out
+
+      await promise;
+
+      // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'reachable', latencyInMilliseconds: 10},
+        xtls: {result: 'untested'}
+      });
+    });
+
+    it('ignores duplicate clientMediaIps', async () => {
+      const promise = clusterReachability.start();
+
+      // generate candidates with duplicate addresses
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
+
+      // send also a relay candidate so that the reachability check finishes
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2']},
+        tcp: {result: 'reachable', latencyInMilliseconds: 40},
+        xtls: {result: 'untested'}
+      });
+    });
+  });
+});