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

package/src/meeting-info/meeting-info-v2.ts

@@ -16,6 +16,9 @@ const CAPTCHA_ERROR_DEFAULT_MESSAGE =
   'Captcha required. Call fetchMeetingInfo() with captchaInfo argument';
 const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
+const MEETING_IS_IN_PROGRESS_MESSAGE = 'Meeting is in progress';
+const STATIC_MEETING_LINK_ALREADY_EXISTS_MESSAGE = 'Static meeting link already exists';
+const FETCH_STATIC_MEETING_LINK = 'Meeting link does not exists for conversation';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
 const CAPTCHA_ERROR_REQUIRES_REGISTRATION_ID_CODES = [423007];
 
@@ -193,6 +196,77 @@ export class MeetingInfoV2JoinForbiddenError extends Error {
   }
 }
 
+/**
+ * Error fetching static link for a conversation when it does not exist
+ */
+export class MeetingInfoV2StaticLinkDoesNotExistError extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, message: string = FETCH_STATIC_MEETING_LINK) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2StaticLinkDoesNotExistError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+/**
+ * Error enabling/disabling static meeting link
+ */
+export class MeetingInfoV2MeetingIsInProgressError extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   * @param {Boolean} [enable]
+   */
+  constructor(
+    wbxAppApiErrorCode?: number,
+    message = MEETING_IS_IN_PROGRESS_MESSAGE,
+    enable = false
+  ) {
+    super(`${message}, code=${wbxAppApiErrorCode}, enable=${enable}`);
+    this.name = 'MeetingInfoV2MeetingIsInProgressError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+/**
+ * Error enabling/disabling static meeting link
+ */
+export class MeetingInfoV2StaticMeetingLinkAlreadyExists extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, message = STATIC_MEETING_LINK_ALREADY_EXISTS_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2StaticMeetingLinkAlreadyExists';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
 /**
  * @class MeetingInfo
  */
@@ -293,17 +367,20 @@ export default class MeetingInfoV2 {
   };
 
   /**
-   * Creates adhoc space meetings for a space by fetching the conversation infomation
+   * helper function to either create an adhoc space meeting or enable static meeting link
    * @param {String} conversationUrl conversationUrl to start adhoc meeting on
    * @param {String} installedOrgID org ID of user's machine
+   * @param {Boolean} enableStaticMeetingLink whether or not to enable static meeting link
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
    */
-  async createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string) {
-    if (!this.webex.meetings.preferredWebexSite) {
-      throw Error('No preferred webex site found');
-    }
+  async createAdhocSpaceMeetingOrEnableStaticMeetingLink(
+    conversationUrl: string,
+    installedOrgID?: string,
+    // setting this to true enables static meeting link
+    enableStaticMeetingLink = false
+  ) {
     const getInvitees = (particpants = []) => {
       const invitees = [];
 
@@ -329,6 +406,7 @@ export default class MeetingInfoV2 {
           kroUrl: conversation.kmsResourceObjectUrl,
           invitees: getInvitees(conversation.participants?.items),
           installedOrgID,
+          schedule: enableStaticMeetingLink,
         };
 
         if (installedOrgID) {
@@ -344,7 +422,23 @@ export default class MeetingInfoV2 {
           uri,
           body,
         });
-      })
+      });
+  }
+
+  /**
+   * Creates adhoc space meetings for a space by fetching the conversation infomation
+   * @param {String} conversationUrl conversationUrl to start adhoc meeting on
+   * @param {String} installedOrgID org ID of user's machine
+   * @returns {Promise} returns a meeting info object
+   * @public
+   * @memberof MeetingInfo
+   */
+  async createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    return this.createAdhocSpaceMeetingOrEnableStaticMeetingLink(conversationUrl, installedOrgID)
       .then((requestResult) => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
 
@@ -363,6 +457,153 @@ export default class MeetingInfoV2 {
       });
   }
 
+  /**
+   * Fetches details for static meeting link
+   * @param {String} conversationUrl conversationUrl that's required to find static meeting link if it exists
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async fetchStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    const body = {
+      spaceUrl: conversationUrl,
+    };
+
+    const uri = this.webex.meetings.preferredWebexSite
+      ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant/query`
+      : '';
+
+    return this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        uri,
+        body,
+      })
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_STATIC_MEETING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_LINK_DOES_NOT_EXIST_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2StaticLinkDoesNotExistError(err.body?.code, err.body?.message);
+        }
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_STATIC_MEETING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
+  /**
+   * Enables static meeting link
+   * @param {String} conversationUrl conversationUrl that's required to enable static meeting link
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async enableStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    return this.createAdhocSpaceMeetingOrEnableStaticMeetingLink(conversationUrl, undefined, true)
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ENABLE_STATIC_METTING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_IS_IN_PROGRESS_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2MeetingIsInProgressError(err.body?.code, err.body?.message, true);
+        }
+
+        if (err?.statusCode === 409) {
+          Metrics.sendBehavioralMetric(
+            BEHAVIORAL_METRICS.STATIC_MEETING_LINK_ALREADY_EXISTS_ERROR,
+            {
+              reason: err.message,
+              stack: err.stack,
+            }
+          );
+
+          throw new MeetingInfoV2StaticMeetingLinkAlreadyExists(err.body?.code, err.body?.message);
+        }
+
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ENABLE_STATIC_METTING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
+  /**
+   * Disables static meeting link for given conversation url
+   * @param {String} conversationUrl conversationUrl that's required to disable static meeting link if it exists
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async disableStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    const body = {
+      spaceUrl: conversationUrl,
+    };
+
+    const uri = this.webex.meetings.preferredWebexSite
+      ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant/deletePersistentMeeting`
+      : '';
+
+    return this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        uri,
+        body,
+      })
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DISABLE_STATIC_MEETING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_IS_IN_PROGRESS_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2MeetingIsInProgressError(err.body?.code, err.body?.message);
+        }
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DISABLE_STATIC_MEETING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
   /**
    * Fetches meeting info from the server
    * @param {String} destination one of many different types of destinations to look up info for

package/src/meetings/index.ts

@@ -854,7 +854,7 @@ export default class Meetings extends WebexPlugin {
       this.executeRegistrationStep(
         () =>
           this.startReachability('registration').catch((error) => {
-            LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
+            LoggerProxy.logger.warn(`Meetings:index#register --> startReachability failed:`, error);
           }),
         'startReachability'
       ),
@@ -1217,6 +1217,29 @@ export default class Meetings extends WebexPlugin {
     );
   }
 
+  /**
+   * Fetch static meeting link for given conversation url.
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public fetchStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .fetchStaticMeetingLink(conversationUrl)
+        // Catch a failure to fetch static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#fetchStaticMeetingLink --> ERROR, unable to fetch persistent meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
   /**
    * Create a meeting or return an existing meeting.
    *
@@ -1369,6 +1392,54 @@ export default class Meetings extends WebexPlugin {
     );
   }
 
+  /**
+   * Enable static meeting links for given conversation url.
+   *
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public enableStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .enableStaticMeetingLink(conversationUrl)
+        // Catch a failure to enable static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#enableStaticMeetingLink --> ERROR, unable to enable static meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
+  /**
+   * Disable static meeting links for given conversation url.
+   *
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public disableStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .disableStaticMeetingLink(conversationUrl)
+        // Catch a failure to disable static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#disableStaticMeetingLink --> ERROR, unable to disable static meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
   /**
    * Create meeting
    *

package/src/member/index.ts

@@ -23,6 +23,7 @@ export default class Member {
   isInMeeting: any;
   isModerator: any;
   isModeratorAssignmentProhibited: any;
+  isPresenterAssignmentProhibited: any;
   isMutable: any;
   isNotAdmitted: any;
   isRecording: any;
@@ -257,6 +258,14 @@ export default class Member {
      */
     this.isModeratorAssignmentProhibited = null;
 
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.isPresenterAssignmentProhibited = null;
+
     /**
      * @instance
      * @type {IExternalRoles}
@@ -309,6 +318,8 @@ export default class Member {
       this.isModerator = MemberUtil.isModerator(participant);
       this.isModeratorAssignmentProhibited =
         MemberUtil.isModeratorAssignmentProhibited(participant);
+      this.isPresenterAssignmentProhibited =
+        MemberUtil.isPresenterAssignmentProhibited(participant);
       this.processStatus(participant);
       this.processRoles(participant as ParticipantWithRoles);
       // must be done last

package/src/member/util.ts

@@ -127,6 +127,9 @@ MemberUtil.isDevice = (participant: any) => participant && participant.type ===
 MemberUtil.isModeratorAssignmentProhibited = (participant) =>
   participant && participant.moderatorAssignmentNotAllowed;
 
+MemberUtil.isPresenterAssignmentProhibited = (participant) =>
+  participant && participant.presenterAssignmentNotAllowed;
+
 /**
  * checks to see if the participant id is the same as the passed id
  * there are multiple ids that can be used

package/src/metrics/constants.ts

@@ -48,10 +48,19 @@ const BEHAVIORAL_METRICS = {
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   UPLOAD_LOGS_SUCCESS: 'js_sdk_upload_logs_success',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
+  MEETING_IS_IN_PROGRESS_ERROR: 'js_sdk_meeting_is_in_progress_error',
+  STATIC_MEETING_LINK_ALREADY_EXISTS_ERROR: 'js_sdk_static_meeting_link_already_exists_error',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
+  ENABLE_STATIC_METTING_LINK_SUCCESS: 'js_sdk_enable_static_meeting_link_success',
+  ENABLE_STATIC_METTING_LINK_FAILURE: 'js_sdk_enable_static_meeting_link_failure',
+  DISABLE_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_disable_static_meeting_link_success',
+  DISABLE_STATIC_MEETING_LINK_FAILURE: 'js_sdk_disable_static_meeting_link_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',
   ADHOC_MEETING_FAILURE: 'js_sdk_adhoc_meeting_failure',
+  FETCH_STATIC_MEETING_LINK_SUCCESS: 'js_sdk_fetch_static_meeting_link_success',
+  FETCH_STATIC_MEETING_LINK_FAILURE: 'js_sdk_fetch_static_meeting_link_failure',
+  MEETING_LINK_DOES_NOT_EXIST_ERROR: 'js_sdk_meeting_link_does_not_exist_error',
   VERIFY_PASSWORD_SUCCESS: 'js_sdk_verify_password_success',
   VERIFY_PASSWORD_ERROR: 'js_sdk_verify_password_error',
   VERIFY_CAPTCHA_ERROR: 'js_sdk_verify_captcha_error',

package/src/reachability/clusterReachability.ts

@@ -6,7 +6,7 @@ import {convertStunUrlToTurn, convertStunUrlToTurnTls} from './util';
 import EventsScope from '../common/events/events-scope';
 
 import {CONNECTION_STATE, Enum, ICE_GATHERING_STATE} from '../constants';
-import {ClusterReachabilityResult} from './reachability.types';
+import {ClusterReachabilityResult, NatType} from './reachability.types';
 
 // data for the Events.resultReady event
 export type ResultEventData = {
@@ -22,9 +22,14 @@ export type ClientMediaIpsUpdatedEventData = {
   clientMediaIPs: string[];
 };
 
+export type NatTypeUpdatedEventData = {
+  natType: NatType;
+};
+
 export const Events = {
   resultReady: 'resultReady', // emitted when a cluster is reached successfully using specific protocol
   clientMediaIpsUpdated: 'clientMediaIpsUpdated', // emitted when more public IPs are found after resultReady was already sent for a given protocol
+  natTypeUpdated: 'natTypeUpdated', // emitted when NAT type is determined
 } as const;
 
 export type Events = Enum<typeof Events>;
@@ -41,6 +46,7 @@ export class ClusterReachability extends EventsScope {
   private pc?: RTCPeerConnection;
   private defer: Defer; // this defer is resolved once reachability checks for this cluster are completed
   private startTimestamp: number;
+  private srflxIceCandidates: RTCIceCandidate[] = [];
   public readonly isVideoMesh: boolean;
   public readonly name;
 
@@ -290,6 +296,44 @@ export class ClusterReachability extends EventsScope {
     }
   }
 
+  /**
+   * Determines NAT Type.
+   *
+   * @param {RTCIceCandidate} candidate
+   * @returns {void}
+   */
+  private determineNatType(candidate: RTCIceCandidate) {
+    this.srflxIceCandidates.push(candidate);
+
+    if (this.srflxIceCandidates.length > 1) {
+      const portsFound: Record<string, Set<number>> = {};
+
+      this.srflxIceCandidates.forEach((c) => {
+        const key = `${c.address}:${c.relatedPort}`;
+        if (!portsFound[key]) {
+          portsFound[key] = new Set();
+        }
+        portsFound[key].add(c.port);
+      });
+
+      Object.entries(portsFound).forEach(([, ports]) => {
+        if (ports.size > 1) {
+          // Found candidates with the same address and relatedPort, but different ports
+          this.emit(
+            {
+              file: 'clusterReachability',
+              function: 'determineNatType',
+            },
+            Events.natTypeUpdated,
+            {
+              natType: NatType.SymmetricNat,
+            }
+          );
+        }
+      });
+    }
+  }
+
   /**
    * Registers a listener for the icecandidate event
    *
@@ -308,6 +352,8 @@ export class ClusterReachability extends EventsScope {
       if (e.candidate) {
         if (e.candidate.type === CANDIDATE_TYPES.SERVER_REFLEXIVE) {
           this.saveResult('udp', latencyInMilliseconds, e.candidate.address);
+
+          this.determineNatType(e.candidate);
         }
 
         if (e.candidate.type === CANDIDATE_TYPES.RELAY) {

package/src/reachability/index.ts

@@ -23,11 +23,13 @@ import {
   ReachabilityResultsForBackend,
   TransportResultForBackend,
   GetClustersTrigger,
+  NatType,
 } from './reachability.types';
 import {
   ClientMediaIpsUpdatedEventData,
   ClusterReachability,
   Events,
+  NatTypeUpdatedEventData,
   ResultEventData,
 } from './clusterReachability';
 import EventsScope from '../common/events/events-scope';
@@ -64,6 +66,7 @@ export default class Reachability extends EventsScope {
   resultsCount = {videoMesh: {udp: 0}, public: {udp: 0, tcp: 0, xtls: 0}};
   startTime = undefined;
   totalDuration = undefined;
+  natType = NatType.Unknown;
 
   protected lastTrigger?: string;
 
@@ -143,6 +146,10 @@ export default class Reachability extends EventsScope {
    * @memberof Reachability
    */
   public async gatherReachability(trigger: string): Promise<ReachabilityResults> {
+    // @ts-ignore
+    if (!this.webex.config.meetings.enableReachabilityChecks) {
+      throw new Error('enableReachabilityChecks is disabled in config');
+    }
     // Fetch clusters and measure latency
     try {
       this.lastTrigger = trigger;
@@ -305,6 +312,7 @@ export default class Reachability extends EventsScope {
       reachability_vmn_tcp_failed: 0,
       reachability_vmn_xtls_success: 0,
       reachability_vmn_xtls_failed: 0,
+      natType: this.natType,
     };
 
     const updateStats = (clusterType: 'public' | 'vmn', result: ClusterReachabilityResult) => {
@@ -963,6 +971,13 @@ export default class Reachability extends EventsScope {
         }
       );
 
+      this.clusterReachability[key].on(
+        Events.natTypeUpdated,
+        async (data: NatTypeUpdatedEventData) => {
+          this.natType = data.natType;
+        }
+      );
+
       this.clusterReachability[key].start(); // not awaiting on purpose
     });
   }

package/src/reachability/reachability.types.ts

@@ -7,6 +7,11 @@ export type TransportResult = {
   clientMediaIPs?: string[];
 };
 
+export enum NatType {
+  Unknown = 'unknown',
+  SymmetricNat = 'symmetric-nat',
+}
+
 // reachability result for a specific media cluster
 export type ClusterReachabilityResult = {
   udp: TransportResult;
@@ -27,6 +32,7 @@ export type ReachabilityMetrics = {
   reachability_vmn_tcp_failed: number;
   reachability_vmn_xtls_success: number;
   reachability_vmn_xtls_failed: number;
+  natType: NatType;
 };
 
 /**

package/src/reachability/request.ts

@@ -45,6 +45,9 @@ class ReachabilityRequest {
     joinCookie: any;
     discoveryOptions?: Record<string, any>;
   }> => {
+    const appType = this.webex?.config?.support?.appType;
+    const appVersion = this.webex?.config?.support?.appVersion;
+
     // we only measure latency for the initial startup call, not for other triggers
     const callWrapper =
       trigger === 'startup'
@@ -67,6 +70,10 @@ class ReachabilityRequest {
               'early-call-min-clusters': true,
             },
             'previous-report': previousReport,
+            ...(appType &&
+              appVersion && {
+                'client-environment': {components: {[appType]: appVersion}},
+              }),
             trigger,
           },
           timeout: this.webex.config.meetings.reachabilityGetClusterTimeout,

package/test/unit/spec/locus-info/controlsUtils.js

@@ -269,6 +269,14 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasPracticeSessionEnabledChanged, true);
       });
 
+      it('returns hasPracticeSessionEnabledChanged = false when enabled is false and previous state is false', () => {
+        const newControls = {practiceSession: {enabled: false}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasPracticeSessionEnabledChanged, false);
+      });
+
       it('returns hasEntryExitToneChanged = true when mode changed', () => {
         const newControls = {
           entryExitTone: {