@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/test/unit/spec/roap/turnDiscovery.ts

@@ -5,10 +5,8 @@ import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
-import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 
 import testUtils from '../../../utils/testUtils';
-import { IP_VERSION } from '../../../../src/constants';
 
 describe('TurnDiscovery', () => {
   let clock;
@@ -25,7 +23,6 @@ describe('TurnDiscovery', () => {
     clock = sinon.useFakeTimers();
 
     sinon.stub(Metrics, 'sendBehavioralMetric');
-    sinon.stub(MeetingUtil, 'getIpVersion').returns(IP_VERSION.unknown);
 
     mockRoapRequest = {
       sendRoap: sinon.fake.resolves({mediaConnections: FAKE_MEDIA_CONNECTIONS_FROM_LOCUS}),
@@ -33,6 +30,11 @@ describe('TurnDiscovery', () => {
 
     testMeeting = {
       id: 'fake meeting id',
+      config: {
+        experimental: {
+          enableTurnDiscovery: true,
+        },
+      },
       correlationId: 'fake correlation id',
       selfUrl: 'fake self url',
       mediaId: 'fake media id',
@@ -48,11 +50,7 @@ describe('TurnDiscovery', () => {
         testMeeting.roapSeq = newSeq;
       }),
       updateMediaConnections: sinon.stub(),
-      webex: {meetings: {reachability: {
-        isAnyPublicClusterReachable: () => Promise.resolve(false),
-      }}},
-      isMultistream: false,
-      locusMediaRequest: { fake: true },
+      webex: {meetings: {reachability: {isAnyClusterReachable: () => false}}},
     };
   });
 
@@ -69,26 +67,19 @@ describe('TurnDiscovery', () => {
     await testUtils.flushPromises();
 
     assert.calledOnce(mockRoapRequest.sendRoap);
-
-    const expectedSendRoapArgs: any = {
+    assert.calledWith(mockRoapRequest.sendRoap, {
       roapMessage: {
         messageType,
         version: '2',
         seq: expectedSeq,
       },
+      correlationId: testMeeting.correlationId,
       locusSelfUrl: testMeeting.selfUrl,
       mediaId: expectedMediaId,
       audioMuted: testMeeting.audio?.isLocallyMuted(),
       videoMuted: testMeeting.video?.isLocallyMuted(),
       meetingId: testMeeting.id,
-      locusMediaRequest: testMeeting.locusMediaRequest,
-    };
-
-    if (messageType === 'TURN_DISCOVERY_REQUEST') {
-      expectedSendRoapArgs.ipVersion = 0;
-    }
-    
-    assert.calledWith(mockRoapRequest.sendRoap, expectedSendRoapArgs);
+    });
 
     if (messageType === 'TURN_DISCOVERY_REQUEST') {
       // check also that we've applied the media connections from the response
@@ -110,82 +101,39 @@ describe('TurnDiscovery', () => {
   };
 
   describe('doTurnDiscovery', () => {
-    [false, true].forEach(function (enabledMultistream ) {
-      it('sends TURN_DISCOVERY_REQUEST'+  (enabledMultistream ? ' when enable Multistream':'') + ', waits for response and sends OK', async () => {
-        testMeeting.isMultistream = enabledMultistream;
-
-        const td = new TurnDiscovery(mockRoapRequest);
-
-        const result = td.doTurnDiscovery(testMeeting, false);
-
-        // check that TURN_DISCOVERY_REQUEST was sent
-        await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
-
-        // @ts-ignore
-        mockRoapRequest.sendRoap.resetHistory();
-
-        // simulate the response
-        td.handleTurnDiscoveryResponse({
-          headers: [
-            `x-cisco-turn-url=${FAKE_TURN_URL}`,
-            `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
-            `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-          ]
-        });
-
-        await testUtils.flushPromises();
-
-        // check that we've sent OK
-        await checkRoapMessageSent('OK', 0);
-
-        const {turnServerInfo, turnDiscoverySkippedReason} = await result;
-
-        assert.deepEqual(turnServerInfo, {
-          url: FAKE_TURN_URL,
-          username: FAKE_TURN_USERNAME,
-          password: FAKE_TURN_PASSWORD
-        });
-
-        assert.isUndefined(turnDiscoverySkippedReason);
-      });
-    });
-
-    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK when isForced = true when cluster is reachable', async () => {
-      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
-      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = sinon.stub().resolves(true);
-
+    it('sends TURN_DISCOVERY_REQUEST, waits for response and sends OK', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
-      const result = td.doTurnDiscovery(testMeeting, false, true);
 
-      // We ignore reachability results so we don't get skip reason
-      assert.notCalled(testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable);
+      const result = td.doTurnDiscovery(testMeeting, false);
 
       // check that TURN_DISCOVERY_REQUEST was sent
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
       // @ts-ignore
       mockRoapRequest.sendRoap.resetHistory();
+
       // simulate the response
       td.handleTurnDiscoveryResponse({
         headers: [
           `x-cisco-turn-url=${FAKE_TURN_URL}`,
           `x-cisco-turn-username=${FAKE_TURN_USERNAME}`,
           `x-cisco-turn-password=${FAKE_TURN_PASSWORD}`,
-        ]
+        ],
       });
+
       await testUtils.flushPromises();
+
       // check that we've sent OK
       await checkRoapMessageSent('OK', 0);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = await result;
+
       assert.deepEqual(turnServerInfo, {
         url: FAKE_TURN_URL,
         username: FAKE_TURN_USERNAME,
-        password: FAKE_TURN_PASSWORD
+        password: FAKE_TURN_PASSWORD,
       });
-      assert.isUndefined(turnDiscoverySkippedReason);
 
-      // restore previous callback
-      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
+      assert.isUndefined(turnDiscoverySkippedReason);
     });
 
     it('sends TURN_DISCOVERY_REQUEST with empty mediaId when isReconnecting is true', async () => {
@@ -259,6 +207,24 @@ describe('TurnDiscovery', () => {
       assert.isUndefined(turnDiscoverySkippedReason);
     });
 
+    it('resolves with undefined if turn discovery feature is disabled in config', async () => {
+      const prevConfigValue = testMeeting.config.experimental.enableTurnDiscovery;
+
+      testMeeting.config.experimental.enableTurnDiscovery = false;
+      // @ts-ignore
+      const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
+
+      const {turnServerInfo, turnDiscoverySkippedReason} = result;
+
+      assert.isUndefined(turnServerInfo);
+      assert.equal(turnDiscoverySkippedReason, 'config');
+      assert.notCalled(mockRoapRequest.sendRoap);
+      assert.notCalled(Metrics.sendBehavioralMetric);
+
+      // restore previous config
+      testMeeting.config.experimental.enableTurnDiscovery = prevConfigValue;
+    });
+
     it('resolves with undefined if sending the request fails', async () => {
       const td = new TurnDiscovery(mockRoapRequest);
 
@@ -274,8 +240,8 @@ describe('TurnDiscovery', () => {
     });
 
     it('resolves with undefined when cluster is reachable', async () => {
-      const prev = testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable;
-      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = () => Promise.resolve(true);
+      const prev = testMeeting.webex.meetings.reachability.isAnyClusterReachable;
+      testMeeting.webex.meetings.reachability.isAnyClusterReachable = () => true;
       const result = await new TurnDiscovery(mockRoapRequest).doTurnDiscovery(testMeeting);
 
       const {turnServerInfo, turnDiscoverySkippedReason} = result;
@@ -284,7 +250,7 @@ describe('TurnDiscovery', () => {
       assert.equal(turnDiscoverySkippedReason, 'reachability');
       assert.notCalled(mockRoapRequest.sendRoap);
       assert.notCalled(Metrics.sendBehavioralMetric);
-      testMeeting.webex.meetings.reachability.isAnyPublicClusterReachable = prev;
+      testMeeting.webex.meetings.reachability.isAnyClusterReachable = prev;
     });
 
     it("resolves with undefined if we don't get a response within 10s", async () => {
@@ -306,8 +272,6 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
-      await testUtils.flushPromises();
-
       // simulate the response without the password
       td.handleTurnDiscoveryResponse({
         headers: [
@@ -327,8 +291,6 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
-      await testUtils.flushPromises();
-
       // simulate the response without the headers
       td.handleTurnDiscoveryResponse({});
 
@@ -344,8 +306,6 @@ describe('TurnDiscovery', () => {
       const td = new TurnDiscovery(mockRoapRequest);
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
-      await testUtils.flushPromises();
-
       // simulate the response without the headers
       td.handleTurnDiscoveryResponse({headers: []});
 
@@ -362,8 +322,6 @@ describe('TurnDiscovery', () => {
 
       const turnDiscoveryPromise = td.doTurnDiscovery(testMeeting, false);
 
-      await testUtils.flushPromises();
-
       // check that TURN_DISCOVERY_REQUEST was sent
       await checkRoapMessageSent('TURN_DISCOVERY_REQUEST', 0);
       // @ts-ignore
@@ -396,11 +354,15 @@ describe('TurnDiscovery', () => {
 
   describe('isSkipped', () => {
     [
-      {isAnyPublicClusterReachable: true, expectedIsSkipped: true},
-      {isAnyPublicClusterReachable: false, expectedIsSkipped: false},
-    ].forEach(({isAnyPublicClusterReachable, expectedIsSkipped}) => {
-      it(`returns ${expectedIsSkipped} when isAnyPublicClusterReachable() returns ${isAnyPublicClusterReachable ? 'true' : 'false'}`, async () => {
-        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyPublicClusterReachable').resolves(isAnyPublicClusterReachable);
+      {enabledInConfig: true, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: true, isAnyClusterReachable: false, expectedIsSkipped: false},
+      {enabledInConfig: false, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: false, isAnyClusterReachable: false, expectedIsSkipped: true},
+    ].forEach(({enabledInConfig, isAnyClusterReachable, expectedIsSkipped}) => {
+      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyClusterReachable() returns ${isAnyClusterReachable ? 'true' : 'false'}`, async () => {
+        testMeeting.config.experimental.enableTurnDiscovery = enabledInConfig;
+
+        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyClusterReachable').resolves(isAnyClusterReachable);
 
         const td = new TurnDiscovery(mockRoapRequest);
 

package/test/unit/spec/roap/util.js

@@ -0,0 +1,30 @@
+import 'jsdom-global/register';
+import {assert} from '@webex/test-helper-chai';
+import RoapUtil from '@webex/plugin-meetings/src/roap/util';
+import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager/index';
+import sinon from 'sinon';
+
+describe('RoapUtil', () => {
+  describe('updatePeerConnection', () => {
+    let meeting, session;
+
+    beforeEach('stub PeerConnectionManager', () => {
+      meeting = {
+        mediaProperties: {
+          peerConnection: {name: 'peer-connection'},
+        },
+        roap: {
+          lastRoapOffer: 'lastRoapOffer',
+        },
+      };
+      session = {OFFER: {sdps: ['sdp1', 'sdp2']}};
+
+      PeerConnectionManager.updatePeerConnection = sinon.stub().returns(Promise.resolve());
+    });
+
+    it('should just call PeerConnection.updatePeerConnection', async () => {
+      await RoapUtil.updatePeerConnection(meeting, session);
+      assert.calledOnce(PeerConnectionManager.updatePeerConnection);
+    });
+  });
+});