@webex/plugin-meetings 3.0.0-beta.174 → 3.0.0-beta.175

package/dist/types/constants.d.ts

@@ -218,6 +218,7 @@ export declare const EVENT_TRIGGERS: {
     MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE: string;
     MEETING_INTERPRETATION_UPDATE: string;
     MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE: string;
+    MEETING_INTERPRETATION_HANDOFF_REQUESTS_ARRIVED: string;
     MEMBERS_UPDATE: string;
     MEMBERS_CLEAR: string;
     MEMBERS_CONTENT_UPDATE: string;
@@ -463,7 +464,15 @@ export declare const BREAKOUTS: {
 export declare const INTERPRETATION: {
     EVENTS: {
         SUPPORT_LANGUAGES_UPDATE: string;
+        HANDOFF_REQUESTS_ARRIVED: string;
     };
+    ACTION_TYPE: {
+        OFFERED: string;
+        ACCEPTED: string;
+        REQUESTED: string;
+        DECLINED: string;
+    };
+    RESOURCE_TYPE: string;
 };
 export declare const LOCUSINFO: {
     EVENTS: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.174",
+  "version": "3.0.0-beta.175",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,12 +32,12 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.174",
-    "@webex/test-helper-chai": "3.0.0-beta.174",
-    "@webex/test-helper-mocha": "3.0.0-beta.174",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.174",
-    "@webex/test-helper-retry": "3.0.0-beta.174",
-    "@webex/test-helper-test-users": "3.0.0-beta.174",
+    "@webex/plugin-meetings": "3.0.0-beta.175",
+    "@webex/test-helper-chai": "3.0.0-beta.175",
+    "@webex/test-helper-mocha": "3.0.0-beta.175",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.175",
+    "@webex/test-helper-retry": "3.0.0-beta.175",
+    "@webex/test-helper-test-users": "3.0.0-beta.175",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
@@ -46,19 +46,19 @@
     "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.174",
+    "@webex/common": "3.0.0-beta.175",
     "@webex/internal-media-core": "1.39.1",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.174",
-    "@webex/internal-plugin-device": "3.0.0-beta.174",
-    "@webex/internal-plugin-llm": "3.0.0-beta.174",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.174",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.174",
-    "@webex/internal-plugin-support": "3.0.0-beta.174",
-    "@webex/internal-plugin-user": "3.0.0-beta.174",
-    "@webex/media-helpers": "3.0.0-beta.174",
-    "@webex/plugin-people": "3.0.0-beta.174",
-    "@webex/plugin-rooms": "3.0.0-beta.174",
-    "@webex/webex-core": "3.0.0-beta.174",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.175",
+    "@webex/internal-plugin-device": "3.0.0-beta.175",
+    "@webex/internal-plugin-llm": "3.0.0-beta.175",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.175",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.175",
+    "@webex/internal-plugin-support": "3.0.0-beta.175",
+    "@webex/internal-plugin-user": "3.0.0-beta.175",
+    "@webex/media-helpers": "3.0.0-beta.175",
+    "@webex/plugin-people": "3.0.0-beta.175",
+    "@webex/plugin-rooms": "3.0.0-beta.175",
+    "@webex/webex-core": "3.0.0-beta.175",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",

package/src/constants.ts

@@ -319,6 +319,7 @@ export const EVENT_TRIGGERS = {
   MEETING_BREAKOUTS_PRE_ASSIGNMENTS_UPDATE: 'meeting:breakouts:preAssignmentsUpdate',
   MEETING_INTERPRETATION_UPDATE: 'meeting:interpretation:update',
   MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE: 'meeting:interpretation:supportLanguagesUpdate',
+  MEETING_INTERPRETATION_HANDOFF_REQUESTS_ARRIVED: 'meeting:interpretation:handoffRequestsArrived',
   MEMBERS_UPDATE: 'members:update',
   MEMBERS_CLEAR: 'members:clear',
   MEMBERS_CONTENT_UPDATE: 'members:content:update',
@@ -597,7 +598,15 @@ export const BREAKOUTS = {
 export const INTERPRETATION = {
   EVENTS: {
     SUPPORT_LANGUAGES_UPDATE: 'SUPPORT_LANGUAGES_UPDATE',
+    HANDOFF_REQUESTS_ARRIVED: 'HANDOFF_REQUESTS_ARRIVED',
   },
+  ACTION_TYPE: {
+    OFFERED: 'OFFERED',
+    ACCEPTED: 'ACCEPTED',
+    REQUESTED: 'REQUESTED',
+    DECLINED: 'DECLINED',
+  },
+  RESOURCE_TYPE: 'SiHandover',
 };
 
 export const LOCUSINFO = {

package/src/interpretation/README.md

@@ -45,7 +45,16 @@ The following are methods available to the interpreters of a meeting.
 //Change direction of interpretation for an interpreter participant
 interpretation.changeDirection();
 
-//Handoff between interpreters, will implement them later
-interpretation.handoff(participantId)
+//Handoff between interpreters, input paramerter participantId is the target to handoff
+interpretation.handoffInterpreter(participantId);
+
+//in-active interpreter request to handoff to self
+interpretation.requestHandoff();
+
+//accept the request of handoff, input paramter url is from last approval event which generate by server side
+interpretation.acceptRequest(url);
+
+//decline the request of handoff, input paramter url is from last approval event which generate by server side
+interpretation.declineRequest(url);
 
 ```

package/src/interpretation/index.ts

@@ -18,6 +18,7 @@ const SimultaneousInterpretation = WebexPlugin.extend({
 
   props: {
     locusUrl: 'string', // appears current meeting's locus url
+    approvalUrl: 'string', // appears current meeting's approval url for handoff between interpreters
     originalLanguage: 'string', // appears current meeting's original language
     sourceLanguage: 'string', // appears self interpreter's source language
     targetLanguage: 'string', // appears self interpreter's target language
@@ -27,18 +28,18 @@ const SimultaneousInterpretation = WebexPlugin.extend({
     selfParticipantId: 'string', // appears the self participant id
     canManageInterpreters: 'boolean', // appears the ability to manage interpreters
     supportLanguages: 'array', // appears the support languages
-    siEnabled: 'boolean', // appears the meeting enabled SI
+    hostSIEnabled: 'boolean', // appears the meeting host feature of SI enabled
   },
   derived: {
     shouldQuerySupportLanguages: {
       cache: false,
-      deps: ['canManageInterpreters', 'siEnabled'],
+      deps: ['canManageInterpreters', 'hostSIEnabled'],
       /**
        * Returns should query support languages or not
        * @returns {boolean}
        */
       fn() {
-        return !!(this.canManageInterpreters && this.siEnabled);
+        return !!(this.canManageInterpreters && this.hostSIEnabled);
       },
     },
   },
@@ -52,6 +53,7 @@ const SimultaneousInterpretation = WebexPlugin.extend({
         this.querySupportLanguages();
       }
     });
+    this.listenToHandoffRequests();
   },
 
   /**
@@ -69,6 +71,14 @@ const SimultaneousInterpretation = WebexPlugin.extend({
   locusUrlUpdate(locusUrl) {
     this.set('locusUrl', locusUrl);
   },
+  /**
+   * Update the approval url for handoff
+   * @param {string} approvalUrl // approval url
+   * @returns {void}
+   */
+  approvalUrlUpdate(approvalUrl) {
+    this.set('approvalUrl', approvalUrl);
+  },
   /**
    * Update whether self has capability to manage interpreters (only host can manage it)
    * @param {boolean} canManageInterpreters
@@ -77,13 +87,20 @@ const SimultaneousInterpretation = WebexPlugin.extend({
   updateCanManageInterpreters(canManageInterpreters) {
     this.set('canManageInterpreters', canManageInterpreters);
   },
+  /**
+   * Update whether the meeting's host si is enabled or not
+   * @param {boolean} hostSIEnabled
+   * @returns {void}
+   */
+  updateHostSIEnabled(hostSIEnabled) {
+    this.set('hostSIEnabled', hostSIEnabled);
+  },
   /**
    * Update the interpretation languages channels which user can choose to subscribe
    * @param {Object} interpretation
    * @returns {void}
    */
   updateInterpretation(interpretation) {
-    this.set('siEnabled', !!interpretation);
     this.siLanguages.set(interpretation?.siLanguages || []);
   },
   /**
@@ -177,6 +194,125 @@ const SimultaneousInterpretation = WebexPlugin.extend({
       throw error;
     });
   },
+  /**
+   * Sets up a listener for handoff requests from mercury
+   * @returns {void}
+   */
+  listenToHandoffRequests() {
+    this.listenTo(this.webex.internal.mercury, 'event:locus.approval_request', (event) => {
+      if (event?.data?.approval?.resourceType === INTERPRETATION.RESOURCE_TYPE) {
+        const {receivers, initiator, actionType, url} = event.data.approval;
+        const receiverId = receivers?.[0]?.participantId;
+        const isReceiver = !!receiverId && receiverId === this.selfParticipantId;
+        const senderId = initiator?.participantId;
+        const isSender = !!senderId && senderId === this.selfParticipantId;
+        if (!isReceiver && !isSender) {
+          return;
+        }
+        this.trigger(INTERPRETATION.EVENTS.HANDOFF_REQUESTS_ARRIVED, {
+          actionType,
+          isReceiver,
+          isSender,
+          senderId,
+          receiverId,
+          url,
+        });
+      }
+    });
+  },
+  /**
+   * handoff the active interpreter role to another interpreter in same group, only the interpreter is allowed to call this api
+   * @param {string} participantId the participant id you want to hand off
+   * @returns {Promise}
+   */
+  handoffInterpreter(participantId) {
+    if (!participantId) {
+      return Promise.reject(new Error('Missing target participant id'));
+    }
+    if (!this.approvalUrl) {
+      return Promise.reject(new Error('Missing approval url'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: this.approvalUrl,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.OFFERED,
+        resourceType: INTERPRETATION.RESOURCE_TYPE,
+        receivers: [
+          {
+            participantId,
+          },
+        ],
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#handoffInterpreter failed', error);
+      throw error;
+    });
+  },
+  /**
+   * the in-active interpreter request to hand off the active role to self
+   * @returns {Promise}
+   */
+  requestHandoff() {
+    if (!this.approvalUrl) {
+      return Promise.reject(new Error('Missing approval url'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: this.approvalUrl,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.REQUESTED,
+        resourceType: INTERPRETATION.RESOURCE_TYPE,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#requestHandoff failed', error);
+      throw error;
+    });
+  },
+  /**
+   * accept the request of handoff
+   * @param {String} url the url get from last approval event
+   * @returns {Promise}
+   */
+  acceptRequest(url) {
+    if (!url) {
+      return Promise.reject(new Error('Missing the url to accept'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: url,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.ACCEPTED,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#acceptRequest failed', error);
+      throw error;
+    });
+  },
+  /**
+   * decline the request of handoff
+   * @param {String} url the url get from last approval event
+   * @returns {Promise}
+   */
+  declineRequest(url) {
+    if (!url) {
+      return Promise.reject(new Error('Missing the url to decline'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: url,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.DECLINED,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#declineRequest failed', error);
+      throw error;
+    });
+  },
 });
 
 export default SimultaneousInterpretation;

package/src/meeting/index.ts

@@ -1608,6 +1608,21 @@ export default class Meeting extends StatelessWebexPlugin {
         EVENT_TRIGGERS.MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE
       );
     });
+
+    this.simultaneousInterpretation.on(
+      INTERPRETATION.EVENTS.HANDOFF_REQUESTS_ARRIVED,
+      (payload) => {
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setUpInterpretationListener',
+          },
+          EVENT_TRIGGERS.MEETING_INTERPRETATION_HANDOFF_REQUESTS_ARRIVED,
+          payload
+        );
+      }
+    );
   }
 
   /**
@@ -2374,6 +2389,7 @@ export default class Meeting extends StatelessWebexPlugin {
       this.recordingController.setSessionId(this.locusInfo?.fullState?.sessionId);
       this.breakouts.breakoutServiceUrlUpdate(payload?.services?.breakout?.url);
       this.annotation.approvalUrlUpdate(payload?.services?.approval?.url);
+      this.simultaneousInterpretation.approvalUrlUpdate(payload?.services?.approval?.url);
     });
   }
 
@@ -3157,6 +3173,9 @@ export default class Meeting extends StatelessWebexPlugin {
       // Need to populate environment when sending CA event
       this.environment = locusMeetingObject?.info.channel || webexMeetingInfo?.channel;
     }
+    this.simultaneousInterpretation.updateHostSIEnabled(
+      !!webexMeetingInfo?.meetingSiteSetting?.enableHostInterpreterControlSI
+    );
   }
 
   /**

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

@@ -12,6 +12,7 @@ describe('plugin-meetings', () => {
     beforeEach(() => {
       // @ts-ignore
       webex = new MockWebex({});
+      webex.internal.mercury.on = sinon.stub();
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       interpretation.locusUrl = 'locusUrl';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
@@ -50,6 +51,14 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#approvalUrlUpdate', () => {
+      it('sets the approval url', () => {
+        interpretation.approvalUrlUpdate('newUrl');
+
+        assert.equal(interpretation.approvalUrl, 'newUrl');
+      });
+    });
+
     describe('#updateCanManageInterpreters', () => {
       it('update canManageInterpreters', () => {
         interpretation.updateCanManageInterpreters(true);
@@ -62,6 +71,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateHostSIEnabled', () => {
+      it('update hostSI feature is on or off', () => {
+        interpretation.updateHostSIEnabled(true);
+
+        assert.equal(interpretation.hostSIEnabled, true);
+
+        interpretation.updateHostSIEnabled(false);
+
+        assert.equal(interpretation.hostSIEnabled, false);
+      });
+    });
+
     describe('#updateInterpretation', () => {
       const checkSILanguage = (siLanguage, expectResult) => {
         return siLanguage?.languageCode === expectResult.languageCode && siLanguage?.languageName === expectResult.languageName
@@ -69,15 +90,6 @@ describe('plugin-meetings', () => {
       it('update interpretation correctly', () => {
         interpretation.updateInterpretation({siLanguages: [{languageName: 'en', languageCode: 1}]});
         checkSILanguage(interpretation.siLanguages.en, {languageName: 'en', languageCode: 1});
-        assert.equal(interpretation.siEnabled, true);
-      });
-
-      it('check siEnable as false if input param interpretation is null/undefined', () => {
-        interpretation.updateInterpretation(null);
-        assert.equal(interpretation.siEnabled, false);
-
-        interpretation.updateInterpretation(undefined);
-        assert.equal(interpretation.siEnabled, false);
       });
     });
 
@@ -325,5 +337,234 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#listenToHandoffRequests', () => {
+      it('triggers handoff update event when the approval is related with self', () => {
+        const call = webex.internal.mercury.on.getCall(0);
+        const callback = call.args[1];
+
+        assert.equal(call.args[0], 'event:locus.approval_request');
+        interpretation.set('selfParticipantId', 'p123');
+
+        let called = false;
+        const triggerSpy = sinon.spy(interpretation, 'trigger');
+
+        interpretation.listenTo(interpretation, 'HANDOFF_REQUESTS_ARRIVED', () => {
+          called = true;
+        });
+
+        callback({
+          data: {
+            approval: {
+              actionType: 'OFFERED',
+              resourceType: 'SiHandover',
+              receivers: [{
+                participantId: 'p123',
+              }],
+              initiator: {participantId: 'p123'},
+              url: 'testUrl',
+            },
+          }
+        });
+
+        assert.isTrue(called);
+        assert.calledWithExactly(triggerSpy, 'HANDOFF_REQUESTS_ARRIVED', {
+          actionType: 'OFFERED',
+          isReceiver: true,
+          isSender: true,
+          senderId: 'p123',
+          receiverId: 'p123',
+          url: 'testUrl',
+        });
+      });
+
+      it('not triggers handoff update event when the approval is not related with self', () => {
+        const call = webex.internal.mercury.on.getCall(0);
+        const callback = call.args[1];
+
+        interpretation.set('selfParticipantId', 'p123');
+
+        let called = false;
+
+        interpretation.listenTo(interpretation, 'HANDOFF_REQUESTS_ARRIVED', () => {
+          called = true;
+        });
+
+        callback({
+          data: {
+            approval: {
+              actionType: 'OFFERED',
+              resourceType: 'SiHandover',
+              receivers: [{
+                participantId: 'p444',
+              }],
+              initiator: {participantId: 'p444'},
+              url: 'testUrl',
+            },
+          }
+        });
+
+        assert.isFalse(called);
+      });
+    });
+
+    describe('#handoffInterpreter', () => {
+      it('makes the request as expected', async () => {
+        interpretation.approvalUrlUpdate('approvalUrl');
+        await interpretation.handoffInterpreter('participant2');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'approvalUrl',
+          body: {
+            actionType: 'OFFERED',
+            resourceType: 'SiHandover',
+            receivers: [
+              {
+                participantId: 'participant2',
+              },
+            ],
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+        interpretation.approvalUrlUpdate('approvalUrl');
+
+        await assert.isRejected(interpretation.handoffInterpreter('p2'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#handoffInterpreter failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no target participant id', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.handoffInterpreter().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing target participant id');
+        });
+      });
+
+      it('rejects error when no approval url', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.handoffInterpreter('p2').catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing approval url');
+        });
+      });
+    });
+
+    describe('#requestHandoff', () => {
+      it('makes the request as expected', async () => {
+        interpretation.approvalUrlUpdate('approvalUrl');
+        await interpretation.requestHandoff();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'approvalUrl',
+          body: {
+            actionType: 'REQUESTED',
+            resourceType: 'SiHandover',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+        interpretation.approvalUrlUpdate('approvalUrl');
+
+        await assert.isRejected(interpretation.requestHandoff(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#requestHandoff failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no approval url', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.requestHandoff().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing approval url');
+        });
+      });
+    });
+
+    describe('#acceptRequest', () => {
+      it('makes the request as expected', async () => {
+        await interpretation.acceptRequest('testUrl');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'testUrl',
+          body: {
+            actionType: 'ACCEPTED',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+
+        await assert.isRejected(interpretation.acceptRequest('testUrl'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#acceptRequest failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no url passed', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.acceptRequest().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing the url to accept');
+        });
+      });
+    });
+
+    describe('#declineRequest', () => {
+      it('makes the request as expected', async () => {
+        await interpretation.declineRequest('testUrl');
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PUT',
+          uri: 'testUrl',
+          body: {
+            actionType: 'DECLINED',
+          },
+        });
+      });
+
+      it('rejects with error', async () => {
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+
+        await assert.isRejected(interpretation.declineRequest('testUrl'), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#declineRequest failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no url passed', async () => {
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.declineRequest().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing the url to decline');
+        });
+      });
+    });
   });
 });

package/test/unit/spec/interpretation/siLanguage.ts

@@ -2,6 +2,7 @@ import {assert} from '@webex/test-helper-chai';
 import SILanguage from '@webex/plugin-meetings/src/interpretation/siLanguage';
 import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
 import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
 
 describe('plugin-meetings', () => {
   describe('SILanguage', () => {
@@ -11,6 +12,7 @@ describe('plugin-meetings', () => {
     beforeEach(() => {
       // @ts-ignore
       webex = new MockWebex({});
+      webex.internal.mercury.on = sinon.stub();
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       siLanguage = new SILanguage({}, {parent: interpretation});
     });