@webex/plugin-meetings 3.0.0-beta.25 → 3.0.0-beta.27

package/src/controls-options-manager/util.ts

@@ -0,0 +1,20 @@
+import {DISPLAY_HINTS} from '../constants';
+
+const canSetMuteOnEntry = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY);
+
+const canSetDisallowUnmute = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.ENABLE_HARD_MUTE);
+
+const canUnsetMuteOnEntry = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY);
+
+const canUnsetDisallowUnmute = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.DISABLE_HARD_MUTE);
+
+export default {
+  canSetMuteOnEntry,
+  canSetDisallowUnmute,
+  canUnsetMuteOnEntry,
+  canUnsetDisallowUnmute,
+};

package/src/meeting/in-meeting-actions.ts

@@ -13,6 +13,10 @@ interface IInMeetingActions {
   canAdmitParticipant?: boolean;
   canLock?: boolean;
   canUnlock?: boolean;
+  canSetMuteOnEntry?: boolean;
+  canUnsetMuteOnEntry?: boolean;
+  canSetDisallowUnmute?: boolean;
+  canUnsetDisallowUnmute?: boolean;
   canAssignHost?: boolean;
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
@@ -59,6 +63,14 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canStopRecording = null;
 
+  canSetMuteOnEntry = null;
+
+  canUnsetMuteOnEntry = null;
+
+  canSetDisallowUnmute = null;
+
+  canUnsetDisallowUnmute = null;
+
   canRaiseHand = null;
 
   canLowerAllHands = null;
@@ -99,6 +111,10 @@ export default class InMeetingActions implements IInMeetingActions {
     canLock: this.canLock,
     canUnlock: this.canUnlock,
     canAssignHost: this.canAssignHost,
+    canSetMuteOnEntry: this.canSetMuteOnEntry,
+    canUnsetMuteOnEntry: this.canUnsetMuteOnEntry,
+    canSetDisallowUnmute: this.canSetDisallowUnmute,
+    canUnsetDisallowUnmute: this.canUnsetDisallowUnmute,
     canStartRecording: this.canStartRecording,
     canPauseRecording: this.canPauseRecording,
     canResumeRecording: this.canResumeRecording,

package/src/meeting/index.ts

@@ -37,6 +37,7 @@ import MeetingRequest from './request';
 import Members from '../members/index';
 import MeetingUtil from './util';
 import RecordingUtil from '../recording-controller/util';
+import ControlsOptionsUtil from '../controls-options-manager/util';
 import MediaUtil from '../media/util';
 import Transcription from '../transcription';
 import {Reactions, SkinTones} from '../reactions/reactions';
@@ -106,6 +107,7 @@ import Breakouts from '../breakouts';
 import InMeetingActions from './in-meeting-actions';
 import {REACTION_RELAY_TYPES} from '../reactions/constants';
 import RecordingController from '../recording-controller';
+import ControlsOptionsManager from '../controls-options-manager';
 
 const {isBrowser} = BrowserDetection();
 
@@ -485,6 +487,7 @@ export default class Meeting extends StatelessWebexPlugin {
   recording: any;
   remoteMediaManager: RemoteMediaManager | null;
   recordingController: RecordingController;
+  controlsOptionsManager: ControlsOptionsManager;
   requiredCaptcha: any;
   receiveSlotManager: ReceiveSlotManager;
   shareStatus: string;
@@ -1098,6 +1101,18 @@ export default class Meeting extends StatelessWebexPlugin {
       displayHints: [],
     });
 
+    /**
+     * The class that helps to control recording functions: start, stop, pause, resume, etc
+     * @instance
+     * @type {ControlsOptionsManager}
+     * @public
+     * @memberof Meeting
+     */
+    this.controlsOptionsManager = new ControlsOptionsManager(this.meetingRequest, {
+      locusUrl: this.locusInfo?.url,
+      displayHints: [],
+    });
+
     this.setUpLocusInfoListeners();
     this.locusInfo.init(attrs.locus ? attrs.locus : {});
     this.hasJoinedOnce = false;
@@ -2187,6 +2202,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.locusUrl = payload;
       this.locusId = this.locusUrl?.split('/').pop();
       this.recordingController.setLocusUrl(this.locusUrl);
+      this.controlsOptionsManager.setLocusUrl(this.locusUrl);
     });
   }
 
@@ -2203,6 +2219,7 @@ export default class Meeting extends StatelessWebexPlugin {
     this.locusInfo.on(LOCUSINFO.EVENTS.LINKS_SERVICES, (payload) => {
       this.recordingController.setServiceUrl(payload?.services?.record?.url);
       this.recordingController.setSessionId(this.locusInfo?.fullState?.sessionId);
+      this.breakouts.breakoutServiceUrlUpdate(payload?.services?.breakout?.url);
     });
   }
 
@@ -2252,6 +2269,16 @@ export default class Meeting extends StatelessWebexPlugin {
           canAdmitParticipant: MeetingUtil.canAdmitParticipant(payload.info.userDisplayHints),
           canLock: MeetingUtil.canUserLock(payload.info.userDisplayHints),
           canUnlock: MeetingUtil.canUserUnlock(payload.info.userDisplayHints),
+          canSetDisallowUnmute: ControlsOptionsUtil.canSetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canUnsetDisallowUnmute: ControlsOptionsUtil.canUnsetDisallowUnmute(
+            payload.info.userDisplayHints
+          ),
+          canSetMuteOnEntry: ControlsOptionsUtil.canSetMuteOnEntry(payload.info.userDisplayHints),
+          canUnsetMuteOnEntry: ControlsOptionsUtil.canUnsetMuteOnEntry(
+            payload.info.userDisplayHints
+          ),
           canStartRecording: RecordingUtil.canUserStart(payload.info.userDisplayHints),
           canStopRecording: RecordingUtil.canUserStop(payload.info.userDisplayHints),
           canPauseRecording: RecordingUtil.canUserPause(payload.info.userDisplayHints),
@@ -2288,6 +2315,7 @@ export default class Meeting extends StatelessWebexPlugin {
         });
 
         this.recordingController.setDisplayHints(payload.info.userDisplayHints);
+        this.controlsOptionsManager.setDisplayHints(payload.info.userDisplayHints);
 
         if (changed) {
           Trigger.trigger(
@@ -6131,6 +6159,28 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.recordingController.startRecording();
   }
 
+  /**
+   * set the mute on entry flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setMuteOnEntry(enabled: boolean) {
+    return this.controlsOptionsManager.setMuteOnEntry(enabled);
+  }
+
+  /**
+   * set the disallow unmute flag for participants if you're the host
+   * @returns {Promise}
+   * @param {boolean} enabled
+   * @public
+   * @memberof Meeting
+   */
+  public setDisallowUnmute(enabled: boolean) {
+    return this.controlsOptionsManager.setDisallowUnmute(enabled);
+  }
+
   /**
    * End the recording of this meeting
    * @returns {Promise}

package/src/meetings/util.ts

@@ -58,12 +58,36 @@ MeetingsUtil.handleRoapMercury = (envelope, meetingCollection) => {
           errorCause,
         };
 
+        const mediaServer = MeetingsUtil.getMediaServer(roapMessage.sdp);
+
         meeting.mediaProperties.webrtcMediaConnection.roapMessageReceived(roapMessage);
+
+        if (mediaServer) {
+          meeting.mediaProperties.webrtcMediaConnection.mediaServer = mediaServer;
+        }
       }
     }
   }
 };
 
+MeetingsUtil.getMediaServer = (sdp) => {
+  let mediaServer;
+
+  // Attempt to collect the media server from the roap message.
+  try {
+    mediaServer = sdp
+      .split('\r\n')
+      .find((line) => line.startsWith('o='))
+      .split(' ')
+      .shift()
+      .replace('o=', '');
+  } catch {
+    mediaServer = undefined;
+  }
+
+  return mediaServer;
+};
+
 MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
   let devices = [];
 

package/test/integration/spec/converged-space-meetings.js

@@ -0,0 +1,176 @@
+import { config } from 'dotenv';
+import 'jsdom-global/register';
+import {assert} from '@webex/test-helper-chai';
+import {skipInNode} from '@webex/test-helper-mocha';
+import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detection';
+
+import {MEDIA_SERVERS} from '../../utils/constants';
+import testUtils from '../../utils/testUtils';
+import webexTestUsers from '../../utils/webex-test-users';
+
+config();
+
+skipInNode(describe)('plugin-meetings', () => {
+  const {isBrowser} = BrowserDetection();
+
+  // `addMedia()` fails on FF, this needs to be debuged and fixed in a later change
+  if (!isBrowser('firefox')) {
+    describe('converged-space-meeting', () => {
+      let shouldSkip = false;
+      let users, alice, bob, chris;
+      let meeting = null;
+      let space = null;
+      let mediaReadyListener = null;
+
+      before('setup users', async () => {
+        const userSet = await webexTestUsers.generateTestUsers({
+          count: 3,
+          whistler: process.env.WHISTLER || process.env.JENKINS,
+          config
+        });
+
+        users = userSet;
+        alice = users[0];
+        bob = users[1];
+        chris = users[2];
+        alice.name = 'alice';
+        bob.name = 'bob';
+        chris.name = 'chris';
+
+        const aliceSync = testUtils.syncAndEndMeeting(alice);
+        const bobSync = testUtils.syncAndEndMeeting(bob);
+        const chrisSync = testUtils.syncAndEndMeeting(chris);
+
+        await aliceSync;
+        await bobSync;
+        await chrisSync;
+      });
+
+      // Skip a test in this series if one failed.
+      // This beforeEach() instance function must use the `function` declaration to preserve the
+      // `this` context. `() => {}` will not generate the correct `this` context
+      beforeEach('check if should skip test', function() {
+        if (shouldSkip) {
+          this.skip();
+        }
+      });
+
+      // Store to the describe scope if a test has failed for skipping.
+      // This beforeEach() instance function must use the `function` declaration to preserve the
+      // `this` context. `() => {}` will not generate the correct `this` context
+      afterEach('check if test failed', function() {
+        if (this.currentTest.state === 'failed') {
+          shouldSkip = true;
+        }
+      });
+
+      it('user "alice" starts a space', async () => {
+        const conversation = await alice.webex.internal.conversation.create({
+          participants: [bob, chris],
+        });
+
+        assert.lengthOf(conversation.participants.items, 3);
+        assert.lengthOf(conversation.activities.items, 1);
+
+        space = conversation;
+
+        const destinationWithType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url, 'CONVERSATION_URL');
+        const destinationWithoutType = await alice.webex.meetings.meetingInfo.fetchMeetingInfo(space.url);
+
+        assert.exists(destinationWithoutType);
+        assert.exists(destinationWithType);
+        assert.exists(destinationWithoutType.body.meetingNumber);
+        assert.exists(destinationWithType.body.meetingNumber);
+      });
+
+      it('user "alice" starts a meeting', async () => {
+        const wait = testUtils.waitForEvents([{
+          scope: alice.webex.meetings,
+          event: 'meeting:added',
+          user: alice,
+        }]);
+
+        const createdMeeting = await testUtils.delayedPromise(alice.webex.meetings.create(space.url));
+
+        await wait;
+
+        assert.exists(createdMeeting);
+
+        meeting = createdMeeting;
+      });
+
+      it('user "alice" joins the meeting', async () => {
+        const wait = testUtils.waitForEvents([
+          {scope: bob.webex.meetings, event: 'meeting:added', user: bob},
+          {scope: chris.webex.meetings, event: 'meeting:added', user: chris},
+        ]);
+
+        await testUtils.delayedPromise(alice.meeting.join({enableMultistream: true}));
+
+        await wait;
+
+        assert.isTrue(!!alice.webex.meetings.meetingCollection.meetings[meeting.id].joinedWith);
+      });
+
+      it('users "bob" and "chris" join the meeting', async () => {
+        await testUtils.waitForStateChange(alice.meeting, 'JOINED');
+
+        const bobIdle = testUtils.waitForStateChange(bob.meeting, 'IDLE');
+        const chrisIdle =  testUtils.waitForStateChange(chris.meeting, 'IDLE');
+
+        await bobIdle;
+        await chrisIdle;
+
+        const bobJoined = testUtils.waitForStateChange(bob.meeting, 'JOINED');
+        const chrisJoined =  testUtils.waitForStateChange(chris.meeting, 'JOINED');
+        const bobJoin = bob.meeting.join({enableMultistream: true});
+        const chrisJoin = chris.meeting.join({enableMultistream: true});
+
+        await bobJoin;
+        await chrisJoin;
+        await bobJoined;
+        await chrisJoined;
+
+        assert.exists(bob.meeting.joinedWith);
+        assert.exists(chris.meeting.joinedWith);
+      });
+
+      it('users "alice", "bob", and "chris" add media', async () => {
+        mediaReadyListener = testUtils.waitForEvents([
+          {scope: alice.meeting, event: 'media:negotiated'},
+          {scope: bob.meeting, event: 'media:negotiated'},
+          {scope: chris.meeting, event: 'media:negotiated'},
+        ]);
+
+        const addMediaAlice = testUtils.addMedia(alice, {expectedMediaReadyTypes: ['local']});
+        const addMediaBob = testUtils.addMedia(bob, {expectedMediaReadyTypes: ['local']});
+        const addMediaChris = testUtils.addMedia(chris, {expectedMediaReadyTypes: ['local']});
+
+        await addMediaAlice;
+        await addMediaBob;
+        await addMediaChris;
+
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(alice.meeting.mediaProperties.mediaDirection.receiveVideo);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(bob.meeting.mediaProperties.mediaDirection.receiveVideo);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.sendAudio);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.sendVideo);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.receiveAudio);
+        assert.isTrue(chris.meeting.mediaProperties.mediaDirection.receiveVideo);
+      });
+
+      it(`users "alice", "bob", and "chris" should be using the "${MEDIA_SERVERS.HOMER}" media server`, async () => {
+        await mediaReadyListener;
+
+        assert.equal(alice.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+        assert.equal(bob.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+        assert.equal(chris.meeting.mediaProperties.webrtcMediaConnection.mediaServer, MEDIA_SERVERS.HOMER);
+      });
+    });
+  }
+});

package/test/unit/spec/breakouts/index.ts

@@ -20,6 +20,9 @@ describe('plugin-meetings', () => {
       webex.internal.llm.on = sinon.stub();
       webex.internal.mercury.on = sinon.stub();
       breakouts = new Breakouts({}, {parent: webex});
+      breakouts.locusUrl = 'locusUrl';
+      breakouts.breakoutServiceUrl = 'breakoutServiceUrl';
+      breakouts.url = 'url';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
     });
 
@@ -289,5 +292,78 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.isInMainSession, true);
       });
     });
+
+    describe('#breakoutServiceUrlUpdate', () => {
+      it('sets the breakoutService url', () => {
+        breakouts.breakoutServiceUrlUpdate('newBreakoutServiceUrl');
+        assert.equal(breakouts.breakoutServiceUrl, 'newBreakoutServiceUrl/breakout/');
+      });
+    });
+
+    describe('#toggleBreakout', () => {
+      it('enableBreakoutSession is undefined, run enableBreakouts then toggleBreakout', async() => {
+        breakouts.enableBreakoutSession = undefined;
+        breakouts.enableBreakouts = sinon.stub().resolves(({body: {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          name: 'name',
+          current: true,
+          sessionType: 'sessionType',
+          url: 'url'
+        }}))
+        breakouts.updateBreakout = sinon.stub().resolves();
+        breakouts.doToggleBreakout = sinon.stub().resolves();
+        
+        await breakouts.toggleBreakout(false);
+        assert.calledOnceWithExactly(breakouts.enableBreakouts);
+        assert.calledOnceWithExactly(breakouts.updateBreakout, {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          name: 'name',
+          current: true,
+          sessionType: 'sessionType',
+          url: 'url'
+        });
+        assert.calledOnceWithExactly(breakouts.doToggleBreakout, false);
+      });
+
+      it('enableBreakoutSession is exist, run toggleBreakout', async() => {
+        breakouts.enableBreakoutSession = true;
+        breakouts.doToggleBreakout = sinon.stub().resolves();
+        await breakouts.toggleBreakout(true);
+        assert.calledOnceWithExactly(breakouts.doToggleBreakout, true);
+      });
+    });
+
+    describe('enableBreakouts', () => {
+      it('makes the request as expected', async () => {
+        const result = await breakouts.enableBreakouts();
+        breakouts.set('breakoutServiceUrl', 'breakoutServiceUrl');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'breakoutServiceUrl',
+          body: {
+            locusUrl: 'locusUrl'
+          }
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+    });
+
+    describe('doToggleBreakout', () => {
+      it('makes the request as expected', async () => {
+        const result = await breakouts.doToggleBreakout(true);
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'url',
+          body: {
+            enableBreakoutSession: true
+          }
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+    });
   });
 });

package/test/unit/spec/controls-options-manager/index.js

@@ -0,0 +1,124 @@
+import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
+
+describe('plugin-meetings', () => {
+    describe('controls-options-manager tests', () => {
+        describe('index', () => {
+            let request;
+
+            describe('class tests', () => {
+                it('can set and extract new values later on', () => {
+                    const manager = new ControlsOptionsManager({});
+                    assert.isUndefined(manager.getLocusUrl());
+                    manager.set({
+                      locusUrl: 'test/id',
+                    })
+                    assert(manager.getLocusUrl(), 'test/id');
+                });
+            });
+
+            describe('Mute On Entry', () => {
+                let manager;
+            
+                beforeEach(() => {
+                  request = {
+                    request: sinon.stub().returns(Promise.resolve()),
+                  };
+
+                  manager = new ControlsOptionsManager(request);
+
+                  manager.set({
+                    locusUrl: 'test/id',
+                    displayHints: [],
+                  })
+                });
+
+                describe('setMuteOnEntry', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_MUTE_ON_ENTRY']);
+              
+                      const result = manager.setMuteOnEntry(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+
+                  describe('setDisallowUnmute', () => {
+                    it('rejects when correct display hint is not present enabled=false', () => {  
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+
+                    it('rejects when correct display hint is not present enabled=true', () => {  
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.notCalled(request.request);
+              
+                      assert.isRejected(result);
+                    });
+      
+                    it('can set mute on entry when the display hint is available enabled=true', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(true);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+
+                    it('can set mute on entry when the display hint is available enabled=false', () => {
+                      manager.setDisplayHints(['DISABLE_HARD_MUTE']);
+              
+                      const result = manager.setDisallowUnmute(false);
+              
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: false } },
+                      method: HTTP_VERBS.PATCH});
+              
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
+                  });
+            });
+          });
+    });
+});

package/test/unit/spec/controls-options-manager/util.js

@@ -0,0 +1,66 @@
+import ControlsOptionsUtil from '@webex/plugin-meetings/src/controls-options-manager/util';
+import { assert } from 'chai';
+
+describe('plugin-meetings', () => {
+    describe('controls-option-manager tests', () => {
+        describe('util tests', () => {
+
+            let locusInfo;
+        
+            beforeEach(() => {
+              locusInfo = {
+                parsedLocus: {
+                  info: {
+                    userDisplayHints: [],
+                  },
+                },
+              };
+            });
+        
+            describe('canUserSetMuteOnEntry', () => {
+              it('can set mute on entry enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set mute on entry disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_MUTE_ON_ENTRY');
+
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present for setting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canSetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present for unsetting mute on entry', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetMuteOnEntry(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+            describe('canSetDisallowUnmute', () => {
+              it('can set disallow unmute enable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('ENABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+
+              it('can set disallow unmute disable', () => {
+                locusInfo.parsedLocus.info.userDisplayHints.push('DISABLE_HARD_MUTE');
+
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), true);
+              });
+        
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canSetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+
+              it('rejects when correct display hint is not present', () => {
+                assert.equal(ControlsOptionsUtil.canUnsetDisallowUnmute(locusInfo.parsedLocus.info.userDisplayHints), false);
+              });
+            });
+
+        });
+    });
+});

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -13,6 +13,10 @@ describe('plugin-meetings', () => {
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
+        canSetMuteOnEntry: null,
+        canUnsetMuteOnEntry: null,
+        canSetDisallowUnmute: null,
+        canUnsetDisallowUnmute: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
@@ -51,6 +55,10 @@ describe('plugin-meetings', () => {
       'canPauseRecording',
       'canResumeRecording',
       'canStopRecording',
+      'canSetMuteOnEntry',
+      'canUnsetMuteOnEntry',
+      'canSetDisallowUnmute',
+      'canUnsetDisallowUnmute',
       'canRaiseHand',
       'canLowerAllHands',
       'canLowerSomeoneElsesHand',