@webex/plugin-meetings 3.8.0-next.8 → 3.8.0-web-workers-keepalive.1

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

@@ -210,6 +210,7 @@ describe('plugin-meetings', () => {
   let membersSpy;
   let meetingRequestSpy;
   let correlationId;
+  let isoLocalClientMeetingJoinTime;
   let uploadEvent;
 
   beforeEach(() => {
@@ -1692,10 +1693,6 @@ describe('plugin-meetings', () => {
             sandbox.stub(MeetingUtil, 'joinMeeting').returns(Promise.resolve(joinMeetingResult));
           });
 
-          afterEach(() => {
-            assert.exists(meeting.isoLocalClientMeetingJoinTime);
-          });
-
           it('should join the meeting and return promise', async () => {
             const join = meeting.join({pstnAudioType: 'dial-in'});
             meeting.config.enableAutomaticLLM = true;
@@ -7530,6 +7527,27 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#setIsoLocalClientMeetingJoinTime', () => {      
+        it('should fallback to system clock ISO string when given an undefined value', () => {
+          const currentSystemTime = new Date().toISOString();
+          meeting.isoLocalClientMeetingJoinTime = undefined;
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, currentSystemTime);
+        });
+      
+        it('should fallback to system clock ISO string when given an invalid value', () => {
+          const currentSystemTime = new Date().toISOString();
+          meeting.isoLocalClientMeetingJoinTime = 'invalid-date';
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, currentSystemTime);
+        });
+      
+        it('should set the isoLocalClientMeetingJoinTime correctly for a valid date string', () => {
+          const validDateString = 'Tue, 01 Apr 2025 13:00:36 GMT';
+          const expectedISOString = new Date(validDateString).toISOString();
+          meeting.isoLocalClientMeetingJoinTime = validDateString;
+          assert.equal(meeting.isoLocalClientMeetingJoinTime, expectedISOString);
+        });
+      });
+
       describe('#updateCallStateForMetrics', () => {
         it('should update the callState, overriding existing values', () => {
           assert.deepEqual(meeting.callStateForMetrics, {correlationId, sessionCorrelationId: ''});
@@ -8596,13 +8614,19 @@ describe('plugin-meetings', () => {
           const fakeErrorMessage = 'test error';
           const fakeRootCauseName = 'root cause name';
           const fakeErrorName = 'test error name';
+          let clock;
 
           beforeEach(() => {
+            clock = sinon.useFakeTimers();
             meeting.setupMediaConnectionListeners();
             webex.internal.newMetrics.submitClientEvent.resetHistory();
             Metrics.sendBehavioralMetric.resetHistory();
           });
 
+          afterEach(() => {
+            clock.restore();
+          });
+
           const checkMetricSent = (event, error) => {
             assert.calledOnce(webex.internal.newMetrics.submitClientEvent);
             assert.calledWithMatch(webex.internal.newMetrics.submitClientEvent, {
@@ -8671,6 +8695,13 @@ describe('plugin-meetings', () => {
           });
 
           it('should send metrics for SdpAnswerHandlingError error', () => {
+            meeting.sdpResponseTimer = '1234';
+            meeting.deferSDPAnswer = {
+              reject: sinon.stub(),
+            };
+            
+            const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+
             const fakeError = new Errors.SdpAnswerHandlingError(fakeErrorMessage, {
               name: fakeErrorName,
               cause: {name: fakeRootCauseName},
@@ -8685,6 +8716,8 @@ describe('plugin-meetings', () => {
               fakeErrorMessage,
               fakeRootCauseName
             );
+            assert.calledOnce(meeting.deferSDPAnswer.reject);
+            assert.calledOnce(clearTimeoutSpy);
           });
 
           it('should send metrics for SdpError error', () => {
@@ -12666,6 +12699,31 @@ describe('plugin-meetings', () => {
             });
           });
         });
+
+        describe('handleShareVideoStreamMuteStateChange', () => {
+          it('should emit MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE event with correct fields', () => {
+            meeting.isMultistream = true;
+            meeting.statsAnalyzer = {shareVideoEncoderImplementation: 'OpenH264'};
+            meeting.mediaProperties.shareVideoStream = {
+              getSettings: sinon.stub().returns({displaySurface: 'monitor', frameRate: 30}),
+            };
+
+            meeting.handleShareVideoStreamMuteStateChange(true);
+
+            assert.calledOnceWithExactly(
+              Metrics.sendBehavioralMetric,
+              BEHAVIORAL_METRICS.MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE,
+              {
+                correlationId: meeting.correlationId,
+                muted: true,
+                encoderImplementation: 'OpenH264',
+                displaySurface: 'monitor',
+                isMultistream: true,
+                frameRate: 30,
+              }
+            );
+          });
+        });
       });
 
       describe('#startKeepAlive', () => {

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

@@ -460,6 +460,50 @@ describe('plugin-meetings', () => {
         });
       });
 
+
+      it('#Should call `meetingRequest.joinMeeting and handle a date header in the response : isoLocalClientMeetingJoinedTime', 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);
+
+        meeting.meetingRequest.joinMeeting.resolves({
+          headers: {
+            date: 'test'
+          },
+          body: {
+            mediaConnections: [{mediaId: 'test'}],
+            locus: {
+              url: 'test',
+              self: {
+                id: 'test'
+              }
+            }
+          }
+        })
+
+        await MeetingUtil.joinMeeting(meeting, {
+          reachability: 'reachability',
+          roapMessage: 'roapMessage',
+        });
+
+        assert.equal(meeting.isoLocalClientMeetingJoinTime, 'test');
+      });
+
       it('should handle failed reachability report retrieval', async () => {
         webex.meetings.reachability.getReachabilityReportToAttachToRoap.rejects(
           new Error('fake error')
@@ -516,6 +560,17 @@ describe('plugin-meetings', () => {
         assert.equal(parameter.liveAnnotationSupported, true);
       });
 
+      it('#Should call meetingRequest.joinMeeting with alias passed through', async () => {
+        await MeetingUtil.joinMeeting(meeting, {
+          alias: 'alias name',
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.alias, 'alias name');
+      });
+
       it('#Should call meetingRequest.joinMeeting with locale=en_UK, deviceCapabilities=["TEST"] when they are passed in as those values', async () => {
         await MeetingUtil.joinMeeting(meeting, {
           locale: 'en_UK',