@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

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

@@ -1,78 +1,84 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
+import Meetings from '@webex/plugin-meetings';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
-import LoggerConfig
-  from '@webex/plugin-meetings/src/common/logs/logger-config';
-import Metrics from '@webex/plugin-meetings/src/metrics/index';
-
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
+import {SELF_POLICY, IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import MockWebex from '@webex/test-helper-mock-webex';
+import * as BrowserDetectionModule from '@webex/plugin-meetings/src/common/browser-detection';
 
 describe('plugin-meetings', () => {
+  let webex;
   describe('Meeting utils function', () => {
     const sandbox = sinon.createSandbox();
     const meeting = {};
 
     beforeEach(() => {
-      Metrics.postEvent = sinon.stub();
+      webex = new MockWebex({
+        children: {
+          meetings: Meetings,
+        },
+      });
       const logger = {
         info: sandbox.stub(),
         log: sandbox.stub(),
         error: sandbox.stub(),
-        warn: sandbox.stub()
+        warn: sandbox.stub(),
+        debug: sandbox.stub(),
       };
 
       LoggerConfig.set({
         verboseEvents: true,
-        enable: true
+        enable: true,
       });
       LoggerProxy.set(logger);
 
-      meeting.closeLocalStream = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closeLocalShare = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closeRemoteTracks = sinon.stub()
-        .returns(Promise.resolve());
-      meeting.closePeerConnections = sinon.stub()
-        .returns(Promise.resolve());
-
-      meeting.unsetLocalVideoTrack = sinon.stub();
-      meeting.unsetLocalShareTrack = sinon.stub();
-      meeting.unsetRemoteTracks = sinon.stub();
+      meeting.cleanupLocalStreams = sinon.stub().returns(Promise.resolve());
+      meeting.closeRemoteStreams = sinon.stub().returns(Promise.resolve());
+      meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+
+      meeting.unsetRemoteStreams = sinon.stub();
       meeting.unsetPeerConnections = sinon.stub();
       meeting.reconnectionManager = {cleanUp: sinon.stub()};
       meeting.stopKeepAlive = sinon.stub();
+      meeting.updateLLMConnection = sinon.stub();
+      meeting.breakouts = {cleanUp: sinon.stub()};
+      meeting.annotaion = {cleanUp: sinon.stub()};
+      meeting.getWebexObject = sinon.stub().returns(webex);
+      meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
+      meeting.trigger = sinon.stub();
     });
 
     afterEach(() => {
       sandbox.restore();
+      sinon.restore();
     });
 
     describe('#cleanup', () => {
       it('do clean up on meeting object', async () => {
         await MeetingUtil.cleanUp(meeting);
-        assert.calledOnce(meeting.closeLocalStream);
-        assert.calledOnce(meeting.closeLocalStream);
-        assert.calledOnce(meeting.closeLocalShare);
-        assert.calledOnce(meeting.closeRemoteTracks);
+        assert.calledOnce(meeting.cleanupLocalStreams);
+        assert.calledOnce(meeting.closeRemoteStreams);
         assert.calledOnce(meeting.closePeerConnections);
 
-        assert.calledOnce(meeting.unsetLocalVideoTrack);
-        assert.calledOnce(meeting.unsetLocalShareTrack);
-        assert.calledOnce(meeting.unsetRemoteTracks);
+        assert.calledOnce(meeting.unsetRemoteStreams);
         assert.calledOnce(meeting.unsetPeerConnections);
         assert.calledOnce(meeting.reconnectionManager.cleanUp);
         assert.calledOnce(meeting.stopKeepAlive);
+        assert.calledOnce(meeting.updateLLMConnection);
+        assert.calledOnce(meeting.breakouts.cleanUp);
+        assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
       });
     });
 
     describe('logging', () => {
       const fakeDevice = sinon.fake.returns({
-        deviceId: 'device-1'
+        deviceId: 'device-1',
       });
 
-      const mockTrack = {
-        getSettings: fakeDevice
+      const mockStream = {
+        getSettings: fakeDevice,
       };
 
       it('#log - should log [info, warn, error, log] to console', () => {
@@ -90,27 +96,27 @@ describe('plugin-meetings', () => {
       });
 
       describe('#handleAudioLogging', () => {
-        it('should not log if called without track', () => {
+        it('should not log if called without stream', () => {
           MeetingUtil.handleAudioLogging();
           assert(!LoggerProxy.logger.log.called, 'log not called');
         });
 
-        it('should log audioTrack settings', () => {
+        it('should log audioStream settings', () => {
           assert(MeetingUtil.handleAudioLogging, 'method is defined');
-          MeetingUtil.handleAudioLogging(mockTrack);
+          MeetingUtil.handleAudioLogging(mockStream);
           assert(LoggerProxy.logger.log.called, 'log called');
         });
       });
 
       describe('#handleVideoLogging', () => {
-        it('should not log if called without track', () => {
+        it('should not log if called without stream', () => {
           MeetingUtil.handleVideoLogging(null);
           assert(!LoggerProxy.logger.log.called, 'log not called');
         });
 
-        it('should log videoTrack settings', () => {
+        it('should log videoStream settings', () => {
           assert(MeetingUtil.handleVideoLogging, 'method is defined');
-          MeetingUtil.handleVideoLogging(mockTrack);
+          MeetingUtil.handleVideoLogging(mockStream);
           assert(LoggerProxy.logger.log.called, 'log called');
         });
       });
@@ -122,10 +128,7 @@ describe('plugin-meetings', () => {
         });
 
         it('should log device settings', () => {
-          const mockDevices = [
-            {deviceId: 'device-1'},
-            {deviceId: 'device-2'}
-          ];
+          const mockDevices = [{deviceId: 'device-1'}, {deviceId: 'device-2'}];
 
           assert(MeetingUtil.handleDeviceLogging, 'is defined');
           MeetingUtil.handleDeviceLogging(mockDevices);
@@ -134,51 +137,236 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('remoteUpdateAudioVideo', () => {
-      it('#Should call meetingRequest.remoteAudioVideoToggle with correct parameters (multistream)', async () => {
+    describe('addSequence', () => {
+      it('should add the sequence object to a request body', () => {
+        const body = {};
+
+        MeetingUtil.addSequence(
+          {
+            locusInfo: {
+              sequence: 'sequence',
+            },
+          },
+          body
+        );
+
+        assert.deepEqual(body, {
+          sequence: 'sequence',
+        });
+      });
+
+      it('should work with an undefined meeting', () => {
+        const body = {};
+
+        MeetingUtil.addSequence(undefined, body);
+
+        assert.deepEqual(body, {});
+      });
+
+      it('should work with an undefined locusInfo', () => {
+        const body = {};
+
+        MeetingUtil.addSequence({}, body);
+
+        assert.deepEqual(body, {});
+      });
+
+      it('should work with an undefined sequence', () => {
+        const body = {};
+
+        MeetingUtil.addSequence({locusInfo: {}}, body);
+
+        assert.deepEqual(body, {});
+      });
+    });
+
+    describe('updateLocusWithDelta', () => {
+      it('should call handleLocusDelta with the new delta locus', () => {
         const meeting = {
-          correlationId: 'correlation id',
-          isMultistream: true,
-          mediaId: '12345',
-          meetingJoinUrl: 'meetingJoinUrl',
-          locusUrl: 'locusUrl',
-          deviceUrl: 'some device url',
-          selfId: 'self id',
-          meetingRequest: {remoteAudioVideoToggle: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}
+          locusInfo: {
+            handleLocusDelta: sinon.stub(),
+          },
         };
 
-        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
+        const originalResponse = {
+          body: {
+            locus: 'locus',
+          },
+        };
 
-        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
-        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+        const response = MeetingUtil.updateLocusWithDelta(meeting, originalResponse);
 
-        assert.equal(parameter.locusUrl, 'locusUrl');
-        assert.equal(parameter.selfId, 'self id');
-        assert.equal(parameter.correlationId, 'correlation id');
-        assert.equal(parameter.deviceUrl, 'some device url');
-        assert.deepEqual(parameter.localMedias, [{localSdp: '{"audioMuted":true,"videoMuted":false}', mediaId: '12345'}]);
-        assert.equal(parameter.preferTranscoding, false);
+        assert.deepEqual(response, originalResponse);
+        assert.calledOnceWithExactly(meeting.locusInfo.handleLocusDelta, 'locus', meeting);
+      });
+
+      it('should handle locus being missing from the response', () => {
+        const meeting = {
+          locusInfo: {
+            handleLocusDelta: sinon.stub(),
+          },
+        };
+
+        const originalResponse = {
+          body: {},
+        };
+
+        const response = MeetingUtil.updateLocusWithDelta(meeting, originalResponse);
+
+        assert.deepEqual(response, originalResponse);
+        assert.notCalled(meeting.locusInfo.handleLocusDelta);
       });
 
-      it('#Should call meetingRequest.remoteAudioVideoToggle with preferTranscoding:true for non multistream connections', async () => {
+      it('should work with an undefined meeting', () => {
+        const originalResponse = {
+          body: {
+            locus: 'locus',
+          },
+        };
+
+        const response = MeetingUtil.updateLocusWithDelta(undefined, originalResponse);
+        assert.deepEqual(response, originalResponse);
+      });
+    });
+
+    describe('generateLocusDeltaRequest', () => {
+      it('generates the correct wrapper function', async () => {
+        const updateLocusWithDeltaSpy = sinon.spy(MeetingUtil, 'updateLocusWithDelta');
+        const addSequenceSpy = sinon.spy(MeetingUtil, 'addSequence');
+
         const meeting = {
-          isMultistream: false,
+          request: sinon.stub().returns(Promise.resolve('result')),
+        };
+
+        const locusDeltaRequest = MeetingUtil.generateLocusDeltaRequest(meeting);
+
+        const options = {
+          some: 'option',
+          body: {},
+        };
+
+        let result = await locusDeltaRequest(options);
+
+        assert.equal(result, 'result');
+        assert.calledOnceWithExactly(updateLocusWithDeltaSpy, meeting, 'result');
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, options.body);
+
+        updateLocusWithDeltaSpy.resetHistory();
+        addSequenceSpy.resetHistory();
+
+        // body missing from options
+        result = await locusDeltaRequest({});
+        assert.equal(result, 'result');
+        assert.calledOnceWithExactly(updateLocusWithDeltaSpy, meeting, 'result');
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, options.body);
+
+        // meeting disappears so the WeakRef returns undefined
+        sinon.stub(WeakRef.prototype, 'deref').returns(undefined);
+
+        result = await locusDeltaRequest(options);
+        assert.equal(result, undefined);
+
+        WeakRef.prototype.deref.restore();
+      });
+
+      it('calls generateBuildLocusDeltaRequestOptions as expected', () => {
+        const generateBuildLocusDeltaRequestOptionsSpy = sinon.spy(
+          MeetingUtil,
+          'generateBuildLocusDeltaRequestOptions'
+        );
+
+        const meeting = {};
+
+        MeetingUtil.generateLocusDeltaRequest(meeting);
+
+        assert.calledOnceWithExactly(generateBuildLocusDeltaRequestOptionsSpy, meeting);
+      });
+    });
+
+    describe('selfSupportsFeature', () => {
+      it('returns true if there are no user policies', () => {
+        assert.equal(
+          MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_ANNOTATION, undefined),
+          true
+        );
+      });
+
+      it('returns true if policy is true', () => {
+        assert.equal(
+          MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_ANNOTATION, {
+            [SELF_POLICY.SUPPORT_ANNOTATION]: true,
+          }),
+          true
+        );
+      });
+
+      it('returns false if policy is false', () => {
+        assert.equal(
+          MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_ANNOTATION, {
+            [SELF_POLICY.SUPPORT_ANNOTATION]: false,
+          }),
+          false
+        );
+      });
+    });
+
+    describe('remoteUpdateAudioVideo', () => {
+      it('#Should call meetingRequest.locusMediaRequest with correct parameters', async () => {
+        const meeting = {
+          id: 'meeting-id',
           mediaId: '12345',
-          meetingRequest: {remoteAudioVideoToggle: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}
+          selfUrl: 'self url',
+          locusInfo: {
+            sequence: {},
+          },
+          locusMediaRequest: {
+            send: sinon.stub().resolves({body: {}, headers: {}}),
+          },
+          getWebexObject: sinon.stub().returns(webex),
         };
 
-        await MeetingUtil.remoteUpdateAudioVideo(true, false, meeting);
+        await MeetingUtil.remoteUpdateAudioVideo(meeting, true, false);
 
-        assert.calledOnce(meeting.meetingRequest.remoteAudioVideoToggle);
-        const parameter = meeting.meetingRequest.remoteAudioVideoToggle.getCall(0).args[0];
+        assert.calledOnceWithExactly(meeting.locusMediaRequest.send, {
+          mediaId: '12345',
+          muteOptions: {
+            audioMuted: true,
+            videoMuted: false,
+          },
+          selfUrl: 'self url',
+          sequence: {},
+          type: 'LocalMute',
+        });
 
-        assert.equal(parameter.preferTranscoding, true);
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.request',
+          options: {meetingId: meeting.id},
+        });
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.media.response',
+          options: {meetingId: meeting.id},
+        });
       });
     });
 
     describe('joinMeeting', () => {
       it('#Should call `meetingRequest.joinMeeting', async () => {
-        const meeting = {meetingJoinUrl: 'meetingJoinUrl', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          meetingJoinUrl: 'meetingJoinUrl',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(
+              Promise.resolve({
+                body: {mediaConnections: 'mediaConnections'},
+                headers: {
+                  trackingid: 'trackingId',
+                },
+              })
+            ),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -188,6 +376,84 @@ describe('plugin-meetings', () => {
 
         assert.equal(parameter.inviteeAddress, 'meetingJoinUrl');
         assert.equal(parameter.preferTranscoding, true);
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.join.request',
+          options: {meetingId: meeting.id},
+        });
+
+        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+          name: 'client.locus.join.response',
+          payload: {
+            trigger: 'loci-update',
+            identifiers: {
+              trackingId: 'trackingId',
+            },
+          },
+          options: {
+            meetingId: meeting.id,
+            mediaConnections: 'mediaConnections',
+          },
+        });
+      });
+
+      it('#Should call meetingRequest.joinMeeting with breakoutsSupported=true when passed in as true', async () => {
+        const meeting = {
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {
+          breakoutsSupported: true,
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.breakoutsSupported, true);
+      });
+
+      it('#Should call meetingRequest.joinMeeting with liveAnnotationSupported=true when passed in as true', async () => {
+        const meeting = {
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {
+          liveAnnotationSupported: true,
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.liveAnnotationSupported, true);
+      });
+
+      it('#Should call meetingRequest.joinMeeting with locale=en_UK, deviceCapabilities=["TEST"] when they are passed in as those values', async () => {
+        const meeting = {
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {
+          locale: 'en_UK',
+          deviceCapabilities: ['TEST'],
+        });
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.locale, 'en_UK');
+        assert.deepEqual(parameter.deviceCapabilities, ['TEST']);
       });
 
       it('#Should call meetingRequest.joinMeeting with preferTranscoding=false when multistream is enabled', async () => {
@@ -195,7 +461,10 @@ describe('plugin-meetings', () => {
           isMultistream: true,
           meetingJoinUrl: 'meetingJoinUrl',
           locusUrl: 'locusUrl',
-          meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
         };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
@@ -209,7 +478,14 @@ describe('plugin-meetings', () => {
       });
 
       it('#Should fallback sipUrl if meetingJoinUrl does not exists', async () => {
-        const meeting = {sipUri: 'sipUri', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          sipUri: 'sipUri',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -221,7 +497,14 @@ describe('plugin-meetings', () => {
       });
 
       it('#Should fallback to meetingNumber if meetingJoinUrl/sipUrl  does not exists', async () => {
-        const meeting = {meetingNumber: 'meetingNumber', locusUrl: 'locusUrl', meetingRequest: {joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}}))}};
+        const meeting = {
+          meetingNumber: 'meetingNumber',
+          locusUrl: 'locusUrl',
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
 
         MeetingUtil.parseLocusJoin = sinon.stub();
         await MeetingUtil.joinMeeting(meeting, {});
@@ -232,21 +515,72 @@ describe('plugin-meetings', () => {
         assert.isUndefined(parameter.inviteeAddress);
         assert.equal(parameter.meetingNumber, 'meetingNumber');
       });
+
+      it('should pass in the locusClusterUrl from meetingInfo', async () => {
+        const meeting = {
+          meetingInfo: {
+            locusClusterUrl: 'locusClusterUrl',
+          },
+          meetingRequest: {
+            joinMeeting: sinon.stub().returns(Promise.resolve({body: {}, headers: {}})),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        MeetingUtil.parseLocusJoin = sinon.stub();
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+
+        assert.equal(parameter.locusClusterUrl, 'locusClusterUrl');
+      });
+    });
+
+    describe('joinMeetingOptions', () => {
+      it('sends client events correctly', async () => {
+        MeetingUtil.joinMeeting = sinon.stub().rejects({});
+        MeetingUtil.isPinOrGuest = sinon.stub().returns(true);
+        const meeting = {
+          id: 'meeting-id',
+          mediaId: '12345',
+          selfUrl: 'self url',
+          locusInfo: {
+            sequence: {},
+          },
+          locusMediaRequest: {
+            send: sinon.stub().resolves({body: {}, headers: {}}),
+          },
+          getWebexObject: sinon.stub().returns(webex),
+        };
+
+        try {
+          await MeetingUtil.joinMeetingOptions(meeting, {pin: true});
+
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.pin.collected',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+        } catch (err) {
+          assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+            name: 'client.pin.prompt',
+            options: {
+              meetingId: meeting.id,
+            },
+          });
+        }
+      });
     });
 
     describe('getUserDisplayHintsFromLocusInfo', () => {
       it('returns display hints', () => {
         assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo(), []);
 
-        assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({}),
-          []
-        );
+        assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo({}), []);
 
-        assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {}}),
-          []
-        );
+        assert.deepEqual(MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {}}), []);
 
         assert.deepEqual(
           MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {}}}),
@@ -254,7 +588,9 @@ describe('plugin-meetings', () => {
         );
 
         assert.deepEqual(
-          MeetingUtil.getUserDisplayHintsFromLocusInfo({parsedLocus: {info: {userDisplayHints: []}}}),
+          MeetingUtil.getUserDisplayHintsFromLocusInfo({
+            parsedLocus: {info: {userDisplayHints: []}},
+          }),
           []
         );
 
@@ -262,11 +598,9 @@ describe('plugin-meetings', () => {
           MeetingUtil.getUserDisplayHintsFromLocusInfo({
             parsedLocus: {
               info: {
-                userDisplayHints: [
-                  'HINT_1'
-                ]
-              }
-            }
+                userDisplayHints: ['HINT_1'],
+              },
+            },
           }),
           ['HINT_1']
         );
@@ -303,68 +637,82 @@ describe('plugin-meetings', () => {
 
     describe('canUserLowerSomeoneElsesHand', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand(['LOWER_SOMEONE_ELSES_HAND']), true);
+        assert.deepEqual(
+          MeetingUtil.canUserLowerSomeoneElsesHand(['LOWER_SOMEONE_ELSES_HAND']),
+          true
+        );
         assert.deepEqual(MeetingUtil.canUserLowerSomeoneElsesHand([]), false);
       });
     });
 
-    describe('bothLeaveAndEndMeetingAvailable', () => {
+    describe('canUserRenameSelfAndObserved', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING']), true);
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_END_MEETING']), true);
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING', 'LEAVE_END_MEETING']), true);
-        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable([]), false);
-      });
-    });
-
-    describe('canUserLock', () => {
-      it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK', 'LOCK_STATUS_UNLOCKED']), true);
-        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK']), false);
-        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_STATUS_UNLOCKED']), false);
-        assert.deepEqual(MeetingUtil.canUserLock([]), false);
+        assert.deepEqual(
+          MeetingUtil.canUserRenameSelfAndObserved(['CAN_RENAME_SELF_AND_OBSERVED']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.canUserRenameSelfAndObserved([]), false);
       });
     });
 
-    describe('canUserUnlock', () => {
+    describe('canUserRenameOthers', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK', 'LOCK_STATUS_LOCKED']), true);
-        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK']), false);
-        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_STATUS_LOCKED']), false);
-        assert.deepEqual(MeetingUtil.canUserUnlock([]), false);
+        assert.deepEqual(MeetingUtil.canUserRenameOthers(['CAN_RENAME_OTHERS']), true);
+        assert.deepEqual(MeetingUtil.canUserRenameOthers([]), false);
       });
     });
 
-    describe('canUserRecord', () => {
+    describe('canShareWhiteBoard', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserRecord(['RECORDING_CONTROL_START']), true);
-        assert.deepEqual(MeetingUtil.canUserRecord([]), false);
+        assert.deepEqual(MeetingUtil.canShareWhiteBoard(['SHARE_WHITEBOARD']), true);
+        assert.deepEqual(MeetingUtil.canShareWhiteBoard([]), false);
       });
     });
 
-    describe('canUserPause', () => {
+    describe('bothLeaveAndEndMeetingAvailable', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserPause(['RECORDING_CONTROL_PAUSE']), true);
-        assert.deepEqual(MeetingUtil.canUserPause([]), false);
+        assert.deepEqual(
+          MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_TRANSFER_HOST_END_MEETING']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable(['LEAVE_END_MEETING']), true);
+        assert.deepEqual(
+          MeetingUtil.bothLeaveAndEndMeetingAvailable([
+            'LEAVE_TRANSFER_HOST_END_MEETING',
+            'LEAVE_END_MEETING',
+          ]),
+          true
+        );
+        assert.deepEqual(MeetingUtil.bothLeaveAndEndMeetingAvailable([]), false);
       });
     });
 
-    describe('canUserResume', () => {
+    describe('canUserLock', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserResume(['RECORDING_CONTROL_RESUME']), true);
-        assert.deepEqual(MeetingUtil.canUserResume([]), false);
+        assert.deepEqual(
+          MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK', 'LOCK_STATUS_UNLOCKED']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_CONTROL_LOCK']), false);
+        assert.deepEqual(MeetingUtil.canUserLock(['LOCK_STATUS_UNLOCKED']), false);
+        assert.deepEqual(MeetingUtil.canUserLock([]), false);
       });
     });
 
-
-    describe('canUserStop', () => {
+    describe('canUserUnlock', () => {
       it('works as expected', () => {
-        assert.deepEqual(MeetingUtil.canUserStop(['RECORDING_CONTROL_STOP']), true);
-        assert.deepEqual(MeetingUtil.canUserStop([]), false);
+        assert.deepEqual(
+          MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK', 'LOCK_STATUS_LOCKED']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_CONTROL_UNLOCK']), false);
+        assert.deepEqual(MeetingUtil.canUserUnlock(['LOCK_STATUS_LOCKED']), false);
+        assert.deepEqual(MeetingUtil.canUserUnlock([]), false);
       });
     });
 
     [
+      {functionName: 'isSaveTranscriptsEnabled', displayHint: 'SAVE_TRANSCRIPTS_ENABLED'},
       {functionName: 'canEnableClosedCaption', displayHint: 'CAPTION_START'},
       {functionName: 'canStartTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_START'},
       {functionName: 'canStopTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_STOP'},
@@ -383,104 +731,304 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('canManageBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canManageBreakout(['BREAKOUT_MANAGEMENT']), true);
+        assert.deepEqual(MeetingUtil.canManageBreakout([]), false);
+      });
+    });
 
-    describe('recording tests', () => {
-      let request;
-      let locusInfo;
-      const locusUrl = 'locusUrl';
+    describe('canBroadcastMessageToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.canBroadcastMessageToBreakout(['BROADCAST_MESSAGE_TO_BREAKOUT'], {
+            [SELF_POLICY.SUPPORT_BROADCAST_MESSAGE]: true,
+          }),
+          true
+        );
+        assert.deepEqual(
+          MeetingUtil.canBroadcastMessageToBreakout([], {
+            [SELF_POLICY.SUPPORT_BROADCAST_MESSAGE]: true,
+          }),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.canBroadcastMessageToBreakout(['BROADCAST_MESSAGE_TO_BREAKOUT'], {
+            [SELF_POLICY.SUPPORT_BROADCAST_MESSAGE]: false,
+          }),
+          false
+        );
+        assert.deepEqual(
+          MeetingUtil.canBroadcastMessageToBreakout(['BROADCAST_MESSAGE_TO_BREAKOUT'], undefined),
+          false
+        );
+      });
+    });
+
+    describe('isSuppressBreakoutSupport', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isSuppressBreakoutSupport(['UCF_SUPPRESS_BREAKOUTS_SUPPORT']),
+          true
+        );
+        assert.deepEqual(MeetingUtil.isSuppressBreakoutSupport([]), false);
+      });
+    });
+
+    describe('canAdmitLobbyToBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout(['DISABLE_LOBBY_TO_BREAKOUT']), false);
+        assert.deepEqual(MeetingUtil.canAdmitLobbyToBreakout([]), true);
+      });
+    });
+
+    describe('canUserAskForHelp', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canUserAskForHelp(['DISABLE_ASK_FOR_HELP']), false);
+        assert.deepEqual(MeetingUtil.canUserAskForHelp([]), true);
+      });
+    });
 
+    describe('isBreakoutPreassignmentsEnabled', () => {
+      it('works as expected', () => {
+        assert.deepEqual(
+          MeetingUtil.isBreakoutPreassignmentsEnabled(['DISABLE_BREAKOUT_PREASSIGNMENTS']),
+          false
+        );
+        assert.deepEqual(MeetingUtil.isBreakoutPreassignmentsEnabled([]), true);
+      });
+    });
+
+    describe('parseInterpretationInfo', () => {
+      let meetingInfo = {};
       beforeEach(() => {
-        locusInfo = {
-          parsedLocus: {
-            info: {
-              userDisplayHints: [
-                'RECORDING_CONTROL_START'
-              ]
-            }
-          }
-        };
-        request = {
-          recordMeeting: sinon.stub().returns(Promise.resolve())
+        meeting.simultaneousInterpretation = {
+          updateMeetingSIEnabled: sinon.stub(),
+          updateHostSIEnabled: sinon.stub(),
+          updateInterpretation: sinon.stub(),
+          siLanguages: [],
         };
       });
+      it('should update simultaneous interpretation settings with SI and host enabled', () => {
+        meetingInfo.turnOnSimultaneousInterpretation = true;
+        meetingInfo.meetingSiteSetting = {
+          enableHostInterpreterControlSI: true,
+        };
+        meetingInfo.simultaneousInterpretation = {
+          currentSIInterpreter: true,
+          siLanguages: [
+            {languageCode: 'en', languageGroupId: 1},
+            {languageCode: 'es', languageGroupId: 2},
+          ],
+        };
 
-      describe('startRecording', () => {
-        it('can start recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_START');
+        MeetingUtil.parseInterpretationInfo(meeting, meetingInfo);
+        assert.calledWith(meeting.simultaneousInterpretation.updateMeetingSIEnabled, true, true);
+        assert.calledWith(meeting.simultaneousInterpretation.updateHostSIEnabled, true);
+        assert.calledWith(meeting.simultaneousInterpretation.updateInterpretation, {
+          siLanguages: [
+            {languageName: 'en', languageCode: 1},
+            {languageName: 'es', languageCode: 2},
+          ],
+        });
+      });
 
-          const result = MeetingUtil.startRecording(request, locusUrl, locusInfo);
+      it('should update simultaneous interpretation settings with host SI disabled', () => {
+        meetingInfo.meetingSiteSetting.enableHostInterpreterControlSI = false;
+        meetingInfo.simultaneousInterpretation.currentSIInterpreter = false;
+        MeetingUtil.parseInterpretationInfo(meeting, meetingInfo);
+        assert.calledWith(meeting.simultaneousInterpretation.updateMeetingSIEnabled, true, false);
+        assert.calledWith(meeting.simultaneousInterpretation.updateHostSIEnabled, false);
+        assert.calledWith(meeting.simultaneousInterpretation.updateInterpretation, {
+          siLanguages: [
+            {languageName: 'en', languageCode: 1},
+            {languageName: 'es', languageCode: 2},
+          ],
+        });
+      });
+      it('should update simultaneous interpretation settings with SI disabled', () => {
+        meetingInfo.turnOnSimultaneousInterpretation = false;
+        MeetingUtil.parseInterpretationInfo(meeting, meetingInfo);
+        assert.calledWith(meeting.simultaneousInterpretation.updateMeetingSIEnabled, false, false);
+        assert.calledWith(meeting.simultaneousInterpretation.updateHostSIEnabled, false);
+      });
 
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
+      it('should not update simultaneous interpretation settings for invalid input', () => {
+        // Call the function with invalid inputs
+        MeetingUtil.parseInterpretationInfo(null, null);
 
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
+        // Ensure that the update functions are not called
+        assert.notCalled(meeting.simultaneousInterpretation.updateMeetingSIEnabled);
+        assert.notCalled(meeting.simultaneousInterpretation.updateHostSIEnabled);
+        assert.notCalled(meeting.simultaneousInterpretation.updateInterpretation);
+      });
+    });
 
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.startRecording(request, locusUrl, {});
+    describe('prepareLeaveMeetingOptions', () => {
+      it('works as expected', () => {
+        const meeting = {
+          locusUrl: 'locusUrl',
+          selfId: 'selfId',
+          correlationId: 'correlationId',
+          resourceId: 'resourceId',
+          deviceUrl: 'deviceUrl',
+        };
 
-          assert.notCalled(request.recordMeeting);
+        const leaveOptions = MeetingUtil.prepareLeaveMeetingOptions(meeting, {
+          selfId: 'bob',
+          foo: 'bar',
+        });
 
-          assert.isRejected(result);
+        assert.deepEqual(leaveOptions, {
+          correlationId: 'correlationId',
+          deviceUrl: 'deviceUrl',
+          foo: 'bar',
+          locusUrl: 'locusUrl',
+          resourceId: 'resourceId',
+          selfId: 'bob',
         });
       });
+    });
 
-      describe('pauseRecording', () => {
-        it('can pause recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_PAUSE');
+    describe('leaveMeeting', () => {
+      it('calls prepareLeaveMeetingOptions as expected', () => {
+        const meeting = {
+          locusUrl: 'locusUrl',
+          selfId: 'selfId',
+          correlationId: 'correlationId',
+          resourceId: 'resourceId',
+          deviceUrl: 'deviceUrl',
+          locusInfo: {parsedLocus: {}},
+          meetingRequest: {
+            leaveMeeting: () => Promise.resolve(),
+          },
+        };
 
-          const result = MeetingUtil.pauseRecording(request, locusUrl, locusInfo);
+        const prepareLeaveMeetingOptionsSpy = sinon.spy(MeetingUtil, 'prepareLeaveMeetingOptions');
 
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: true});
+        MeetingUtil.leaveMeeting(meeting, {foo: 'bar'});
 
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
-        });
+        assert.calledOnce(prepareLeaveMeetingOptionsSpy);
+        assert.deepEqual(prepareLeaveMeetingOptionsSpy.getCall(0).args[0], meeting);
+        assert.deepEqual(prepareLeaveMeetingOptionsSpy.getCall(0).args[1], {foo: 'bar'});
+      });
+    });
+
+    describe('buildLeaveFetchRequestOptions', () => {
+      it('calls expected functions', () => {
+        const buildLeaveMeetingRequestOptionsSpy = sinon.stub();
+
+        const meeting = {
+          locusUrl: 'locusUrl',
+          selfId: 'selfId',
+          correlationId: 'correlationId',
+          resourceId: 'resourceId',
+          deviceUrl: 'deviceUrl',
+          meetingRequest: {
+            leaveMeeting: () => Promise.resolve(),
+            buildLeaveMeetingRequestOptions: buildLeaveMeetingRequestOptionsSpy,
+          },
+        };
 
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.pauseRecording(request, locusUrl, {});
+        const prepareLeaveMeetingOptionsSpy = sinon.spy(MeetingUtil, 'prepareLeaveMeetingOptions');
 
-          assert.notCalled(request.recordMeeting);
+        const options = MeetingUtil.buildLeaveFetchRequestOptions(meeting, {foo: 'bar'});
 
-          assert.isRejected(result);
+        assert.calledOnce(prepareLeaveMeetingOptionsSpy);
+        assert.deepEqual(prepareLeaveMeetingOptionsSpy.getCall(0).args[0], meeting);
+        assert.deepEqual(prepareLeaveMeetingOptionsSpy.getCall(0).args[1], {foo: 'bar'});
+
+        assert.calledOnce(buildLeaveMeetingRequestOptionsSpy);
+        assert.deepEqual(buildLeaveMeetingRequestOptionsSpy.getCall(0).args[0], {
+          correlationId: 'correlationId',
+          deviceUrl: 'deviceUrl',
+          foo: 'bar',
+          locusUrl: 'locusUrl',
+          resourceId: 'resourceId',
+          selfId: 'selfId',
         });
       });
+    });
 
-      describe('resumeRecording', () => {
-        it('can resume recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_RESUME');
+    describe('generateBuildLocusDeltaRequestOptions', () => {
+      it('generates the correct wrapper function', async () => {
+        const addSequenceSpy = sinon.spy(MeetingUtil, 'addSequence');
 
-          const result = MeetingUtil.resumeRecording(request, locusUrl, locusInfo);
+        const meeting = {locusInfo: {sequence: 123}};
 
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: true, paused: false});
+        const buildLocusDeltaRequestOptions =
+          MeetingUtil.generateBuildLocusDeltaRequestOptions(meeting);
 
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
+        let result = buildLocusDeltaRequestOptions({
+          some: 'option',
+          body: {},
         });
+        assert.deepEqual(result, {some: 'option', body: {sequence: 123}});
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, {sequence: 123});
 
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.resumeRecording(request, locusUrl, {});
+        addSequenceSpy.resetHistory();
 
-          assert.notCalled(request.recordMeeting);
+        // body missing from options
+        result = buildLocusDeltaRequestOptions({});
+        assert.deepEqual(result, {body: {sequence: 123}});
+        assert.calledOnceWithExactly(addSequenceSpy, meeting, {sequence: 123});
 
-          assert.isRejected(result);
-        });
+        // meeting disappears so the WeakRef returns undefined
+        sinon.stub(WeakRef.prototype, 'deref').returns(undefined);
+
+        const input = {foo: 'bar'};
+        result = buildLocusDeltaRequestOptions(input);
+        assert.equal(result, input);
       });
+    });
 
-      describe('stopRecording', () => {
-        it('can stop recording when the correct display hint is present', () => {
-          locusInfo.parsedLocus.info.userDisplayHints.push('RECORDING_CONTROL_STOP');
+    describe('getIpVersion', () => {
+      let isBrowserStub;
+      beforeEach(() => {
+        isBrowserStub = sinon.stub().returns(false);
 
-          const result = MeetingUtil.stopRecording(request, locusUrl, locusInfo);
+        sinon.stub(BrowserDetectionModule, 'default').returns({
+          isBrowser: isBrowserStub,
+        });
+      });
 
-          assert.calledWith(request.recordMeeting, {locusUrl, recording: false, paused: false});
+      afterEach(() => {
+        sinon.restore();
+      });
 
-          assert.deepEqual(result, request.recordMeeting.firstCall.returnValue);
+      [
+        {supportsIpV4: undefined, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: undefined, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: undefined, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: true, supportsIpV6: undefined, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: true, supportsIpV6: true, expectedOutput: IP_VERSION.ipv4_and_ipv6},
+        {supportsIpV4: true, supportsIpV6: false, expectedOutput: IP_VERSION.only_ipv4},
+        {supportsIpV4: false, supportsIpV6: undefined, expectedOutput: IP_VERSION.unknown},
+        {supportsIpV4: false, supportsIpV6: true, expectedOutput: IP_VERSION.only_ipv6},
+        {supportsIpV4: false, supportsIpV6: false, expectedOutput: IP_VERSION.unknown},
+      ].forEach(({supportsIpV4, supportsIpV6, expectedOutput}) => {
+        it(`returns ${expectedOutput} when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6}`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
+
+          assert.equal(MeetingUtil.getIpVersion(webex), expectedOutput);
         });
 
-        it('rejects when correct display hint is not present', () => {
-          const result = MeetingUtil.stopRecording(request, locusUrl, {});
+        it(`returns undefined when supportsIpV4=${supportsIpV4} and supportsIpV6=${supportsIpV6} and browser is firefox`, () => {
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
+            .get(() => supportsIpV4);
+          sinon
+            .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
+            .get(() => supportsIpV6);
 
-          assert.notCalled(request.recordMeeting);
+          isBrowserStub.callsFake((name) => name === 'firefox');
 
-          assert.isRejected(result);
+          assert.equal(MeetingUtil.getIpVersion(webex), undefined);
         });
       });
     });