@webex/plugin-meetings 3.0.0-beta.160 → 3.0.0-beta.161

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

@@ -0,0 +1,329 @@
+import {assert, expect} from '@webex/test-helper-chai';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+  describe('SimultaneousInterpretation', () => {
+    let webex;
+    let interpretation;
+
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      interpretation = new SimultaneousInterpretation({}, {parent: webex});
+      interpretation.locusUrl = 'locusUrl';
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+      webex.meetings = {};
+      webex.meetings.getMeetingByType = sinon.stub();
+    });
+
+    describe('#initialize', () => {
+      it('creates SimultaneousInterpretation as expected', () => {
+        assert.equal(interpretation.namespace, 'Meetings');
+      });
+      it('call querySupportLanguages correctly when meet the conditions', () => {
+        interpretation.querySupportLanguages = sinon.stub();
+        interpretation.set({
+          canManageInterpreters: true,
+        });
+        assert.called(interpretation.querySupportLanguages);
+      });
+    });
+
+    describe('#cleanUp', () => {
+      it('stops listening', () => {
+        interpretation.stopListening = sinon.stub();
+
+        interpretation.cleanUp();
+
+        assert.calledOnceWithExactly(interpretation.stopListening);
+      });
+    });
+
+    describe('#locusUrlUpdate', () => {
+      it('sets the locus url', () => {
+        interpretation.locusUrlUpdate('newUrl');
+
+        assert.equal(interpretation.locusUrl, 'newUrl');
+      });
+    });
+
+    describe('#updateCanManageInterpreters', () => {
+      it('update canManageInterpreters', () => {
+        interpretation.updateCanManageInterpreters(true);
+
+        assert.equal(interpretation.canManageInterpreters, true);
+
+        interpretation.updateCanManageInterpreters(false);
+
+        assert.equal(interpretation.canManageInterpreters, false);
+      });
+    });
+
+    describe('#updateInterpretation', () => {
+      const checkSILanguage = (siLanguage, expectResult) => {
+        return siLanguage?.languageCode === expectResult.languageCode && siLanguage?.languageName === expectResult.languageName
+      }
+      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);
+      });
+    });
+
+    describe('#updateSelfInterpretation', () => {
+      it('update self interpretation correctly', () => {
+        const sampleData: any = {
+          interpretation: {
+            originalLanguage: 'en',
+            sourceLanguage: 'en',
+            targetLanguage: 'zh',
+            isActive: true,
+            receiveLanguage: 'en',
+            order: 0,
+          }, selfParticipantId: '123'};
+        interpretation.updateSelfInterpretation(sampleData);
+        assert.equal(interpretation.originalLanguage, 'en');
+        assert.equal(interpretation.sourceLanguage, 'en');
+        assert.equal(interpretation.targetLanguage, 'zh');
+        assert.equal(interpretation.receiveLanguage, 'en');
+        assert.equal(interpretation.isActive, true);
+        assert.equal(interpretation.order, 0);
+
+        sampleData.interpretation = {
+          originalLanguage: 'en',
+          order: 0,
+        };
+        interpretation.updateSelfInterpretation(sampleData);
+        assert.equal(interpretation.sourceLanguage, undefined);
+        assert.equal(interpretation.targetLanguage, undefined);
+        assert.equal(interpretation.receiveLanguage, undefined);
+      });
+    });
+
+    describe('#querySupportLanguages', () => {
+      it('makes the request as expected', async () => {
+        const mockedReturnBody = {
+          siLanguages: [{
+              languageCode: 43,
+              languageName: 'it'
+            },
+            {
+              languageCode: 20,
+              languageName: 'en'
+            }]
+        };
+        webex.request.returns(
+          Promise.resolve({
+            body: mockedReturnBody,
+          })
+        );
+
+        await interpretation.querySupportLanguages();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'GET',
+          uri: 'locusUrl/languages/interpretation',
+        });
+        assert.deepEqual(interpretation.supportLanguages, mockedReturnBody.siLanguages);
+      });
+
+      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.querySupportLanguages(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#querySupportLanguages failed',
+          mockError
+        );
+      });
+    });
+
+    describe('#getInterpreters', () => {
+      it('makes the request as expected', async () => {
+        const mockedReturnBody = {
+          interpreters: [{
+            emailAddress : 'bob@example.com',
+            emailHash : 'fdde32a3-97b0-4511-b0b5-2731cc9c5266',
+            originalLanguageId : 0,
+            originalLanguage : 'cn',
+            sourceLanguageId : 0,
+            sourceLanguage : 'cn',
+            targetLanguageId : 1,
+            targetLanguage : 'en',
+            order : 0,
+            isActive : true
+          },]
+        };
+        webex.request.returns(
+          Promise.resolve({
+            body: mockedReturnBody,
+          })
+        );
+
+        const result = await interpretation.getInterpreters();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'GET',
+          uri: 'locusUrl/interpretation/interpreters',
+        });
+        assert.deepEqual(result, {body: mockedReturnBody})
+      });
+
+      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.getInterpreters(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#getInterpreters failed',
+          mockError
+        );
+      });
+    });
+
+    describe('#updateInterpreters', () => {
+      it('makes the request as expected', async () => {
+        const sampleData = [{
+            emailAddress : 'bob@example.com',
+            emailHash : 'fdde32a3-97b0-4511-b0b5-2731cc9c5266',
+            originalLanguageId : 0,
+            originalLanguage : 'cn',
+            sourceLanguageId : 0,
+            sourceLanguage : 'cn',
+            targetLanguageId : 1,
+            targetLanguage : 'en',
+            order : 0,
+            isActive : true
+          },];
+        webex.request.returns(Promise.resolve({}));
+
+        await interpretation.updateInterpreters(sampleData);
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PATCH',
+          uri: 'locusUrl/controls',
+          body: {
+            interpretation: {
+              interpreters: sampleData,
+            },
+          },
+        });
+      });
+
+      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.updateInterpreters(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#updateInterpreters failed',
+          mockError
+        );
+      });
+    });
+
+    describe('#changeDirection', () => {
+      it('makes the request as expected', async () => {
+        interpretation.set({
+          sourceLanguage : 'cn',
+          targetLanguage : 'en',
+          isActive: true,
+          order: 0,
+          selfParticipantId: '123',
+        });
+        webex.request.returns(Promise.resolve({}));
+
+        await interpretation.changeDirection();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'PATCH',
+          uri: 'locusUrl/participant/123/controls',
+          body: {
+            interpretation: {
+              sourceLanguage : 'en',
+              targetLanguage : 'cn',
+              isActive: true,
+              order: 0,
+            },
+          },
+        });
+      });
+
+      it('request rejects with error', async () => {
+        interpretation.set({
+          sourceLanguage : 'cn',
+          targetLanguage : 'en',
+          isActive: true,
+          order: 0,
+          selfParticipantId: '123',
+        });
+        const mockError = new Error('something wrong');
+        webex.request.returns(Promise.reject(mockError));
+        LoggerProxy.logger.error = sinon.stub();
+
+        await assert.isRejected(interpretation.changeDirection(), mockError, 'something wrong');
+
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:interpretation#changeDirection failed',
+          mockError
+        );
+      });
+
+      it('rejects error when no sourceLanguage or targetLanguage', async () => {
+        interpretation.set({
+          sourceLanguage : 'cn',
+          isActive: true,
+          order: 0,
+          selfParticipantId: '123',
+        });
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.changeDirection().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing sourceLanguage or targetLanguage');
+        });
+
+        interpretation.set({
+          targetLanguage : 'en',
+          isActive: true,
+          order: 0,
+          selfParticipantId: '123',
+        });
+        await interpretation.changeDirection().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing sourceLanguage or targetLanguage');
+        });
+      });
+
+      it('rejects error when no self participant id', async () => {
+        interpretation.set({
+          sourceLanguage : 'cn',
+          targetLanguage : 'en',
+          isActive: true,
+          order: 0,
+        });
+        LoggerProxy.logger.error = sinon.stub();
+
+        await interpretation.changeDirection().catch((error) => {
+          assert.equal(error.toString(), 'Error: Missing self participant id');
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,26 @@
+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';
+
+describe('plugin-meetings', () => {
+  describe('SILanguage', () => {
+    let webex;
+    let siLanguage;
+    let interpretation;
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      interpretation = new SimultaneousInterpretation({}, {parent: webex});
+      siLanguage = new SILanguage({}, {parent: interpretation});
+    });
+    it('set siLanguage props correctly', () => {
+      siLanguage.set({
+        languageCode: 20,
+        languageName: 'en',
+      });
+      assert.equal(siLanguage.languageCode, 20);
+      assert.equal(siLanguage.languageName, 'en');
+    });
+  });
+});

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

@@ -249,6 +249,26 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasBreakoutChanged, false);
       });
 
+      it('returns hasInterpretationChanged = true when it has changed', () => {
+        const newControls = {
+          interpretation: 'interpretation',
+        };
+
+        const {updates} = ControlsUtils.getControls({interpretation: 'old one'}, newControls);
+
+        assert.equal(updates.hasInterpretationChanged, true);
+      });
+
+      it('returns hasInterpretationChanged = false when it has not changed', () => {
+        const newControls = {
+          interpretation: 'interpretation',
+        };
+
+        const {updates} = ControlsUtils.getControls({interpretation: 'interpretation'}, newControls);
+
+        assert.equal(updates.hasInterpretationChanged, false);
+      });
+
       describe('videoEnabled', () => {
         const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
           const result = ControlsUtils.getControls(oldControls, newControls);

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

@@ -397,6 +397,26 @@ describe('plugin-meetings', () => {
         tmpStub.restore();
       });
 
+      it('should update the interpretation state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        newControls.interpretation = {siLanguages: [{languageCode: 20, languageName: 'en'}]};
+        let selfInfo = {};
+
+        locusInfo.updateControls(newControls, selfInfo);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_INTERPRETATION_UPDATED,
+          {
+            interpretation: newControls.interpretation,
+          }
+        );
+      });
+
       it('should update the transcript state', () => {
         locusInfo.emitScoped = sinon.stub();
         locusInfo.controls = {
@@ -1235,6 +1255,50 @@ describe('plugin-meetings', () => {
           {oldRoles: ['PRESENTER'], newRoles: ['PRESENTER']}
         );
       });
+
+      it('should trigger SELF_MEETING_INTERPRETATION_CHANGED if self interpretation info changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.interpretation.targetLanguage = 'it';
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          {
+            interpretation: sampleNewSelf.controls.interpretation,
+            selfParticipantId: self.id,
+          }
+        );
+      });
+
+      it('should not trigger SELF_MEETING_INTERPRETATION_CHANGED if self interpretation info not changed', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const sampleNewSelf = cloneDeep(self);
+        sampleNewSelf.controls.interpretation.targetLanguage = 'cn'; // same with previous one
+
+        locusInfo.updateSelf(sampleNewSelf, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          {
+            interpretation: sampleNewSelf.controls.interpretation,
+            selfParticipantId: self.id,
+          }
+        );
+      });
     });
 
     describe('#updateMeetingInfo', () => {

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

@@ -147,6 +147,16 @@ export const self = {
         readOnly: true,
       },
     },
+    interpretation: {
+      originalLanguage: 'en',
+      sourceLanguage: 'en',
+      targetLanguage: 'cn',
+      order: 0,
+      isActive: true,
+      meta: {
+        lastModified: '2023-07-11T01:57:31.040Z',
+      }
+    },
     localRecord: {
       recording: false,
     },

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

@@ -431,4 +431,30 @@ describe('plugin-meetings', () => {
       assert.deepEqual(SelfUtils.isRolesChanged(parsedSelf, clonedSelf), false);
     });
   });
+
+  describe('interpretationChanged', () => {
+    it('should return false if new self is null', () => {
+      const parsedSelf = SelfUtils.parse(self);
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, null), false);
+    });
+
+    it('should return true if interpretation info has changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.interpretation.sourceLanguage = 'ja';
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, clonedSelf), true);
+    });
+
+    it('should return false if interpretation info  has not changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.interpretation.sourceLanguage = 'en';
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, clonedSelf), false);
+    });
+  });
 });

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

@@ -70,6 +70,7 @@ import * as ReceiveSlotManagerModule from '@webex/plugin-meetings/src/multistrea
 import LLM from '@webex/internal-plugin-llm';
 import Mercury from '@webex/internal-plugin-mercury';
 import Breakouts from '@webex/plugin-meetings/src/breakouts';
+import SimultaneousInterpretation from '@webex/plugin-meetings/src/interpretation';
 import {REACTION_RELAY_TYPES} from '../../../../src/reactions/constants';
 import locus from '../fixture/locus';
 import {
@@ -318,6 +319,7 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.destination, testDestination);
           assert.equal(meeting.destinationType, _MEETING_ID_);
           assert.instanceOf(meeting.breakouts, Breakouts);
+          assert.instanceOf(meeting.simultaneousInterpretation, SimultaneousInterpretation);
         });
         it('creates MediaRequestManager instances', () => {
           assert.instanceOf(meeting.mediaRequestManagers.audio, MediaRequestManager);
@@ -4415,8 +4417,9 @@ describe('plugin-meetings', () => {
         });
 
         it('listens to the self roles changed event', () => {
-          const payload = {oldRoles: [], newRoles: ['COHOST']};
+          const payload = {oldRoles: [], newRoles: ['COHOST', 'MODERATOR']};
           meeting.breakouts.updateCanManageBreakouts = sinon.stub();
+          meeting.simultaneousInterpretation.updateCanManageInterpreters = sinon.stub();
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -4425,6 +4428,7 @@ describe('plugin-meetings', () => {
           );
 
           assert.calledOnceWithExactly(meeting.breakouts.updateCanManageBreakouts, true);
+          assert.calledOnceWithExactly(meeting.simultaneousInterpretation.updateCanManageInterpreters, true);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,
@@ -4433,6 +4437,26 @@ describe('plugin-meetings', () => {
             {payload}
           );
         });
+
+        it('listens to the interpretation changed event', () => {
+          meeting.simultaneousInterpretation.updateSelfInterpretation = sinon.stub();
+
+          const payload = 'payload';
+
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'SELF_MEETING_INTERPRETATION_CHANGED',
+            payload
+          );
+
+          assert.calledOnceWithExactly(meeting.simultaneousInterpretation.updateSelfInterpretation, payload);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpLocusInfoSelfListener'},
+            EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
+          );
+        });
       });
 
       describe('#setUpBreakoutsListener', () => {
@@ -4714,6 +4738,27 @@ describe('plugin-meetings', () => {
 
           assert.notCalled(meeting.locusInfo.clearMainSessionLocusCache);
         });
+
+        it('listens to the locus interpretation update event', () => {
+          const interpretation = {
+            siLanguages: [{languageCode: 20, languageName: 'en'}],
+          };
+
+          meeting.simultaneousInterpretation.updateInterpretation = sinon.stub();
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'CONTROLS_MEETING_INTERPRETATION_UPDATED',
+            {interpretation}
+          );
+
+          assert.calledOnceWithExactly(meeting.simultaneousInterpretation.updateInterpretation, interpretation);
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setupLocusControlsListener'},
+            EVENT_TRIGGERS.MEETING_INTERPRETATION_UPDATE
+          );
+        });
       });
 
       describe('#setUpLocusUrlListener', () => {
@@ -4726,6 +4771,7 @@ describe('plugin-meetings', () => {
 
           meeting.breakouts.locusUrlUpdate = sinon.stub();
           meeting.annotation.locusUrlUpdate = sinon.stub();
+          meeting.simultaneousInterpretation.locusUrlUpdate = sinon.stub();
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -4738,6 +4784,7 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.members.locusUrlUpdate, newLocusUrl);
           assert.calledWith(meeting.recordingController.setLocusUrl, newLocusUrl);
           assert.calledWith(meeting.controlsOptionsManager.setLocusUrl, newLocusUrl);
+          assert.calledWith(meeting.simultaneousInterpretation.locusUrlUpdate, newLocusUrl);
           assert.equal(meeting.locusUrl, newLocusUrl);
           assert(meeting.locusId, '12345');
           done();
@@ -4869,6 +4916,20 @@ describe('plugin-meetings', () => {
           done();
         });
       });
+
+      describe('#setUpInterpretationListener', () => {
+        it('listens to the support languages update event from interpretation and triggers the update event', () => {
+          TriggerProxy.trigger.reset();
+          meeting.simultaneousInterpretation.trigger('SUPPORT_LANGUAGES_UPDATE');
+
+          assert.calledWith(
+            TriggerProxy.trigger,
+            meeting,
+            {file: 'meeting/index', function: 'setUpInterpretationListener'},
+            EVENT_TRIGGERS.MEETING_INTERPRETATION_SUPPORT_LANGUAGES_UPDATE
+          );
+        });
+      });
     });
     describe('Private Detailed API and Helpers', () => {
       let sandbox;

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

@@ -37,6 +37,7 @@ describe('plugin-meetings', () => {
       meeting.updateLLMConnection = sinon.stub();
       meeting.breakouts = {cleanUp: sinon.stub()};
       meeting.annotaion = {cleanUp: sinon.stub()};
+      meeting.simultaneousInterpretation = {cleanUp: sinon.stub()};
     });
 
     afterEach(() => {
@@ -56,6 +57,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.stopKeepAlive);
         assert.calledOnce(meeting.updateLLMConnection);
         assert.calledOnce(meeting.breakouts.cleanUp);
+        assert.calledOnce(meeting.simultaneousInterpretation.cleanUp);
       });
     });
 

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

@@ -9,6 +9,13 @@ describe('member', () => {
     sinon.restore();
   });
 
+  it('checks member properties', () => {
+    const member = new Member({});
+    assert.exists(member.supportsInterpretation);
+    assert.exists(member.supportsBreakouts);
+    assert.exists(member.supportLiveAnnotation);
+  });
+
   it('checks that processParticipant calls isHandRaised', () => {
     const participant = {controls: {}};
 
@@ -25,10 +32,10 @@ describe('member', () => {
       const participant = {};
 
       const member = new Member({});
-  
+
       sinon.spy(member, 'processRoles');
       member.processParticipant(participant);
-  
+
       assert.calledOnceWithExactly(member.processRoles, participant);
     });
 
@@ -36,10 +43,10 @@ describe('member', () => {
       const participant = {};
 
       const member = new Member({});
-  
+
       sinon.spy(MemberUtil, 'extractControlRoles');
       member.processParticipant(participant);
-  
+
       assert.calledOnceWithExactly(MemberUtil.extractControlRoles, participant);
     });
   })