@webex/plugin-meetings 3.10.0-next.3 → 3.10.0-next.30

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

@@ -1,17 +1,16 @@
 import {assert} from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import testUtils from '../../../utils/testUtils';
 
-// packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
 import {
   ClusterReachability,
   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';
+} from '@webex/plugin-meetings/src/reachability/clusterReachability';
+import {ReachabilityPeerConnection} from '@webex/plugin-meetings/src/reachability/reachabilityPeerConnection';
+import {ReachabilityPeerConnectionEvents} from '@webex/plugin-meetings/src/reachability/reachability.types';
 
 describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
@@ -49,7 +48,7 @@ describe('ClusterReachability', () => {
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
 
-    gatherIceCandidatesSpy = sinon.spy(clusterReachability, 'gatherIceCandidates');
+    gatherIceCandidatesSpy = sinon.spy(clusterReachability.reachabilityPeerConnection as any, 'gatherIceCandidates');
 
     resetEmittedEvents();
 
@@ -70,75 +69,341 @@ describe('ClusterReachability', () => {
     global.RTCPeerConnection = previousRTCPeerConnection;
   });
 
-  it('should create an instance correctly', () => {
+  it('should create an instance correctly with provided cluster info', () => {
     assert.instanceOf(clusterReachability, ClusterReachability);
     assert.equal(clusterReachability.name, 'testName');
     assert.equal(clusterReachability.isVideoMesh, false);
-    assert.equal(clusterReachability.numUdpUrls, 2);
-    assert.equal(clusterReachability.numTcpUrls, 2);
+    assert.instanceOf(clusterReachability.reachabilityPeerConnection, ReachabilityPeerConnection);
   });
 
-  it('should create a peer connection with the right config', () => {
-    assert.calledOnceWithExactly(global.RTCPeerConnection, {
-      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'],
-        },
+  it('should initialize reachedSubnets as empty set', () => {
+    assert.instanceOf(clusterReachability.reachedSubnets, Set);
+    assert.equal(clusterReachability.reachedSubnets.size, 0);
+  });
+
+  it('returns correct results before start() is called', () => {
+    assert.deepEqual(clusterReachability.getResult(), {
+      udp: {result: 'untested'},
+      tcp: {result: 'untested'},
+      xtls: {result: 'untested'},
+    });
+
+    // verify that no events were emitted
+    assert.deepEqual(emittedEvents[Events.resultReady], []);
+    assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
+  });
+
+  it('should create separate peer connections when enablePerUdpUrlReachability is true', () => {
+    const perUdpClusterReachability = new ClusterReachability(
+      'testName',
+      {
+        isVideoMesh: false,
+        udp: ['stun:udp1', 'stun:udp2'],
+        tcp: ['stun:tcp1.webex.com'],
+        xtls: ['stun:xtls1.webex.com'],
+      },
+      true
+    );
+
+    assert.equal((perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp.length, 2);
+    assert.instanceOf((perUdpClusterReachability as any).reachabilityPeerConnection, ReachabilityPeerConnection);
+  });
+
+  describe('#event relaying', () => {
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    it('relays resultReady event from ReachabilityPeerConnection', async () => {
+      const promise = clusterReachability.start();
+
+      await testUtils.flushPromises();
+
+      // Simulate RPC emitting resultReady
+      await clock.tickAsync(50);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      // ClusterReachability should relay the event
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.deepEqual(emittedEvents[Events.resultReady][0], {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 50,
+        clientMediaIPs: ['somePublicIp1'],
+      });
+
+      clusterReachability.abort();
+      await promise;
+    });
+
+    it('relays clientMediaIpsUpdated event from ReachabilityPeerConnection', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      // First IP found - only resultReady emitted
+      assert.equal(emittedEvents[Events.resultReady].length, 1);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 0);
+      resetEmittedEvents();
+
+      // New IP found - should emit clientMediaIpsUpdated
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
+
+      assert.equal(emittedEvents[Events.resultReady].length, 0);
+      assert.equal(emittedEvents[Events.clientMediaIpsUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated][0], {
+        protocol: 'udp',
+        clientMediaIPs: ['somePublicIp1', 'somePublicIp2'],
+      });
+
+      clusterReachability.abort();
+      await promise;
+    });
+
+    it('relays natTypeUpdated event from ReachabilityPeerConnection', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', port: 1000, relatedPort: 3478}});
+
+      // No NAT detection yet (only 1 candidate)
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 0);
+
+      // Second candidate with same address but different port - indicates symmetric NAT
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1', port: 2000, relatedPort: 3478}});
+
+      assert.equal(emittedEvents[Events.natTypeUpdated].length, 1);
+      assert.deepEqual(emittedEvents[Events.natTypeUpdated][0], {
+        natType: 'symmetric-nat',
+      });
+
+      clusterReachability.abort();
+      await promise;
+    });
+
+    it('emits only the first successful UDP result when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
         {
-          username: 'webexturnreachuser',
-          credential: 'webexturnreachpwd',
-          urls: ['turns:xtls1.webex.com?transport=tcp'],
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: [],
+          xtls: [],
         },
+        true
+      );
+
+      const udpEvents: ResultEventData[] = [];
+      perUdpClusterReachability.on(Events.resultReady, (data: ResultEventData) => {
+        udpEvents.push(data);
+      });
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+
+      udpRpc1.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.resultReady, {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 50,
+        clientMediaIPs: ['1.1.1.1'],
+      });
+
+      udpRpc2.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.resultReady, {
+        protocol: 'udp',
+        result: 'reachable',
+        latencyInMilliseconds: 30,
+        clientMediaIPs: ['2.2.2.2'],
+      });
+
+      assert.equal(udpEvents.length, 1);
+      assert.equal(udpEvents[0].latencyInMilliseconds, 50);
+    });
+  });
+
+  describe('#subnet collection', () => {
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    it('collects reached subnets from ReachabilityPeerConnection events', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:192.168.1.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:10.0.0.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'relay.server.ip'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.equal(clusterReachability.reachedSubnets.size, 3);
+      assert.isTrue(clusterReachability.reachedSubnets.has('192.168.1.1'));
+      assert.isTrue(clusterReachability.reachedSubnets.has('10.0.0.1'));
+      assert.isTrue(clusterReachability.reachedSubnets.has('relay.server.ip'));
+    });
+
+    it('stores only unique subnet addresses', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:192.168.1.1:5004'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:192.168.1.1:9000'}});
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '192.168.1.1'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      // Should have only 1 unique subnet
+      assert.equal(clusterReachability.reachedSubnets.size, 1);
+      assert.isTrue(clusterReachability.reachedSubnets.has('192.168.1.1'));
+    });
+
+    it('accumulates subnets from multiple candidates', async () => {
+      const promise = clusterReachability.start();
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:192.168.1.1:5004'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:10.0.0.1:5004'}});
+
+      await clock.tickAsync(10);
+      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '172.16.0.1'}});
+
+      clusterReachability.abort();
+      await promise;
+
+      assert.equal(clusterReachability.reachedSubnets.size, 3);
+      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['192.168.1.1', '10.0.0.1', '172.16.0.1']);
+    });
+
+    it('collects reached subnets from all peer connections when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
         {
-          username: 'webexturnreachuser',
-          credential: 'webexturnreachpwd',
-          urls: ['turns:xtls2.webex.com:443?transport=tcp'],
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: ['stun:tcp1.webex.com'],
+          xtls: [],
         },
-      ],
-      iceCandidatePoolSize: 0,
-      iceTransportPolicy: 'all',
+        true
+      );
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+      const tcpTlsRpc = (perUdpClusterReachability as any).reachabilityPeerConnection;
+
+      udpRpc1.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['192.168.1.1'],
+      });
+      udpRpc2.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['10.0.0.1'],
+      });
+      tcpTlsRpc.emit({file: 'test', function: 'test'}, ReachabilityPeerConnectionEvents.reachedSubnets, {
+        subnets: ['172.16.0.1'],
+      });
+
+      assert.equal(perUdpClusterReachability.reachedSubnets.size, 3);
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('192.168.1.1'));
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('10.0.0.1'));
+      assert.isTrue(perUdpClusterReachability.reachedSubnets.has('172.16.0.1'));
     });
   });
 
-  it('should create a peer connection with the right config even if lists of urls are empty', () => {
-    (global.RTCPeerConnection as any).resetHistory();
+  describe('#delegation', () => {
+    it('delegates getResult() to ReachabilityPeerConnection', () => {
+      const rpcGetResultStub = sinon.stub(clusterReachability.reachabilityPeerConnection, 'getResult').returns({
+        udp: {result: 'reachable', latencyInMilliseconds: 42},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'untested'},
+      });
 
-    clusterReachability = new ClusterReachability('testName', {
-      isVideoMesh: false,
-      udp: [],
-      tcp: [],
-      xtls: [],
+      const result = clusterReachability.getResult();
+
+      assert.calledOnce(rpcGetResultStub);
+      assert.equal(result.udp.result, 'reachable');
+      assert.equal(result.udp.latencyInMilliseconds, 42);
     });
 
-    assert.calledOnceWithExactly(global.RTCPeerConnection, {
-      iceServers: [],
-      iceCandidatePoolSize: 0,
-      iceTransportPolicy: 'all',
+    it('delegates abort() to ReachabilityPeerConnection', () => {
+      const rpcAbortStub = sinon.stub(clusterReachability.reachabilityPeerConnection, 'abort');
+
+      clusterReachability.abort();
+
+      assert.calledOnce(rpcAbortStub);
     });
-  });
 
-  it('returns correct results before start() is called', () => {
-    assert.deepEqual(clusterReachability.getResult(), {
-      udp: {result: 'untested'},
-      tcp: {result: 'untested'},
-      xtls: {result: 'untested'},
+    it('delegates start() to ReachabilityPeerConnection and returns result', async () => {
+      const expectedResult = {
+        udp: {result: 'reachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'unreachable'},
+      };
+
+      const rpcStartStub = sinon.stub(clusterReachability.reachabilityPeerConnection, 'start').resolves();
+      const rpcGetResultStub = sinon.stub(clusterReachability.reachabilityPeerConnection, 'getResult').returns(expectedResult);
+
+      const result = await clusterReachability.start();
+
+      assert.calledOnce(rpcStartStub);
+      assert.calledOnce(rpcGetResultStub);
+      assert.deepEqual(result, expectedResult);
     });
 
-    // verify that no events were emitted
-    assert.deepEqual(emittedEvents[Events.resultReady], []);
-    assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
+    it('delegates start() and abort() to all peer connections when enablePerUdpUrlReachability is true', async () => {
+      const perUdpClusterReachability = new ClusterReachability(
+        'testName',
+        {
+          isVideoMesh: false,
+          udp: ['stun:udp1', 'stun:udp2'],
+          tcp: ['stun:tcp1.webex.com'],
+          xtls: [],
+        },
+        true
+      );
+
+      const udpRpc1 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[0];
+      const udpRpc2 = (perUdpClusterReachability as any).reachabilityPeerConnectionsForUdp[1];
+      const tcpTlsRpc = (perUdpClusterReachability as any).reachabilityPeerConnection;
+
+      const startStub1 = sinon.stub(udpRpc1, 'start').resolves({udp: {result: 'reachable'}});
+      const startStub2 = sinon.stub(udpRpc2, 'start').resolves({udp: {result: 'unreachable'}});
+      const startStubTcp = sinon.stub(tcpTlsRpc, 'start').resolves({tcp: {result: 'reachable'}});
+
+      const abortStub1 = sinon.stub(udpRpc1, 'abort');
+      const abortStub2 = sinon.stub(udpRpc2, 'abort');
+      const abortStubTcp = sinon.stub(tcpTlsRpc, 'abort');
+
+      await perUdpClusterReachability.start();
+
+      assert.calledOnce(startStub1);
+      assert.calledOnce(startStub2);
+      assert.calledOnce(startStubTcp);
+
+      perUdpClusterReachability.abort();
+
+      assert.calledOnce(abortStub1);
+      assert.calledOnce(abortStub2);
+      assert.calledOnce(abortStubTcp);
+    });
   });
 
-  describe('#start', () => {
+  describe('#WebRTC peer connection setup', () => {
     let clock;
 
     beforeEach(() => {
@@ -149,6 +414,37 @@ describe('ClusterReachability', () => {
       clock.restore();
     });
 
+    it('should create a peer connection with the right config', () => {
+      assert.calledOnceWithExactly(global.RTCPeerConnection, {
+        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: ['turns:xtls1.webex.com?transport=tcp'],
+          },
+          {
+            username: 'webexturnreachuser',
+            credential: 'webexturnreachpwd',
+            urls: ['turns:xtls2.webex.com:443?transport=tcp'],
+          },
+        ],
+        iceCandidatePoolSize: 0,
+        iceTransportPolicy: 'all',
+      });
+    });
+
     it('should initiate the ICE gathering process', async () => {
       const promise = clusterReachability.start();
 
@@ -174,6 +470,40 @@ describe('ClusterReachability', () => {
       assert.deepEqual(emittedEvents[Events.clientMediaIpsUpdated], []);
     });
 
+    it('resolves when ICE gathering is completed', async () => {
+      const promise = clusterReachability.start();
+
+      await testUtils.flushPromises();
+
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'unreachable'},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'unreachable'},
+      });
+    });
+
+    it('resolves with the right result when ICE gathering is completed', async () => {
+      const promise = clusterReachability.start();
+
+      // send 1 candidate
+      await clock.tickAsync(30);
+      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
+
+      fakePeerConnection.iceGatheringState = 'complete';
+      fakePeerConnection.onicegatheringstatechange();
+      await promise;
+
+      assert.deepEqual(clusterReachability.getResult(), {
+        udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
+        tcp: {result: 'unreachable'},
+        xtls: {result: 'unreachable'},
+      });
+    });
+
     it('resolves and returns correct results when aborted before it gets any candidates', async () => {
       const promise = clusterReachability.start();
 
@@ -216,39 +546,17 @@ describe('ClusterReachability', () => {
         xtls: {result: 'unreachable'},
       });
     });
+  });
 
-    it('resolves when ICE gathering is completed', async () => {
-      const promise = clusterReachability.start();
-
-      await testUtils.flushPromises();
-
-      fakePeerConnection.iceGatheringState = 'complete';
-      fakePeerConnection.onicegatheringstatechange();
-      await promise;
+  describe('#latency and candidate handling', () => {
+    let clock;
 
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'unreachable'},
-      });
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
     });
 
-    it('resolves with the right result when ICE gathering is completed', async () => {
-      const promise = clusterReachability.start();
-
-      // send 1 candidate
-      await clock.tickAsync(30);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
-
-      fakePeerConnection.iceGatheringState = 'complete';
-      fakePeerConnection.onicegatheringstatechange();
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'unreachable'},
-      });
+    afterEach(() => {
+      clock.restore();
     });
 
     it('should store latency only for the first srflx candidate, but IPs from all of them', async () => {
@@ -257,17 +565,16 @@ describe('ClusterReachability', () => {
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
 
-      // generate more candidates
-      await clock.tickAsync(10);
+      await clock.tickAsync(50); // total elapsed time: 60
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
 
-      await clock.tickAsync(10);
+      await clock.tickAsync(10); // total elapsed time: 70
       fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
 
       clusterReachability.abort();
       await promise;
 
-      // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
+      // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates
       assert.deepEqual(clusterReachability.getResult(), {
         udp: {
           result: 'reachable',
@@ -283,19 +590,18 @@ describe('ClusterReachability', () => {
       const promise = clusterReachability.start();
 
       await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp1'}});
-
-      // generate more candidates
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp2'}});
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'relayIp1', port: 3478},
+      });
 
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
+      await clock.tickAsync(50); // total elapsed time: 60
+      fakePeerConnection.onicecandidate({
+        candidate: {type: 'relay', address: 'relayIp2', port: 3478},
+      });
 
       clusterReachability.abort();
       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: 'reachable', latencyInMilliseconds: 10},
@@ -308,24 +614,17 @@ describe('ClusterReachability', () => {
 
       await clock.tickAsync(10);
       fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp1', port: 443},
+        candidate: {type: 'relay', address: 'relayIp1', port: 443},
       });
 
-      // generate more candidates
-      await clock.tickAsync(10);
+      await clock.tickAsync(50); // total elapsed time: 60
       fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp2', port: 443},
-      });
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({
-        candidate: {type: 'relay', address: 'someTurnRelayIp3', port: 443},
+        candidate: {type: 'relay', address: 'relayIp2', port: 443},
       });
 
       clusterReachability.abort();
       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'},
@@ -440,37 +739,5 @@ describe('ClusterReachability', () => {
         xtls: {result: 'reachable', latencyInMilliseconds: 20},
       });
     });
-
-    it('should gather correctly reached subnets', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:4.3.2.1:5004'}});
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      clusterReachability.abort();
-      await promise;
-
-      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), [
-        '1.2.3.4',
-        '4.3.2.1',
-        'someTurnRelayIp'
-      ]);
-    });
-
-    it('should store only unique subnet address', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:5004'}});
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', url: 'stun:1.2.3.4:9000'}});
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: '1.2.3.4'}});
-
-      clusterReachability.abort();
-      await promise;
-
-      assert.deepEqual(Array.from(clusterReachability.reachedSubnets), ['1.2.3.4']);
-    });
   });
-});
+});

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

@@ -1693,7 +1693,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: ['testXTLS1', 'testXTLS2'],
-    });
+    }, undefined);
   });
 
   it('does not do TLS reachability if it is disabled in config', async () => {
@@ -1728,7 +1728,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: ['testTCP1', 'testTCP2'],
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('does not do TCP or TLS reachability if it is disabled in config', async () => {
@@ -1763,7 +1763,7 @@ describe('gatherReachability', () => {
       udp: ['testUDP1', 'testUDP2'],
       tcp: [], // empty list because TCP is disabled in config
       xtls: [], // empty list because TLS is disabled in config
-    });
+    }, undefined);
   });
 
   it('retry of getClusters is succesfull', async () => {