@webex/plugin-meetings 3.6.0 → 3.7.0-next.10

package/src/recording-controller/enums.ts

@@ -1,8 +1,11 @@
-enum RecordingAction {
+export enum RecordingAction {
   Start = 'Start',
   Stop = 'Stop',
   Pause = 'Pause',
   Resume = 'Resume',
 }
 
-export default RecordingAction;
+export enum RecordingType {
+  Premise = 'premise',
+  Cloud = 'cloud',
+}

package/src/recording-controller/index.ts

@@ -1,9 +1,9 @@
 import PermissionError from '../common/errors/permission';
+import LoggerProxy from '../common/logs/logger-proxy';
 import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
-import RecordingAction from './enums';
+import {RecordingAction, RecordingType} from './enums';
 import Util from './util';
-import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
@@ -228,11 +228,12 @@ export default class RecordingController {
 
   /**
    * @param {RecordingAction} action
+   * @param {RecordingType} recordingType
    * @private
    * @memberof RecordingController
    * @returns {Promise}
    */
-  private recordingService(action: RecordingAction): Promise<any> {
+  private recordingService(action: RecordingAction, recordingType: RecordingType): Promise<any> {
     // @ts-ignore
     return this.request.request({
       body: {
@@ -242,6 +243,7 @@ export default class RecordingController {
         recording: {
           action: action.toLowerCase(),
         },
+        recordingType,
       },
       uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
       method: HTTP_VERBS.PUT,
@@ -276,14 +278,25 @@ export default class RecordingController {
    * @returns {Promise}
    */
   private recordingFacade(action: RecordingAction): Promise<any> {
+    const isPremiseRecordingEnabled = Util.isPremiseRecordingEnabled(
+      this.displayHints,
+      this.selfUserPolicies
+    );
     LoggerProxy.logger.log(
       `RecordingController:index#recordingFacade --> recording action [${action}]`
     );
 
+    let recordingType: RecordingType;
+    if (isPremiseRecordingEnabled) {
+      recordingType = RecordingType.Premise;
+    } else {
+      recordingType = RecordingType.Cloud;
+    }
+
     // assumes action is proper cased (i.e., Example)
     if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
-        return this.recordingService(action);
+        return this.recordingService(action, recordingType);
       }
 
       return this.recordingControls(action);

package/src/recording-controller/util.ts

@@ -1,33 +1,47 @@
 import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
-import RecordingAction from './enums';
+import {RecordingAction} from './enums';
 import MeetingUtil from '../meeting/util';
 
 const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+
+const isPremiseRecordingEnabled = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
@@ -70,6 +84,7 @@ export default {
   canUserPause,
   canUserResume,
   canUserStop,
+  isPremiseRecordingEnabled,
   deriveRecordingStates,
   extractLocusId,
 };

package/src/roap/index.ts

@@ -107,7 +107,7 @@ export default class Roap extends StatelessWebexPlugin {
           roapMessage,
           locusSelfUrl: meeting.selfUrl,
           mediaId: options.mediaId,
-          meetingId: meeting.id,
+          isMultistream: meeting.isMultistream,
           locusMediaRequest: meeting.locusMediaRequest,
         })
         .then(() => {
@@ -141,7 +141,7 @@ export default class Roap extends StatelessWebexPlugin {
       roapMessage,
       locusSelfUrl: meeting.selfUrl,
       mediaId: options.mediaId,
-      meetingId: meeting.id,
+      isMultistream: meeting.isMultistream,
       locusMediaRequest: meeting.locusMediaRequest,
     });
   }
@@ -170,7 +170,7 @@ export default class Roap extends StatelessWebexPlugin {
         roapMessage,
         locusSelfUrl: meeting.selfUrl,
         mediaId: options.mediaId,
-        meetingId: meeting.id,
+        isMultistream: meeting.isMultistream,
         locusMediaRequest: meeting.locusMediaRequest,
       })
       .then(() => {
@@ -207,10 +207,9 @@ export default class Roap extends StatelessWebexPlugin {
         roapMessage,
         locusSelfUrl: meeting.selfUrl,
         mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        meetingId: meeting.id,
+        isMultistream: meeting.isMultistream,
         preferTranscoding: !meeting.isMultistream,
         locusMediaRequest: meeting.locusMediaRequest,
-        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
       .then(({locus, mediaConnections}) => {
         if (mediaConnections) {

package/src/roap/request.ts

@@ -4,44 +4,13 @@ import {StatelessWebexPlugin} from '@webex/webex-core';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {IP_VERSION, REACHABILITY} from '../constants';
 import {LocusMediaRequest} from '../meeting/locusMediaRequest';
+import MeetingUtil from '../meeting/util';
+import {ClientMediaPreferences} from '../reachability/reachability.types';
 
 /**
  * @class RoapRequest
  */
 export default class RoapRequest extends StatelessWebexPlugin {
-  /**
-   * Returns reachability data.
-   * @param {Object} localSdp
-   * @returns {Object}
-   */
-  async attachReachabilityData(localSdp) {
-    let joinCookie;
-
-    // @ts-ignore
-    const reachabilityResult = await this.webex.meetings.reachability.getReachabilityResults();
-
-    if (reachabilityResult && Object.keys(reachabilityResult).length) {
-      localSdp.reachability = reachabilityResult;
-    }
-
-    // @ts-ignore
-    const joinCookieRaw = await this.webex.boundedStorage
-      .get(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie)
-      .catch(() => {});
-
-    if (joinCookieRaw) {
-      try {
-        joinCookie = JSON.parse(joinCookieRaw);
-      } catch (e) {
-        LoggerProxy.logger.error(
-          `MeetingRequest#constructor --> Error in parsing join cookie data: ${e}`
-        );
-      }
-    }
-
-    return {localSdp, joinCookie};
-  }
-
   /**
    * Sends a ROAP message
    * @param {Object} options
@@ -50,18 +19,16 @@ export default class RoapRequest extends StatelessWebexPlugin {
    * @param {String} options.mediaId
    * @param {String} options.correlationId
    * @param {String} options.meetingId
-   * @param {IP_VERSION} options.ipVersion only required for offers
    * @returns {Promise} returns the response/failure of the request
    */
   async sendRoap(options: {
     roapMessage: any;
     locusSelfUrl: string;
     mediaId: string;
-    meetingId: string;
-    ipVersion?: IP_VERSION;
+    isMultistream: boolean;
     locusMediaRequest?: LocusMediaRequest;
   }) {
-    const {roapMessage, locusSelfUrl, mediaId, locusMediaRequest, ipVersion} = options;
+    const {roapMessage, locusSelfUrl, isMultistream, mediaId, locusMediaRequest} = options;
 
     if (!mediaId) {
       LoggerProxy.logger.info('Roap:request#sendRoap --> sending empty mediaID');
@@ -74,23 +41,44 @@ export default class RoapRequest extends StatelessWebexPlugin {
 
       return Promise.reject(new Error('sendRoap called when locusMediaRequest is undefined'));
     }
-    const {localSdp: localSdpWithReachabilityData, joinCookie} = await this.attachReachabilityData({
-      roapMessage,
-    });
+
+    let reachability;
+    let clientMediaPreferences: ClientMediaPreferences = {
+      // bare minimum fallback value that should allow us to join;
+      joinCookie: undefined,
+      ipver: IP_VERSION.unknown,
+      preferTranscoding: !isMultistream,
+    };
+
+    try {
+      clientMediaPreferences =
+        // @ts-ignore
+        await this.webex.meetings.reachability.getClientMediaPreferences(
+          isMultistream,
+          // @ts-ignore
+          MeetingUtil.getIpVersion(this.webex)
+        );
+      reachability =
+        // @ts-ignore
+        await this.webex.meetings.reachability.getReachabilityReportToAttachToRoap();
+    } catch (error) {
+      LoggerProxy.logger.error('Roap:request#sendRoap --> reachability error:', error);
+    }
 
     LoggerProxy.logger.info(
-      `Roap:request#sendRoap --> ${locusSelfUrl} \n ${roapMessage.messageType} \n seq:${roapMessage.seq}`
+      `Roap:request#sendRoap --> ${roapMessage.messageType} seq:${roapMessage.seq} ${
+        clientMediaPreferences?.ipver ? `ipver=${clientMediaPreferences?.ipver} ` : ''
+      } ${locusSelfUrl}`
     );
 
     return locusMediaRequest
       .send({
         type: 'RoapMessage',
         selfUrl: locusSelfUrl,
-        joinCookie,
         mediaId,
         roapMessage,
-        reachability: localSdpWithReachabilityData.reachability,
-        ipVersion,
+        reachability,
+        clientMediaPreferences,
       })
       .then((res) => {
         // always it will be the first mediaConnection Object

package/src/roap/turnDiscovery.ts

@@ -408,10 +408,8 @@ export default class TurnDiscovery {
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        meetingId: meeting.id,
+        isMultistream: meeting.isMultistream,
         locusMediaRequest: meeting.locusMediaRequest,
-        // @ts-ignore - because of meeting.webex
-        ipVersion: MeetingUtil.getIpVersion(meeting.webex),
       })
       .then(async (response) => {
         const {mediaConnections} = response;
@@ -451,7 +449,7 @@ export default class TurnDiscovery {
       locusSelfUrl: meeting.selfUrl,
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
-      meetingId: meeting.id,
+      isMultistream: meeting.isMultistream,
       locusMediaRequest: meeting.locusMediaRequest,
     });
   }

package/src/webinar/index.ts

@@ -2,9 +2,11 @@
  * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
  */
 import {WebexPlugin} from '@webex/webex-core';
-import {MEETINGS} from '../constants';
+import {get} from 'lodash';
+import {HTTP_VERBS, MEETINGS, SELF_ROLES} from '../constants';
 
 import WebinarCollection from './collection';
+import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @class Webinar
@@ -17,14 +19,16 @@ const Webinar = WebexPlugin.extend({
 
   props: {
     locusUrl: 'string', // appears current webinar's locus url
-    webcastUrl: 'string', // current webinar's webcast url
-    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url
+    webcastInstanceUrl: 'string', // current webinar's webcast instance url
     canManageWebcast: 'boolean', // appears the ability to manage webcast
+    selfIsPanelist: 'boolean', // self is panelist
+    selfIsAttendee: 'boolean', // self is attendee
+    practiceSessionEnabled: 'boolean', // practice session enabled
   },
 
   /**
    * Update the current locus url of the webinar
-   * @param {string} locusUrl // locus url
+   * @param {string} locusUrl
    * @returns {void}
    */
   locusUrlUpdate(locusUrl) {
@@ -32,30 +36,72 @@ const Webinar = WebexPlugin.extend({
   },
 
   /**
-   * Update the current webcast url of the meeting
-   * @param {string} webcastUrl // webcast url
+   * Update the current webcast instance url of the meeting
+   * @param {object} payload
    * @returns {void}
    */
-  webcastUrlUpdate(webcastUrl) {
-    this.set('webcastUrl', webcastUrl);
+  updateWebcastUrl(payload) {
+    this.set('webcastInstanceUrl', get(payload, 'resources.webcastInstance.url'));
   },
 
   /**
-   * Update the current webinarAttendeesSearching url of the meeting
-   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url
+   * Update whether self has capability to manage start/stop webcast (only host can manage it)
+   * @param {boolean} canManageWebcast
    * @returns {void}
    */
-  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {
-    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);
+  updateCanManageWebcast(canManageWebcast) {
+    this.set('canManageWebcast', canManageWebcast);
   },
 
   /**
-   * Update whether self has capability to manage start/stop webcast (only host can manage it)
-   * @param {boolean} canManageWebcast
+   * Updates user roles and manages associated state transitions
+   * @param {object} payload
+   * @param {string[]} payload.oldRoles - Previous roles of the user
+   * @param {string[]} payload.newRoles - New roles of the user
+   * @returns {{isPromoted: boolean, isDemoted: boolean}} Role transition states
+   */
+  updateRoleChanged(payload) {
+    const oldRoles = get(payload, 'oldRoles', []);
+    const newRoles = get(payload, 'newRoles', []);
+
+    const isPromoted =
+      oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.PANELIST);
+    const isDemoted =
+      oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE);
+    this.set('selfIsPanelist', newRoles.includes(SELF_ROLES.PANELIST));
+    this.set('selfIsAttendee', newRoles.includes(SELF_ROLES.ATTENDEE));
+    this.updateCanManageWebcast(newRoles.includes(SELF_ROLES.MODERATOR));
+
+    return {isPromoted, isDemoted};
+  },
+
+  /**
+   * start or stop practice session for webinar
+   * @param {boolean} enabled
+   * @returns {Promise}
+   */
+  setPracticeSessionState(enabled) {
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/controls`,
+      body: {
+        practiceSession: {
+          enabled,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update practice session status
+   * @param {object} payload
    * @returns {void}
    */
-  updateCanManageWebcast(canManageWebcast) {
-    this.set('canManageWebcast', canManageWebcast);
+  updatePracticeSessionStatus(payload) {
+    this.set('practiceSessionEnabled', payload.enabled);
   },
 });
 

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

@@ -22,7 +22,7 @@ describe('plugin-meetings', () => {
 
             describe('Mute On Entry', () => {
                 let manager;
-            
+
                 beforeEach(() => {
                   request = {
                     request: sinon.stub().returns(Promise.resolve()),
@@ -37,85 +37,85 @@ describe('plugin-meetings', () => {
                 });
 
                 describe('setMuteOnEntry', () => {
-                    it('rejects when correct display hint is not present enabled=false', () => {  
+                    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', () => {  
+                    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', () => {  
+                    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', () => {  
+                    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', () => {
+
+                    it('can set disallow unmute when ENABLE_HARD_MUTE display hint is available', () => {
                       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', () => {
+                    it('can set allow unmute when DISABLE_HARD_MUTE display hint is available', () => {
                       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);
                     });
                   });
@@ -218,7 +218,7 @@ describe('plugin-meetings', () => {
                 })
               });
 
-              it('rejects when correct display hint is not present mutedEnabled=false', () => {  
+              it('rejects when correct display hint is not present mutedEnabled=false', () => {
                 const result = manager.setMuteAll(false, false, false);
 
                 assert.notCalled(request.request);
@@ -226,7 +226,7 @@ describe('plugin-meetings', () => {
                 assert.isRejected(result);
               });
 
-              it('rejects when correct display hint is not present mutedEnabled=true', () => {  
+              it('rejects when correct display hint is not present mutedEnabled=true', () => {
                 const result = manager.setMuteAll(true, false, false);
 
                 assert.notCalled(request.request);
@@ -281,7 +281,31 @@ describe('plugin-meetings', () => {
 
                 assert.deepEqual(result, request.request.firstCall.returnValue);
               });
+
+              it('can set mute all panelists when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true, ['panelist']);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['panelist'] } },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('can set mute all attendees when the display hint is available mutedEnabled=true', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
+
+                const result = manager.setMuteAll(true, true, true, ['attendee']);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] } },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
             });
           });
     });
-});
+});

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

@@ -348,6 +348,50 @@ describe('plugin-meetings', () => {
           });
         });
 
+        it('should call hasHints() with proper hints when `panelistEnabled` is true, attendeeCount is false', () => {
+          ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: true, panelistEnabled: true, attendeeCount: false}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST,
+              DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST,
+              DISPLAY_HINTS.DISABLE_SHOW_ATTENDEE_COUNT],
+            displayHints: [],
+          });
+        });
+
+        it('should call hasHints() with proper hints when `panelistEnabled` is true, attendeeCount is true', () => {
+          ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: true, panelistEnabled: true, attendeeCount: true}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST,
+            DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST,
+            DISPLAY_HINTS.ENABLE_SHOW_ATTENDEE_COUNT],
+            displayHints: [],
+          });
+        });
+
+        it('should call hasHints() with proper hints when `panelistEnabled` is false, attendeeCount is false', () => {
+          ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: true, panelistEnabled: false, attendeeCount: false}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST,
+              DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST,
+              DISPLAY_HINTS.DISABLE_SHOW_ATTENDEE_COUNT],
+            displayHints: [],
+          });
+        });
+
+        it('should call hasHints() with proper hints when `panelistEnabled` is false, attendeeCount is true', () => {
+          ControlsOptionsUtil.canUpdateViewTheParticipantsList({properties: {enabled: true, panelistEnabled: false, attendeeCount: true}}, []);
+
+          assert.calledWith(ControlsOptionsUtil.hasHints, {
+            requiredHints: [DISPLAY_HINTS.ENABLE_VIEW_THE_PARTICIPANT_LIST,
+              DISPLAY_HINTS.DISABLE_VIEW_THE_PARTICIPANT_LIST_PANELIST,
+              DISPLAY_HINTS.ENABLE_SHOW_ATTENDEE_COUNT],
+            displayHints: [],
+          });
+        });
+
         it('should return the resolution of hasHints()', () => {
           const expected = 'example-return-value';
           ControlsOptionsUtil.hasHints.returns(expected);