@webex/plugin-meetings 2.37.2 → 2.38.1

package/test/unit/spec/meeting/index.js

@@ -35,6 +35,7 @@ import Media from '@webex/plugin-meetings/src/media/index';
 import PeerConnectionManager from '@webex/plugin-meetings/src/peer-connection-manager';
 import ReconnectionManager from '@webex/plugin-meetings/src/reconnection-manager';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
 import TriggerProxy from '@webex/plugin-meetings/src/common/events/trigger-proxy';
@@ -3583,6 +3584,7 @@ describe('plugin-meetings', () => {
           const newLocusUrl = 'newLocusUrl/12345';
 
           meeting.members = {locusUrlUpdate: sinon.stub().returns(Promise.resolve(test1))};
+          meeting.recordingController = {setLocusUrl: sinon.stub().returns(undefined)};
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -3590,11 +3592,36 @@ describe('plugin-meetings', () => {
             newLocusUrl
           );
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
+          assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
           done();
         });
       });
+
+      describe('#setUpLocusServicesListener', () => {
+        it('listens to the locus services update event', (done) => {
+          const newLocusServices = {
+              services: {
+                record: {
+                  url: 'url',
+                }
+              },
+          };
+
+          meeting.recordingController = {setServiceUrl: sinon.stub().returns(undefined), setSessionId: sinon.stub().returns(undefined)};
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'LINKS_SERVICES',
+            newLocusServices
+          );
+
+          assert.calledWith(meeting.recordingController.setServiceUrl, newLocusServices.services.record.url);
+          assert.calledOnce(meeting.recordingController.setSessionId);
+          done();
+        });
+      });
       describe('#setUpLocusInfoMediaInactiveListener', () => {
         it('listens to disconnect due to un activity ', (done) => {
           TriggerProxy.trigger.reset();
@@ -4009,7 +4036,7 @@ describe('plugin-meetings', () => {
         let inMeetingActionsSetSpy;
         let canUserLockSpy;
         let canUserUnlockSpy;
-        let canUserRecordSpy;
+        let canUserStartSpy;
         let canUserStopSpy;
         let canUserPauseSpy;
         let canUserResumeSpy;
@@ -4023,10 +4050,10 @@ describe('plugin-meetings', () => {
           locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
           canUserLockSpy = sinon.spy(MeetingUtil, 'canUserLock');
           canUserUnlockSpy = sinon.spy(MeetingUtil, 'canUserUnlock');
-          canUserRecordSpy = sinon.spy(MeetingUtil, 'canUserRecord');
-          canUserStopSpy = sinon.spy(MeetingUtil, 'canUserStop');
-          canUserPauseSpy = sinon.spy(MeetingUtil, 'canUserPause');
-          canUserResumeSpy = sinon.spy(MeetingUtil, 'canUserResume');
+          canUserStartSpy = sinon.spy(RecordingUtil, 'canUserStart');
+          canUserStopSpy = sinon.spy(RecordingUtil, 'canUserStop');
+          canUserPauseSpy = sinon.spy(RecordingUtil, 'canUserPause');
+          canUserResumeSpy = sinon.spy(RecordingUtil, 'canUserResume');
           inMeetingActionsSetSpy = sinon.spy(meeting.inMeetingActions, 'set');
           canUserRaiseHandSpy = sinon.spy(MeetingUtil, 'canUserRaiseHand');
           canUserLowerAllHandsSpy = sinon.spy(MeetingUtil, 'canUserLowerAllHands');
@@ -4064,7 +4091,7 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(canUserLockSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserUnlockSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserRecordSpy, payload.info.userDisplayHints);
+          assert.calledWith(canUserStartSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
           assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);

package/test/unit/spec/meeting/muteState.js

@@ -161,6 +161,17 @@ describe('plugin-meetings', () => {
       assert.isFalse(audio.isSelf());
     });
 
+    describe('#isLocallyMuted()', () => {
+      it('does not consider remote mute status for audio', async () => {
+        // simulate being already remote muted
+        meeting.remoteMuted = true;
+        // create a new MuteState intance
+        audio = createMuteState(AUDIO, meeting, {sendAudio: true});
+
+        assert.isFalse(audio.isLocallyMuted());
+      });
+    });
+
     describe('#handleClientRequest', () => {
       it('disables/enables the local audio track when audio is muted/unmuted', async () => {
         // mute

package/test/unit/spec/meeting/utils.js

@@ -297,34 +297,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('canUserRecord', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserRecord(['RECORDING_CONTROL_START']), true);
-        assert.deepEqual(MeetingUtil.canUserRecord([]), false);
-      });
-    });
-
-    describe('canUserPause', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserPause(['RECORDING_CONTROL_PAUSE']), true);
-        assert.deepEqual(MeetingUtil.canUserPause([]), false);
-      });
-    });
-
-    describe('canUserResume', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserResume(['RECORDING_CONTROL_RESUME']), true);
-        assert.deepEqual(MeetingUtil.canUserResume([]), false);
-      });
-    });
-
-    describe('canUserStop', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserStop(['RECORDING_CONTROL_STOP']), true);
-        assert.deepEqual(MeetingUtil.canUserStop([]), false);
-      });
-    });
-
     [
       {functionName: 'canEnableClosedCaption', displayHint: 'CAPTION_START'},
       {functionName: 'canStartTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_START'},
@@ -343,104 +315,5 @@ describe('plugin-meetings', () => {
         });
       });
     });
-
-    describe('recording tests', () => {
-      let request;
-      let locusInfo;
-      const locusUrl = 'locusUrl';
-
-      beforeEach(() => {
-        locusInfo = {
-          parsedLocus: {
-            info: {
-              userDisplayHints: ['RECORDING_CONTROL_START'],
-            },
-          },
-        };
-        request = {
-          recordMeeting: sinon.stub().returns(Promise.resolve()),
-        };
-      });
-
-      describe('startRecording', () => {
-        it('can start recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
-
-          const result = MeetingUtil.startRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.startRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
-      });
-
-      describe('pauseRecording', () => {
-        it('can pause recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
-
-          const result = MeetingUtil.pauseRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: true});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.pauseRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
-      });
-
-      describe('resumeRecording', () => {
-        it('can resume recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
-
-          const result = MeetingUtil.resumeRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.resumeRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
-      });
-
-      describe('stopRecording', () => {
-        it('can stop recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
-
-          const result = MeetingUtil.stopRecording(request, locusUrl, locusInfo);
-
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: false, paused: false});
-
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
-
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.stopRecording(request, locusUrl, {});
-
-          assert.notCalled(request.recordMeeting);
-
-          assert.isRejected(result);
-        });
-      });
-    });
   });
 });

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

@@ -0,0 +1,231 @@
+import RecordingController from '@webex/plugin-meetings/src/recording-controller';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { HTTP_VERBS } 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('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('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('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('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,102 @@
+import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
+import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
+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));
+              });
+            });
+        });
+    });
+});

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

@@ -6,12 +6,13 @@ import {ROAP} from '@webex/plugin-meetings/src/constants';
 import RoapRequest from '@webex/plugin-meetings/src/roap/request';
 import RoapHandler from '@webex/plugin-meetings/src/roap/handler';
 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 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')
@@ -46,8 +47,12 @@ describe('Roap', () => {
       correlationId: 'correlation id',
       selfUrl: 'self url',
       mediaId: 'media id',
-      isAudioMuted: () => true,
-      isVideoMuted: () => false,
+      audio:{
+        isLocallyMuted: () => true,
+      },
+      video:{
+        isLocallyMuted: () => false,
+      },
       setRoapSeq: sinon.stub(),
       config: {experimental: {enableTurnDiscovery: false}},
     };
@@ -98,8 +103,8 @@ describe('Roap', () => {
           correlationId: meeting.correlationId,
           locusSelfUrl: meeting.selfUrl,
           mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
+          audioMuted: meeting.audio?.isLocallyMuted(),
+          videoMuted: meeting.video?.isLocallyMuted(),
           meetingId: meeting.id,
         });