@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

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

@@ -4,12 +4,13 @@ import TurnDiscovery from '@webex/plugin-meetings/src/roap/turnDiscovery';
 
 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 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')
@@ -45,9 +46,12 @@ describe('Roap', () => {
         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}},
       };
@@ -97,8 +101,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,
           preferTranscoding: true,
         });
@@ -131,8 +135,8 @@ describe('Roap', () => {
         correlationId: meeting.correlationId,
         locusSelfUrl: meeting.selfUrl,
         mediaId: meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
+        audioMuted: meeting.audio.isLocallyMuted(),
+        videoMuted: meeting.video.isLocallyMuted(),
         meetingId: meeting.id,
         preferTranscoding: false,
       });

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

@@ -0,0 +1,217 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import Meetings from '@webex/plugin-meetings';
+import RoapRequest from '@webex/plugin-meetings/src/roap/request';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import {REACHABILITY} from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings/roap', () => {
+  let roapRequest;
+  let webex;
+  const locusUrl = 'locusUrl';
+
+  beforeEach(async () => {
+    webex = new MockWebex({
+      children: {
+        meetings: Meetings,
+      },
+    });
+
+    webex.meetings.clientRegion = {
+      countryCode: 'US',
+      regionCode: 'WEST-COAST',
+    };
+
+    webex.internal = {
+      services: {
+        get: sinon.mock().returns(locusUrl),
+        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
+      },
+      device: {
+        url: 'url',
+      },
+    };
+
+    // @ts-ignore
+    roapRequest = new RoapRequest({webex});
+
+    roapRequest.request = sinon.mock().returns(
+      Promise.resolve({
+        body: {
+          locus: {
+            roapSeq: '',
+            id: '',
+            url: 'url/path',
+            fullState: {
+              lastActive: 'lastActive',
+            },
+          },
+        },
+      })
+    );
+
+    Metrics.postEvent = sinon.stub().returns();
+
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageJoinCookie,
+      JSON.stringify({
+        anycastEntryPoint: 'aws-eu-west-1',
+      })
+    );
+    await webex.boundedStorage.put(
+      REACHABILITY.namespace,
+      REACHABILITY.localStorageResult,
+      JSON.stringify({
+        clusterId: {
+          udp: 'test',
+        },
+      })
+    );
+  });
+
+  describe('#attachReachabilityData', () => {
+    it('returns the correct reachability data', async () => {
+      const res = await roapRequest.attachReachabilityData({});
+
+      assert.deepEqual(res.localSdp, {
+        reachability: {
+          clusterId: {
+            udp: 'test',
+          },
+        },
+      });
+      assert.deepEqual(res.joinCookie, {
+        anycastEntryPoint: 'aws-eu-west-1',
+      });
+    });
+
+    it('handles the case when reachability data does not exist', async () => {
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
+
+      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
+      const sdp = {
+        some: 'attribute',
+      };
+
+      const result = await roapRequest.attachReachabilityData(sdp);
+
+      assert.deepEqual(result, {
+        joinCookie: undefined,
+        localSdp: {
+          some: 'attribute',
+        },
+      });
+    });
+  });
+
+  describe('sendRoap', () => {
+    it('includes joinCookie in the request correctly', async () => {
+      await roapRequest.sendRoap({
+        locusSelfUrl: locusUrl,
+        mediaId: 'mediaId',
+        roapMessage: {
+          seq: 'seq',
+        },
+      });
+
+      const requestParams = roapRequest.request.getCall(0).args[0];
+      assert.equal(requestParams.method, 'PUT');
+      assert.equal(requestParams.uri, `${locusUrl}/media`);
+      assert.deepEqual(requestParams.body.localMedias, [
+        {
+          localSdp:
+            '{"roapMessage":{"seq":"seq"},"audioMuted":false,"videoMuted":false,"reachability":{"clusterId":{"udp":"test"}}}',
+          mediaId: 'mediaId',
+        },
+      ]);
+      assert.deepEqual(requestParams.body.clientMediaPreferences, {
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+        preferTranscoding: true,
+      });
+    });
+  });
+
+  it('calls attachReachabilityData when sendRoap', async () => {
+    const newSdp = {
+      new: 'sdp',
+    };
+
+    roapRequest.attachReachabilityData = sinon.stub().returns(
+      Promise.resolve({
+        localSdp: newSdp,
+        joinCookie: {
+          anycastEntryPoint: 'aws-eu-west-1',
+        },
+      })
+    );
+    webex.request.returns(
+      Promise.resolve({
+        body: {
+          locus: {},
+        },
+      })
+    );
+
+    const result = await roapRequest.sendRoap({
+      roapMessage: {
+        seq: 1,
+      },
+      locusSelfUrl: 'locusSelfUrl',
+      mediaId: 'mediaId',
+      correlationId: 'correlationId',
+      audioMuted: true,
+      videoMuted: true,
+      meetingId: 'meetingId',
+      preferTranscoding: true,
+    });
+
+    const requestParams = roapRequest.request.getCall(0).args[0];
+
+    assert.deepEqual(requestParams, {
+      uri: 'locusSelfUrl/media',
+      method: 'PUT',
+      body: {
+        device: {
+          url: 'url',
+          deviceType: undefined,
+        },
+        correlationId: 'correlationId',
+        localMedias: [
+          {
+            localSdp: JSON.stringify(newSdp),
+            mediaId: 'mediaId',
+          },
+        ],
+        clientMediaPreferences: {
+          joinCookie: {
+            anycastEntryPoint: 'aws-eu-west-1',
+          },
+          preferTranscoding: true,
+        },
+      },
+    });
+
+    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
+      roapMessage: {
+        seq: 1,
+      },
+      audioMuted: true,
+      videoMuted: true,
+    });
+
+    assert.deepEqual(result, {
+      locus: {
+        fullState: {
+          lastActive: 'lastActive',
+        },
+        id: '',
+        roapSeq: 1,
+        url: 'url/path',
+      }
+    });
+  });
+});