@webex/plugin-meetings 3.0.0-beta.201 → 3.0.0-beta.202

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

@@ -330,19 +330,21 @@ describe('plugin-meetings', () => {
         });
 
         it('uses meeting id as correlation id if not provided in constructor', () => {
-          const newMeeting = new Meeting({
-            userId: uuid1,
-            resource: uuid2,
-            deviceUrl: uuid3,
-            locus: {url: url1},
-            destination: testDestination,
-            destinationType: _MEETING_ID_,
-          },
-          {
-            parent: webex,
-          });
+          const newMeeting = new Meeting(
+            {
+              userId: uuid1,
+              resource: uuid2,
+              deviceUrl: uuid3,
+              locus: {url: url1},
+              destination: testDestination,
+              destinationType: _MEETING_ID_,
+            },
+            {
+              parent: webex,
+            }
+          );
           assert.equal(newMeeting.correlationId, newMeeting.id);
-        })
+        });
 
         describe('creates ReceiveSlot manager instance', () => {
           let mockReceiveSlotManagerCtor;
@@ -3073,6 +3075,7 @@ describe('plugin-meetings', () => {
           meeting.destinationType = FAKE_TYPE;
           meeting.config.installedOrgID = FAKE_INSTALLED_ORG_ID;
           meeting.parseMeetingInfo = sinon.stub().returns(undefined);
+          meeting.updateMeetingActions = sinon.stub().returns(undefined);
 
           await meeting.fetchMeetingInfo({
             password: FAKE_PASSWORD,
@@ -3104,13 +3107,14 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.NONE);
           assert.equal(meeting.requiredCaptcha, null);
-          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledThrice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
             {file: 'meetings', function: 'fetchMeetingInfo'},
             'meeting:meetingInfoAvailable'
           );
+          assert.calledWith(meeting.updateMeetingActions);
         });
 
         it('calls meetingInfoProvider with all the right parameters and parses the result when random delay is applied', async () => {
@@ -3122,6 +3126,7 @@ describe('plugin-meetings', () => {
           meeting.destination = FAKE_DESTINATION;
           meeting.destinationType = FAKE_TYPE;
           meeting.parseMeetingInfo = sinon.stub().returns(undefined);
+          meeting.updateMeetingActions = sinon.stub().returns(undefined);
           meeting.fetchMeetingInfoTimeoutId = FAKE_TIMEOUT_FETCHMEETINGINFO_ID;
 
           const clock = sinon.useFakeTimers();
@@ -3162,13 +3167,14 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.requiredCaptcha, null);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.NOT_REQUIRED);
 
-          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledThrice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
             {file: 'meetings', function: 'fetchMeetingInfo'},
             'meeting:meetingInfoAvailable'
           );
+          assert.calledWith(meeting.updateMeetingActions);
         });
 
         it('fails if captchaCode is provided when captcha not needed', async () => {
@@ -4327,7 +4333,7 @@ describe('plugin-meetings', () => {
         it('should stop remote tracks, and trigger a media:stopped event when the remote tracks are stopped', async () => {
           await meeting.closeRemoteTracks();
 
-          assert.equal(TriggerProxy.trigger.callCount, 4);
+          assert.equal(TriggerProxy.trigger.callCount, 5);
           assert.calledWith(
             TriggerProxy.trigger,
             sinon.match.instanceOf(Meeting),
@@ -4382,8 +4388,8 @@ describe('plugin-meetings', () => {
             track: 'track',
             type: RemoteTrackType.AUDIO,
           });
-          assert.equal(TriggerProxy.trigger.getCall(1).args[2], 'media:ready');
-          assert.deepEqual(TriggerProxy.trigger.getCall(1).args[3], {
+          assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
+          assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
             type: 'remoteAudio',
             stream: {id: 'stream'},
           });
@@ -4392,8 +4398,8 @@ describe('plugin-meetings', () => {
             track: 'track',
             type: RemoteTrackType.VIDEO,
           });
-          assert.equal(TriggerProxy.trigger.getCall(2).args[2], 'media:ready');
-          assert.deepEqual(TriggerProxy.trigger.getCall(2).args[3], {
+          assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
+          assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
             type: 'remoteVideo',
             stream: {id: 'stream'},
           });
@@ -4402,8 +4408,8 @@ describe('plugin-meetings', () => {
             track: 'track',
             type: RemoteTrackType.SCREENSHARE_VIDEO,
           });
-          assert.equal(TriggerProxy.trigger.getCall(3).args[2], 'media:ready');
-          assert.deepEqual(TriggerProxy.trigger.getCall(3).args[3], {
+          assert.equal(TriggerProxy.trigger.getCall(4).args[2], 'media:ready');
+          assert.deepEqual(TriggerProxy.trigger.getCall(4).args[3], {
             type: 'remoteShare',
             stream: {id: 'stream'},
           });
@@ -4830,7 +4836,7 @@ describe('plugin-meetings', () => {
           meeting.startKeepAlive = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_UNADMITTED_GUEST', test1);
           assert.calledOnceWithExactly(meeting.startKeepAlive);
-          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledThrice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
             sinon.match.instanceOf(Meeting),
@@ -4844,7 +4850,7 @@ describe('plugin-meetings', () => {
           meeting.stopKeepAlive = sinon.stub();
           meeting.locusInfo.emit({function: 'test', file: 'test'}, 'SELF_ADMITTED_GUEST', test1);
           assert.calledOnceWithExactly(meeting.stopKeepAlive);
-          assert.calledTwice(TriggerProxy.trigger);
+          assert.calledThrice(TriggerProxy.trigger);
           assert.calledWith(
             TriggerProxy.trigger,
             sinon.match.instanceOf(Meeting),
@@ -5251,6 +5257,19 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.simultaneousInterpretation.locusUrlUpdate, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
+
+          assert.calledThrice(TriggerProxy.trigger);
+          assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'setUpLocusSelfListener',
+              },
+              EVENT_TRIGGERS.MEETING_LOCUS_URL_UPDATE,
+              {'locusUrl': 'newLocusUrl/12345'}
+          );
+          
           done();
         });
       });
@@ -5777,6 +5796,59 @@ describe('plugin-meetings', () => {
 
       describe('#setUpLocusInfoMeetingInfoListener', () => {
         let locusInfoOnSpy;
+        let handleDataChannelUrlChangeSpy;
+        let updateMeetingActionsSpy;
+
+        beforeEach(() => {
+          locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
+          handleDataChannelUrlChangeSpy = sinon.spy(meeting, 'handleDataChannelUrlChange');
+          updateMeetingActionsSpy = sinon.spy(meeting, 'updateMeetingActions');
+        });
+
+        afterEach(() => {
+          locusInfoOnSpy.restore();
+          updateMeetingActionsSpy.restore();
+        });
+
+        it('registers the correct MEETING_INFO_UPDATED event', () => {
+          const userDisplayPolicy = {a: true};
+          const userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
+          const datachannelUrl = 'some url';
+
+          const setUserPolicySpy = sinon.spy(meeting.recordingController, 'setUserPolicy');
+          const setRecordingDisplayHintsSpy = sinon.spy(
+            meeting.recordingController,
+            'setDisplayHints'
+          );
+          const setControlsDisplayHintsSpy = sinon.spy(
+            meeting.controlsOptionsManager,
+            'setDisplayHints'
+          );
+
+          meeting.selfUserPolicies = userDisplayPolicy;
+          meeting.userDisplayHints = userDisplayHints;
+          meeting.datachannelUrl = datachannelUrl;
+
+          meeting.setUpLocusInfoMeetingInfoListener();
+
+          assert.calledThrice(locusInfoOnSpy);
+
+          assert.equal(locusInfoOnSpy.firstCall.args[0], 'MEETING_LOCKED');
+          assert.equal(locusInfoOnSpy.secondCall.args[0], 'MEETING_UNLOCKED');
+          assert.equal(locusInfoOnSpy.thirdCall.args[0], 'MEETING_INFO_UPDATED');
+          const callback = locusInfoOnSpy.thirdCall.args[1];
+
+          callback();
+
+          assert.calledWith(updateMeetingActionsSpy);
+          assert.calledWith(setRecordingDisplayHintsSpy, userDisplayHints);
+          assert.calledWith(setUserPolicySpy, userDisplayPolicy);
+          assert.calledWith(setControlsDisplayHintsSpy, userDisplayHints);
+          assert.calledWith(handleDataChannelUrlChangeSpy, datachannelUrl);
+        });
+      });
+
+      describe('#updateMeetingActions', () => {
         let inMeetingActionsSetSpy;
         let canUserLockSpy;
         let canUserUnlockSpy;
@@ -5793,14 +5865,12 @@ describe('plugin-meetings', () => {
         let canUserLowerAllHandsSpy;
         let canUserLowerSomeoneElsesHandSpy;
         let waitingForOthersToJoinSpy;
-        let handleDataChannelUrlChangeSpy;
         let canSendReactionsSpy;
         let canUserRenameSelfAndObservedSpy;
         let canUserRenameOthersSpy;
-        let hasHintsSpy;
+        // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
 
         beforeEach(() => {
-          locusInfoOnSpy = sinon.spy(meeting.locusInfo, 'on');
           canUserLockSpy = sinon.spy(MeetingUtil, 'canUserLock');
           canUserUnlockSpy = sinon.spy(MeetingUtil, 'canUserUnlock');
           canUserStartSpy = sinon.spy(RecordingUtil, 'canUserStart');
@@ -5820,14 +5890,12 @@ describe('plugin-meetings', () => {
           );
           canUserLowerSomeoneElsesHandSpy = sinon.spy(MeetingUtil, 'canUserLowerSomeoneElsesHand');
           waitingForOthersToJoinSpy = sinon.spy(MeetingUtil, 'waitingForOthersToJoin');
-          handleDataChannelUrlChangeSpy = sinon.spy(meeting, 'handleDataChannelUrlChange');
           canSendReactionsSpy = sinon.spy(MeetingUtil, 'canSendReactions');
           canUserRenameSelfAndObservedSpy = sinon.spy(MeetingUtil, 'canUserRenameSelfAndObserved');
           canUserRenameOthersSpy = sinon.spy(MeetingUtil, 'canUserRenameOthers');
         });
 
         afterEach(() => {
-          locusInfoOnSpy.restore();
           inMeetingActionsSetSpy.restore();
           waitingForOthersToJoinSpy.restore();
         });
@@ -5864,21 +5932,23 @@ describe('plugin-meetings', () => {
               callType: 'MEETING',
               expectedEnabled: false,
             },
+            {
+              actionName: 'canUseVoip',
+              callType: 'CALL',
+              expectedEnabled: true,
+            },
+            {
+              actionName: 'canUseVoip',
+              callType: 'MEETING',
+              expectedEnabled: false,
+            },
           ],
           ({actionName, callType, expectedEnabled}) => {
             it(`${actionName} is ${expectedEnabled} when the call type is ${callType}`, () => {
               meeting.type = callType;
-              meeting.setUpLocusInfoMeetingInfoListener();
+              meeting.userDisplayHints = [];
 
-              const callback = locusInfoOnSpy.thirdCall.args[1];
-
-              const payload = {
-                info: {
-                  userDisplayHints: [],
-                },
-              };
-
-              callback(payload);
+              meeting.updateMeetingActions();
 
               assert.equal(meeting.inMeetingActions.get()[actionName], expectedEnabled);
             });
@@ -5937,6 +6007,7 @@ describe('plugin-meetings', () => {
           ],
           ({actionName, requiredDisplayHints, requiredPolicies, enableUnifiedMeetings}) => {
             it(`${actionName} is enabled when the conditions are met`, () => {
+              meeting.userDisplayHints = requiredDisplayHints;
               meeting.selfUserPolicies = {};
 
               meeting.config.experimental.enableUnifiedMeetings = isUndefined(enableUnifiedMeetings)
@@ -5947,209 +6018,249 @@ describe('plugin-meetings', () => {
                 meeting.selfUserPolicies[policy] = true;
               });
 
-              meeting.setUpLocusInfoMeetingInfoListener();
-
-              const callback = locusInfoOnSpy.thirdCall.args[1];
-
-              const payload = {
-                info: {
-                  userDisplayHints: requiredDisplayHints,
-                },
-              };
-
-              callback(payload);
+              meeting.updateMeetingActions();
 
               assert.isTrue(meeting.inMeetingActions.get()[actionName]);
             });
 
             if (requiredDisplayHints.length !== 0) {
               it(`${actionName} is disabled when the required display hints are missing`, () => {
+                meeting.userDisplayHints = [];
                 meeting.selfUserPolicies = {};
 
                 forEach(requiredPolicies, (policy) => {
                   meeting.selfUserPolicies[policy] = true;
                 });
 
-                meeting.setUpLocusInfoMeetingInfoListener();
-
-                const callback = locusInfoOnSpy.thirdCall.args[1];
-
-                const payload = {
-                  info: {
-                    userDisplayHints: [],
-                  },
-                };
-
-                callback(payload);
+                meeting.updateMeetingActions();
 
                 assert.isFalse(meeting.inMeetingActions.get()[actionName]);
               });
             }
 
             it(`${actionName} is disabled when the required policies are missing`, () => {
+              meeting.userDisplayHints = requiredDisplayHints;
               meeting.selfUserPolicies = {};
 
-              meeting.setUpLocusInfoMeetingInfoListener();
-
-              const callback = locusInfoOnSpy.thirdCall.args[1];
-
-              const payload = {
-                info: {
-                  userDisplayHints: requiredDisplayHints,
-                },
-              };
-
-              callback(payload);
+              meeting.updateMeetingActions();
 
               assert.isFalse(meeting.inMeetingActions.get()[actionName]);
             });
           }
         );
 
-        it('registers the correct MEETING_INFO_UPDATED event', () => {
-          // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
-          const restorableHasHints = ControlsOptionsUtil.hasHints;
-          ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
-          ControlsOptionsUtil.hasPolicies = sinon.stub().returns(true);
+        it('canUseVoip is enabled based on locus info when the conditions are met', () => {
+          meeting.userDisplayHints = [DISPLAY_HINTS.VOIP_IS_ENABLED];
+          meeting.selfUserPolicies = {[SELF_POLICY.SUPPORT_VOIP]: true};
+          meeting.meetingInfo.supportVoIP = false;
+          meeting.config.experimental.enableUnifiedMeetings = true;
 
-          const setUserPolicySpy = sinon.spy(meeting.recordingController, 'setUserPolicy');
-          meeting.selfUserPolicies = {a: true};
+          meeting.updateMeetingActions();
 
-          meeting.setUpLocusInfoMeetingInfoListener();
+          assert.isTrue(meeting.inMeetingActions.get()['canUseVoip']);
+        });
 
-          assert.calledThrice(locusInfoOnSpy);
+        it('canUseVoip is disabled based on locus info when the required display hints are missing', () => {
+          meeting.userDisplayHints = [];
+          meeting.selfUserPolicies = {[SELF_POLICY.SUPPORT_VOIP]: true};
+          meeting.meetingInfo.supportVoIP = true;
+          meeting.config.experimental.enableUnifiedMeetings = true;
 
-          assert.equal(locusInfoOnSpy.firstCall.args[0], 'MEETING_LOCKED');
-          assert.equal(locusInfoOnSpy.secondCall.args[0], 'MEETING_UNLOCKED');
-          assert.equal(locusInfoOnSpy.thirdCall.args[0], 'MEETING_INFO_UPDATED');
-          const callback = locusInfoOnSpy.thirdCall.args[1];
+          meeting.updateMeetingActions();
 
-          const payload = {
-            info: {
-              userDisplayHints: ['LOCK_CONTROL_UNLOCK'],
-              datachannelUrl: 'some url',
-            },
-          };
+          assert.isFalse(meeting.inMeetingActions.get()['canUseVoip']);
+        });
 
-          callback(payload);
+        it('canUseVoip is disabled based on locus info when the required policies are missing', () => {
+          meeting.userDisplayHints = [DISPLAY_HINTS.VOIP_IS_ENABLED];
+          meeting.selfUserPolicies = {};
+          meeting.meetingInfo.supportVoIP = true;
+          meeting.config.experimental.enableUnifiedMeetings = true;
+
+          meeting.updateMeetingActions();
+
+          assert.isFalse(meeting.inMeetingActions.get()['canUseVoip']);
+        });
+
+        it('canUseVoip is enabled based on api info when the conditions are met', () => {
+          meeting.userDisplayHints = undefined;
+          meeting.selfUserPolicies = {[SELF_POLICY.SUPPORT_VOIP]: true};
+          meeting.meetingInfo.supportVoIP = true;
+          meeting.config.experimental.enableUnifiedMeetings = true;
+
+          meeting.updateMeetingActions();
+
+          assert.isTrue(meeting.inMeetingActions.get()['canUseVoip']);
+        });
 
-          assert.calledWith(canUserLockSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserUnlockSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserStartSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserStopSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserPauseSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserResumeSpy, payload.info.userDisplayHints);
-          assert.calledWith(canSetMuteOnEntrySpy, payload.info.userDisplayHints);
-          assert.calledWith(canUnsetMuteOnEntrySpy, payload.info.userDisplayHints);
-          assert.calledWith(canSetDisallowUnmuteSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUnsetDisallowUnmuteSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserRaiseHandSpy, payload.info.userDisplayHints);
-          assert.calledWith(bothLeaveAndEndMeetingAvailableSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserLowerAllHandsSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserLowerSomeoneElsesHandSpy, payload.info.userDisplayHints);
-          assert.calledWith(waitingForOthersToJoinSpy, payload.info.userDisplayHints);
-          assert.calledWith(handleDataChannelUrlChangeSpy, payload.info.datachannelUrl);
-          assert.calledWith(canSendReactionsSpy, null, payload.info.userDisplayHints);
-          assert.calledWith(canUserRenameSelfAndObservedSpy, payload.info.userDisplayHints);
-          assert.calledWith(canUserRenameOthersSpy, payload.info.userDisplayHints);
+        it('canUseVoip is disabled based on api info when supportVoip is false', () => {
+          meeting.userDisplayHints = undefined;
+          meeting.selfUserPolicies = {[SELF_POLICY.SUPPORT_VOIP]: true};
+          meeting.meetingInfo.supportVoIP = false;
+          meeting.config.experimental.enableUnifiedMeetings = true;
+
+          meeting.updateMeetingActions();
+
+          assert.isFalse(meeting.inMeetingActions.get()['canUseVoip']);
+        });
+
+        it('canUseVoip is disabled based on api info when the required policies are missing', () => {
+          meeting.userDisplayHints = undefined;
+          meeting.selfUserPolicies = {};
+          meeting.meetingInfo.supportVoIP = true;
+          meeting.config.experimental.enableUnifiedMeetings = true;
+
+          meeting.updateMeetingActions();
+
+          assert.isFalse(meeting.inMeetingActions.get()['canUseVoip']);
+        });
+
+        it('canUseVoip is enabled when enableUnifiedMeetings is false', () => {
+          meeting.userDisplayHints = [];
+          meeting.selfUserPolicies = {};
+          meeting.meetingInfo.supportVoIP = false;
+          meeting.config.experimental.enableUnifiedMeetings = false;
+
+          meeting.updateMeetingActions();
+
+          assert.isTrue(meeting.inMeetingActions.get()['canUseVoip']);
+        });
+
+        it('correctly updates the meeting actions', () => {
+          // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
+          const restorableHasHints = ControlsOptionsUtil.hasHints;
+          ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+          ControlsOptionsUtil.hasPolicies = sinon.stub().returns(true);
+
+          const selfUserPolicies = {a: true};
+          meeting.selfUserPolicies = {a: true};
+          const userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
+          meeting.userDisplayHints = ['LOCK_CONTROL_UNLOCK'];
+
+          meeting.updateMeetingActions();
+
+          assert.calledWith(canUserLockSpy, userDisplayHints);
+          assert.calledWith(canUserUnlockSpy, userDisplayHints);
+          assert.calledWith(canUserStartSpy, userDisplayHints);
+          assert.calledWith(canUserStopSpy, userDisplayHints);
+          assert.calledWith(canUserPauseSpy, userDisplayHints);
+          assert.calledWith(canUserResumeSpy, userDisplayHints);
+          assert.calledWith(canSetMuteOnEntrySpy, userDisplayHints);
+          assert.calledWith(canUnsetMuteOnEntrySpy, userDisplayHints);
+          assert.calledWith(canSetDisallowUnmuteSpy, userDisplayHints);
+          assert.calledWith(canUnsetDisallowUnmuteSpy, userDisplayHints);
+          assert.calledWith(canUserRaiseHandSpy, userDisplayHints);
+          assert.calledWith(bothLeaveAndEndMeetingAvailableSpy, userDisplayHints);
+          assert.calledWith(canUserLowerAllHandsSpy, userDisplayHints);
+          assert.calledWith(canUserLowerSomeoneElsesHandSpy, userDisplayHints);
+          assert.calledWith(waitingForOthersToJoinSpy, userDisplayHints);
+          assert.calledWith(canSendReactionsSpy, null, userDisplayHints);
+          assert.calledWith(canUserRenameSelfAndObservedSpy, userDisplayHints);
+          assert.calledWith(canUserRenameOthersSpy, userDisplayHints);
 
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.MUTE_ALL],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.UNMUTE_ALL],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.ENABLE_HARD_MUTE],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.DISABLE_HARD_MUTE],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.ENABLE_MUTE_ON_ENTRY],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.DISABLE_MUTE_ON_ENTRY],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.ENABLE_REACTIONS],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.DISABLE_REACTIONS],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.ENABLE_SHOW_DISPLAY_NAME],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.DISABLE_SHOW_DISPLAY_NAME],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_CONTROL],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_FILE],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasPolicies, {
             requiredPolicies: [SELF_POLICY.SUPPORT_FILE_SHARE],
-            policies: {a: true},
+            policies: selfUserPolicies,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasPolicies, {
             requiredPolicies: [SELF_POLICY.SUPPORT_APP_SHARE],
-            policies: {a: true},
+            policies: selfUserPolicies,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasPolicies, {
             requiredPolicies: [SELF_POLICY.SUPPORT_CAMERA_SHARE],
-            policies: {a: true},
+            policies: selfUserPolicies,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
           });
           assert.calledWith(ControlsOptionsUtil.hasPolicies, {
             requiredPolicies: [SELF_POLICY.SUPPORT_DESKTOP_SHARE],
-            policies: {a: true},
+            policies: selfUserPolicies,
           });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
-            displayHints: payload.info.userDisplayHints,
+            displayHints: userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.VOIP_IS_ENABLED],
+            displayHints: userDisplayHints,
+          });
+          assert.calledWith(ControlsOptionsUtil.hasPolicies, {
+            requiredPolicies: [SELF_POLICY.SUPPORT_VOIP],
+            policies: selfUserPolicies,
           });
-
-          assert.calledWith(setUserPolicySpy, {a: true});
 
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
             {
               file: 'meeting/index',
-              function: 'setUpLocusInfoMeetingInfoListener',
+              function: 'updateMeetingActions',
             },
             'meeting:actionsUpdate',
             meeting.inMeetingActions.get()
@@ -6157,7 +6268,7 @@ describe('plugin-meetings', () => {
 
           TriggerProxy.trigger.resetHistory();
 
-          callback(payload);
+          meeting.updateMeetingActions();
 
           assert.notCalled(TriggerProxy.trigger);
 
@@ -6520,6 +6631,10 @@ describe('plugin-meetings', () => {
                   endedSharingId: null,
                 },
               },
+              meeting: {
+                eventName: EVENT_TRIGGERS.MEETING_LOCUS_URL_UPDATE,
+                eventPayload: 'newLocusUrl',
+              },
             };
 
             let shareStatus = null;
@@ -6743,7 +6858,7 @@ describe('plugin-meetings', () => {
             assert.equal(meeting.shareStatus, SHARE_STATUS.NO_SHARE);
 
             // Called once --> members:update (ignore)
-            let callCounter = 1;
+            let callCounter = 2;
 
             data.forEach((d, index) => {
               meeting.locusInfo.emit(
@@ -6771,10 +6886,10 @@ describe('plugin-meetings', () => {
 
             assert.callCount(TriggerProxy.trigger, callCounter);
 
-            // Start with 1 to ignore members:update trigger
+            // Start with 2 to ignore members:update trigger, and meeting:locus:locusUrl:update
 
-            let i = 1;
-            let offset = 2;
+            let i = 2;
+            let offset = 3;
 
             while (i < callCounter) {
               const index = Math.floor(i / offset);