@webex/plugin-meetings 3.8.0 → 3.8.1-next.1

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

@@ -22,16 +22,54 @@ describe('plugin-meetings', () => {
     });
 
     describe('#initialize', () => {
+      beforeEach(() => {
+        interpretation.querySupportLanguages = sinon.stub();
+        interpretation.set({
+          canManageInterpreters: undefined,
+          hostSIEnabled: undefined,
+          locusUrl: undefined
+        });
+      });
+
+      afterEach(() => {
+        interpretation.querySupportLanguages.reset();
+      });
+
       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,
+          hostSIEnabled: true,
+          locusUrl: "MOCK_LOCUS_URL"
         });
         assert.called(interpretation.querySupportLanguages);
       });
+
+      it('does not call querySupportLanguages when canManageInterpreters is not set', () => {
+        interpretation.set({
+          hostSIEnabled: true,
+          locusUrl: "MOCK_LOCUS_URL"
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
+
+      it('does not call querySupportLanguages when hostSIEnabled is not set', () => {
+        interpretation.set({
+          canManageInterpreters: true,
+          locusUrl: "MOCK_LOCUS_URL"
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
+
+      it('does not call querySupportLanguages when locusUrl is not set', () => {
+        interpretation.set({
+          canManageInterpreters: true,
+          hostSIEnabled: true,
+        });
+        assert.notCalled(interpretation.querySupportLanguages);
+      });
     });
 
     describe('#cleanUp', () => {

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

@@ -1,6 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import ControlsUtils from '@webex/plugin-meetings/src/locus-info/controlsUtils';
 import controlsUtils from "@webex/plugin-meetings/src/locus-info/controlsUtils";
+import {
+  MEETING_STATE,
+  BREAKOUTS,
+} from '../../../../src/constants';
 
 const defaultControls = {
   entryExitTone: {
@@ -140,7 +144,25 @@ describe('plugin-meetings', () => {
         assert.equal(parsedControls.videoLayout.overrideDefault, newControls.videoLayout.overrideDefault);
         assert.equal(parsedControls.videoLayout.lockAttendeeViewOnStageOnly, newControls.videoLayout.lockAttendeeViewOnStageOnly);
         assert.equal(parsedControls.videoLayout.stageParameters, newControls.videoLayout.stageParameters);
+      });
+
+      it('should parse the annotationControl control', () => {
+        const newControls = {annotationControl: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
 
+        assert.equal(
+          parsedControls.annotationControl.enabled,
+          newControls.annotationControl.enabled
+        );
+      });
+
+      it('should parse the rdcControl control', () => {
+        const newControls = {rdcControl: {enabled: true}};
+
+        const parsedControls = ControlsUtils.parse(newControls);
+
+        assert.equal(parsedControls.rdcControl.enabled, newControls.rdcControl.enabled);
       });
 
       describe('videoEnabled', () => {
@@ -269,6 +291,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: {
@@ -365,6 +395,58 @@ describe('plugin-meetings', () => {
         assert.equal(updates.hasManualCaptionChanged, false);
       });
 
+      it('returns hasAnnotationControlChanged = true when changed', () => {
+        const newControls = {annotationControl: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasAnnotationControlChanged, true);
+      });
+
+      it('returns hasRemoteDesktopControlChanged = true when changed', () => {
+        const newControls = {rdcControl: {enabled: true}};
+
+        const {updates} = ControlsUtils.getControls(defaultControls, newControls);
+
+        assert.equal(updates.hasRemoteDesktopControlChanged, true);
+      });
+
+      it('returns false when previous spoken language is undefined and current is a invalid value', () => {
+        const previous = { transcribe: undefined };
+        const current = { transcribe: { spokenLanguage: null } };
+
+        const {updates} = ControlsUtils.getControls(previous, current);
+
+        assert.equal(updates.hasTranscribeSpokenLanguageChanged, false);
+      });
+
+      it('detects spoken language change when previous is undefined and current is a valid value', () => {
+        const previous = { transcribe: undefined };
+        const current = { transcribe: { spokenLanguage: 'en-US' } };
+
+        const {updates} = ControlsUtils.getControls(previous, current);
+
+        assert.equal(updates.hasTranscribeSpokenLanguageChanged, true);
+      });
+
+      it('returns false when spoken language changes to a same value', () => {
+        const previous = { transcribe: {caption: true, spokenLanguage: 'en-US' } };
+        const current = { transcribe: {caption: true, spokenLanguage: 'en-US' } };
+
+        const {updates} = ControlsUtils.getControls(previous, current);
+
+        assert.equal(updates.hasTranscribeSpokenLanguageChanged, false);
+      });
+
+      it('returns true when spoken language changes to a different value', () => {
+        const previous = { transcribe: {caption: true, spokenLanguage: 'en-US' } };
+        const current = { transcribe: {caption: true, spokenLanguage: 'fr-FR' } };
+
+        const {updates} = ControlsUtils.getControls(previous, current);
+
+        assert.equal(updates.hasTranscribeSpokenLanguageChanged, true);
+      });
+
       describe('videoEnabled', () => {
         const testVideoEnabled = (oldControls, newControls, updatedProperty) => {
           const result = ControlsUtils.getControls(oldControls, newControls);
@@ -424,28 +506,76 @@ describe('plugin-meetings', () => {
 
     describe('getSessionSwitchStatus', () => {
       it('if no breakout control, return switch status both false', () => {
-        const oldControls = {};
-        const newControls = {};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {};
+        const newLocus = {};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: false, isJoinToBreakout: false
         });
       });
 
       it('if switch session from breakout to main, return isReturnToMain as true', () => {
-        const oldControls = {breakout: {sessionType: 'BREAKOUT'}};
-        const newControls = {breakout: {sessionType: 'MAIN'}};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {controls: {breakout: {sessionType: 'BREAKOUT'}}};
+        const newLocus = {controls: {breakout: {sessionType: 'MAIN'}}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: true, isJoinToBreakout: false
         });
       });
 
       it('if switch session from main to breakout, return isJoinToBreakout as true', () => {
-        const oldControls = {breakout: {sessionType: 'MAIN'}};
-        const newControls = {breakout: {sessionType: 'BREAKOUT'}};
-        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldControls, newControls), {
+        const oldLocus = {controls: {breakout: {sessionType: 'MAIN'}}};
+        const newLocus = {controls: {breakout: {sessionType: 'BREAKOUT'}}};
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
           isReturnToMain: false, isJoinToBreakout: true
         });
       });
+
+      it('if needUseCache conditions are met, return isJoinToBreakout as true', () => {
+        const oldLocus = {
+          self: { isCreator: true },
+          controls: { breakout: { sessionType: BREAKOUTS.SESSION_TYPES.MAIN} },
+        };
+
+        const newLocus = {
+          participants: [
+            { isCreator: true, state: MEETING_STATE.STATES.JOINED },
+          ],
+          controls: {
+            breakout: {
+              sessionType: BREAKOUTS.SESSION_TYPES.MAIN,
+              groups: [{ id: 'group1' }]
+            },
+          },
+        };
+
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
+          isReturnToMain: true,
+          isJoinToBreakout: false
+        });
+      });
+
+      it('if needUseCache conditions are not met, return newLocus and isReturnToMain as false', () => {
+        const oldLocus = {
+          self: { isCreator: false },
+          controls: { breakout: { sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT} },
+        };
+
+        const newLocus = {
+          participants: [
+            { isCreator: true, state: MEETING_STATE.STATES.JOINED },
+          ],
+          controls: {
+            breakout: {
+              sessionType: BREAKOUTS.SESSION_TYPES.BREAKOUT,
+              groups: []
+            },
+          },
+        };
+
+        assert.deepEqual(controlsUtils.getSessionSwitchStatus(oldLocus, newLocus), {
+          isReturnToMain: false,
+          isJoinToBreakout: false
+        });
+      });
     });
 
     describe('#isMainSessionDTO', () => {