@webex/plugin-meetings 3.7.0-wxcc.1 → 3.8.0

package/src/meeting/index.ts

@@ -122,8 +122,9 @@ import {
   ROAP_OFFER_ANSWER_EXCHANGE_TIMEOUT,
   NAMED_MEDIA_GROUP_TYPE_AUDIO,
   WEBINAR_ERROR_WEBCAST,
-  WEBINAR_ERROR_REGISTRATIONID,
+  WEBINAR_ERROR_REGISTRATION_ID,
   JOIN_BEFORE_HOST,
+  REGISTRATION_ID_STATUS,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -163,6 +164,7 @@ import {LocusMediaRequest} from './locusMediaRequest';
 import {ConnectionStateHandler, ConnectionStateEvent} from './connectionStateHandler';
 import JoinWebinarError from '../common/errors/join-webinar-error';
 import Member from '../member';
+import {BrbState, createBrbState} from './brbState';
 import MultistreamNotSupportedError from '../common/errors/multistream-not-supported-error';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
 
@@ -255,6 +257,7 @@ export enum ScreenShareFloorStatus {
 
 type FetchMeetingInfoParams = {
   password?: string;
+  registrationId?: string;
   captchaCode?: string;
   extraParams?: Record<string, any>;
   sendCAevents?: boolean;
@@ -649,6 +652,8 @@ export default class Meeting extends StatelessWebexPlugin {
   turnServerUsed: boolean;
   areVoiceaEventsSetup = false;
   isMoveToInProgress = false;
+  registrationIdStatus: string;
+  brbState: BrbState;
 
   voiceaListenerCallbacks: object = {
     [VOICEAEVENTS.VOICEA_ANNOUNCEMENT]: (payload: Transcription['languageOptions']) => {
@@ -1345,6 +1350,16 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.passwordStatus = PASSWORD_STATUS.UNKNOWN;
 
+    /**
+     * registrationId status. If it's REGISTRATIONID_STATUS.REQUIRED then verifyRegistrationId() needs to be called
+     * with the correct registrationId before calling join()
+     * @instance
+     * @type {REGISTRATION_ID_STATUS}
+     * @public
+     * @memberof Meeting
+     */
+    this.registrationIdStatus = REGISTRATION_ID_STATUS.UNKNOWN;
+
     /**
      * Information about required captcha. If null, then no captcha is required. status. If it's PASSWORD_STATUS.REQUIRED then verifyPassword() needs to be called
      * with the correct password before calling join()
@@ -1657,6 +1672,15 @@ export default class Meeting extends StatelessWebexPlugin {
       this.passwordStatus = PASSWORD_STATUS.NOT_REQUIRED;
     }
 
+    if (
+      this.registrationIdStatus === REGISTRATION_ID_STATUS.REQUIRED ||
+      this.registrationIdStatus === REGISTRATION_ID_STATUS.VERIFIED
+    ) {
+      this.registrationIdStatus = REGISTRATION_ID_STATUS.VERIFIED;
+    } else {
+      this.registrationIdStatus = REGISTRATION_ID_STATUS.NOT_REQUIRED;
+    }
+
     Trigger.trigger(
       this,
       {
@@ -1700,7 +1724,12 @@ export default class Meeting extends StatelessWebexPlugin {
    * @private
    */
   private prepForFetchMeetingInfo(
-    {password = null, captchaCode = null, extraParams = {}}: FetchMeetingInfoParams,
+    {
+      password = null,
+      registrationId = null,
+      captchaCode = null,
+      extraParams = {},
+    }: FetchMeetingInfoParams,
     caller: string
   ): Promise<void> {
     // when fetch meeting info is called directly by the client, we want to clear out the random timer for sdk to do it
@@ -1740,6 +1769,7 @@ export default class Meeting extends StatelessWebexPlugin {
     captchaCode = null,
     extraParams = {},
     sendCAevents = false,
+    registrationId = null,
   }): Promise<void> {
     try {
       const captchaInfo = captchaCode
@@ -1755,7 +1785,8 @@ export default class Meeting extends StatelessWebexPlugin {
         this.config.installedOrgID,
         this.locusId,
         extraParams,
-        {meetingId: this.id, sendCAevents}
+        {meetingId: this.id, sendCAevents},
+        registrationId
       );
 
       this.parseMeetingInfo(info?.body, this.destination, info?.errors);
@@ -1777,14 +1808,15 @@ export default class Meeting extends StatelessWebexPlugin {
         this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_REGISTRATION;
         if (WEBINAR_ERROR_WEBCAST.includes(err.wbxAppApiCode)) {
           this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.NEED_JOIN_WITH_WEBCAST;
-        } else if (WEBINAR_ERROR_REGISTRATIONID.includes(err.wbxAppApiCode)) {
-          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATIONID;
+        } else if (WEBINAR_ERROR_REGISTRATION_ID.includes(err.wbxAppApiCode)) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WEBINAR_NEED_REGISTRATION_ID;
         }
         this.meetingInfoFailureCode = err.wbxAppApiCode;
 
         if (err.meetingInfo) {
           this.meetingInfo = err.meetingInfo;
         }
+        this.requiredCaptcha = null;
 
         throw new JoinWebinarError();
       } else if (err instanceof MeetingInfoV2JoinForbiddenError) {
@@ -1829,9 +1861,13 @@ export default class Meeting extends StatelessWebexPlugin {
           `Meeting:index#fetchMeetingInfo --> Info Unable to fetch meeting info for ${this.destination} - captcha required (code=${err?.body?.code}).`
         );
 
-        this.meetingInfoFailureReason = this.requiredCaptcha
-          ? MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA
-          : MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+        if (this.requiredCaptcha) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_CAPTCHA;
+        } else if (err.isRegistrationIdRequired) {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_REGISTRATION_ID;
+        } else {
+          this.meetingInfoFailureReason = MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD;
+        }
 
         this.meetingInfoFailureCode = err.wbxAppApiCode;
 
@@ -1839,6 +1875,10 @@ export default class Meeting extends StatelessWebexPlugin {
           this.passwordStatus = PASSWORD_STATUS.REQUIRED;
         }
 
+        if (err.isRegistrationIdRequired) {
+          this.registrationIdStatus = REGISTRATION_ID_STATUS.REQUIRED;
+        }
+
         this.requiredCaptcha = err.captchaInfo;
         throw new CaptchaError();
       } else {
@@ -1979,6 +2019,48 @@ export default class Meeting extends StatelessWebexPlugin {
       });
   }
 
+  /**
+   * Checks if the supplied registrationId is correct. It returns a promise with information whether the
+   * registrationId and captcha code were correct or not.
+   * @param {String | undefined} registrationId - can be undefined if only captcha was required
+   * @param {String | undefined} captchaCode - can be undefined if captcha was not required by the server
+   * @param {Boolean} sendCAevents - whether Call Analyzer events should be sent when fetching meeting information
+   * @public
+   * @memberof Meeting
+   * @returns {Promise<{isRegistrationIdValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
+   */
+  public verifyRegistrationId(registrationId: string, captchaCode: string, sendCAevents = false) {
+    return this.fetchMeetingInfo({
+      registrationId,
+      captchaCode,
+      sendCAevents,
+    })
+      .then(() => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_REGISTRATION_ID_SUCCESS);
+
+        return {
+          isRegistrationIdValid: true,
+          requiredCaptcha: null,
+          failureReason: MEETING_INFO_FAILURE_REASON.NONE,
+        };
+      })
+      .catch((error) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_REGISTRATION_ID_ERROR);
+
+        if (error instanceof JoinWebinarError || error instanceof CaptchaError) {
+          return {
+            isRegistrationIdValid: this.registrationIdStatus === REGISTRATION_ID_STATUS.VERIFIED,
+            requiredCaptcha: this.requiredCaptcha,
+            failureReason:
+              error instanceof JoinWebinarError
+                ? MEETING_INFO_FAILURE_REASON.WRONG_REGISTRATION_ID
+                : this.meetingInfoFailureReason,
+          };
+        }
+        throw error;
+      });
+  }
+
   /**
    * Refreshes the captcha. As a result the meeting will have new captcha id, image and audio.
    * If the refresh operation fails, meeting remains with the old captcha properties.
@@ -3349,6 +3431,10 @@ export default class Meeting extends StatelessWebexPlugin {
     // The second on is if the audio is muted, we need to tell the statsAnalyzer when
     // the audio is muted or the user is not willing to send media
     this.locusInfo.on(LOCUSINFO.EVENTS.MEDIA_STATUS_CHANGE, (status) => {
+      LoggerProxy.logger.info(
+        'Meeting:index#setUpLocusInfoSelfListener --> MEDIA_STATUS_CHANGE received, processing...'
+      );
+
       if (this.statsAnalyzer) {
         this.statsAnalyzer.updateMediaStatus({
           actual: status,
@@ -3362,6 +3448,10 @@ export default class Meeting extends StatelessWebexPlugin {
             receiveShare: this.mediaProperties.mediaDirection?.receiveShare,
           },
         });
+      } else {
+        LoggerProxy.logger.warn(
+          'Meeting:index#setUpLocusInfoSelfListener --> MEDIA_STATUS_CHANGE, statsAnalyzer is not available.'
+        );
       }
     });
 
@@ -3407,6 +3497,7 @@ export default class Meeting extends StatelessWebexPlugin {
     });
 
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED, (payload) => {
+      this.brbState?.handleServerBrbUpdate(payload?.brb?.enabled);
       Trigger.trigger(
         this,
         {
@@ -3650,22 +3741,7 @@ export default class Meeting extends StatelessWebexPlugin {
       return Promise.reject(error);
     }
 
-    // this logic should be applied only to multistream meetings
-    return this.meetingRequest
-      .setBrb({
-        enabled,
-        locusUrl: this.locusUrl,
-        deviceUrl: this.deviceUrl,
-        selfId: this.selfId,
-      })
-      .then(() => {
-        this.sendSlotManager.setSourceStateOverride(MediaType.VideoMain, enabled ? 'away' : null);
-      })
-      .catch((error) => {
-        LoggerProxy.logger.error('Meeting:index#beRightBack --> Error ', error);
-
-        return Promise.reject(error);
-      });
+    return this.brbState.enable(enabled, this.sendSlotManager);
   }
 
   /**
@@ -6099,9 +6175,12 @@ export default class Meeting extends StatelessWebexPlugin {
    * @returns {undefined}
    */
   public roapMessageReceived = (roapMessage: RoapMessage) => {
-    const mediaServer = MeetingsUtil.getMediaServer(roapMessage.sdp);
+    const mediaServer =
+      roapMessage.messageType === 'ANSWER'
+        ? MeetingsUtil.getMediaServer(roapMessage.sdp)
+        : undefined;
 
-    if (this.isMultistream && mediaServer !== 'homer') {
+    if (this.isMultistream && mediaServer && mediaServer !== 'homer') {
       throw new MultistreamNotSupportedError(
         `Client asked for multistream backend (Homer), but got ${mediaServer} instead`
       );
@@ -6716,6 +6795,9 @@ export default class Meeting extends StatelessWebexPlugin {
         new RtcMetrics(this.webex, {meetingId: this.id}, this.correlationId)
       : undefined;
 
+    // ongoing reachability checks slow down new media connections especially on Firefox, so we stop them
+    this.getWebexObject().meetings.reachability.stopReachability();
+
     const mc = Media.createMediaConnection(
       this.isMultistream,
       this.getMediaConnectionDebugId(),
@@ -7432,6 +7514,7 @@ export default class Meeting extends StatelessWebexPlugin {
 
     this.audio = createMuteState(AUDIO, this, audioEnabled);
     this.video = createMuteState(VIDEO, this, videoEnabled);
+    this.brbState = createBrbState(this, false);
 
     try {
       await this.setUpLocalStreamReferences(localStreams);
@@ -7467,6 +7550,9 @@ export default class Meeting extends StatelessWebexPlugin {
           throw error;
         }
       }
+
+      LoggerProxy.logger.info(`${LOG_HEADER} media connected, finalizing...`);
+
       if (this.mediaProperties.hasLocalShareStream()) {
         await this.enqueueScreenShareFloorRequest();
       }

package/src/meeting/muteState.ts

@@ -379,12 +379,7 @@ export class MuteState {
     }
     if (muted !== undefined) {
       this.state.server.remoteMute = muted;
-
-      // We never want to unmute the local stream from a server remote mute update.
-      // Moderated unmute is handled by a different function.
-      if (muted) {
-        this.muteLocalStream(meeting, muted, 'remotelyMuted');
-      }
+      this.muteLocalStream(meeting, muted, 'remotelyMuted');
     }
   }
 

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

@@ -17,6 +17,8 @@ const CAPTCHA_ERROR_DEFAULT_MESSAGE =
 const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
+const CAPTCHA_ERROR_REQUIRES_REGISTRATION_ID_CODES = [423007];
+
 const POLICY_ERROR_CODES = [403049, 403104, 403103, 403048, 403102, 403101];
 const JOIN_FORBIDDEN_CODES = [403003];
 /**
@@ -113,6 +115,7 @@ export class MeetingInfoV2PolicyError extends Error {
 export class MeetingInfoV2CaptchaError extends Error {
   captchaInfo: any;
   isPasswordRequired: any;
+  isRegistrationIdRequired: any;
   sdkMessage: any;
   wbxAppApiCode: any;
   body: any;
@@ -134,6 +137,8 @@ export class MeetingInfoV2CaptchaError extends Error {
     this.stack = new Error().stack;
     this.wbxAppApiCode = wbxAppApiErrorCode;
     this.isPasswordRequired = CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES.includes(wbxAppApiErrorCode);
+    this.isRegistrationIdRequired =
+      CAPTCHA_ERROR_REQUIRES_REGISTRATION_ID_CODES.includes(wbxAppApiErrorCode);
     this.captchaInfo = captchaInfo;
   }
 }
@@ -370,6 +375,7 @@ export default class MeetingInfoV2 {
    * @param {String} locusId
    * @param {Object} extraParams
    * @param {Object} options
+   * @param {String} registrationId
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
@@ -385,7 +391,8 @@ export default class MeetingInfoV2 {
     installedOrgID = null,
     locusId = null,
     extraParams: object = {},
-    options: {meetingId?: string; sendCAevents?: boolean} = {}
+    options: {meetingId?: string; sendCAevents?: boolean} = {},
+    registrationId: string = null
   ) {
     const {meetingId, sendCAevents} = options;
 
@@ -410,6 +417,7 @@ export default class MeetingInfoV2 {
       installedOrgID,
       locusId,
       extraParams,
+      registrationId,
     });
 
     // If the body only contains the default properties, we don't have enough to

package/src/meeting-info/utilv2.ts

@@ -228,8 +228,16 @@ export default class MeetingInfoUtil {
    * @returns {Object} returns an object with {resource, method}
    */
   static getRequestBody(options: {type: DESTINATION_TYPE; destination: object} | any) {
-    const {type, destination, password, captchaInfo, installedOrgID, locusId, extraParams} =
-      options;
+    const {
+      type,
+      destination,
+      password,
+      captchaInfo,
+      installedOrgID,
+      locusId,
+      extraParams,
+      registrationId,
+    } = options;
     const body: any = {
       ...DEFAULT_MEETING_INFO_REQUEST_BODY,
       ...extraParams,
@@ -271,6 +279,10 @@ export default class MeetingInfoUtil {
       body.password = password;
     }
 
+    if (registrationId) {
+      body.registrationId = registrationId;
+    }
+
     if (captchaInfo) {
       body.captchaID = captchaInfo.id;
       body.captchaVerifyCode = captchaInfo.code;

package/src/metrics/constants.ts

@@ -73,6 +73,8 @@ const BEHAVIORAL_METRICS = {
   JOIN_WEBINAR_ERROR: 'js_sdk_join_webinar_error',
   GUEST_ENTERED_LOBBY: 'js_sdk_guest_entered_lobby',
   GUEST_EXITED_LOBBY: 'js_sdk_guest_exited_lobby',
+  VERIFY_REGISTRATION_ID_SUCCESS: 'js_sdk_verify_registrationId_success',
+  VERIFY_REGISTRATION_ID_ERROR: 'js_sdk_verify_registrationId_error',
   JOIN_FORBIDDEN_ERROR: 'js_sdk_join_forbidden_error',
 };
 

package/src/reachability/index.ts

@@ -259,6 +259,32 @@ export default class Reachability extends EventsScope {
     }
   }
 
+  /**
+   * Stops all reachability checks that are in progress
+   * @public
+   * @memberof Reachability
+   * @returns {void}
+   */
+  public stopReachability() {
+    // overallTimer is always there only if there is reachability in progress
+    if (this.overallTimer) {
+      LoggerProxy.logger.log(
+        'Reachability:index#stopReachability --> stopping reachability checks'
+      );
+      this.abortCurrentChecks();
+      this.emit(
+        {
+          file: 'reachability',
+          function: 'stopReachability',
+        },
+        'reachability:stopped',
+        {}
+      );
+      this.sendMetric(true);
+      this.resolveReachabilityPromise();
+    }
+  }
+
   /**
    * Returns statistics about last reachability results. The returned value is an object
    * with a flat list of properties so that it can be easily sent with metrics
@@ -637,9 +663,10 @@ export default class Reachability extends EventsScope {
   /**
    * Sends a metric with all the statistics about how long reachability took
    *
+   * @param {boolean} aborted true if the reachability checks were aborted
    * @returns {void}
    */
-  protected async sendMetric() {
+  protected async sendMetric(aborted = false) {
     const results = [];
 
     Object.values(this.clusterReachability).forEach((clusterReachability) => {
@@ -650,6 +677,7 @@ export default class Reachability extends EventsScope {
     });
 
     const stats = {
+      aborted,
       vmn: {
         udp: this.getStatistics(results, 'udp', true),
       },

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

@@ -450,6 +450,16 @@ describe('plugin-meetings', () => {
       assert.equal(SelfUtils.mutedByOthersChanged(null, {remoteMuted: true}), true);
     });
 
+    it('should return false when selfIdentity and modifiedBy are the same', function () {
+      assert.equal(
+        SelfUtils.mutedByOthersChanged(
+          {remoteMuted: false},
+          {remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user1'}
+        ),
+        false
+      );
+    });
+
     it('should return true when remoteMuted values are different', function () {
       assert.equal(
         SelfUtils.mutedByOthersChanged(

package/test/unit/spec/media/properties.ts

@@ -66,6 +66,21 @@ describe('MediaProperties', () => {
       assert.equal(numTransports, 0);
     });
 
+    it('handles time out in the case when getStats() is not resolving', async () => {
+      // Promise that never resolves
+      mockMC.getStats = new Promise(() => {});
+
+      const promise = mediaProperties.getCurrentConnectionInfo();
+
+      await clock.tickAsync(1000);
+
+      const {connectionType, selectedCandidatePairChanges, numTransports} = await promise;
+
+      assert.equal(connectionType, 'unknown');
+      assert.equal(selectedCandidatePairChanges, -1);
+      assert.equal(numTransports, 0);
+    });
+
     describe('selectedCandidatePairChanges and numTransports', () => {
       it('returns correct values when getStats() returns no transport stats at all', async () => {
         mockMC.getStats.resolves([{type: 'something', id: '1234'}]);

package/test/unit/spec/meeting/brbState.ts

@@ -0,0 +1,114 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+
+import testUtils from '../../../utils/testUtils';
+import {BrbState, createBrbState} from '@webex/plugin-meetings/src/meeting/brbState';
+
+describe('plugin-meetings', () => {
+  let meeting: any;
+  let brbState: BrbState;
+
+  beforeEach(async () => {
+    meeting = {
+      isMultistream: true,
+      locusUrl: 'locus url',
+      deviceUrl: 'device url',
+      selfId: 'self id',
+      mediaProperties: {
+        webrtcMediaConnection: true,
+      },
+      sendSlotManager: {
+        setSourceStateOverride: sinon.stub(),
+      },
+      meetingRequest: {
+        setBrb: sinon.stub().resolves(),
+      },
+    };
+
+    brbState = new BrbState(meeting, false);
+    await testUtils.flushPromises();
+  });
+
+  describe('brbState library', () => {
+    it('takes into account current status when instantiated', async () => {
+      // create a new BrbState instance
+      brbState = createBrbState(meeting, true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+
+      // now check the opposite case
+      brbState = createBrbState(meeting, false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+    });
+
+    it('can be enabled', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+      assert.isTrue(brbState.state.server.enabled);
+    });
+
+    it('can be disabled', async () => {
+      brbState.enable(false, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+      assert.isFalse(brbState.state.server.enabled);
+    });
+
+    it('does not send local brb state to server if it is not a multistream meeting', async () => {
+      meeting.isMultistream = false;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send local brb state to server if webrtc media connection is not defined', async () => {
+      meeting.mediaProperties.webrtcMediaConnection = undefined;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send request twice when in progress', async () => {
+      brbState.state.syncToServerInProgress = true;
+      brbState.enable(true, meeting.sendSlotManager);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('syncs with server when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.calledOnce);
+    });
+
+    it('sets source state override when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.sendSlotManager.setSourceStateOverride.calledOnce);
+    });
+
+    it('handles server update', async () => {
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.server.enabled);
+    });
+  });
+});