@webex/plugin-meetings 2.60.0-next.9 → 2.60.1-next.1

package/src/reachability/util.ts

@@ -0,0 +1,24 @@
+/* eslint-disable import/prefer-default-export */
+/**
+ * Converts a stun url to a turn url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @param {'tcp'|'udp'} protocol what protocol to use for the turn server
+ * @returns {string} url of a turn server
+ */
+export function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp') {
+  // stunUrl looks like this: "stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004"
+  // and we need it to be like this: "turn:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004?transport=tcp"
+  const url = new URL(stunUrl);
+
+  if (url.protocol !== 'stun:') {
+    throw new Error(`Not a STUN URL: ${stunUrl}`);
+  }
+
+  url.protocol = 'turn:';
+  if (protocol === 'tcp') {
+    url.searchParams.append('transport', 'tcp');
+  }
+
+  return url.toString();
+}

package/src/statsAnalyzer/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable prefer-destructuring */
 
-import {cloneDeep} from 'lodash';
+import {cloneDeep, isEmpty} from 'lodash';
 import {ConnectionState} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
@@ -78,6 +78,7 @@ export class StatsAnalyzer extends EventsScope {
   statsResults: any;
   statsStarted: any;
   successfulCandidatePair: any;
+  localIpAddress: string; // Returns the local IP address for diagnostics. this is the local IP of the interface used for the current media connection a host can have many local Ip Addresses
   receiveSlotCallback: ReceiveSlotCallback;
 
   /**
@@ -107,6 +108,7 @@ export class StatsAnalyzer extends EventsScope {
     this.lastEmittedStartStopEvent = {};
     this.receiveSlotCallback = receiveSlotCallback;
     this.successfulCandidatePair = {};
+    this.localIpAddress = '';
   }
 
   /**
@@ -266,6 +268,16 @@ export class StatsAnalyzer extends EventsScope {
     this.mediaConnection = mediaConnection;
   }
 
+  /**
+   * Returns the local IP address for diagnostics.
+   * this is the local IP of the interface used for the current media connection
+   * a host can have many local Ip Addresses
+   * @returns {string | undefined} The local IP address.
+   */
+  getLocalIpAddress(): string {
+    return this.localIpAddress;
+  }
+
   /**
    * Starts the stats analyzer on interval
    *
@@ -405,6 +417,10 @@ export class StatsAnalyzer extends EventsScope {
       this.statsResults[type].direction = statsItem.currentDirection;
       this.statsResults[type].trackLabel = statsItem.localTrackLabel;
       this.statsResults[type].csi = statsItem.csi;
+      this.extractAndSetLocalIpAddressInfoForDiagnostics(
+        this.successfulCandidatePair?.localCandidateId,
+        this.statsResults?.candidates
+      );
       // reset the successful candidate pair.
       this.successfulCandidatePair = {};
     }
@@ -983,6 +999,48 @@ export class StatsAnalyzer extends EventsScope {
     }
   }
 
+  /**
+   * extracts the local Ip address from the statsResult object by looking at stats results candidates
+   * and matches that ID with the successful candidate pair. It looks at the type of local candidate it is
+   * and then extracts the IP address from the relatedAddress or address property based on conditions known in webrtc
+   * note, there are known incompatibilities and it is possible for this to set undefined, or for the IP address to be the public IP address
+   * for example, firefox does not set the relayProtocol, and if the user is behind a NAT it might be the public IP
+   * @private
+   * @param {string} successfulCandidatePairId - The ID of the successful candidate pair.
+   * @param {Object} candidates - the stats result candidates
+   * @returns {void}
+   */
+  extractAndSetLocalIpAddressInfoForDiagnostics = (
+    successfulCandidatePairId: string,
+    candidates: {[key: string]: Record<string, unknown>}
+  ) => {
+    let newIpAddress = '';
+    if (successfulCandidatePairId && !isEmpty(candidates)) {
+      const localCandidate = candidates[successfulCandidatePairId];
+      if (localCandidate) {
+        if (localCandidate.candidateType === 'host') {
+          // if it's a host candidate, use the address property - it will be the local IP
+          newIpAddress = `${localCandidate.address}`;
+        } else if (localCandidate.candidateType === 'prflx') {
+          // if it's a peer reflexive candidate and we're not using a relay (there is no relayProtocol set)
+          // then look at the relatedAddress - it will be the local
+          //
+          // Firefox doesn't populate the relayProtocol property
+          if (!localCandidate.relayProtocol) {
+            newIpAddress = `${localCandidate.relatedAddress}`;
+          } else {
+            // if it's a peer reflexive candidate and we are using a relay -
+            // in that case the relatedAddress will be the IP of the TURN server (Linus),
+            // so we can only look at the address, but it might be local IP or public IP,
+            // depending on if the user is behind a NAT or not
+            newIpAddress = `${localCandidate.address}`;
+          }
+        }
+      }
+    }
+    this.localIpAddress = newIpAddress;
+  };
+
   /**
    * Processes remote and local candidate result and stores
    * @private
@@ -1020,6 +1078,11 @@ export class StatsAnalyzer extends EventsScope {
     this.statsResults.candidates[result.id] = {
       candidateType: result.candidateType,
       ipAddress: result.ip, // TODO: add ports
+      relatedAddress: result.relatedAddress,
+      relatedPort: result.relatedPort,
+      relayProtocol: result.relayProtocol,
+      protocol: result.protocol,
+      address: result.address,
       portNumber: result.port,
       networkType: result.networkType,
       priority: result.priority,

package/src/statsAnalyzer/mqaUtil.ts

@@ -23,6 +23,7 @@ export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSen
   }
 
   audioReceiver.common.common.direction = statsResults[mediaType].direction;
+  audioReceiver.common.common.isMain = !mediaType.includes('-share');
   audioReceiver.common.transportType = statsResults.connectionType.local.transport;
 
   // add rtpPacket info inside common as also for call analyzer
@@ -83,6 +84,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent, m
   }
 
   audioSender.common.common.direction = statsResults[mediaType].direction;
+  audioSender.common.common.isMain = !mediaType.includes('-share');
   audioSender.common.transportType = statsResults.connectionType.local.transport;
 
   audioSender.common.maxRemoteJitter =
@@ -146,6 +148,7 @@ export const getVideoReceiverMqa = ({videoReceiver, statsResults, lastMqaDataSen
   }
 
   videoReceiver.common.common.direction = statsResults[mediaType].direction;
+  videoReceiver.common.common.isMain = !mediaType.includes('-share');
   videoReceiver.common.transportType = statsResults.connectionType.local.transport;
 
   // collect the packets received for the last min
@@ -226,6 +229,7 @@ export const getVideoSenderMqa = ({videoSender, statsResults, lastMqaDataSent, m
   }
 
   videoSender.common.common.direction = statsResults[mediaType].direction;
+  videoSender.common.common.isMain = !mediaType.includes('-share');
   videoSender.common.transportType = statsResults.connectionType.local.transport;
 
   // @ts-ignore

package/test/unit/spec/interceptors/locusRetry.ts

@@ -0,0 +1,131 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+/* eslint-disable camelcase */
+import {assert} from '@webex/test-helper-chai';
+import { expect } from "@webex/test-helper-chai";
+import MockWebex from '@webex/test-helper-mock-webex';
+import {LocusRetryStatusInterceptor} from "@webex/plugin-meetings/src/interceptors";
+import {WebexHttpError} from '@webex/webex-core';
+import Meetings from '@webex/plugin-meetings';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+    describe('Interceptors', () => {
+      describe('LocusRetryStatusInterceptor', () => { 
+        let interceptor, webex;
+        beforeEach(() => {
+            webex = new MockWebex({
+                children: {
+                    meeting: Meetings,
+                  },
+            });
+            interceptor = Reflect.apply(LocusRetryStatusInterceptor.create, {
+                sessionId: 'mock-webex_uuid',
+              }, []);
+          });  
+        describe('#onResponseError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                    'retry-after': 1000,
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const reason1 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 403,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'POST not allwed',
+                },
+                });
+            const reason2 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 503,
+                options: {
+                    headers: {
+                        trackingid: 'test',
+                        'retry-after': 1000,
+                    },    
+                    uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                    },
+                body: {
+                    error: 'Service Unavailable',
+                    },
+                });
+
+            it('rejects when not locus service unavailable error', () => {
+                return assert.isRejected(interceptor.onResponseError(options, reason1));
+            });
+
+            it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
+                handleRetryStub.returns(Promise.resolve());
+
+                return interceptor.onResponseError(options, reason2).then(() => {
+                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+                    
+                });
+            });
+        });
+
+        describe('#handleRetryRequestLocusServiceError', () => {
+            const options = {
+                method: 'POST',
+                headers: {
+                    trackingid: 'test',
+                },
+                uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
+                body: 'foo'
+                };
+            const retryAfterTime = 2000;
+
+            it('returns the correct resolved value when the request is successful', () => {
+                const mockResponse = 'mock response'
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+          
+                return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                  .then((response) => {
+                    expect(response).to.equal(mockResponse);
+                  });
+              });
+
+            it('rejects the promise when the request is unsuccessful', () => {
+              const rejectionReason = 'Service Unavaialble after retry';
+    
+              interceptor.webex.request = sinon.stub().returns(Promise.reject(rejectionReason));
+        
+              return interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime)
+                .catch((error) => {
+                  expect(error).to.equal(rejectionReason);
+                });
+            });
+
+            it('retries the request after the specified time', () => {
+                let clock;
+                clock = sinon.useFakeTimers();
+                const mockResponse = 'mock response'
+      
+                interceptor.webex.request = sinon.stub().returns(Promise.resolve(mockResponse));
+                const promise = interceptor.handleRetryRequestLocusServiceError(options, retryAfterTime);
+      
+                clock.tick(retryAfterTime);
+
+                return promise.then(() => {
+                    expect(interceptor.webex.request.calledOnce).to.be.true;
+                    });
+            });
+        });
+    });
+    });
+});
+

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

@@ -635,7 +635,14 @@ describe('plugin-meetings', () => {
         describe('rejection', () => {
           it('should error out and return a promise', async () => {
             meeting.join = sinon.stub().returns(Promise.reject());
-            assert.isRejected(meeting.joinWithMedia({}));
+            assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: true}}));
+          });
+
+          it('should fail if called with allowMediaInLobby:false', async () => {
+            meeting.join = sinon.stub().returns(Promise.resolve(test1));
+            meeting.addMedia = sinon.stub().returns(Promise.resolve(test4));
+
+            assert.isRejected(meeting.joinWithMedia({mediaOptions: {allowMediaInLobby: false}}));
           });
         });
       });

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

@@ -559,43 +559,46 @@ describe('plugin-meetings', () => {
               });
             });
           });
-          describe('destory non active meeting', () => {
-            let initialSetup;
-            let parse;
+          describe('destroy non active locus meetings', () => {
             let destroySpy;
 
+            const meetingCollectionMeetings =  {
+              stillValidLocusMeeting: {
+                locusUrl: 'still-valid-locus-url',
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+              noLongerValidLocusMeeting: {
+                locusUrl: 'no-longer-valid-locus-url',
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+              otherNonLocusMeeting1: {
+                locusUrl: null,
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+              otherNonLocusMeeting2: {
+                locusUrl: undefined,
+                sendCallAnalyzerMetrics: sinon.stub(),
+              },
+            };
+
             beforeEach(() => {
               destroySpy = sinon.spy(webex.meetings, 'destroy');
-              initialSetup = sinon.stub().returns(true);
-              webex.meetings.meetingCollection.getByKey = sinon.stub().returns({
-                locusInfo,
-                sendCallAnalyzerMetrics: sinon.stub(),
-              });
-              webex.meetings.meetingCollection.getAll = sinon.stub().returns({
-                meetingutk: {
-                  locusUrl: 'fdfdjfdhj',
-                  sendCallAnalyzerMetrics: sinon.stub(),
-                },
-              });
-              webex.meetings.create = sinon.stub().returns(
-                Promise.resolve({
-                  locusInfo: {
-                    initialSetup,
-                  },
-                  sendCallAnalyzerMetrics: sinon.stub(),
-                })
-              );
+              webex.meetings.meetingCollection.getAll = sinon.stub().returns(meetingCollectionMeetings);
               webex.meetings.request.getActiveMeetings = sinon.stub().returns(
                 Promise.resolve({
-                  loci: [],
+                  loci: [
+                    {url: 'still-valid-locus-url'}
+                  ],
                 })
               );
               MeetingUtil.cleanUp = sinon.stub().returns(Promise.resolve());
             });
-            it('destroy non active meetings', async () => {
+            it('destroy only non active locus meetings and keep active locus meetings and any other non-locus meeting', async () => {
               await webex.meetings.syncMeetings();
               assert.calledOnce(webex.meetings.request.getActiveMeetings);
-              assert.calledOnce(destroySpy);
+              assert.calledOnce(webex.meetings.meetingCollection.getAll);
+              assert.calledWith(destroySpy, meetingCollectionMeetings.noLongerValidLocusMeeting);
+              assert.callCount(destroySpy, 1);
 
               assert.calledOnce(MeetingUtil.cleanUp);
             });

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