@webex/plugin-meetings 3.3.1 → 3.4.0-next.10

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

@@ -1,12 +1,15 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
+import EventEmitter from 'events';
+import testUtils from '../../../utils/testUtils';
 import Reachability, {
-  ReachabilityResults,
   ReachabilityResultsForBackend,
 } from '@webex/plugin-meetings/src/reachability/';
+import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 
@@ -141,7 +144,6 @@ describe('isAnyPublicClusterReachable', () => {
   });
 });
 
-
 describe('isWebexMediaBackendUnreachable', () => {
   let webex;
 
@@ -381,156 +383,1066 @@ describe('isWebexMediaBackendUnreachable', () => {
           tcp: {result: 'unreachable'},
           xtls: {result: 'reachable'},
         },
-        c: {
-          udp: {result: 'unreachable'},
+        c: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+        },
+      },
+      expectedResult: false,
+    },
+    {
+      title: 'multiple clusters with some missing results',
+      mockStorage: {
+        a: {udp: {result: 'unreachable'}},
+        b: {tcp: {result: 'unreachable'}},
+        c: {xtls: {result: 'unreachable'}},
+        d: {},
+      },
+      expectedResult: true,
+    },
+  ].forEach(({mockStorage, expectedResult, title}) => {
+    it(`returns ${expectedResult} when ${title}`, async () => {
+      await runCheck(mockStorage, expectedResult);
+    });
+  });
+});
+
+/**
+ * helper class to mock ClusterReachability and allow to easily
+ * simulate 'resultReady' events from it
+ */
+class MockClusterReachability extends EventEmitter {
+  mockResult = {
+    udp: {
+      result: 'untested',
+    },
+    tcp: {
+      result: 'untested',
+    },
+    xtls: {
+      result: 'untested',
+    },
+  };
+
+  isVideoMesh: boolean;
+  name: string;
+
+  constructor(name: string, clusterInfo: ClusterNode) {
+    super();
+    this.name = name;
+    this.isVideoMesh = clusterInfo.isVideoMesh;
+  }
+
+  abort = sinon.stub();
+  start = sinon.stub();
+
+  getResult() {
+    return this.mockResult;
+  }
+
+  /**
+   * Emits a fake 'resultReady' event and makes sure that the same result
+   * is returned when getResult() is called.
+   *
+   * @param protocol
+   * @param result
+   */
+  public emitFakeResult(protocol, result) {
+    this.mockResult[protocol] = result;
+    this.emit(ClusterReachabilityModule.Events.resultReady, {protocol, ...result});
+  }
+
+  public emitFakeClientMediaIpUpdate(protocol, newIp) {
+    this.mockResult[protocol].clientMediaIPs.push(newIp);
+    this.emit(ClusterReachabilityModule.Events.clientMediaIpsUpdated, {
+      protocol,
+      clientMediaIPs: this.mockResult[protocol].clientMediaIPs,
+    });
+  }
+}
+
+describe('gatherReachability', () => {
+  let webex;
+  let clock;
+  let clusterReachabilityCtorStub;
+  let mockClusterReachabilityInstances: Record<string, MockClusterReachability>;
+
+  beforeEach(async () => {
+    webex = new MockWebex();
+
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.result',
+      JSON.stringify({old: 'results'})
+    );
+    await webex.boundedStorage.put(
+      'Reachability',
+      'reachability.joinCookie',
+      JSON.stringify({old: 'joinCookie'})
+    );
+
+    webex.internal.device.ipNetworkDetector = {
+      supportsIpV4: false,
+      supportsIpV6: false,
+      firstIpV4: -1,
+      firstIpV6: -1,
+      firstMdns: -1,
+      totalTime: -1,
+      detect: sinon.stub().resolves(),
+    };
+
+    clock = sinon.useFakeTimers();
+
+    mockClusterReachabilityInstances = {};
+
+    clusterReachabilityCtorStub = sinon
+      .stub(ClusterReachabilityModule, 'ClusterReachability')
+      .callsFake((id, cluster) => {
+        const mockInstance = new MockClusterReachability(id, cluster);
+
+        mockClusterReachabilityInstances[id] = mockInstance;
+        return mockInstance;
+      });
+
+    webex.config.meetings.experimental = {
+      enableTcpReachability: false,
+      enableTlsReachability: false,
+    };
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    clock.restore();
+  });
+
+  // simulates time progression so that Reachability times out
+  const simulateTimeout = async () => {
+    await testUtils.flushPromises();
+    clock.tick(3000);
+  };
+
+  const checkResults = async (expectedResults, expectedJoinCookie) => {
+    const storedResultForReachabilityResult = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.result'
+    );
+    const storedResultForJoinCookie = await webex.boundedStorage.get(
+      'Reachability',
+      'reachability.joinCookie'
+    );
+
+    assert.equal(storedResultForReachabilityResult, JSON.stringify(expectedResults));
+    assert.equal(storedResultForJoinCookie, JSON.stringify(expectedJoinCookie));
+  };
+
+  [
+    // ========================================================================
+    {
+      title: '1 cluster with events triggered for each protocol',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: ['tcp-url1'],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 11,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 22,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 33,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 22},
+          tcp: {result: 'reachable', latencyInMilliseconds: 11},
+          xtls: {result: 'reachable', latencyInMilliseconds: 33},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 22,
+        public_udp_max: 22,
+        public_udp_average: 22,
+        public_tcp_min: 11,
+        public_tcp_max: 11,
+        public_tcp_average: 11,
+        public_xtls_min: 33,
+        public_xtls_max: 33,
+        public_xtls_average: 33,
+      },
+    },
+    // ========================================================================
+    {
+      title:
+        '3 clusters: one with an event for each protocol, one with no events, one with no urls for tcp and xtls',
+      waitShortTimeout: 'public',
+      waitLongTimeout: true,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1.1', 'udp-url1.2'],
+          tcp: ['tcp-url1.1', 'tcp-url1.2'],
+          xtls: ['xtls-url1.1', 'xtls-url1.2'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2.1'],
+          tcp: ['tcp-url2.1'],
+          xtls: ['xtls-url2.1'],
+          isVideoMesh: false,
+        },
+        cluster3: {
+          udp: ['udp-url1'],
+          tcp: [],
+          xtls: [],
+          isVideoMesh: true,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 13,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 53,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 113,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 13},
+          tcp: {result: 'reachable', latencyInMilliseconds: 53},
+          xtls: {result: 'reachable', latencyInMilliseconds: 113},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+        cluster3: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
+          isVideoMesh: true,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 13,
+        public_udp_max: 13,
+        public_udp_average: 13,
+        public_tcp_min: 53,
+        public_tcp_max: 53,
+        public_tcp_average: 53,
+        public_xtls_min: 113,
+        public_xtls_max: 113,
+        public_xtls_average: 113,
+      },
+    },
+    // ========================================================================
+    {
+      title: '3 clusters: all with all results ready in time for all protocols',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: ['tcp-url1'],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+        cluster3: {
+          udp: ['udp-url3'],
+          tcp: ['tcp-url3'],
+          xtls: ['xtls-url3'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 20,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 110,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 220,
+          },
+        },
+        {
+          clusterId: 'cluster3',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 30,
+          },
+        },
+        {
+          clusterId: 'cluster3',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 120,
+          },
+        },
+        {
+          clusterId: 'cluster3',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 240,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 20},
+          tcp: {result: 'reachable', latencyInMilliseconds: 110},
+          xtls: {result: 'reachable', latencyInMilliseconds: 220},
+          isVideoMesh: false,
+        },
+        cluster3: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 30},
+          tcp: {result: 'reachable', latencyInMilliseconds: 120},
+          xtls: {result: 'reachable', latencyInMilliseconds: 240},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 30,
+        public_udp_average: 20,
+        public_tcp_min: 100,
+        public_tcp_max: 120,
+        public_tcp_average: 110,
+        public_xtls_min: 200,
+        public_xtls_max: 240,
+        public_xtls_average: 220,
+      },
+    },
+    // ========================================================================
+    {
+      title: '2 clusters: both with no results at all',
+      waitShortTimeout: 'public',
+      waitLongTimeout: true,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: ['tcp-url1'],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: -1,
+        public_udp_max: -1,
+        public_udp_average: -1,
+        public_tcp_min: -1,
+        public_tcp_max: -1,
+        public_tcp_average: -1,
+        public_xtls_min: -1,
+        public_xtls_max: -1,
+        public_xtls_average: -1,
+      },
+    },
+    // ========================================================================
+    {
+      title:
+        '3 clusters: 2 VMN clusters missing results, but the public one has all results within 1s',
+      waitShortTimeout: 'vmn',
+      waitLongTimeout: true,
+      mockClusters: {
+        vmnCluster1: {
+          udp: ['udp-url1'],
+          tcp: ['tcp-url1'],
+          xtls: ['xtls-url1'],
+          isVideoMesh: true,
+        },
+        publicCluster: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+        vmnCluster2: {
+          udp: ['udp-url3'],
+          tcp: ['tcp-url3'],
+          xtls: ['xtls-url3'],
+          isVideoMesh: true,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'publicCluster',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'publicCluster',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'publicCluster',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+      ],
+      expectedResults: {
+        vmnCluster1: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
+          isVideoMesh: true,
+        },
+        publicCluster: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+        vmnCluster2: {
+          udp: {result: 'unreachable'},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
+          isVideoMesh: true,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 10,
+        public_udp_average: 10,
+        public_tcp_min: 100,
+        public_tcp_max: 100,
+        public_tcp_average: 100,
+        public_xtls_min: 200,
+        public_xtls_max: 200,
+        public_xtls_average: 200,
+      },
+    },
+    // ========================================================================
+    {
+      title: '2 VMN clusters with all results',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        vmnCluster1: {
+          udp: ['udp-url1'],
+          tcp: [],
+          xtls: [],
+          isVideoMesh: true,
+        },
+        vmnCluster2: {
+          udp: ['udp-url3'],
+          tcp: [],
+          xtls: [],
+          isVideoMesh: true,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'vmnCluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['192.168.10.1'],
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'vmnCluster2',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['192.168.0.1'],
+            latencyInMilliseconds: 300,
+          },
+        },
+      ],
+      expectedResults: {
+        vmnCluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['192.168.10.1'], latencyInMilliseconds: 100},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
+          isVideoMesh: true,
+        },
+        vmnCluster2: {
+          udp: {result: 'reachable', clientMediaIPs: ['192.168.0.1'], latencyInMilliseconds: 300},
+          tcp: {result: 'untested'},
+          xtls: {result: 'untested'},
+          isVideoMesh: true,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: 100,
+        vmn_udp_max: 300,
+        vmn_udp_average: 200,
+        public_udp_min: -1,
+        public_udp_max: -1,
+        public_udp_average: -1,
+        public_tcp_min: -1,
+        public_tcp_max: -1,
+        public_tcp_average: -1,
+        public_xtls_min: -1,
+        public_xtls_max: -1,
+        public_xtls_average: -1,
+      },
+    },
+  ].forEach(
+    ({
+      title,
+      waitShortTimeout,
+      waitLongTimeout,
+      mockClusters,
+      mockResultReadyEvents,
+      expectedResults,
+      expectedMetrics,
+    }) =>
+      it(`works correctly for the case: ${title}`, async () => {
+        webex.config.meetings.experimental = {
+          enableTcpReachability: true,
+          enableTlsReachability: true,
+        };
+
+        // the metrics related to ipver and trigger are not tested in these tests and are all the same, so setting them up here
+        const expectedMetricsFull = {
+          ...expectedMetrics,
+          ipver_firstIpV4: -1,
+          ipver_firstIpV6: -1,
+          ipver_firstMdns: -1,
+          ipver_totalTime: -1,
+          trigger: 'test',
+        };
+
+        const receivedEvents = {
+          done: 0,
+          firstResultAvailable: {
+            udp: 0,
+            tcp: 0,
+            xtls: 0,
+          },
+        };
+
+        const reachability = new Reachability(webex);
+
+        reachability.on('reachability:done', () => {
+          receivedEvents.done += 1;
+        });
+        reachability.on('reachability:firstResultAvailable', ({protocol}) => {
+          receivedEvents.firstResultAvailable[protocol] += 1;
+        });
+
+        const mockGetClustersResult = {
+          clusters: {},
+          joinCookie: {id: 'id'},
+        };
+
+        Object.entries(mockClusters).forEach(([id, mockCluster]) => {
+          mockGetClustersResult.clusters[id] = mockCluster;
+        });
+
+        reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+        const resultPromise = reachability.gatherReachability('test');
+
+        await testUtils.flushPromises();
+
+        // check that ClusterReachability instance was created for each cluster
+        Object.entries(mockClusters).forEach(([id, mockCluster]) => {
+          assert.calledWith(clusterReachabilityCtorStub, id, mockCluster);
+        });
+
+        // trigger mock result events from ClusterReachability instances
+        mockResultReadyEvents.forEach((mockEvent) => {
+          mockClusterReachabilityInstances[mockEvent.clusterId].emitFakeResult(
+            mockEvent.protocol,
+            mockEvent.result
+          );
+        });
+
+        if (waitShortTimeout === 'public') {
+          clock.tick(3000);
+        }
+        if (waitShortTimeout === 'vmn') {
+          clock.tick(1000);
+        }
+
+        await resultPromise;
+
+        await checkResults(expectedResults, mockGetClustersResult.joinCookie);
+
+        if (waitLongTimeout) {
+          // we need to wait either 14 or 12 seconds to get to the 15s timeout (depending on how much we waited earlier)
+          clock.tick(waitShortTimeout === 'vmn' ? 14000 : 12000);
+
+          // we check the results again after the long timeout - they should be the same
+          await checkResults(expectedResults, mockGetClustersResult.joinCookie);
+        }
+
+        // now check events emitted by Reachability class
+        assert.equal(receivedEvents['done'], 1);
+
+        // if we've mocked at least one event for any protocol, check that we received
+        // firstResultAvailable event for that protocol
+        if (mockResultReadyEvents.filter((event) => event.protocol === 'udp').length > 0) {
+          assert.equal(receivedEvents['firstResultAvailable']['udp'], 1);
+        }
+        if (mockResultReadyEvents.filter((event) => event.protocol === 'tcp').length > 0) {
+          assert.equal(receivedEvents['firstResultAvailable']['tcp'], 1);
+        }
+        if (mockResultReadyEvents.filter((event) => event.protocol === 'xtls').length > 0) {
+          assert.equal(receivedEvents['firstResultAvailable']['xtls'], 1);
+        }
+
+        // finally, check the metrics
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          'js_sdk_reachability_completed',
+          expectedMetricsFull
+        );
+      })
+  );
+
+  it('sends the trigger parameter in the metrics', async () => {
+    const reachability = new TestReachability(webex);
+
+    const mockGetClustersResult = {
+      clusters: {
+        clusterA: {
+          udp: ['udp-url'],
+          tcp: [],
+          xtls: [],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+    const resultPromise = reachability.gatherReachability('some trigger');
+
+    // let it time out
+    await testUtils.flushPromises();
+    clock.tick(15000);
+    await resultPromise;
+
+    // check the metric contains the right trigger value
+    assert.calledWith(
+      Metrics.sendBehavioralMetric,
+      'js_sdk_reachability_completed',
+      sinon.match({trigger: 'some trigger'})
+    );
+  });
+
+  it(`starts ip network version detection and includes the results in the metrics`, async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: true,
+    };
+    webex.internal.device.ipNetworkDetector = {
+      supportsIpV4: true,
+      supportsIpV6: true,
+      firstIpV4: 10,
+      firstIpV6: 20,
+      firstMdns: 30,
+      totalTime: 40,
+      detect: sinon.stub().resolves(),
+    };
+
+    const receivedEvents = {
+      done: 0,
+    };
+
+    const reachability = new Reachability(webex);
+
+    reachability.on('reachability:done', () => {
+      receivedEvents.done += 1;
+    });
+
+    // simulate having just 1 cluster, we don't need more for this test
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns({
+      clusters: {
+        publicCluster: {
+          udp: ['udp-url'],
+          tcp: [],
+          xtls: [],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    });
+
+    const resultPromise = reachability.gatherReachability('test');
+
+    await testUtils.flushPromises();
+
+    // trigger mock result events from ClusterReachability instance
+    mockClusterReachabilityInstances['publicCluster'].emitFakeResult('udp', {
+      result: 'reachable',
+      clientMediaIPs: ['1.2.3.4'],
+      latencyInMilliseconds: 100,
+    });
+
+    await resultPromise;
+
+    // check events emitted by Reachability class
+    assert.equal(receivedEvents['done'], 1);
+
+    // and that ip network detection was started
+    assert.calledOnceWithExactly(webex.internal.device.ipNetworkDetector.detect);
+
+    // finally, check the metrics - they should contain values from ipNetworkDetector
+    assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
+      vmn_udp_min: -1,
+      vmn_udp_max: -1,
+      vmn_udp_average: -1,
+      public_udp_min: 100,
+      public_udp_max: 100,
+      public_udp_average: 100,
+      public_tcp_min: -1,
+      public_tcp_max: -1,
+      public_tcp_average: -1,
+      public_xtls_min: -1,
+      public_xtls_max: -1,
+      public_xtls_average: -1,
+      ipver_firstIpV4: webex.internal.device.ipNetworkDetector.firstIpV4,
+      ipver_firstIpV6: webex.internal.device.ipNetworkDetector.firstIpV6,
+      ipver_firstMdns: webex.internal.device.ipNetworkDetector.firstMdns,
+      ipver_totalTime: webex.internal.device.ipNetworkDetector.totalTime,
+      trigger: 'test',
+    });
+  });
+
+  it('keeps updating reachability results after the 3s public cloud timeout expires', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: true,
+    };
+
+    const reachability = new Reachability(webex);
+
+    const mockGetClustersResult = {
+      clusters: {
+        clusterA: {
+          udp: ['udp-urlA'],
+          tcp: ['tcp-urlA'],
+          xtls: ['xtls-urlA'],
+          isVideoMesh: false,
+        },
+        clusterB: {
+          udp: ['udp-urlB'],
+          tcp: ['tcp-urlB'],
+          xtls: ['xtls-urlB'],
+          isVideoMesh: false,
+        },
+      },
+      joinCookie: {id: 'id'},
+    };
+
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+    const resultPromise = reachability.gatherReachability('test');
+
+    await testUtils.flushPromises();
+
+    // trigger some mock result events from ClusterReachability instances
+    mockClusterReachabilityInstances['clusterA'].emitFakeResult('udp', {
+      result: 'reachable',
+      clientMediaIPs: ['1.2.3.4'],
+      latencyInMilliseconds: 11,
+    });
+    mockClusterReachabilityInstances['clusterB'].emitFakeResult('udp', {
+      result: 'reachable',
+      clientMediaIPs: ['10.20.30.40'],
+      latencyInMilliseconds: 22,
+    });
+
+    clock.tick(3000);
+    await resultPromise;
+
+    // check that the reachability results contain the 2 results from above
+    await checkResults(
+      {
+        clusterA: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 11},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+        clusterB: {
+          udp: {result: 'reachable', clientMediaIPs: ['10.20.30.40'], latencyInMilliseconds: 22},
           tcp: {result: 'unreachable'},
           xtls: {result: 'unreachable'},
+          isVideoMesh: false,
         },
       },
-      expectedResult: false,
-    },
-    {
-      title: 'multiple clusters with some missing results',
-      mockStorage: {
-        a: {udp: {result: 'unreachable'}},
-        b: {tcp: {result: 'unreachable'}},
-        c: {xtls: {result: 'unreachable'}},
-        d: {},
-      },
-      expectedResult: true,
-    },
-  ].forEach(({mockStorage, expectedResult, title}) => {
-    it(`returns ${expectedResult} when ${title}`, async () => {
-      await runCheck(mockStorage, expectedResult);
-    });
-  });
-});
-
+      mockGetClustersResult.joinCookie
+    );
 
-describe('gatherReachability', () => {
-  let webex;
+    // now simulate some more "late" results
+    mockClusterReachabilityInstances['clusterA'].emitFakeResult('tcp', {
+      result: 'reachable',
+      latencyInMilliseconds: 101,
+    });
+    mockClusterReachabilityInstances['clusterB'].emitFakeResult('xtls', {
+      result: 'reachable',
+      latencyInMilliseconds: 102,
+    });
 
-  beforeEach(async () => {
-    webex = new MockWebex();
+    // and wait for the final overall timeout
+    clock.tick(12000);
 
-    await webex.boundedStorage.put(
-      'Reachability',
-      'reachability.result',
-      JSON.stringify({old: 'results'})
-    );
-    await webex.boundedStorage.put(
-      'Reachability',
-      'reachability.joinCookie',
-      JSON.stringify({old: 'joinCookie'})
+    // the reachability results should include all results from above (including the late ones)
+    await checkResults(
+      {
+        clusterA: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 11},
+          tcp: {result: 'reachable', latencyInMilliseconds: 101},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+        clusterB: {
+          udp: {result: 'reachable', clientMediaIPs: ['10.20.30.40'], latencyInMilliseconds: 22},
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 102},
+          isVideoMesh: false,
+        },
+      },
+      mockGetClustersResult.joinCookie
     );
   });
 
-  afterEach(() => {
-    sinon.restore();
-  });
+  it('handles clientMediaIpsUpdated event by updating clientMediaIps in results', async () => {
+    webex.config.meetings.experimental = {
+      enableTcpReachability: true,
+      enableTlsReachability: true,
+    };
 
-  it('stores the reachability', async () => {
     const reachability = new Reachability(webex);
 
-    const reachabilityResults = {
+    const mockGetClustersResult = {
       clusters: {
-        clusterId: {
-          udp: 'testUDP',
+        clusterA: {
+          udp: ['udp-urlA'],
+          tcp: ['tcp-urlA'],
+          xtls: ['xtls-urlA'],
+          isVideoMesh: false,
         },
       },
-    };
-    const getClustersResult = {
-      clusters: {clusterId: 'cluster'},
       joinCookie: {id: 'id'},
     };
 
-    reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
-    (reachability as any).performReachabilityChecks = sinon.stub().returns(reachabilityResults);
+    reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
 
-    const result = await reachability.gatherReachability();
+    const resultPromise = reachability.gatherReachability('test');
 
-    assert.equal(result, reachabilityResults);
+    await testUtils.flushPromises();
 
-    const storedResultForReachabilityResult = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.result'
-    );
-    const storedResultForJoinCookie = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.joinCookie'
-    );
+    // trigger a mock result event
+    mockClusterReachabilityInstances['clusterA'].emitFakeResult('udp', {
+      result: 'reachable',
+      clientMediaIPs: ['64.103.40.20'],
+      latencyInMilliseconds: 11,
+    });
+    // followed by some updates to client media IPs
+    mockClusterReachabilityInstances['clusterA'].emitFakeClientMediaIpUpdate('udp', '64.103.40.21');
+    mockClusterReachabilityInstances['clusterA'].emitFakeClientMediaIpUpdate('udp', '64.103.40.22');
+
+    // wait for the final overall timeout
+    clock.tick(15000);
+    await resultPromise;
 
-    assert.equal(JSON.stringify(result), storedResultForReachabilityResult);
-    assert.equal(JSON.stringify(getClustersResult.joinCookie), storedResultForJoinCookie);
+    // check that the reachability results contain all the client media ips
+    await checkResults(
+      {
+        clusterA: {
+          udp: {
+            result: 'reachable',
+            clientMediaIPs: ['64.103.40.20', '64.103.40.21', '64.103.40.22'],
+            latencyInMilliseconds: 11,
+          },
+          tcp: {result: 'unreachable'},
+          xtls: {result: 'unreachable'},
+          isVideoMesh: false,
+        },
+      },
+      mockGetClustersResult.joinCookie
+    );
   });
 
   it('keeps the stored reachability from previous call to gatherReachability if getClusters fails', async () => {
     const reachability = new Reachability(webex);
 
-    const reachabilityResults = {
-      clusters: {
-        clusterId: {
-          udp: 'testUDP',
-        },
-      },
-    };
-    const getClustersResult = {
-      clusters: {clusterId: 'cluster'},
-      joinCookie: {id: 'id'},
-    };
-
     reachability.reachabilityRequest.getClusters = sinon.stub().throws();
 
-    const result = await reachability.gatherReachability();
+    const result = await reachability.gatherReachability('test');
 
     assert.empty(result);
 
-    const storedResultForReachabilityResult = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.result'
-    );
-    const storedResultForJoinCookie = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.joinCookie'
-    );
-
-    assert.equal(JSON.stringify({old: 'results'}), storedResultForReachabilityResult);
-    assert.equal(JSON.stringify({old: 'joinCookie'}), storedResultForJoinCookie);
+    await checkResults({old: 'results'}, {old: 'joinCookie'});
   });
 
   it('keeps the stored reachability from previous call to gatherReachability if performReachabilityChecks fails', async () => {
     const reachability = new Reachability(webex);
 
-    const reachabilityResults = {
-      clusters: {
-        clusterId: {
-          udp: 'testUDP',
-        },
-      },
-    };
     const getClustersResult = {
       clusters: {clusterId: 'cluster'},
-      joinCookie: {id: 'id'},
+      joinCookie: {id: 'cookie id'},
     };
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
     (reachability as any).performReachabilityChecks = sinon.stub().throws();
 
-    const result = await reachability.gatherReachability();
+    const result = await reachability.gatherReachability('test');
 
     assert.empty(result);
 
-    const storedResultForReachabilityResult = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.result'
-    );
-    const storedResultForJoinCookie = await webex.boundedStorage.get(
-      'Reachability',
-      'reachability.joinCookie'
-    );
-
-    assert.equal(JSON.stringify({old: 'results'}), storedResultForReachabilityResult);
-    assert.equal(JSON.stringify({old: 'joinCookie'}), storedResultForJoinCookie);
+    await checkResults({old: 'results'}, {id: 'cookie id'});
   });
 
   it('starts ClusterReachability on each media cluster', async () => {
@@ -561,14 +1473,10 @@ describe('gatherReachability', () => {
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    const startStub = sinon.stub().resolves({});
-    const clusterReachabilityCtorStub = sinon
-      .stub(ClusterReachabilityModule, 'ClusterReachability')
-      .callsFake(() => ({
-        start: startStub,
-      }));
+    const promise = reachability.gatherReachability('test');
 
-    await reachability.gatherReachability();
+    await simulateTimeout();
+    await promise;
 
     assert.calledTwice(clusterReachabilityCtorStub);
     assert.calledWith(clusterReachabilityCtorStub, 'cluster 1', {
@@ -585,7 +1493,8 @@ describe('gatherReachability', () => {
       isVideoMesh: true,
     });
 
-    assert.calledTwice(startStub);
+    assert.calledOnce(mockClusterReachabilityInstances['cluster 1'].start);
+    assert.calledOnce(mockClusterReachabilityInstances['cluster 2'].start);
   });
 
   it('does not do TCP reachability if it is disabled in config', async () => {
@@ -610,13 +1519,9 @@ describe('gatherReachability', () => {
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    const clusterReachabilityCtorStub = sinon
-      .stub(ClusterReachabilityModule, 'ClusterReachability')
-      .callsFake(() => ({
-        start: sinon.stub().resolves({}),
-      }));
-
-    await reachability.gatherReachability();
+    const promise = reachability.gatherReachability('test');
+    await simulateTimeout();
+    await promise;
 
     assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
       isVideoMesh: false,
@@ -648,13 +1553,10 @@ describe('gatherReachability', () => {
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    const clusterReachabilityCtorStub = sinon
-      .stub(ClusterReachabilityModule, 'ClusterReachability')
-      .callsFake(() => ({
-        start: sinon.stub().resolves({}),
-      }));
+    const promise = reachability.gatherReachability('test');
 
-    await reachability.gatherReachability();
+    await simulateTimeout();
+    await promise;
 
     assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
       isVideoMesh: false,
@@ -686,13 +1588,10 @@ describe('gatherReachability', () => {
 
     reachability.reachabilityRequest.getClusters = sinon.stub().returns(getClustersResult);
 
-    const clusterReachabilityCtorStub = sinon
-      .stub(ClusterReachabilityModule, 'ClusterReachability')
-      .callsFake(() => ({
-        start: sinon.stub().resolves({}),
-      }));
+    const promise = reachability.gatherReachability('test');
 
-    await reachability.gatherReachability();
+    await simulateTimeout();
+    await promise;
 
     assert.calledOnceWithExactly(clusterReachabilityCtorStub, 'cluster name', {
       isVideoMesh: false,
@@ -701,6 +1600,70 @@ describe('gatherReachability', () => {
       xtls: [], // empty list because TLS is disabled in config
     });
   });
+
+  it('retry of getClusters is succesfull', 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);
+
+    let getClustersCallCount = 0;
+    
+    reachability.reachabilityRequest.getClusters = sinon.stub().callsFake(() => {
+      getClustersCallCount++;
+
+      if (getClustersCallCount == 1) {
+        throw new Error('fake error');
+      }
+      
+      return getClustersResult;
+    });
+
+    const promise = reachability.gatherReachability('test');
+
+    await simulateTimeout();
+    await promise;
+    
+    assert.equal(getClustersCallCount, 2);
+
+    assert.calledOnce(clusterReachabilityCtorStub);
+  });
+
+  it('two failed calls to getClusters', async () => {
+    const reachability = new Reachability(webex);
+
+    let getClustersCallCount = 0;
+    
+    reachability.reachabilityRequest.getClusters = sinon.stub().callsFake(() => {
+      getClustersCallCount++;
+
+      throw new Error('fake error');
+    });
+
+    const promise = reachability.gatherReachability('test');
+
+    await simulateTimeout();
+    
+    await promise;
+    
+    assert.equal(getClustersCallCount, 2);
+
+    assert.neverCalledWith(clusterReachabilityCtorStub);
+  });
 });
 
 describe('getReachabilityResults', () => {
@@ -1033,3 +1996,307 @@ describe('getReachabilityMetrics', () => {
     );
   });
 });
+
+class TestReachability extends Reachability {
+  constructor(webex: object) {
+    super(webex);
+  }
+
+  public testGetStatistics(
+    results: Array<ClusterReachabilityModule.ClusterReachabilityResult & {isVideoMesh: boolean}>,
+    protocol: 'udp' | 'tcp' | 'xtls',
+    isVideoMesh: boolean
+  ) {
+    return this.getStatistics(results, protocol, isVideoMesh);
+  }
+
+  public testSendMetric() {
+    return this.sendMetric();
+  }
+
+  public setFakeClusterReachability(fakeClusterReachability) {
+    this.clusterReachability = fakeClusterReachability;
+  }
+}
+
+describe('getStatistics', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+  });
+
+  it('takes values from the correct protocol', () => {
+    const results = [
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+        },
+        tcp: {
+          result: 'reachable',
+          latencyInMilliseconds: 1010,
+        },
+        xtls: {
+          result: 'reachable',
+          latencyInMilliseconds: 2010,
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 20,
+        },
+        tcp: {
+          result: 'reachable',
+          latencyInMilliseconds: 1020,
+        },
+        xtls: {
+          result: 'reachable',
+          latencyInMilliseconds: 2020,
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 30,
+        },
+        tcp: {
+          result: 'reachable',
+          latencyInMilliseconds: 1030,
+        },
+        xtls: {
+          result: 'reachable',
+          latencyInMilliseconds: 2030,
+        },
+        isVideoMesh: false,
+      },
+    ];
+
+    assert.deepEqual(reachability.testGetStatistics(results, 'udp', false), {
+      min: 10,
+      max: 30,
+      average: 20,
+    });
+    assert.deepEqual(reachability.testGetStatistics(results, 'tcp', false), {
+      min: 1010,
+      max: 1030,
+      average: 1020,
+    });
+    assert.deepEqual(reachability.testGetStatistics(results, 'xtls', false), {
+      min: 2010,
+      max: 2030,
+      average: 2020,
+    });
+  });
+
+  it('filters based on isVideoMesh value', () => {
+    const results = [
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+        },
+        isVideoMesh: true,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 20,
+        },
+        isVideoMesh: true,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 30,
+        },
+        isVideoMesh: true,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 100,
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 200,
+        },
+        isVideoMesh: false,
+      },
+    ];
+
+    assert.deepEqual(reachability.testGetStatistics(results, 'udp', true), {
+      min: 10,
+      max: 30,
+      average: 20,
+    });
+    assert.deepEqual(reachability.testGetStatistics(results, 'udp', false), {
+      min: 100,
+      max: 200,
+      average: 150,
+    });
+  });
+
+  it('only takes into account "reachable" results', () => {
+    const results = [
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'unreachable',
+          latencyInMilliseconds: 100, // value put in here just for testing, in practice we wouldn't have any value here if it was unreachable
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 20,
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'untested',
+          latencyInMilliseconds: 200, // value put in here just for testing, in practice we wouldn't have any value here if it was untested
+        },
+        isVideoMesh: false,
+      },
+    ];
+
+    assert.deepEqual(reachability.testGetStatistics(results, 'udp', false), {
+      min: 10,
+      max: 20,
+      average: 15,
+    });
+  });
+
+  it('handles the case when results are empty', () => {
+    assert.deepEqual(reachability.testGetStatistics([], 'udp', false), {
+      min: -1,
+      max: -1,
+      average: -1,
+    });
+  });
+
+  it('handles the case when results are empty after filtering', () => {
+    const fakeResults = [
+      {
+        udp: {
+          result: 'untested', // it will get filtered out because of this value
+          latencyInMilliseconds: 10,
+        },
+        tcp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10, // it will get filtered out because of the tcp protocol
+        },
+        isVideoMesh: false,
+      },
+      {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+        },
+        isVideoMesh: true, // it will get filtered out because of this value
+      },
+    ];
+
+    assert.deepEqual(reachability.testGetStatistics(fakeResults, 'udp', false), {
+      min: -1,
+      max: -1,
+      average: -1,
+    });
+  });
+});
+
+describe('sendMetric', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+  });
+
+  it('works as expected', async () => {
+    // setup stub for getStatistics to return values that show what parameters it was called with,
+    // this way we can verify that the correct results of calls to getStatistics are placed
+    // in correct data fields when sendBehavioralMetric() is called
+    const getStatisticsStub = sinon
+      .stub(reachability, 'getStatistics')
+      .callsFake((results, protocol, isVideoMesh) => {
+        return {result: 'fake', protocol, isVideoMesh};
+      });
+
+    // setup fake clusterReachability results
+    reachability.setFakeClusterReachability({
+      cluster1: {
+        getResult: sinon.stub().returns({result: 'result 1'}),
+        isVideoMesh: true,
+      },
+      cluster2: {
+        getResult: sinon.stub().returns({result: 'result 2'}),
+        isVideoMesh: false,
+      },
+      cluster3: {
+        getResult: sinon.stub().returns({result: 'result 3'}),
+        isVideoMesh: false,
+      },
+    });
+
+    await reachability.sendMetric();
+
+    // each call to getStatistics should be made with all the results from all fake clusterReachability:
+    const expectedResults = [
+      {
+        result: 'result 1',
+        isVideoMesh: true,
+      },
+      {
+        result: 'result 2',
+        isVideoMesh: false,
+      },
+      {
+        result: 'result 3',
+        isVideoMesh: false,
+      },
+    ];
+
+    // check that getStatistics is called 4 times and each time with all the results
+    assert.callCount(getStatisticsStub, 4);
+    assert.alwaysCalledWith(getStatisticsStub, expectedResults, sinon.match.any, sinon.match.any);
+
+    assert.calledWith(Metrics.sendBehavioralMetric, 'js_sdk_reachability_completed', {
+      vmn_udp_result: 'fake',
+      vmn_udp_protocol: 'udp',
+      vmn_udp_isVideoMesh: true,
+
+      public_udp_result: 'fake',
+      public_udp_protocol: 'udp',
+      public_udp_isVideoMesh: false,
+
+      public_tcp_result: 'fake',
+      public_tcp_protocol: 'tcp',
+      public_tcp_isVideoMesh: false,
+
+      public_xtls_result: 'fake',
+      public_xtls_protocol: 'xtls',
+      public_xtls_isVideoMesh: false,
+    });
+  });
+});