@webex/plugin-meetings 3.0.0 → 3.1.0

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

@@ -4,7 +4,7 @@ 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
+import {ClusterReachability} from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -28,9 +28,8 @@ describe('ClusterReachability', () => {
       isVideoMesh: false,
       udp: ['stun:udp1', 'stun:udp2'],
       tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-      xtls: ['xtls1', 'xtls2'],
+      xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
-
   });
 
   afterEach(() => {
@@ -50,8 +49,26 @@ describe('ClusterReachability', () => {
       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']}
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turn:tcp2.webex.com:5004?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls1.webex.com?transport=tcp'],
+        },
+        {
+          username: 'webexturnreachuser',
+          credential: 'webexturnreachpwd',
+          urls: ['turns:xtls2.webex.com:443?transport=tcp'],
+        },
       ],
       iceCandidatePoolSize: 0,
       iceTransportPolicy: 'all',
@@ -79,7 +96,7 @@ describe('ClusterReachability', () => {
     assert.deepEqual(clusterReachability.getResult(), {
       udp: {result: 'untested'},
       tcp: {result: 'untested'},
-      xtls: {result: 'untested'}
+      xtls: {result: 'untested'},
     });
   });
 
@@ -92,7 +109,7 @@ describe('ClusterReachability', () => {
 
     afterEach(() => {
       clock.restore();
-    })
+    });
 
     it('should initiate the ICE gathering process', async () => {
       const promise = clusterReachability.start();
@@ -107,11 +124,11 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      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 () => {
+    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);
@@ -120,12 +137,17 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(100);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
 
+      await clock.tickAsync(100);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
         tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 300},
       });
     });
 
@@ -139,7 +161,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -148,7 +170,7 @@ describe('ClusterReachability', () => {
         isVideoMesh: true,
         udp: ['stun:udp1', 'stun:udp2'],
         tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['xtls1', 'xtls2'],
+        xtls: ['stun:xtls1.webex.com', 'stun:xtls1.webex.com:443'],
       });
 
       const promise = clusterReachability.start();
@@ -160,7 +182,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -176,7 +198,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -194,7 +216,7 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -211,15 +233,19 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      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']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3'],
+        },
         tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
       });
     });
 
@@ -236,7 +262,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
 
-      await clock.tickAsync(3000);// move the clock so that reachability times out
+      await clock.tickAsync(3000); // move the clock so that reachability times out
 
       await promise;
 
@@ -244,7 +270,38 @@ describe('ClusterReachability', () => {
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {result: 'unreachable'},
         tcp: {result: 'reachable', latencyInMilliseconds: 10},
-        xtls: {result: 'untested'}
+        xtls: {result: 'unreachable'},
+      });
+    });
+
+    it('should store latency only for the first tls relay candidate', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp1', port: 443},
+      });
+
+      // generate more candidates
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp2', port: 443},
+      });
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
+      });
+
+      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: 'unreachable'},
+        xtls: {result: 'reachable', latencyInMilliseconds: 10},
       });
     });
 
@@ -266,13 +323,20 @@ describe('ClusterReachability', () => {
 
       // send also a relay candidate so that the reachability check finishes
       fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
+      });
 
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2']},
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+        },
         tcp: {result: 'reachable', latencyInMilliseconds: 40},
-        xtls: {result: 'untested'}
+        xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
   });

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

@@ -1,11 +1,14 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
-import Reachability, {ReachabilityResults, ReachabilityResultsForBackend} 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';
+import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 
 describe('isAnyPublicClusterReachable', () => {
   let webex;
@@ -36,19 +39,31 @@ describe('isAnyPublicClusterReachable', () => {
   };
 
   it('returns true when udp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}}, true);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'reachable'}, tcp: {result: 'unreachable'}}},
+      true
+    );
   });
 
   it('returns true when tcp is reachable', async () => {
-    await checkIsClusterReachable({x: {udp: {result: 'unreachable'}, tcp: {result: 'reachable'}}}, 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: {result: 'reachable'}, tcp: {result: 'reachable'}}}, 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: {result: 'unreachable'}, tcp: {result: 'unreachable'}}}, false);
+    await checkIsClusterReachable(
+      {x: {udp: {result: 'unreachable'}, tcp: {result: 'unreachable'}}},
+      false
+    );
   });
 
   it('returns false when reachability result is empty', async () => {
@@ -61,60 +76,69 @@ describe('isAnyPublicClusterReachable', () => {
 
   describe('ignores video mesh reachability', () => {
     it('returns false if there are no public cluster results, only video mesh', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        }
-      }, false);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+        },
+        false
+      );
     });
 
     it('returns false if there public cluster reachability failed, only video mesh succeeded', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'unreachable'},
-          isVideoMesh: true,
-        },
-        publicOne: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'unreachable'},
-          isVideoMesh: false,
-        }
-      }, false);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'unreachable'},
+            isVideoMesh: true,
+          },
+          publicOne: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'unreachable'},
+            isVideoMesh: false,
+          },
+        },
+        false
+      );
     });
 
     it('returns true if there is at least 1 public cluster result, while video mesh is not reachable', async () => {
-      await checkIsClusterReachable({
-        x: {
-          udp: {result: 'reachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        y: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: true,
-        },
-        publicOne: {
-          udp: {result: 'unreachable'},
-          tcp: {result: 'reachable'},
-          isVideoMesh: false,
-        }
-      }, true);
+      await checkIsClusterReachable(
+        {
+          x: {
+            udp: {result: 'reachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          y: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: true,
+          },
+          publicOne: {
+            udp: {result: 'unreachable'},
+            tcp: {result: 'reachable'},
+            isVideoMesh: false,
+          },
+        },
+        true
+      );
     });
-  })
+  });
 });
 
 describe('gatherReachability', () => {
@@ -244,7 +268,10 @@ describe('gatherReachability', () => {
   });
 
   it('starts ClusterReachability on each media cluster', async () => {
-    webex.config.meetings.experimental = {enableTcpReachability: true};
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: true,
+    };
 
     const getClustersResult = {
       clusters: {
@@ -284,11 +311,11 @@ describe('gatherReachability', () => {
       xtls: ['xtls1.1', 'xtls1.2'],
       isVideoMesh: false,
     });
-    // cluster 2 is video mesh, so we should not do TCP reachability on it
+    // cluster 2 is video mesh, so we should not do TCP or TLS reachability on it
     assert.calledWith(clusterReachabilityCtorStub, 'cluster 2', {
       udp: ['udp2.1', 'udp2.2'],
       tcp: [],
-      xtls: ['xtls2.1', 'xtls2.2'],
+      xtls: [],
       isVideoMesh: true,
     });
 
@@ -296,7 +323,10 @@ describe('gatherReachability', () => {
   });
 
   it('does not do TCP reachability if it is disabled in config', async () => {
-    webex.config.meetings.experimental = {enableTcpReachability: false};
+    webex.config.meetings.experimental = {
+      enableTcpReachability: false,
+      enableTlsReachability: true,
+    };
 
     const getClustersResult = {
       clusters: {
@@ -329,6 +359,82 @@ describe('gatherReachability', () => {
       xtls: ['testXTLS1', 'testXTLS2'],
     });
   });
+
+  it('does not do TLS reachability if it is disabled in config', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: false,
+    };
+
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    const reachability = new Reachability(webex);
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: sinon.stub().resolves({}),
+      }));
+
+    await reachability.gatherReachability();
+
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: ['testTCP1', 'testTCP2'],
+      xtls: [], // empty list because TLS is disabled in config
+    });
+  });
+
+  it('does not do TCP or TLS reachability if it is disabled in config', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: false,
+      enableTlsReachability: false,
+    };
+
+    const getClustersResult = {
+      clusters: {
+        'cluster name': {
+          udp: ['testUDP1', 'testUDP2'],
+          tcp: ['testTCP1', 'testTCP2'],
+          xtls: ['testXTLS1', 'testXTLS2'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    const reachability = new Reachability(webex);
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
+
+    const clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake(() => ({
+        start: sinon.stub().resolves({}),
+      }));
+
+    await reachability.gatherReachability();
+
+    assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
+      isVideoMesh: false,
+      udp: ['testUDP1', 'testUDP2'],
+      tcp: [], // empty list because TCP is disabled in config
+      xtls: [], // empty list because TLS is disabled in config
+    });
+  });
 });
 
 describe('getReachabilityResults', () => {
@@ -460,10 +566,14 @@ describe('getReachabilityMetrics', () => {
       reachability_public_udp_failed: 0,
       reachability_public_tcp_success: 0,
       reachability_public_tcp_failed: 0,
+      reachability_public_xtls_success: 0,
+      reachability_public_xtls_failed: 0,
       reachability_vmn_udp_success: 0,
       reachability_vmn_udp_failed: 0,
       reachability_vmn_tcp_success: 0,
       reachability_vmn_tcp_failed: 0,
+      reachability_vmn_xtls_success: 0,
+      reachability_vmn_xtls_failed: 0,
     });
   });
 
@@ -523,10 +633,14 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 2,
         reachability_public_tcp_success: 2,
         reachability_public_tcp_failed: 1,
+        reachability_public_xtls_success: 0,
+        reachability_public_xtls_failed: 0,
         reachability_vmn_udp_success: 1,
         reachability_vmn_udp_failed: 0,
         reachability_vmn_tcp_success: 1,
         reachability_vmn_tcp_failed: 1,
+        reachability_vmn_xtls_success: 0,
+        reachability_vmn_xtls_failed: 0,
       }
     );
   });
@@ -562,7 +676,16 @@ describe('getReachabilityMetrics', () => {
         public5: {
           udp: {result: 'reachable', latencyInMilliseconds: '400', clientMediaIPs: ['10.10.10.10']},
           tcp: {result: 'untested'},
-          xtls: {result: 'untested'},
+          xtls: {result: 'unreachable'},
+        },
+        public6: {
+          udp: {result: 'untested'},
+          tcp: {result: 'untested'},
+          xtls: {
+            result: 'reachable',
+            latencyInMilliseconds: '200',
+            clientMediaIPs: ['10.10.10.10'],
+          },
         },
       },
       // expected result:
@@ -571,10 +694,14 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 1,
         reachability_public_tcp_success: 1,
         reachability_public_tcp_failed: 2,
+        reachability_public_xtls_success: 1,
+        reachability_public_xtls_failed: 1,
         reachability_vmn_udp_success: 0,
         reachability_vmn_udp_failed: 0,
         reachability_vmn_tcp_success: 0,
         reachability_vmn_tcp_failed: 0,
+        reachability_vmn_xtls_success: 0,
+        reachability_vmn_xtls_failed: 0,
       }
     );
   });
@@ -611,10 +738,16 @@ describe('getReachabilityMetrics', () => {
         vmn5: {
           udp: {result: 'reachable', latencyInMilliseconds: 200, clientMediaIPs: ['10.10.10.10']},
           tcp: {result: 'unreachable'},
-          xtls: {result: 'untested'},
+          xtls: {result: 'unreachable'},
           isVideoMesh: true,
           someOtherField: 'any value',
         },
+        vmn6: {
+          udp: {result: 'untested'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['10.10.10.10']},
+          isVideoMesh: true,
+        },
       },
       // expected result:
       {
@@ -622,11 +755,15 @@ describe('getReachabilityMetrics', () => {
         reachability_public_udp_failed: 0,
         reachability_public_tcp_success: 0,
         reachability_public_tcp_failed: 0,
+        reachability_public_xtls_success: 0,
+        reachability_public_xtls_failed: 0,
         reachability_vmn_udp_success: 3,
         reachability_vmn_udp_failed: 1,
         reachability_vmn_tcp_success: 1,
         reachability_vmn_tcp_failed: 3,
+        reachability_vmn_xtls_success: 1,
+        reachability_vmn_xtls_failed: 1,
       }
     );
   });
-});
+});

package/test/unit/spec/reachability/request.js

@@ -4,6 +4,7 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import {NewMetrics} from '@webex/internal-plugin-metrics';
 
 
 describe('plugin-meetings/reachability', () => {
@@ -14,6 +15,7 @@ describe('plugin-meetings/reachability', () => {
     webex = new MockWebex({
       children: {
         meetings: Meetings,
+        newMetrics: NewMetrics
       },
     });
 
@@ -22,19 +24,25 @@ describe('plugin-meetings/reachability', () => {
       regionCode: 'WEST-COAST',
     };
 
-    webex.internal = {
-      services: {
-        get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
-      },
+    webex.internal.services = {
+      get: sinon.mock().returns('locusUrl'),
+      waitForCatalog: sinon.mock().returns(Promise.resolve({})),
     };
 
-
     reachabilityRequest = new ReachabilityRequest(webex);
 
   });
 
   describe('#getClusters', () => {
+
+    beforeEach(() => {
+      sinon.spy(webex.internal.newMetrics.callDiagnosticLatencies, 'measureLatency');
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
     it('sends a GET request with the correct params', async () => {
       webex.request = sinon.mock().returns(Promise.resolve({
         body: {
@@ -49,7 +57,6 @@ describe('plugin-meetings/reachability', () => {
       }));
 
       const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
-
       const requestParams = webex.request.getCall(0).args[0];
 
       assert.equal(requestParams.method, 'GET');
@@ -63,6 +70,7 @@ describe('plugin-meetings/reachability', () => {
       });
       assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
       assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
+      assert.calledOnceWithExactly(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency, sinon.match.func, 'internal.get.cluster.time');
     });
   });
 });