@webex/plugin-meetings 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -10,7 +10,6 @@ import {
   NatTypeUpdatedEventData,
 } 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;
@@ -93,22 +92,6 @@ describe('ClusterReachability', () => {
     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;
 
@@ -189,44 +172,6 @@ describe('ClusterReachability', () => {
       clusterReachability.abort();
       await promise;
     });
-
-    it('emits only the first successful UDP result when enablePerUdpUrlReachability is true', async () => {
-      const perUdpClusterReachability = new ClusterReachability(
-        'testName',
-        {
-          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', () => {
@@ -291,38 +236,6 @@ describe('ClusterReachability', () => {
       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',
-        {
-          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;
-
-      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'));
-    });
   });
 
   describe('#delegation', () => {
@@ -364,43 +277,6 @@ describe('ClusterReachability', () => {
       assert.calledOnce(rpcGetResultStub);
       assert.deepEqual(result, expectedResult);
     });
-
-    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('#WebRTC peer connection setup', () => {
@@ -740,4 +616,4 @@ describe('ClusterReachability', () => {
       });
     });
   });
-});
+});

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

@@ -1,6 +1,5 @@
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
-import { CapabilityState, WebCapabilities } from '@webex/web-capabilities';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
@@ -9,7 +8,6 @@ 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 * as InternalMediaCore from '@webex/internal-media-core';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
 import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
@@ -468,13 +466,11 @@ describe('gatherReachability', () => {
   let clock;
   let clusterReachabilityCtorStub;
   let mockClusterReachabilityInstances: Record<string, MockClusterReachability>;
-  let supportsRTCPeerConnectionStub;
 
   beforeEach(async () => {
     webex = new MockWebex();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
-    supportsRTCPeerConnectionStub = sinon.stub(WebCapabilities, 'supportsRTCPeerConnection').returns(CapabilityState.CAPABLE);
 
     await webex.boundedStorage.put(
       'Reachability',
@@ -549,25 +545,6 @@ describe('gatherReachability', () => {
     await assert.isRejected(reachability.gatherReachability('test'), 'enableReachabilityChecks is disabled in config');
   });
 
-  [CapabilityState.NOT_CAPABLE, CapabilityState.UNKNOWN].forEach((capabilityState) =>
-    it(`returns empty object if WebRTC API is not available (capabilityState=${capabilityState}`, async () => {
-      supportsRTCPeerConnectionStub.returns(capabilityState);
-
-      const reachability = new Reachability(webex);
-
-      const result = await reachability.gatherReachability('test');
-
-      assert.deepEqual(result, {});
-
-      // Verify that no new reachability result was stored - old results should remain unchanged
-      // This check is mainly to ensure that we don't put any "unreachable" results into storage
-      const storedResults = await webex.boundedStorage.get('Reachability', 'reachability.result');
-      assert.equal(storedResults, JSON.stringify({old: 'results'}));
-
-      assert.equal(await reachability.isWebexMediaBackendUnreachable(), false);
-    })
-  );
-
   [
     // ========================================================================
     {
@@ -1716,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 () => {
@@ -1751,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 () => {
@@ -1786,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 () => {

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

@@ -54,8 +54,8 @@ describe('plugin-meetings', () => {
           webrtcMediaConnection: fakeMediaConnection,
         },
         mediaRequestManagers: {
-          audio: {commit: sinon.stub()},
-          video: {commit: sinon.stub()},
+          audio: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
+          video: {commit: sinon.stub(), clearPreviousRequests: sinon.stub()},
         },
         roap: {
           doTurnDiscovery: sinon.stub().resolves({
@@ -179,22 +179,26 @@ describe('plugin-meetings', () => {
       });
     });
 
-    it('does not re-request media for non-multistream meetings', async () => {
+    it('does not clear previous requests and re-request media for non-multistream meetings', async () => {
       fakeMeeting.isMultistream = false;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
+      assert.notCalled(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.notCalled(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.notCalled(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.notCalled(fakeMeeting.mediaRequestManagers.video.commit);
     });
 
-    it('does re-request media for multistream meetings', async () => {
+    it('does clear previous requests and re-request media for multistream meetings', async () => {
       fakeMeeting.isMultistream = true;
       const rm = new ReconnectionManager(fakeMeeting);
 
       await rm.reconnect();
 
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.clearPreviousRequests);
+      assert.calledOnce(fakeMeeting.mediaRequestManagers.video.clearPreviousRequests);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.audio.commit);
       assert.calledOnce(fakeMeeting.mediaRequestManagers.video.commit);
     });