@webex/plugin-meetings 3.7.0-next.2 → 3.7.0-next.20

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -18,7 +18,7 @@ import MeetingInfo, {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2AdhocMeetingError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError,
 } from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 import Metrics from '@webex/plugin-meetings/src/metrics';
@@ -895,9 +895,14 @@ describe('plugin-meetings', () => {
           {errorCode: 403021},
           {errorCode: 403022},
           {errorCode: 403024},
+          {errorCode: 403137},
+          {errorCode: 423007},
+          {errorCode: 403026},
+          {errorCode: 403037},
+          {errorCode: 403137},
         ],
         ({errorCode}) => {
-          it(`should throw a MeetingInfoV2WebinarRegistrationError for error code ${errorCode}`, async () => {
+          it(`should throw a MeetingInfoV2JoinWebinarError for error code ${errorCode}`, async () => {
             const message = 'a message';
             const meetingInfoData = {meetingInfo: {registrationUrl: 'registrationUrl'}};
 
@@ -909,7 +914,7 @@ describe('plugin-meetings', () => {
               await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
               assert.fail('createAdhocSpaceMeeting should have thrown, but has not done that');
             } catch (err) {
-              assert.instanceOf(err, MeetingInfoV2WebinarRegistrationError);
+              assert.instanceOf(err, MeetingInfoV2JoinWebinarError);
               assert.deepEqual(err.message, `${message}, code=${errorCode}`);
               assert.equal(err.wbxAppApiCode, errorCode);
               assert.deepEqual(err.meetingInfo, meetingInfoData);
@@ -917,7 +922,7 @@ describe('plugin-meetings', () => {
               assert(Metrics.sendBehavioralMetric.calledOnce);
               assert.calledWith(
                 Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.WEBINAR_REGISTRATION_ERROR,
+                BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR,
                 {code: errorCode}
               );
 

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

@@ -131,9 +131,9 @@ describe('plugin-meetings', () => {
         logger,
         people: {
           _getMe: sinon.stub().resolves({
-            type: 'validuser', 
+            type: 'validuser',
           }),
-        }
+        },
       });
 
       startReachabilityStub = sinon.stub(webex.meetings, 'startReachability').resolves();
@@ -1985,6 +1985,8 @@ describe('plugin-meetings', () => {
             const meetingIds = {
               meetingId: meeting.id,
               correlationId: meeting.correlationId,
+              roles: meeting.roles,
+              callStateForMetrics: meeting.callStateForMetrics,
             };
 
             webex.meetings.destroy(meeting, test1);
@@ -2021,6 +2023,8 @@ describe('plugin-meetings', () => {
 
             assert.equal(deletedMeetingInfo.id, meetingIds.meetingId);
             assert.equal(deletedMeetingInfo.correlationId, meetingIds.correlationId);
+            assert.equal(deletedMeetingInfo.roles, meetingIds.roles);
+            assert.equal(deletedMeetingInfo.callStateForMetrics, meetingIds.callStateForMetrics);
           });
         });
 
@@ -2092,7 +2096,7 @@ describe('plugin-meetings', () => {
           );
         });
 
-        const setup = ({me = { type: 'validuser'}, user} = {}) => {
+        const setup = ({me = {type: 'validuser'}, user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
 
@@ -2113,9 +2117,9 @@ describe('plugin-meetings', () => {
 
         it('should not call request.getMeetingPreferences if user is a guest', async () => {
           setup({me: {type: 'appuser'}});
-      
+
           await webex.meetings.fetchUserPreferredWebexSite();
-      
+
           assert.equal(webex.meetings.preferredWebexSite, '');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
           assert.notCalled(webex.internal.services.getMeetingPreferences);

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

@@ -262,5 +262,100 @@ describe('plugin-meetings', () => {
         testParams(false);
       });
     });
+
+    describe('#getAddMemberBody', () => {
+      it('returns the correct body with email address and roles', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1', 'role2'],
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1', 'role2'],
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('returns the correct body with phone number and no roles', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
+      it('returns the correct body with fallback to email', () => {
+        const options = {
+          invitee: {
+            email: 'fallback@example.com',
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'fallback@example.com',
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('handles missing `alertIfActive` gracefully', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1'],
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1'],
+            },
+          ],
+          alertIfActive: undefined,
+        });
+      });
+
+      it('ignores roles if not provided', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+    });
   });
 });

package/test/unit/spec/multistream/remoteMedia.ts

@@ -249,14 +249,18 @@ describe('RemoteMedia', () => {
 
     forEach(
       [
-        {height: 134, fs: 60},
-        {height: 135, fs: 240},
-        {height: 269, fs: 240},
-        {height: 270, fs: 920},
-        {height: 539, fs: 920},
-        {height: 540, fs: 3600},
+        {height: 90, fs: 60}, // 90p
+        {height: 98, fs: 60},
+        {height: 99, fs: 240}, // 180p
+        {height: 180, fs: 240},
+        {height: 197, fs: 240},
+        {height: 198, fs: 920}, // 360p
+        {height: 360, fs: 920},
+        {height: 395, fs: 920},
+        {height: 396, fs: 3600}, // 720p
         {height: 720, fs: 3600},
-        {height: 721, fs: 8192},
+        {height: 721, fs: 8192}, // 1080p
+        {height: 1080, fs: 8192},
       ],
       ({height, fs}) => {
         it(`sets the max fs to ${fs} correctly when height is ${height}`, () => {

package/test/unit/spec/reachability/clusterReachability.ts

@@ -15,6 +15,7 @@ describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
+  let gatherIceCandidatesSpy;
 
   const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
     [Events.resultReady]: [],
@@ -44,6 +45,8 @@ describe('ClusterReachability', () => {
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
 
+    gatherIceCandidatesSpy = sinon.spy(clusterReachability, 'gatherIceCandidates');
+
     resetEmittedEvents();
 
     clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
@@ -151,6 +154,10 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
+      // Make sure that gatherIceCandidates is called before setLocalDescription
+      // as setLocalDescription triggers the ICE gathering process
+      assert.isTrue(gatherIceCandidatesSpy.calledBefore(fakePeerConnection.setLocalDescription));
+
       clusterReachability.abort();
       await promise;
 

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

@@ -221,7 +221,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can start premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_START']);
+
+            const result = controller.startRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'start'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -238,14 +252,28 @@ describe('plugin-meetings', () => {
             assert.isRejected(result);
           });
 
-          it('can start recording when the correct display hint is present', () => {
+          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: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can stop premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_STOP']);
+
+            const result = controller.stopRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'stop'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -269,7 +297,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can pause premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_PAUSE']);
+
+            const result = controller.pauseRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'pause'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 
@@ -293,7 +335,21 @@ describe('plugin-meetings', () => {
 
             assert.calledWith(request.request, {
               uri: `test/loci/id/recording`,
-              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}},
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'cloud'},
+              method: HTTP_VERBS.PUT,
+            });
+
+            assert.deepEqual(result, request.request.firstCall.returnValue);
+          });
+
+          it('can resume premise recording when the correct display hint is present', () => {
+            controller.setDisplayHints(['PREMISE_RECORDING_CONTROL_RESUME']);
+
+            const result = controller.resumeRecording();
+
+            assert.calledWith(request.request, {
+              uri: `test/loci/id/recording`,
+              body: {meetingInfo: {locusSessionId: 'testId'}, recording: {action: 'resume'}, recordingType: 'premise'},
               method: HTTP_VERBS.PUT,
             });
 

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

@@ -1,5 +1,5 @@
 import RecordingUtil from '@webex/plugin-meetings/src/recording-controller/util';
-import RecordingAction from '@webex/plugin-meetings/src/recording-controller/enums';
+import { RecordingAction } from '@webex/plugin-meetings/src/recording-controller/enums';
 import {SELF_POLICY} from '@webex/plugin-meetings/src/constants';
 
 import {assert} from 'chai';
@@ -29,6 +29,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can start premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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');
 
@@ -69,6 +78,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can pause premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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');
 
@@ -109,6 +127,15 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('can stop premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_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,
@@ -142,7 +169,7 @@ describe('plugin-meetings', () => {
       });
 
       describe('canUserResume', () => {
-        it('can start recording when the correct display hint is present', () => {
+        it('can resume recording when the correct display hint is present', () => {
           locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
 
           assert.equal(
@@ -151,7 +178,16 @@ describe('plugin-meetings', () => {
           );
         });
 
-        it('can start recording when the correct display hint is present and the policy is true', () => {
+        it('can resume premise recording when the correct display hint is present', () => {
+          locusInfo.parsedLocus.info.userDisplayHints.push('PREMISE_RECORDING_CONTROL_RESUME');
+
+          assert.equal(
+            RecordingUtil.canUserResume(locusInfo.parsedLocus.info.userDisplayHints),
+            true
+          );
+        });
+
+        it('can resume recording when the correct display hint is present and the policy is true', () => {
           locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
 
           assert.equal(