@webex/plugin-meetings 3.0.0-beta.21 → 3.0.0-beta.211

package/test/unit/spec/recording-controller/util.js

@@ -1,102 +1,229 @@
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
 import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
-import { assert } from 'chai';
+import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
+
+import {assert} from 'chai';
 
 describe('plugin-meetings', () => {
-    describe('recording-controller tests', () => {
-        describe('recording util tests', () => {
-
-            let locusInfo;
-        
-            beforeEach(() => {
-              locusInfo = {
-                parsedLocus: {
-                  info: {
-                    userDisplayHints: [],
-                  },
-                },
-              };
-            });
-        
-            describe('canUserStart', () => {
-              it('can start recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
-
-                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserPause', () => {
-              it('can pause recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
-
-                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserStop', () => {
-              it('can stop recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
-
-                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('canUserResume', () => {
-              it('can start recording when the correct display hint is present', () => {
-                locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
-
-                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), true);
-              });
-        
-              it('rejects when correct display hint is not present', () => {
-                assert.equal(RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints), false);
-              });
-            });
-
-            describe('deriveRecordingStates', () => {
-              it('gets the correct values for a start recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Start), {recording: true, paused: false});
-              });
-
-              it('gets the correct values for a stop recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Stop), {recording: false, paused: false});
-              });
-
-              it('gets the correct values for a resume recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Resume), {recording: true, paused: false});
-              });
-
-              it('gets the correct values for a paused recording action', () => {
-                assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Pause), {recording: true, paused: true});
-              });
-            });
-
-            describe('extractLocusId', () => {
-              it('gets the correct id from the url param', () => {
-                assert.equal(RecordingUtil.extractLocusId('test/id'), 'id');
-              });
-
-              it('works with empty string parameters passed', () => {
-                assert.equal(RecordingUtil.extractLocusId(''), '');
-              });
-
-              it('works with no parameters passed', () => {
-                assert.isUndefined(RecordingUtil.extractLocusId(undefined));
-              });
-            });
+  describe('recording-controller tests', () => {
+    describe('recording util tests', () => {
+      let locusInfo;
+
+      beforeEach(() => {
+        locusInfo = {
+          parsedLocus: {
+            info: {
+              userDisplayHints: [],
+            },
+          },
+        };
+      });
+
+      describe('canUserStart', () => {
+        it('can start recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can start recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+
+          assert.equal(
+            RecordingUtil.canUserStart(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserPause', () => {
+        it('can pause recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can pause recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+
+          assert.equal(
+            RecordingUtil.canUserPause(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserStop', () => {
+        it('can stop recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can stop recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP', {
+            [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+          });
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP', {
+            [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+          });
+
+          assert.equal(
+            RecordingUtil.canUserStop(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('canUserResume', () => {
+        it('can start recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can start recording when the correct display hint is present and the policy is true', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: true,
+            }),
+            true
+          );
+        });
+
+        it('rejects when correct display hint is not present', () => {
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            false
+          );
+        });
+
+        it('rejects when correct display hint is present but the policy is false', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints, {
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            }),
+            false
+          );
+        });
+      });
+
+      describe('deriveRecordingStates', () => {
+        it('gets the correct values for a start recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Start), {
+            recording: true,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a stop recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Stop), {
+            recording: false,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a resume recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Resume), {
+            recording: true,
+            paused: false,
+          });
+        });
+
+        it('gets the correct values for a paused recording action', () => {
+          assert.deepEqual(RecordingUtil.deriveRecordingStates(RecordingAction.Pause), {
+            recording: true,
+            paused: true,
+          });
+        });
+      });
+
+      describe('extractLocusId', () => {
+        it('gets the correct id from the url param', () => {
+          assert.equal(RecordingUtil.extractLocusId('test/id'), 'id');
+        });
+
+        it('works with empty string parameters passed', () => {
+          assert.equal(RecordingUtil.extractLocusId(''), '');
+        });
+
+        it('works with no parameters passed', () => {
+          assert.isUndefined(RecordingUtil.extractLocusId(undefined));
         });
+      });
     });
-});
+  });
+});

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

@@ -1,6 +1,7 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
+import MockWebex from '@webex/test-helper-mock-webex';
 
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import Roap from '@webex/plugin-meetings/src/roap/';
@@ -9,6 +10,8 @@ import Meeting from '@webex/plugin-meetings/src/meeting';
 describe('Roap', () => {
   describe('doTurnDiscovery', () => {
     it('calls this.turnDiscovery.doTurnDiscovery() and forwards all the arguments', async () => {
+      const webex = new MockWebex({});
+
       const RESULT = {something: 'some value'};
       const meeting = {id: 'some meeting id'} as Meeting;
 
@@ -16,7 +19,7 @@ describe('Roap', () => {
         .stub(TurnDiscovery.prototype, 'doTurnDiscovery')
         .resolves(RESULT);
 
-      const roap = new Roap({}, {parent: 'fake'});
+      const roap = new Roap({}, {parent: webex});
 
       // call with isReconnecting: true
       const result = await roap.doTurnDiscovery(meeting, true);
@@ -40,17 +43,25 @@ describe('Roap', () => {
     let sendRoapStub;
     let meeting;
 
+    let webex;
+
     beforeEach(() => {
+      webex = new MockWebex({});
       meeting = {
         id: 'some meeting id',
         correlationId: 'correlation id',
         selfUrl: 'self url',
         mediaId: 'media id',
-        isMultistream: false,
-        isAudioMuted: () => true,
-        isVideoMuted: () => false,
+        audio:{
+          isLocallyMuted: () => true,
+        },
+        video:{
+          isLocallyMuted: () => false,
+        },
         setRoapSeq: sinon.stub(),
         config: {experimental: {enableTurnDiscovery: false}},
+        locusMediaRequest: {fake: true},
+        webex: { meetings: { reachability: { isAnyClusterReachable: () => true}}},
       };
 
       sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
@@ -62,19 +73,19 @@ describe('Roap', () => {
     });
 
     [
-      {reconnect: true, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: true, enableTurnDiscovery: false, expectEmptyMediaId: true},
-      {reconnect: false, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: false, enableTurnDiscovery: false, expectEmptyMediaId: false},
-    ].forEach(({reconnect, enableTurnDiscovery, expectEmptyMediaId}) =>
+      {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+      {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
+      {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+      {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
+    ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
       it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
         reconnect ? '' : 'not '
       }reconnecting and TURN discovery is ${
-        enableTurnDiscovery ? 'enabled' : 'disabled'
+        turnDiscoverySkipped ? 'skipped' : 'not skipped'
       }`, async () => {
-        meeting.config.experimental.enableTurnDiscovery = enableTurnDiscovery;
+        const roap = new Roap({}, {parent: webex});
 
-        const roap = new Roap({}, {parent: 'fake'});
+        sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(turnDiscoverySkipped);
 
         await roap.sendRoapMediaRequest({
           meeting,
@@ -93,50 +104,14 @@ describe('Roap', () => {
         };
 
         assert.calledOnce(sendRoapStub);
-        assert.calledWith(sendRoapStub, {
+        assert.calledWith(sendRoapStub, sinon.match({
           roapMessage: expectedRoapMessage,
-          correlationId: meeting.correlationId,
           locusSelfUrl: meeting.selfUrl,
           mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
           meetingId: meeting.id,
-          preferTranscoding: true,
-        });
+          locusMediaRequest: meeting.locusMediaRequest,
+        }));
       })
     );
-    it('sends roap request with preferTranscoding=false for multistream meetings', async () => {
-      const roap = new Roap({}, {parent: 'fake'});
-
-      meeting.isMultistream = true;
-
-      await roap.sendRoapMediaRequest({
-        meeting,
-        sdp: 'sdp',
-        reconnect: false,
-        seq: 10,
-        tieBreaker: 1,
-      });
-
-      const expectedRoapMessage = {
-        messageType: 'OFFER',
-        sdps: ['sdp'],
-        version: '2',
-        seq: 10,
-        tieBreaker: 1,
-      };
-
-      assert.calledOnce(sendRoapStub);
-      assert.calledWith(sendRoapStub, {
-        roapMessage: expectedRoapMessage,
-        correlationId: meeting.correlationId,
-        locusSelfUrl: meeting.selfUrl,
-        mediaId: meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
-        meetingId: meeting.id,
-        preferTranscoding: false,
-      });
-    });
   });
 });