@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.171

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

@@ -0,0 +1,307 @@
+import RecordingController from '@webex/plugin-meetings/src/recording-controller';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {HTTP_VERBS, SELF_POLICY} from '@webex/plugin-meetings/src/constants';
+
+
+describe('plugin-meetings', () => {
+  describe('recording-controller tests', () => {
+    describe('index', () => {
+      let request;
+
+      describe('class tests', () => {
+        it('can set and extract new values later on', () => {
+          const controller = new RecordingController({});
+          assert.isUndefined(controller.getServiceUrl());
+          assert.isUndefined(controller.getSessionId());
+          assert.isUndefined(controller.getLocusUrl());
+          assert.isUndefined(controller.getLocusId());
+          controller.set({
+            serviceUrl: 'test',
+            sessionId: 'testId',
+            locusUrl: 'test/id',
+            displayHints: [],
+          });
+          assert(controller.getServiceUrl(), 'test');
+          assert(controller.getSessionId(), 'testId');
+          assert(controller.getLocusUrl(), 'test/id');
+          assert(controller.getLocusId(), 'id');
+        });
+      });
+
+      describe('legacy locus style recording', () => {
+        const locusUrl = 'locusUrl';
+        let controller;
+
+        beforeEach(() => {
+          request = {
+            request: sinon.stub().returns(Promise.resolve()),
+          };
+
+          controller = new RecordingController(request);
+
+          controller.set({
+            locusUrl,
+            displayHints: [],
+          });
+        });
+
+        describe('startRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+            controller.setUserPolicy({[SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false});
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: false}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('stopRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.stopRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+            controller.setUserPolicy({[SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false})
+            const result = controller.stopRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can stop recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: false, paused: false}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('pauseRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+            controller.setUserPolicy({
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            });
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can pause recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: true}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('resumeRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('rejects when correct display hint is present but the policy is false', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+            controller.setUserPolicy({
+              [SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD]: false,
+            });
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+
+          it('can resume recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `${locusUrl}/controls`,
+              body: {record: {recording: true, paused: false}},
+              method: HTTP_VERBS.PATCH,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+      });
+
+      describe('recording streaming service style tests', () => {
+        let controller;
+
+        beforeEach(() => {
+          request = {
+            request: sinon.stub().returns(Promise.resolve()),
+          };
+
+          controller = new RecordingController(request);
+
+          controller.set({
+            serviceUrl: 'test',
+            sessionId: 'testId',
+            locusUrl: 'test/id',
+            displayHints: [],
+          });
+        });
+
+        describe('startRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.startRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('stopRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can start recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('pauseRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.pauseRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can pause recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+
+        describe('resumeRecording', () => {
+          it('rejects when correct display hint is not present', () => {
+            const result = controller.resumeRecording();
+
+            assert.notCalled(request.request);
+
+            assert.isRejected(result);
+          });
+
+          it('can resume recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,229 @@
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
+import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
+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('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,21 +1,25 @@
 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/';
+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'};
+      const meeting = {id: 'some meeting id'} as Meeting;
 
       const doTurnDiscoveryStub = sinon
         .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);
@@ -39,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({});
@@ -61,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,
@@ -92,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,
-      });
-    });
   });
 });