@webex/plugin-meetings 3.8.0-web-workers-keepalive.1 → 3.8.1-next.1

package/test/unit/spec/members/utils.js

@@ -357,5 +357,80 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#getMoveMemberToLobbyRequestBody', () => {
+      it('returns the correct options', () => {
+        const memberId = 'test1';
+        assert.deepEqual(MembersUtil.getMoveMemberToLobbyRequestBody(memberId), {
+          moveToLobby: {
+            participantIds: [memberId],
+          },
+        });
+      });
+    });
+
+    describe('#getMoveMemberToLobbyRequestParams', () => {
+      it('returns the correct params', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test1';
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+        };
+        const body = {
+          moveToLobby: {participantIds: [memberId]},
+        };
+
+        const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+        assert.deepEqual(MembersUtil.getMoveMemberToLobbyRequestParams(options, body), {
+          method: HTTP_VERBS.PATCH,
+          uri,
+          body,
+        });
+      });
+    });
+
+    describe('#cancelSIPInviteOptions', () => {
+      it('returns the correct options', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test';
+        const invitee = {memberId};
+
+        assert.deepEqual(
+          MembersUtil.cancelSIPInviteOptions(
+            invitee,
+            locusUrl
+          ),
+          {
+            invitee,
+            locusUrl,
+          }
+        );
+      });
+    });
+
+    describe('#generateCancelSIPInviteRequestParams', () => {
+      it('returns the correct params', () => {
+        const locusUrl = 'TestLocusUrl';
+        const memberId = 'test';
+        const options = {
+          locusUrl,
+          invitee: {memberId}
+        };
+        const body = {
+          actionType: 'REMOVE',
+          invitees: [{address: options.invitee.memberId}],
+        };
+
+        const uri = options.locusUrl;
+
+        assert.deepEqual(MembersUtil.generateCancelSIPInviteRequestParams(options), {
+          method: HTTP_VERBS.PUT,
+          uri,
+          body,
+        });
+      });
+    });
   });
 });

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

@@ -174,59 +174,6 @@ describe('ClusterReachability', () => {
       assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
-    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
-
-      // check the right events were emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 1);
-      assert.deepEqual(emittedEvents[Events.resultReady][0], {
-        protocol: 'udp',
-        result: 'reachable',
-        latencyInMilliseconds: 100,
-        clientMediaIPs: ['somePublicIp'],
-      });
-
-      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 2);
-      assert.deepEqual(emittedEvents[Events.resultReady][1], {
-        protocol: 'tcp',
-        result: 'reachable',
-        latencyInMilliseconds: 200,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
-      });
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 3);
-      assert.deepEqual(emittedEvents[Events.resultReady][2], {
-        protocol: 'xtls',
-        result: 'reachable',
-        latencyInMilliseconds: 300,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'reachable', latencyInMilliseconds: 300},
-      });
-    });
-
     it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
@@ -275,7 +222,7 @@ describe('ClusterReachability', () => {
 
       await testUtils.flushPromises();
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -293,7 +240,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(30);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -436,6 +383,9 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -474,6 +424,10 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await clock.tickAsync(10);
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -486,5 +440,37 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 20},
       });
     });
+
+    it('should gather correctly reached subnets', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:4.3.2.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), [
+        '1.2.3.4',
+        '4.3.2.1',
+        'someTurnRelayIp'
+      ]);
+    });
+
+    it('should store only unique subnet address', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:9000'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '1.2.3.4'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['1.2.3.4']);
+    });
   });
 });

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

@@ -1955,6 +1955,7 @@ describe('gatherReachability', () => {
         receivedEvents[event] = receivedEvents[event] + 1 || 1;
       });
     };
+    
     it('works as expected', async () => {
       setListener('reachability:stopped');
       setListener('reachability:done');
@@ -2016,6 +2017,59 @@ describe('gatherReachability', () => {
       assert.equal(receivedEvents['reachability:done'], undefined);
       assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
     });
+
+    it('does not fallback when no clusters were reached and min clusters were specified', async () => {
+      setListener('reachability:stopped');
+      setListener('reachability:done');
+      setListener('reachability:firstResultAvailable');
+
+      const mockGetClustersResult = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 1,
+        },
+        clusters: {
+          clusterA: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+          clusterB: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'id'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+      const gatherReachabilityFallbackSpy = sinon.spy(reachability, 'gatherReachabilityFallback');
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      reachability.stopReachability();
+
+      await resultPromise;
+
+      // simulate a lot of time passing to check that all timers were stopped and nothing else happens
+      clock.tick(99000);
+
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterA'].abort);
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterB'].abort);
+
+      assert.calledOnceWithExactly(sendMetricSpy, true);
+
+      assert.equal(receivedEvents['reachability:stopped'], 1);
+      assert.equal(receivedEvents['reachability:done'], undefined);
+      assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
+
+      assert.notCalled(gatherReachabilityFallbackSpy);
+    });
   });
 });
 
@@ -2686,3 +2740,38 @@ describe('sendMetric', () => {
     });
   });
 });
+
+describe('isSubnetReachable', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+
+    reachability.setFakeClusterReachability({
+      cluster1: {
+        reachedSubnets: new Set(['1.2.3.4', '2.3.4.5']),
+      },
+      cluster2: {
+        reachedSubnets: new Set(['3.4.5.6', '4.5.6.7']),
+      },
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('returns true if the subnet is reachable', () => {
+    assert(reachability.isSubnetReachable('1.2.3.4'));
+  });
+
+  it(`returns false if the subnet is unreachable`, () => {
+    assert(!reachability.isSubnetReachable('11.2.3.4'));
+  });
+
+  it('returns null if the subnet is not provided', () => {
+    assert.isNull(reachability.isSubnetReachable(undefined));
+  });
+});

package/test/unit/spec/reconnection-manager/index.js

@@ -60,7 +60,7 @@ describe('plugin-meetings', () => {
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
             turnServerInfo: {
-              url: 'fake_turn_url',
+              urls: ['fake_turn_url1', 'fake_turn_url2'],
               username: 'fake_turn_username',
               password: 'fake_turn_password',
             },
@@ -137,7 +137,7 @@ describe('plugin-meetings', () => {
       assert.calledOnce(fakeMediaConnection.reconnect);
       assert.calledWith(fakeMediaConnection.reconnect, [
         {
-          urls: 'fake_turn_url',
+          urls: ['fake_turn_url1', 'fake_turn_url2'],
           username: 'fake_turn_username',
           credential: 'fake_turn_password',
         },
@@ -152,12 +152,12 @@ describe('plugin-meetings', () => {
     });
 
     // this can happen when we land on a video mesh node
-    it('does not use TURN server if TURN url is an empty string', async () => {
+    it('does not use TURN server if TURN urls is an empty array', async () => {
       const rm = new ReconnectionManager(fakeMeeting);
 
       fakeMeeting.roap.doTurnDiscovery.resolves({
         turnServerInfo: {
-          url: '',
+          urls: [],
           username: 'whatever',
           password: 'whatever',
         },

package/test/unit/spec/roap/turnDiscovery.ts

@@ -15,7 +15,8 @@ describe('TurnDiscovery', () => {
   let mockRoapRequest: RoapRequest;
   let testMeeting: any;
 
-  const FAKE_TURN_URL = 'turns:fakeTurnServer.com:443?transport=tcp';
+  const FAKE_TURN_URL1 = 'turns:fakeTurnServer1.com:443?transport=tcp';
+  const FAKE_TURN_URL2 = 'turns:fakeTurnServer2.com:443?transport=tcp';
   const FAKE_TURN_USERNAME = 'someUsernameFromServer';
   const FAKE_TURN_PASSWORD = 'fakePasswordFromServer';
   const FAKE_LOCUS_ID = '09493311-f5d5-3e58-b491-009cc628162e';
@@ -186,7 +187,8 @@ describe('TurnDiscovery', () => {
             {
               messageType: 'TURN_DISCOVERY_RESPONSE',
               headers: [
-                `x-cisco-turn-url=${FAKE_TURN_URL}`,
+                `x-cisco-turn-url=${FAKE_TURN_URL1}`,
+                `x-cisco-turn-url=${FAKE_TURN_URL2}`,
                 `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
                 `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
               ],
@@ -195,7 +197,7 @@ describe('TurnDiscovery', () => {
           );
 
           await checkResult(result, 'OK', {
-            url: FAKE_TURN_URL,
+            urls: [FAKE_TURN_URL1, FAKE_TURN_URL2],
             username: FAKE_TURN_USERNAME,
             password: FAKE_TURN_PASSWORD,
           });
@@ -220,7 +222,7 @@ describe('TurnDiscovery', () => {
             {
               messageType: 'TURN_DISCOVERY_RESPONSE',
               headers: [
-                `x-cisco-turn-url=${FAKE_TURN_URL}`,
+                `x-cisco-turn-url=${FAKE_TURN_URL1}`,
                 `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
                 `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
                 'noOkInTransaction',
@@ -230,7 +232,7 @@ describe('TurnDiscovery', () => {
           );
 
           await checkResult(result, undefined, {
-            url: FAKE_TURN_URL,
+            urls: [FAKE_TURN_URL1],
             username: FAKE_TURN_USERNAME,
             password: FAKE_TURN_PASSWORD,
           });
@@ -241,7 +243,7 @@ describe('TurnDiscovery', () => {
             mediaConnections: [
               {
                 mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
-                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
+                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL1}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
               },
             ],
           });
@@ -256,7 +258,7 @@ describe('TurnDiscovery', () => {
           mockRoapRequest.sendRoap.resetHistory();
 
           await checkResult(result, undefined, {
-            url: FAKE_TURN_URL,
+            urls: [FAKE_TURN_URL1],
             username: FAKE_TURN_USERNAME,
             password: FAKE_TURN_PASSWORD,
           });
@@ -268,7 +270,7 @@ describe('TurnDiscovery', () => {
             mediaConnections: [
               {
                 mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
-                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}"]}}`,
+                remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL1}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}"]}}`,
               },
             ],
           };
@@ -290,7 +292,7 @@ describe('TurnDiscovery', () => {
           sendRoapPromiseResolve(sendRoapResult);
 
           await checkResult(result, 'OK', {
-            url: FAKE_TURN_URL,
+            urls: [FAKE_TURN_URL1],
             username: FAKE_TURN_USERNAME,
             password: FAKE_TURN_PASSWORD,
           });
@@ -350,16 +352,17 @@ describe('TurnDiscovery', () => {
             {
               messageType: 'TURN_DISCOVERY_RESPONSE',
               headers: [
-                `x-cisco-turn-url=${FAKE_TURN_URL}`,
+                `x-cisco-turn-url=${FAKE_TURN_URL1}`,
                 `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
                 `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+                `x-cisco-turn-url=${FAKE_TURN_URL2}`,
               ],
             },
             'from test'
           );
 
           await checkResult(result, 'OK', {
-            url: FAKE_TURN_URL,
+            urls: [FAKE_TURN_URL1, FAKE_TURN_URL2],
             username: FAKE_TURN_USERNAME,
             password: FAKE_TURN_PASSWORD,
           });
@@ -391,6 +394,44 @@ describe('TurnDiscovery', () => {
             'failure: TURN_DISCOVERY_RESPONSE in http response has unexpected messageType: {"seq":"0","messageType":"ERROR"}'
           );
         });
+
+        it('resets turnInfo each time TURN discovery is done', async () => {
+          const runCheck = async (td, turnUrl, expectedResult) => {
+            mockRoapRequest.sendRoap = sinon.fake.resolves({
+              mediaConnections: [
+                {
+                  mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
+                  remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${turnUrl}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
+                },
+              ],
+            });
+
+            const result = td.doTurnDiscovery(testMeeting, false);
+
+            // check that TURN_DISCOVERY_REQUEST was sent
+            await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+
+            // @ts-ignore
+            mockRoapRequest.sendRoap.resetHistory();
+
+            await checkResult(result, undefined, expectedResult);
+          };
+
+          const td = new TurnDiscovery(mockRoapRequest);
+
+          await runCheck(td, FAKE_TURN_URL1, {
+            urls: [FAKE_TURN_URL1],
+            username: FAKE_TURN_USERNAME,
+            password: FAKE_TURN_PASSWORD,
+          });
+
+          // call it again with different turn url, the result should not have the previous url
+          await runCheck(td, FAKE_TURN_URL2, {
+            urls: [FAKE_TURN_URL2],
+            username: FAKE_TURN_USERNAME,
+            password: FAKE_TURN_PASSWORD,
+          });
+        });
       });
     });
 
@@ -415,7 +456,7 @@ describe('TurnDiscovery', () => {
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
             `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           ],
@@ -428,7 +469,7 @@ describe('TurnDiscovery', () => {
 
       const {turnServerInfo, turnDiscoverySkippedReason} = await result;
       assert.deepEqual(turnServerInfo, {
-        url: FAKE_TURN_URL,
+        urls: [FAKE_TURN_URL1],
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD,
       });
@@ -455,7 +496,7 @@ describe('TurnDiscovery', () => {
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
             `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           ],
@@ -471,7 +512,7 @@ describe('TurnDiscovery', () => {
       const {turnServerInfo, turnDiscoverySkippedReason} = await result;
 
       assert.deepEqual(turnServerInfo, {
-        url: FAKE_TURN_URL,
+        urls: [FAKE_TURN_URL1],
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD,
       });
@@ -493,7 +534,7 @@ describe('TurnDiscovery', () => {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
             'x-cisco-turn-unexpected-header=xxx',
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             'x-cisco-some-other-header',
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
             `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
@@ -510,7 +551,47 @@ describe('TurnDiscovery', () => {
 
       const {turnServerInfo, turnDiscoverySkippedReason} = await result;
       assert.deepEqual(turnServerInfo, {
-        url: FAKE_TURN_URL,
+        urls: [FAKE_TURN_URL1],
+        username: FAKE_TURN_USERNAME,
+        password: FAKE_TURN_PASSWORD,
+      });
+      assert.isUndefined(turnDiscoverySkippedReason);
+    });
+
+    // this happens when we land on video-mesh nodes (VMN) - we will get a single empty url
+    it('filters out any empty TURN urls', async () => {
+      const td = new TurnDiscovery(mockRoapRequest);
+      const result = td.doTurnDiscovery(testMeeting, false);
+
+      // check that TURN_DISCOVERY_REQUEST was sent
+      await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
+      // @ts-ignore
+      mockRoapRequest.sendRoap.resetHistory();
+
+      // simulate the response with some empty urls, normally there would be just 1, but we put more just for the sake of testing 
+      td.handleTurnDiscoveryResponse(
+        {
+          messageType: 'TURN_DISCOVERY_RESPONSE',
+          headers: [
+            'x-cisco-turn-url=',
+            `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
+            'x-cisco-turn-url=',
+            `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
+            'x-cisco-turn-url=non-empty-url',
+            'x-cisco-turn-url=',
+          ],
+        },
+        'from test'
+      );
+
+      await testUtils.flushPromises();
+
+      // check that we've sent OK and still parsed the headers we care about
+      await checkRoapMessageSent('OK', 0);
+
+      const {turnServerInfo, turnDiscoverySkippedReason} = await result;
+      assert.deepEqual(turnServerInfo, {
+        urls: ['non-empty-url'], // empty urls should be filtered out
         username: FAKE_TURN_USERNAME,
         password: FAKE_TURN_PASSWORD,
       });
@@ -575,7 +656,7 @@ describe('TurnDiscovery', () => {
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           ],
         },
@@ -587,7 +668,7 @@ describe('TurnDiscovery', () => {
       assert.isUndefined(turnServerInfo);
       assert.equal(
         turnDiscoverySkippedReason,
-        `failure: TURN_DISCOVERY_RESPONSE from test missing some headers: ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}"]`
+        `failure: TURN_DISCOVERY_RESPONSE from test missing some headers: ["x-cisco-turn-url=${FAKE_TURN_URL1}","x-cisco-turn-username=${FAKE_TURN_USERNAME}"]`
       );
       checkFailureMetricsSent();
     });
@@ -655,7 +736,7 @@ describe('TurnDiscovery', () => {
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
             `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           ],
@@ -707,7 +788,7 @@ describe('TurnDiscovery', () => {
         {
           messageType: 'TURN_DISCOVERY_RESPONSE',
           headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
+            `x-cisco-turn-url=${FAKE_TURN_URL1}`,
             `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
             `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           ],
@@ -816,7 +897,8 @@ describe('TurnDiscovery', () => {
         errorType: undefined,
         errorCause: undefined,
         headers: [
-          `x-cisco-turn-url=${FAKE_TURN_URL}`,
+          `x-cisco-turn-url=${FAKE_TURN_URL1}`,
+          `x-cisco-turn-url=${FAKE_TURN_URL2}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
           'noOkInTransaction',
@@ -902,7 +984,7 @@ describe('TurnDiscovery', () => {
 
       assert.deepEqual(result, {
         turnServerInfo: {
-          url: FAKE_TURN_URL,
+          urls: [FAKE_TURN_URL1, FAKE_TURN_URL2],
           username: FAKE_TURN_USERNAME,
           password: FAKE_TURN_PASSWORD,
         },
@@ -914,7 +996,7 @@ describe('TurnDiscovery', () => {
 
     it('works as expected when httpResponse is missing some headers', async () => {
       roapMessage.headers = [
-        `x-cisco-turn-url=${FAKE_TURN_URL}`, // missing headers for username and password
+        `x-cisco-turn-url=${FAKE_TURN_URL1}`, // missing headers for username and password
       ];
 
       const httpResponse = {mediaConnections: [{remoteSdp: JSON.stringify({roapMessage})}]};
@@ -930,7 +1012,7 @@ describe('TurnDiscovery', () => {
       assert.deepEqual(result, {
         turnServerInfo: undefined,
         turnDiscoverySkippedReason:
-          'failure: TURN_DISCOVERY_RESPONSE in http response missing some headers: ["x-cisco-turn-url=turns:fakeTurnServer.com:443?transport=tcp"]',
+          'failure: TURN_DISCOVERY_RESPONSE in http response missing some headers: ["x-cisco-turn-url=turns:fakeTurnServer1.com:443?transport=tcp"]',
       });
       assert.calledOnceWithExactly(handleTurnDiscoveryResponseSpy, roapMessage, 'in http response');
 
@@ -939,7 +1021,7 @@ describe('TurnDiscovery', () => {
 
     it('sends OK when required', async () => {
       roapMessage.headers = [
-        `x-cisco-turn-url=${FAKE_TURN_URL}`,
+        `x-cisco-turn-url=${FAKE_TURN_URL1}`,
         `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
         `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
         // noOkInTransaction is missing
@@ -951,7 +1033,7 @@ describe('TurnDiscovery', () => {
 
       assert.deepEqual(result, {
         turnServerInfo: {
-          url: FAKE_TURN_URL,
+          urls: [FAKE_TURN_URL1],
           username: FAKE_TURN_USERNAME,
           password: FAKE_TURN_PASSWORD,
         },
@@ -982,7 +1064,7 @@ describe('TurnDiscovery', () => {
           mediaConnections: [
             {
               mediaId: '464ff97f-4bda-466a-ad06-3a22184a2274',
-              remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
+              remoteSdp: `{"roapMessage": {"messageType":"TURN_DISCOVERY_RESPONSE","seq":"0","headers": ["x-cisco-turn-url=${FAKE_TURN_URL1}","x-cisco-turn-username=${FAKE_TURN_USERNAME}","x-cisco-turn-password=${FAKE_TURN_PASSWORD}", "noOkInTransaction"]}}`,
             },
           ],
         });