@webex/plugin-meetings 3.8.0 → 3.8.1-next.10

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

@@ -9,7 +9,9 @@ import {
   ResultEventData,
   Events,
   ClientMediaIpsUpdatedEventData,
+  NatTypeUpdatedEventData,
 } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
+import { NatType } from 'packages/@webex/plugin-meetings/dist/reachability/reachability.types';
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -17,15 +19,17 @@ describe('ClusterReachability', () => {
   let fakePeerConnection;
   let gatherIceCandidatesSpy;
 
-  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
+  const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData | NatTypeUpdatedEventData)[]> = {
     [Events.resultReady]: [],
     [Events.clientMediaIpsUpdated]: [],
+    [Events.natTypeUpdated]: [],
   };
   const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
 
   const resetEmittedEvents = () => {
     emittedEvents[Events.resultReady].length = 0;
     emittedEvents[Events.clientMediaIpsUpdated].length = 0;
+    emittedEvents[Events.natTypeUpdated].length = 0;
   };
   beforeEach(() => {
     fakePeerConnection = {
@@ -56,6 +60,10 @@ describe('ClusterReachability', () => {
     clusterReachability.on(Events.clientMediaIpsUpdated, (data: ClientMediaIpsUpdatedEventData) => {
       emittedEvents[Events.clientMediaIpsUpdated].push(data);
     });
+
+    clusterReachability.on(Events.natTypeUpdated, (data: NatTypeUpdatedEventData) => {
+      emittedEvents[Events.natTypeUpdated].push(data);
+    });
   });
 
   afterEach(() => {
@@ -166,59 +174,6 @@ describe('ClusterReachability', () => {
       assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
-    it('resolves and has correct result as soon as it finds that all udp, tcp and tls are reachable', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
-
-      // check the right events were emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 1);
-      assert.deepEqual(emittedEvents[Events.resultReady][0], {
-        protocol: 'udp',
-        result: 'reachable',
-        latencyInMilliseconds: 100,
-        clientMediaIPs: ['somePublicIp'],
-      });
-
-      // clientMediaIpsUpdated shouldn't be emitted, because the IP is already passed in the resultReady event
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 2);
-      assert.deepEqual(emittedEvents[Events.resultReady][1], {
-        protocol: 'tcp',
-        result: 'reachable',
-        latencyInMilliseconds: 200,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
-      });
-
-      // check the right event was emitted
-      assert.equal(emittedEvents[Events.resultReady].length, 3);
-      assert.deepEqual(emittedEvents[Events.resultReady][2], {
-        protocol: 'xtls',
-        result: 'reachable',
-        latencyInMilliseconds: 300,
-      });
-      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'reachable', latencyInMilliseconds: 300},
-      });
-    });
-
     it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
@@ -267,7 +222,7 @@ describe('ClusterReachability', () => {
 
       await testUtils.flushPromises();
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -285,7 +240,7 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(30);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
-      fakePeerConnection.iceConnectionState = 'complete';
+      fakePeerConnection.iceGatheringState = 'complete';
       fakePeerConnection.onicegatheringstatechange();
       await promise;
 
@@ -428,6 +383,9 @@ describe('ClusterReachability', () => {
         candidate: {type: 'relay', address: 'someTurnRelayIp', port: 443},
       });
 
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+
       await promise;
 
       assert.deepEqual(clusterReachability.getResult(), {
@@ -440,5 +398,79 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 40},
       });
     });
+
+    it('determines correctly if symmetric-nat is detected', async () => {
+      const promise = clusterReachability.start();
+
+      // generate candidates with duplicate addresses
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 1000}});
+
+      // check events emitted: there shouldn't be any natTypeUpdated emitted
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 0);
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', relatedPort: 3478, port: 2000}});
+
+      // should emit natTypeUpdated event
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.natTypeUpdated][0], {
+        natType: 'symmetric-nat',
+      });
+
+      // 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},
+      });
+
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await clock.tickAsync(10);
+
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {
+          result: 'reachable',
+          latencyInMilliseconds: 10,
+          clientMediaIPs: ['somePublicIp1'],
+        },
+        tcp: {result: 'reachable', latencyInMilliseconds: 20},
+        xtls: {result: 'reachable', latencyInMilliseconds: 20},
+      });
+    });
+
+    it('should gather correctly reached subnets', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:4.3.2.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), [
+        '1.2.3.4',
+        '4.3.2.1',
+        'someTurnRelayIp'
+      ]);
+    });
+
+    it('should store only unique subnet address', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:9000'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '1.2.3.4'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['1.2.3.4']);
+    });
   });
 });

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

@@ -538,6 +538,14 @@ describe('gatherReachability', () => {
     assert.equal(storedResultForJoinCookie, JSON.stringify(expectedJoinCookie));
   };
 
+  it('rejects if reachability is disabled in config', async () => {
+    webex.config.meetings.enableReachabilityChecks = false;
+
+    const reachability = new Reachability(webex);
+
+    await assert.isRejected(reachability.gatherReachability('test'), 'enableReachabilityChecks is disabled in config');
+  });
+
   [
     // ========================================================================
     {
@@ -1947,6 +1955,7 @@ describe('gatherReachability', () => {
         receivedEvents[event] = receivedEvents[event] + 1 || 1;
       });
     };
+    
     it('works as expected', async () => {
       setListener('reachability:stopped');
       setListener('reachability:done');
@@ -2008,6 +2017,59 @@ describe('gatherReachability', () => {
       assert.equal(receivedEvents['reachability:done'], undefined);
       assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
     });
+
+    it('does not fallback when no clusters were reached and min clusters were specified', async () => {
+      setListener('reachability:stopped');
+      setListener('reachability:done');
+      setListener('reachability:firstResultAvailable');
+
+      const mockGetClustersResult = {
+        discoveryOptions: {
+          ['early-call-min-clusters']: 1,
+        },
+        clusters: {
+          clusterA: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+          clusterB: {
+            udp: [],
+            tcp: [],
+            xtls: [],
+            isVideoMesh: false,
+          },
+        },
+        joinCookie: {id: 'id'},
+      };
+
+      reachability.reachabilityRequest.getClusters = sinon.stub().returns(mockGetClustersResult);
+
+      const gatherReachabilityFallbackSpy = sinon.spy(reachability, 'gatherReachabilityFallback');
+
+      const resultPromise = reachability.gatherReachability('test');
+
+      await testUtils.flushPromises();
+
+      reachability.stopReachability();
+
+      await resultPromise;
+
+      // simulate a lot of time passing to check that all timers were stopped and nothing else happens
+      clock.tick(99000);
+
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterA'].abort);
+      assert.calledOnceWithExactly(mockClusterReachabilityInstances['clusterB'].abort);
+
+      assert.calledOnceWithExactly(sendMetricSpy, true);
+
+      assert.equal(receivedEvents['reachability:stopped'], 1);
+      assert.equal(receivedEvents['reachability:done'], undefined);
+      assert.equal(receivedEvents['reachability:firstResultAvailable'], undefined);
+
+      assert.notCalled(gatherReachabilityFallbackSpy);
+    });
   });
 });
 
@@ -2148,6 +2210,7 @@ describe('getReachabilityMetrics', () => {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: 'unknown'
     });
   });
 
@@ -2215,6 +2278,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 1,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2276,6 +2340,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 0,
         reachability_vmn_xtls_success: 0,
         reachability_vmn_xtls_failed: 0,
+        natType: 'unknown'
       }
     );
   });
@@ -2337,6 +2402,7 @@ describe('getReachabilityMetrics', () => {
         reachability_vmn_tcp_failed: 3,
         reachability_vmn_xtls_success: 1,
         reachability_vmn_xtls_failed: 1,
+        natType: 'unknown'
       }
     );
   });
@@ -2674,3 +2740,34 @@ describe('sendMetric', () => {
     });
   });
 });
+
+describe('isSubnetReachable', () => {
+  let webex;
+  let reachability;
+
+  beforeEach(() => {
+    webex = new MockWebex();
+    reachability = new TestReachability(webex);
+
+    reachability.setFakeClusterReachability({
+      cluster1: {
+        reachedSubnets: new Set(['1.2.3.4', '2.3.4.5']),
+      },
+      cluster2: {
+        reachedSubnets: new Set(['3.4.5.6', '4.5.6.7']),
+      },
+    });
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('returns true if the subnet is reachable', () => {
+    assert(reachability.isSubnetReachable('1'));
+  });
+
+  it(`returns false if the subnet is unreachable`, () => {
+    assert(!reachability.isSubnetReachable('11'));
+  });
+});

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

@@ -12,6 +12,9 @@ describe('plugin-meetings/reachability', () => {
   let reachabilityRequest;
   let webex;
 
+  let appType;
+  let appVersion;
+
   beforeEach(() => {
     webex = new MockWebex({
       children: {
@@ -20,6 +23,14 @@ describe('plugin-meetings/reachability', () => {
       },
     });
 
+    webex.config.support = {
+      'appType': 'NetworkChecker',
+      'appVersion': '43.3.0.1',
+    }
+
+    appType = webex?.config?.support?.appType;
+    appVersion = webex?.config?.support?.appVersion;
+
     webex.meetings.clientRegion = {
       countryCode: 'US',
       regionCode: 'WEST-COAST',
@@ -56,7 +67,9 @@ describe('plugin-meetings/reachability', () => {
 
       previousReport = {
         id: 'fake previous report',
-      }
+      };
+
+
     });
 
     afterEach(() => {
@@ -79,6 +92,7 @@ describe('plugin-meetings/reachability', () => {
             'report-version': 1,
             'early-call-min-clusters': true,
           },
+          'client-environment': { components: { [appType]: appVersion } },
           'previous-report': previousReport,
           trigger: 'startup',
         },
@@ -105,6 +119,7 @@ describe('plugin-meetings/reachability', () => {
             'report-version': 1,
             'early-call-min-clusters': true,
           },
+          'client-environment': { components: { [appType]: appVersion } },
           'previous-report': previousReport,
           trigger: 'early-call/no-min-reached',
         },
@@ -114,5 +129,35 @@ describe('plugin-meetings/reachability', () => {
       assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
       assert.notCalled(webex.internal.newMetrics.callDiagnosticLatencies.measureLatency);
     });
+
+    it('sends a POST request with the correct params when appVersion is undefined', async () => {
+      // Setting appType & appVersion to undefined
+      webex.config.support.appType = undefined;
+      webex.config.support.appVersion = undefined;
+    
+      const res = await reachabilityRequest.getClusters('startup', IP_VERSION.only_ipv4, previousReport);
+      const requestParams = webex.request.getCall(0).args[0];
+    
+      assert.deepEqual(requestParams, {
+        method: 'POST',
+        resource: `clusters`,
+        api: 'calliopeDiscovery',
+        shouldRefreshAccessToken: false,
+        timeout: 3000,
+        body: {
+          ipver: IP_VERSION.only_ipv4,
+          'supported-options': {
+            'report-version': 1,
+            'early-call-min-clusters': true,
+          },
+          'previous-report': previousReport,
+          trigger: 'startup',
+        },
+      });
+    
+      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');
+    });
   });
-});
+});

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

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