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

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

@@ -1,8 +1,9 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import Reachability, {ICECandidateResult, ReachabilityResults} from '@webex/plugin-meetings/src/reachability/';
+import Reachability, {ReachabilityResults, ReachabilityResultsForBackend} from '@webex/plugin-meetings/src/reachability/';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
+import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 
 import { IP_VERSION } from '@webex/plugin-meetings/src/constants';
 
@@ -35,19 +36,19 @@ describe('isAnyPublicClusterReachable', () => {
   };
 
   it('returns true when udp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'false'}}}, true);
+    await checkIsClusterReachable({x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}}, true);
   });
 
   it('returns true when tcp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'true'}}}, true);
+    await checkIsClusterReachable({x: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}}}, true);
   });
 
   it('returns true when both tcp and udp are reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {reachable: 'true'}, tcp: {reachable: 'true'}}}, true);
+    await checkIsClusterReachable({x: {udp: {result: 'reachable'}, tcp: {result: 'reachable'}}}, true);
   });
 
   it('returns false when both tcp and udp are unreachable', async () => {
-    await checkIsClusterReachable({x: {udp: {reachable: 'false'}, tcp: {reachable: 'false'}}}, false);
+    await checkIsClusterReachable({x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}}}, false);
   });
 
   it('returns false when reachability result is empty', async () => {
@@ -62,13 +63,13 @@ describe('isAnyPublicClusterReachable', () => {
     it('returns false if there are no public cluster results, only video mesh', async () => {
       await checkIsClusterReachable({
         x: {
-          udp: {reachable: 'true'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'reachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: true,
         },
         y: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: true,
         }
       }, false);
@@ -77,18 +78,18 @@ describe('isAnyPublicClusterReachable', () => {
     it('returns false if there public cluster reachability failed, only video mesh succeeded', async () => {
       await checkIsClusterReachable({
         x: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: true,
         },
         y: {
-          udp: {reachable: 'true'},
-          tcp: {reachable: 'false'},
+          udp: {result: 'reachable'},
+          tcp: {result: 'unreachable'},
           isVideoMesh: true,
         },
         publicOne: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'false'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
           isVideoMesh: false,
         }
       }, false);
@@ -97,18 +98,18 @@ describe('isAnyPublicClusterReachable', () => {
     it('returns true if there is at least 1 public cluster result, while video mesh is not reachable', async () => {
       await checkIsClusterReachable({
         x: {
-          udp: {reachable: 'true'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'reachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: true,
         },
         y: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: true,
         },
         publicOne: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable'},
           isVideoMesh: false,
         }
       }, true);
@@ -129,6 +130,10 @@ describe('gatherReachability', () => {
     );
   });
 
+  afterEach(() => {
+    sinon.restore();
+  });
+
   it('stores the reachability', async () => {
     const reachability = new Reachability(webex);
 
@@ -145,7 +150,7 @@ describe('gatherReachability', () => {
     };
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
-    (reachability as any).performReachabilityCheck = sinon.stub().returns(reachabilityResults);
+    (reachability as any).performReachabilityChecks = sinon.stub().returns(reachabilityResults);
 
     const result = await reachability.gatherReachability();
 
@@ -164,161 +169,89 @@ describe('gatherReachability', () => {
     assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
   });
 
-  it('does reachability only on udp', async () => {
-    const reachability = new Reachability(webex);
+  it('starts ClusterReachability on each media cluster', async () => {
+    webex.config.meetings.experimental = {enableTcpReachability: true};
 
     const getClustersResult = {
-      clusters: {clusterId: {
-        tcp: [
-          'stun:170.72.164.1:5004',
-          'stun:170.72.165.2:5004'
-        ],
-        udp: [
-            'stun:170.72.164.3:5004',
-            'stun:170.72.164.3:9000',
-        ],
-        xtls: [
-            'stun:external-media101.public.wjfkm-a-4.prod.infra.webex.com:443',
-            'stun:external-media94.public.wjfkm-a-8.prod.infra.webex.com:443'
-        ]
-      }},
+      clusters: {
+        'cluster 1': {
+          udp: ['udp1.1', 'udp1.2'],
+          tcp: ['tcp1.1', 'tcp1.2'],
+          xtls: ['xtls1.1', 'xtls1.2'],
+          isVideoMesh: false,
+        },
+        'cluster 2': {
+          udp: ['udp2.1', 'udp2.2'],
+          tcp: ['tcp2.1', 'tcp2.2'],
+          xtls: ['xtls2.1', 'xtls2.2'],
+          isVideoMesh: true,
+        },
+      },
       joinCookie: {id: 'id'},
     };
 
-    sinon.stub(reachability.reachabilityRequest, 'getClusters').returns(getClustersResult);
-
-    const createPeerConnectionStub = sinon.stub(reachability, 'createPeerConnection');
+    const reachability = new Reachability(webex);
 
-    await reachability.gatherReachability();
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    // check that a peer connection was created with only the udp urls 
-    assert.calledOnceWithExactly(createPeerConnectionStub, {
-      key: 'clusterId',
-      config: {
-        iceServers: [
-          {
-            username: '',
-            credential: '',
-            urls: ['stun:170.72.164.3:5004'],
-          },
-          {
-            username: '',
-            credential: '',
-            urls: ['stun:170.72.164.3:9000'],
-          }
-        ],
-        iceCandidatePoolSize: '0',
-        iceTransportPolicy: 'all'
-      }
-    })
-  });
+    const startStub = sinon.stub().resolves({});
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: startStub,
+      }));
 
-  describe('clientMediaIPs', () => {
-    let testingClass: TestReachability;
+    await reachability.gatherReachability();
 
-    class TestReachability extends Reachability {
-      public testParseIceResultsToInternalReachabilityResults(iceResults: Array<ICECandidateResult>) {
-        return this.parseIceResultsToInternalReachabilityResults(iceResults);
-      }
-      public testAddPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null) {
-        return this.addPublicIP(peerConnection, publicIP);
-      }
-    }
-    beforeEach(() => {
-      testingClass = new TestReachability({webex});
+    assert.calledTwice(clusterReachabilityCtorStub);
+    assert.calledWith(clusterReachabilityCtorStub, 'cluster 1', {
+      udp: ['udp1.1', 'udp1.2'],
+      tcp: ['tcp1.1', 'tcp1.2'],
+      xtls: ['xtls1.1', 'xtls1.2'],
+      isVideoMesh: false,
     });
-
-    it('calls parseIceResultsToInternalReachabilityResults correctly', () => {
-      const res = testingClass.testParseIceResultsToInternalReachabilityResults([
-        {
-          clusterId: 'id1',
-          elapsed: '12312',
-          publicIPs: ['1.1.1.1'],
-          isVideoMesh: true,
-        },
-        {
-          clusterId: 'id2',
-          elapsed: null,
-          publicIPs: ['1.1.1.1'],
-          isVideoMesh: false,
-        },
-        {
-          clusterId: 'id2',
-          elapsed: '14123',
-          publicIPs: undefined,
-          isVideoMesh: false,
-        },
-      ]);
-
-      assert.deepEqual(res, {
-        id1: {
-          tcp: {
-            untested: 'true',
-          },
-          xtls: {
-            untested: 'true',
-          },
-          udp: {
-            clientMediaIPs: ['1.1.1.1'],
-            latencyInMilliseconds: '12312',
-            reachable: 'true',
-          },
-          isVideoMesh: true,
-        },
-        id2: {
-          xtls: {
-            untested: 'true',
-          },
-          tcp: {
-            untested: 'true',
-          },
-          udp: {
-            latencyInMilliseconds: '14123',
-            reachable: 'true',
-          },
-          isVideoMesh: false,
-        },
-      });
+    assert.calledWith(clusterReachabilityCtorStub, 'cluster 2', {
+      udp: ['udp2.1', 'udp2.2'],
+      tcp: ['tcp2.1', 'tcp2.2'],
+      xtls: ['xtls2.1', 'xtls2.2'],
+      isVideoMesh: true,
     });
 
-    it('calls addPublicIP correctly with no existing public APIs', () => {
-      const peerConnection = {
-        connectionState: 'not_closed',
-      };
-
-      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, '1.1.1.1');
+    assert.calledTwice(startStub);
+  });
 
-      assert.deepEqual(peerConnection, {
-        connectionState: 'not_closed',
-        publicIPs: ['1.1.1.1'],
-      });
-    });
+  it('does not do TCP reachability if it is disabled in config', async () => {
+    webex.config.meetings.experimental = {enableTcpReachability: false};
 
-    it('calls addPublicIP correctly with existing public APIs', () => {
-      const peerConnection = {
-        connectionState: 'not_closed',
-        publicIPs: ['2.2.2.2'],
-      };
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
 
-      testingClass.testAddPublicIP(peerConnection as any, '1.1.1.1');
+    const reachability = new Reachability(webex);
 
-      assert.deepEqual(peerConnection, {
-        connectionState: 'not_closed',
-        publicIPs: ['2.2.2.2', '1.1.1.1'],
-      });
-    });
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    it('calls addPublicIP correctly null publicAPI', () => {
-      const peerConnection = {
-        connectionState: 'not_closed',
-      };
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: sinon.stub().resolves({}),
+      }));
 
-      testingClass.testAddPublicIP(peerConnection as RTCPeerConnection, null);
+    await reachability.gatherReachability();
 
-      assert.deepEqual(peerConnection, {
-        connectionState: 'not_closed',
-        publicIPs: null,
-      });
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: [], // empty list because TCP is disabled in config
+      xtls: ['testXTLS1', 'testXTLS2'],
     });
   });
 });
@@ -334,7 +267,7 @@ describe('getReachabilityResults', () => {
     sinon.restore();
   });
 
-  const runCheck = async (mockStorage: any, expectedResult: ReachabilityResults) => {
+  const runCheck = async (mockStorage: any, expectedResult: ReachabilityResultsForBackend) => {
     if (mockStorage) {
       await webex.boundedStorage.put(
         'Reachability',
@@ -359,36 +292,36 @@ describe('getReachabilityResults', () => {
     assert.isUndefined(result);
   });
 
-  it('returns results from local storage, stripping any internal data', async () => {
+  it('returns results from local storage, converted to the backend data format', async () => {
     await runCheck(
       // mock storage:
       {
         cluster1: {
-          udp: {reachable: 'true', latencyInMilliseconds: '100'},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 100},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
         },
         cluster2: {
-          udp: {reachable: 'true', latencyInMilliseconds: '200'},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 200},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
         },
         cluster3: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
-          xtls: {untested: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },
         cluster4: {
-          udp: {reachable: 'false', latencyInMilliseconds: '300'},
-          tcp: {reachable: 'false', untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 300},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
           someOtherField: 'any value',
         },
       },
-      // expected result (same as above, but with isVideoMesh and someOtherField stripped out):
+      // expected result (same as above, but with values converted and isVideoMesh and someOtherField stripped out):
       {
         cluster1: {
           udp: {reachable: 'true', latencyInMilliseconds: '100'},
@@ -406,8 +339,8 @@ describe('getReachabilityResults', () => {
           xtls: {untested: 'true'},
         },
         cluster4: {
-          udp: {reachable: 'false', latencyInMilliseconds: '300'},
-          tcp: {reachable: 'false', untested: 'true'},
+          udp: {reachable: 'true', latencyInMilliseconds: '300'},
+          tcp: {untested: 'true'},
           xtls: {untested: 'true'},
         },
       }
@@ -464,47 +397,47 @@ describe('getReachabilityMetrics', () => {
       // mock storage:
       {
         public1: {
-          udp: {reachable: 'true', latencyInMilliseconds: '100'},
-          tcp: {untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 100},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
         },
         vmn1: {
-          udp: {reachable: 'true', latencyInMilliseconds: '200'},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 200},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
         },
         vmn2: {
-          udp: {untested: 'true'},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
-          xtls: {untested: 'true'},
+          udp: {result: 'untested'},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },
         public2: {
-          udp: {reachable: 'false', latencyInMilliseconds: '300'},
-          tcp: {reachable: 'false', untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           someOtherField: 'any value',
         },
         public3: {
-          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 400, clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          xtls: {result: 'untested'},
           isVideoMesh: false,
           someOtherField: 'any value',
         },
         public4: {
-          udp: {reachable: 'true', latencyInMilliseconds: '40', clientMediaIPs: ['10.10.10.11']},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.11']},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 40, clientMediaIPs: ['10.10.10.11']},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.11']},
+          xtls: {result: 'untested'},
           isVideoMesh: false,
           someOtherField: 'any value',
         },
         public5: {
-          udp: {reachable: 'false'},
-          tcp: {untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
           isVideoMesh: false,
           someOtherField: 'any value',
         },
@@ -528,33 +461,33 @@ describe('getReachabilityMetrics', () => {
       // mock storage:
       {
         public1: {
-          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 400, clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          xtls: {result: 'untested'},
           isVideoMesh: false,
         },
         public2: {
-          udp: {reachable: 'true', latencyInMilliseconds: '100'},
-          tcp: {untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 100},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
         },
         public3: {
-          udp: {reachable: 'false', latencyInMilliseconds: '300'},
-          tcp: {reachable: 'false', untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           someOtherField: 'any value',
         },
         public4: {
-          udp: {untested: 'true'},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'untested'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: false,
           someOtherField: 'any value',
         },
         public5: {
-          udp: {reachable: 'true', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
-          tcp: {untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
         },
       },
       // expected result:
@@ -576,34 +509,34 @@ describe('getReachabilityMetrics', () => {
       // mock storage:
       {
         vmn1: {
-          udp: {reachable: 'false'},
-          tcp: {reachable: 'true', latencyInMilliseconds: '100', clientMediaIPs: ['10.10.10.10']},
-          xtls: {untested: 'true'},
+          udp: {result: 'unreachable'},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
         },
         vmn2: {
-          udp: {reachable: 'true', latencyInMilliseconds: '200', clientMediaIPs: ['10.10.10.10']},
-          tcp: {untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 200, clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
         },
         vmn3: {
-          udp: {reachable: 'true', latencyInMilliseconds: '300', clientMediaIPs: ['10.10.10.10']},
-          tcp: {reachable: 'false', untested: 'true'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 300, clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
         },
         vmn4: {
-          udp: {untested: 'true'},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'untested'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },
         vmn5: {
-          udp: {reachable: 'true', latencyInMilliseconds: '200', clientMediaIPs: ['10.10.10.10']},
-          tcp: {reachable: 'false'},
-          xtls: {untested: 'true'},
+          udp: {result: 'reachable', latencyInMilliseconds: 200, clientMediaIPs: ['10.10.10.10']},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'untested'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },

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

@@ -0,0 +1,40 @@
+import {assert} from '@webex/test-helper-chai';
+
+import {convertStunUrlToTurn} from '@webex/plugin-meetings/src/reachability/util';
+
+describe('plugin-meetings/src/reachability/util', () => {
+  describe('#convertStunUrlToTurn()', () => {
+    [
+      {
+        title: 'a stun url with port',
+        stunUrl: 'stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
+        expectedUrlPart: 'external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
+      },
+      {
+        title: 'a stun url without port',
+        stunUrl: 'stun:something.somewhere.com',
+        expectedUrlPart: 'something.somewhere.com',
+      },
+    ].forEach(({title, stunUrl, expectedUrlPart}) => {
+      it(`should convert ${title} to a TCP turn url`, () => {
+        const turnUrl = convertStunUrlToTurn(stunUrl, 'tcp');
+
+        assert.equal(turnUrl, `turn:${expectedUrlPart}?transport=tcp`);
+      });
+
+      it(`should convert ${title} to a UDP turn url`, () => {
+        const turnUrl = convertStunUrlToTurn(stunUrl, 'udp');
+
+        assert.equal(turnUrl, `turn:${expectedUrlPart}`);
+      });
+    });
+
+    it('show fail if stunUrl is not a valid url', () => {
+      assert.throws(() => convertStunUrlToTurn('not a url', 'tcp'), 'Invalid URL: not a url');
+    });
+
+    it('show fail if stunUrl is not a STUN url', () => {
+      assert.throws(() => convertStunUrlToTurn('http://webex.com', 'tcp'), 'Not a STUN URL: http://webex.com');
+    });
+  });
+});