@webex/plugin-meetings 3.7.0 → 3.8.0-next.1

package/test/unit/spec/meeting/locusMediaRequest.ts

@@ -34,12 +34,19 @@ describe('LocusMediaRequest.send()', () => {
       'wjfkm.wjfkm.*': {udp:{reachable: true}, tcp:{reachable:false}},
       '1eb65fdf-9643-417f-9974-ad72cae0e10f.59268c12-7a04-4b23-a1a1-4c74be03019a.*': {udp:{reachable: false}, tcp:{reachable:true}},
     },
-    joinCookie: {
-      anycastEntryPoint: 'aws-eu-west-1',
-      clientIpAddress: 'some ip',
-      timeShot: '2023-05-23T08:03:49Z',
-    },
-    ipVersion: IP_VERSION.only_ipv4,
+    clientMediaPreferences: {
+      preferTranscoding: false,
+      joinCookie: {
+        anycastEntryPoint: 'aws-eu-west-1',
+        clientIpAddress: 'some ip',
+        timeShot: '2023-05-23T08:03:49Z',
+      },
+      ipver: IP_VERSION.only_ipv4,
+      reachability: {
+        version: '1',
+        result: 'some fake reachability result',
+      }
+    }
   };
 
   const createExpectedRoapBody = (expectedMessageType, expectedMute:{audioMuted: boolean, videoMuted: boolean}) => {
@@ -53,12 +60,16 @@ describe('LocusMediaRequest.send()', () => {
         }
       ],
       clientMediaPreferences: {
-        preferTranscoding: true,
+        preferTranscoding: false,
         ipver: 4,
         joinCookie: {
           anycastEntryPoint: 'aws-eu-west-1',
           clientIpAddress: 'some ip',
           timeShot: '2023-05-23T08:03:49Z'
+        },
+        reachability: {
+          version: '1',
+          result: 'some fake reachability result',
         }
       }
     };
@@ -87,10 +98,6 @@ describe('LocusMediaRequest.send()', () => {
           localSdp: `{"audioMuted":${expectedMute.audioMuted},"videoMuted":${expectedMute.videoMuted}}`,
         },
       ],
-      clientMediaPreferences: {
-        preferTranscoding: true,
-        ipver: undefined,
-      },
     };
 
     if (sequence) {

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

@@ -113,30 +113,6 @@ describe('plugin-meetings', () => {
       assert.isTrue(audio.isRemotelyMuted());
     });
 
-    it('does not locally unmute on a server unmute', async () => {
-      const setServerMutedSpy = meeting.mediaProperties.audioStream.setServerMuted;
-
-      // simulate remote mute
-      audio.handleServerRemoteMuteUpdate(meeting, true, true);
-
-      assert.isTrue(audio.isRemotelyMuted());
-      assert.isTrue(audio.isLocallyMuted());
-
-      // mutes local
-      assert.calledOnceWithExactly(setServerMutedSpy, true, 'remotelyMuted');
-
-      setServerMutedSpy.resetHistory();
-
-      // simulate remote unmute
-      audio.handleServerRemoteMuteUpdate(meeting, false, true);
-
-      assert.isFalse(audio.isRemotelyMuted());
-      assert.isTrue(audio.isLocallyMuted());
-
-      // does not unmute local
-      assert.notCalled(setServerMutedSpy);
-    });
-
     it('does local audio unmute if localAudioUnmuteRequired is received', async () => {
       // first we need to have the local stream user muted
       meeting.mediaProperties.audioStream.userMuted = true;

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

@@ -196,6 +196,7 @@ describe('plugin-meetings', () => {
         const permissionToken = 'permission-token';
         const installationId = 'installationId';
         const reachability = 'reachability';
+        const clientMediaPreferences = 'clientMediaPreferences';
 
         await meetingsRequest.joinMeeting({
           locusUrl,
@@ -204,6 +205,7 @@ describe('plugin-meetings', () => {
           roapMessage,
           reachability,
           permissionToken,
+          clientMediaPreferences
         });
         const requestParams = meetingsRequest.request.getCall(0).args[0];
 
@@ -214,6 +216,7 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.device.countryCode, 'US');
         assert.equal(requestParams.body.permissionToken, 'permission-token');
         assert.equal(requestParams.body.device.regionCode, 'WEST-COAST');
+        assert.equal(requestParams.body.clientMediaPreferences, 'clientMediaPreferences');
         assert.include(requestParams.body.device.localIp, '127.0.0');
         assert.deepEqual(requestParams.body.localMedias, [
           {localSdp: '{"roapMessage":"roap-message","reachability":"reachability"}'},
@@ -386,32 +389,6 @@ describe('plugin-meetings', () => {
 
         assert.deepEqual(requestParams.body.alias, undefined);
       });
-
-      it('includes joinCookie and ipver correctly', async () => {
-        const locusUrl = 'locusURL';
-        const deviceUrl = 'deviceUrl';
-        const correlationId = 'random-uuid';
-        const roapMessage = 'roap-message';
-        const permissionToken = 'permission-token';
-
-        await meetingsRequest.joinMeeting({
-          locusUrl,
-          deviceUrl,
-          correlationId,
-          roapMessage,
-          permissionToken,
-          ipVersion: IP_VERSION.ipv4_and_ipv6,
-        });
-        const requestParams = meetingsRequest.request.getCall(0).args[0];
-
-        assert.equal(requestParams.method, 'POST');
-        assert.equal(requestParams.uri, `${locusUrl}/participant?alternateRedirect=true`);
-        assert.deepEqual(requestParams.body.clientMediaPreferences, {
-          joinCookie: {anycastEntryPoint: 'aws-eu-west-1'},
-          preferTranscoding: true,
-          ipver: 1,
-        });
-      });
     });
 
     describe('#pstn', () => {

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

@@ -22,6 +22,12 @@ describe('plugin-meetings', () => {
           meetings: Meetings,
         },
       });
+
+      webex.meetings.reachability = {
+        getReachabilityReportToAttachToRoap: sinon.stub().resolves({}),
+        getClientMediaPreferences: sinon.stub().resolves({}),
+      };
+
       const logger = {
         info: sandbox.stub(),
         log: sandbox.stub(),
@@ -39,6 +45,7 @@ describe('plugin-meetings', () => {
       meeting.cleanupLocalStreams = sinon.stub().returns(Promise.resolve());
       meeting.closeRemoteStreams = sinon.stub().returns(Promise.resolve());
       meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+      meeting.stopPeriodicLogUpload = sinon.stub();
 
       meeting.unsetRemoteStreams = sinon.stub();
       meeting.unsetPeerConnections = sinon.stub();
@@ -64,6 +71,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.cleanupLocalStreams);
         assert.calledOnce(meeting.closeRemoteStreams);
         assert.calledOnce(meeting.closePeerConnections);
+        assert.calledOnce(meeting.stopPeriodicLogUpload);
 
         assert.calledOnce(meeting.unsetRemoteStreams);
         assert.calledOnce(meeting.unsetPeerConnections);
@@ -157,21 +165,6 @@ describe('plugin-meetings', () => {
           assert(LoggerProxy.logger.log.called, 'log called');
         });
       });
-
-      describe('#handleDeviceLogging', () => {
-        it('should not log if called without devices', () => {
-          MeetingUtil.handleDeviceLogging();
-          assert(!LoggerProxy.logger.log.called, 'log not called');
-        });
-
-        it('should log device settings', () => {
-          const mockDevices = [{deviceId: 'device-1'}, {deviceId: 'device-2'}];
-
-          assert(MeetingUtil.handleDeviceLogging, 'is defined');
-          MeetingUtil.handleDeviceLogging(mockDevices);
-          assert(LoggerProxy.logger.log.called, 'log called');
-        });
-      });
     });
 
     describe('addSequence', () => {
@@ -408,17 +401,39 @@ describe('plugin-meetings', () => {
       });
 
       it('#Should call `meetingRequest.joinMeeting', async () => {
+        meeting.isMultistream = true;
+
+        const FAKE_REACHABILITY_REPORT = {
+          id: 'fake reachability report',
+        };
+        const FAKE_CLIENT_MEDIA_PREFERENCES = {
+          id: 'fake client media preferences',
+        };
+
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
+        webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
+
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+          .get(() => true);
+        sinon
+          .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+          .get(() => true);
+
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
           roapMessage: 'roapMessage',
         });
 
+        assert.calledOnceWithExactly(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+        assert.calledOnceWithExactly(webex.meetings.reachability.getClientMediaPreferences, meeting.isMultistream, IP_VERSION.ipv4_and_ipv6);
+
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
         const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
-        assert.equal(parameter.preferTranscoding, true);
-        assert.equal(parameter.reachability, 'reachability');
+        assert.equal(parameter.reachability, FAKE_REACHABILITY_REPORT);
+        assert.equal(parameter.clientMediaPreferences, FAKE_CLIENT_MEDIA_PREFERENCES);
         assert.equal(parameter.roapMessage, 'roapMessage');
 
         assert.calledOnce(meeting.setLocus)
@@ -445,6 +460,40 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('should handle failed reachability report retrieval', async () => {
+        webex.meetings.reachability.getReachabilityReportToAttachToRoap.rejects(
+          new Error('fake error')
+        );
+        await MeetingUtil.joinMeeting(meeting, {});
+        // Verify meeting join still proceeds
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+      });
+
+      it('should not attach reachability if there is no roap message', async () => {
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.notCalled(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+        assert.isUndefined(parameter.reachability);
+        assert.isUndefined(parameter.roapMessage);
+      });
+
+      it('should handle failed clientMediaPreferences retrieval', async () => {
+        webex.meetings.reachability.getClientMediaPreferences.rejects(new Error('fake error'));
+        meeting.isMultistream = true;
+        await MeetingUtil.joinMeeting(meeting, {});
+        // Verify meeting join still proceeds
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+        assert.deepEqual(parameter.clientMediaPreferences, {
+          preferTranscoding: false,
+          ipver: 0,
+          joinCookie: undefined,
+        });
+      });
+
       it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
         await MeetingUtil.joinMeeting(meeting, {
           breakoutsSupported: true,
@@ -480,17 +529,6 @@ describe('plugin-meetings', () => {
         assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
       });
 
-      it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
-        meeting.isMultistream = true;
-        await MeetingUtil.joinMeeting(meeting, {});
-
-        assert.calledOnce(meeting.meetingRequest.joinMeeting);
-        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
-
-        assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
-        assert.equal(parameter.preferTranscoding, false);
-      });
-
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
         meeting.meetingJoinUrl = undefined;
         meeting.sipUri = 'sipUri';
@@ -733,6 +771,13 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('canStartBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canStartBreakout(['DISABLE_BREAKOUT_START']), false);
+        assert.deepEqual(MeetingUtil.canStartBreakout([]), true);
+      });
+    });
+
     describe('canBroadcastMessageToBreakout', () => {
       it('works as expected', () => {
         assert.deepEqual(

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

@@ -18,7 +18,8 @@ import MeetingInfo, {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2AdhocMeetingError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError,
+  MeetingInfoV2JoinForbiddenError,
 } 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 +896,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 +915,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 +923,43 @@ describe('plugin-meetings', () => {
               assert(Metrics.sendBehavioralMetric.calledOnce);
               assert.calledWith(
                 Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.WEBINAR_REGISTRATION_ERROR,
+                BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR,
+                {code: errorCode}
+              );
+
+            }
+          });
+        }
+      );
+
+      forEach(
+        [
+          {errorCode: 403003},
+        ],
+        ({errorCode}) => {
+          it(`should throw a MeetingInfoV2JoinForbiddenError for error code ${errorCode}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+            });
+            try {
+              await meetingInfo.fetchMeetingInfo('1234323', DESTINATION_TYPE.MEETING_ID, 'abc', {
+                id: '999',
+                code: 'aabbcc11',
+              });
+            } catch (err) {
+              assert.instanceOf(err, MeetingInfoV2JoinForbiddenError);
+              assert.deepEqual(err.message, `${message}, code=${errorCode}`);
+              assert.equal(err.wbxAppApiCode, errorCode);
+              assert.deepEqual(err.meetingInfo, meetingInfoData);
+
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.JOIN_FORBIDDEN_ERROR,
                 {code: errorCode}
               );
 

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

@@ -192,6 +192,15 @@ describe('plugin-meetings', () => {
         assert.equal(res.meetingUUID, 'xsddsdsdsdssdsdsdsdsd');
       });
 
+      it('for registrationId', () => {
+        const res = MeetingInfoUtil.getRequestBody({
+          type: DESTINATION_TYPE.MEETING_UUID,
+          registrationId: 'registrationId',
+        });
+
+        assert.equal(res.registrationId, 'registrationId');
+      });
+
       it('for DESTINATION_TYPE.LOCUS_ID', () => {
         const res = MeetingInfoUtil.getRequestBody({
           type: DESTINATION_TYPE.LOCUS_ID,
@@ -345,5 +354,22 @@ describe('plugin-meetings', () => {
         );
       });
     });
+
+    describe('#isMeetingLink', () => {
+      it('should return true for valid join meeting link with MTID', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://cisco.webex.com/cisco/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return true for valid join meeting link without cisco domain', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return false for an invalid meeting link', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MiD=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.false;
+      });
+    });
   });
 });