@webex/plugin-meetings 3.0.0-beta.12 → 3.0.0-beta.121

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

@@ -33,6 +33,24 @@ describe('plugin-meetings', () => {
         assert.calledWith(getRolesSpy, self);
 
         assert.deepEqual(parsedSelf.roles, ['PRESENTER']);
+        assert.deepEqual(parsedSelf.breakoutSessions, {
+          active: [
+            {
+              name: 'Breakout session 2',
+              groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+              sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+              sessionType: 'BREAKOUT',
+            },
+          ],
+          allowed: [
+            {
+              name: 'Breakout session 2',
+              groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+              sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+              sessionType: 'BREAKOUT',
+            },
+          ],
+        });
       });
 
       it('calls getLayout and returns the resulting layout', () => {
@@ -58,9 +76,107 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('getBreakoutSessions', () => {
+      it('should return breakout sessions', () => {
+        assert.deepEqual(
+          SelfUtils.getBreakoutSessions({controls: {breakout: {sessions: 'SESSIONS'}}}),
+          'SESSIONS'
+        );
+      });
+    });
+
+    describe('breakoutsChanged', () => {
+      it('should return true if breakouts have changed', () => {
+        const current = {
+          breakoutSessions: {
+            allowed: [
+              {
+                name: 'Breakout session 2',
+                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                sessionType: 'BREAKOUT',
+              },
+            ],
+          },
+          breakout: {},
+        };
+        const previous = {
+          breakoutSessions: {
+            active: [
+              {
+                name: 'Breakout session 2',
+                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                sessionType: 'BREAKOUT',
+              },
+            ],
+          },
+          breakout: {},
+        };
+
+        assert.isTrue(SelfUtils.breakoutsChanged(previous, current));
+      });
+
+      it('should return false if breakouts have not changed', () => {
+        const current = {
+          breakoutSessions: {
+            active: [
+              {
+                name: 'Breakout session 2',
+                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                sessionType: 'BREAKOUT',
+              },
+            ],
+          },
+          breakout: {},
+        };
+        const previous = {
+          breakoutSessions: {
+            active: [
+              {
+                name: 'Breakout session 2',
+                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                sessionType: 'BREAKOUT',
+              },
+            ],
+          },
+          breakout: {},
+        };
+
+        assert.isFalse(SelfUtils.breakoutsChanged(previous, current));
+      });
+
+      it('should return false if no breakouts in current', () => {
+        const current = {
+          breakoutSessions: {
+          },
+        };
+        const previous = {
+          breakoutSessions: {
+            active: [
+              {
+                name: 'Breakout session 2',
+                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
+                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
+                sessionType: 'BREAKOUT',
+              },
+            ],
+          },
+          breakout: {},
+        };
+
+        assert.isFalse(SelfUtils.breakoutsChanged(previous, current));
+      });
+    });
+
     describe('canNotViewTheParticipantList', () => {
       it('should return the correct value', () => {
-        assert.equal(SelfUtils.canNotViewTheParticipantList(self), self.canNotViewTheParticipantList);
+        assert.equal(
+          SelfUtils.canNotViewTheParticipantList(self),
+          self.canNotViewTheParticipantList
+        );
       });
 
       it('should return false if the new self does not have a value', () => {
@@ -90,17 +206,23 @@ describe('plugin-meetings', () => {
       it('get roles works', () => {
         assert.deepEqual(SelfUtils.getRoles(self), ['PRESENTER']);
 
-        assert.deepEqual(SelfUtils.getRoles({
-          controls: {
-            role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: true}]}
-          }
-        }), ['SOME_ARBITRARY_ROLE']);
-
-        assert.deepEqual(SelfUtils.getRoles({
-          controls: {
-            role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: false}]}
-          }
-        }), []);
+        assert.deepEqual(
+          SelfUtils.getRoles({
+            controls: {
+              role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: true}]},
+            },
+          }),
+          ['SOME_ARBITRARY_ROLE']
+        );
+
+        assert.deepEqual(
+          SelfUtils.getRoles({
+            controls: {
+              role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: false}]},
+            },
+          }),
+          []
+        );
 
         assert.deepEqual(SelfUtils.getRoles({}), []);
         assert.deepEqual(SelfUtils.getRoles(), []);
@@ -173,4 +295,106 @@ describe('plugin-meetings', () => {
       assert.deepEqual(SelfUtils.isJoined(customSelf), false);
     });
   });
+
+  describe('videoMutedByOthersChanged', () => {
+    it('returns true if changed', () => {
+      assert.equal(
+        SelfUtils.videoMutedByOthersChanged({remoteVideoMuted: true}, {remoteVideoMuted: false}),
+        true
+      );
+    });
+
+    it('returns true if changed from undefined', () => {
+      assert.equal(SelfUtils.videoMutedByOthersChanged({}, {remoteVideoMuted: false}), true);
+    });
+
+    it('returns false if not changed', () => {
+      assert.equal(
+        SelfUtils.videoMutedByOthersChanged({remoteVideoMuted: false}, {remoteVideoMuted: false}),
+        false
+      );
+    });
+  });
+
+  describe('isUpgradeToModeratorOrCohost', () => {
+    it('returns true if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','MODERATOR']}),
+        true
+      );
+    });
+
+    it('returns true if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','COHOST']}),
+        true
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','MODERATOR']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','COHOST']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','HOST','MODERATOR']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+  });
+
+  describe('getReplacedBreakoutMoveId', () => {
+    const deviceId = 'https://wdm-a.wbx2.com/wdm/api/v1/devices/20eabde3-4254-48da-9a24';
+    const breakoutMoveId = 'e5caeb2c-ffcc-4e06-a08a-1122e7710398';
+    const clonedSelf = cloneDeep(self);
+
+    it('get breakoutMoveId works', () => {
+
+      assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(self, deviceId), breakoutMoveId);
+
+    });
+
+    it('replaces is empty', () => {
+
+      clonedSelf.devices[0].replaces = undefined;
+      assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(clonedSelf, deviceId), null);
+
+    });
+
+    it('no self or self.devices is not array', () => {
+
+      assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(undefined, deviceId), null);
+
+      clonedSelf.devices =     {
+        url: 'https://wdm-a.wbx2.com/wdm/api/v1/devices/20eabde3-4254-48da-9a24',
+        deviceType: 'WEB',
+        mediaSessionsExternal: false,
+        replaces: [
+          {
+            breakoutMoveId: 'e5caeb2c-ffcc-4e06-a08a-1122e7710398',
+            lastActive: '2023-05-04T07:14:32.068Z',
+            locusUrl: 'https://locus-alpha-apdx.prod.meetapi.webex.com/locus/api/v1/loci/495061ca-7b3c-3b77-85ff-4e1bd58600d1',
+            replacedAt: '2023-05-04T07:16:04.905Z',
+            sessionId: 'be3147d4-c318-86d8-7611-8d24beaaca8d',
+          }
+        ],
+        state: 'JOINED',
+      };
+      assert.deepEqual(SelfUtils.getReplacedBreakoutMoveId(clonedSelf, deviceId), null);
+
+    });
+
+
+  });
+
 });

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

@@ -1,8 +1,9 @@
-import * as internalMediaModule from '@webex/plugin-meetings/src/media/internal-media-core-wrapper';
+import * as internalMediaModule from '@webex/internal-media-core';
 import Media from '@webex/plugin-meetings/src/media/index';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import StaticConfig from '@webex/plugin-meetings/src/common/config';
+import { forEach } from 'lodash';
 
 describe('createMediaConnection', () => {
   const fakeRoapMediaConnection = {
@@ -10,9 +11,11 @@ describe('createMediaConnection', () => {
   };
   const fakeAudioTrack = {
     id: 'audio track',
+    underlyingTrack: 'underlying audio track',
   };
   const fakeVideoTrack = {
     id: 'video track',
+    underlyingTrack: 'underlying video track',
   };
 
   afterEach(() => {
@@ -80,9 +83,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: fakeVideoTrack,
-          screenShareVideo: null,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: fakeVideoTrack.underlyingTrack,
+          screenShareVideo: undefined,
         },
         receive: {
           audio: true,
@@ -101,11 +104,22 @@ describe('createMediaConnection', () => {
       .returns(fakeRoapMediaConnection);
 
     Media.createMediaConnection(true, 'some debug id', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        }
+      },
       turnServerInfo: {
         url: 'turn server url',
         username: 'turn username',
         password: 'turn password',
       },
+      bundlePolicy: 'max-bundle',
     });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
@@ -118,25 +132,107 @@ describe('createMediaConnection', () => {
             credential: 'turn password',
           },
         ],
+        enableMainAudio: true,
+        enableMainVideo: true,
+        bundlePolicy: 'max-bundle',
       },
       'some debug id'
     );
   });
 
+  forEach([
+    {sendAudio: true, receiveAudio: true, sendVideo: true, receiveVideo: true, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: true, receiveAudio: false, sendVideo: true, receiveVideo: false, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: false, receiveAudio: true, sendVideo: false, receiveVideo: true, enableMainAudio: true, enableMainVideo: true,},
+    {sendAudio: false, receiveAudio: false, sendVideo: false, receiveVideo: false, enableMainAudio: false, enableMainVideo: false,},
+  ], ({sendAudio, sendVideo, receiveAudio, receiveVideo, enableMainAudio, enableMainVideo}) => {
+    it(`sets enableMainVideo to ${enableMainVideo} and enableMainAudio to ${enableMainAudio} when sendAudio: ${sendAudio} sendVideo: ${sendVideo} receiveAudio: ${receiveAudio} receiveVideo: ${receiveVideo}`, () => {
+      const multistreamRoapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
+
+      Media.createMediaConnection(true, 'some debug id', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio,
+            sendVideo,
+            sendShare: false,
+            receiveAudio,
+            receiveVideo,
+            receiveShare: true,
+          },
+        },
+      });
+      assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+      assert.calledWith(
+        multistreamRoapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          enableMainAudio,
+          enableMainVideo,
+        },
+        'some debug id'
+      );
+    });
+  });
+
   it('passes empty ICE servers array to MultistreamRoapMediaConnection if turnServerInfo is undefined (multistream enabled)', () => {
     const multistreamRoapMediaConnectionConstructorStub = sinon
       .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
       .returns(fakeRoapMediaConnection);
 
-    Media.createMediaConnection(true, 'debug string', {});
+    Media.createMediaConnection(true, 'debug string', {
+      mediaProperties: {
+        mediaDirection: {
+          sendAudio: true,
+          sendVideo: true,
+          sendShare: false,
+          receiveAudio: true,
+          receiveVideo: true,
+          receiveShare: true,
+        },
+      },
+    });
     assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
     assert.calledWith(
       multistreamRoapMediaConnectionConstructorStub,
       {
         iceServers: [],
+        enableMainAudio: true,
+        enableMainVideo: true,
       },
       'debug string'
     );
+
+    it('does not pass bundlePolicy to MultistreamRoapMediaConnection if bundlePolicy is undefined', () => {
+      const multistreamRoapMediaConnectionConstructorStub = sinon
+        .stub(internalMediaModule, 'MultistreamRoapMediaConnection')
+        .returns(fakeRoapMediaConnection);
+  
+      Media.createMediaConnection(true, 'debug string', {
+        mediaProperties: {
+          mediaDirection: {
+            sendAudio: true,
+            sendVideo: true,
+            sendShare: false,
+            receiveAudio: true,
+            receiveVideo: true,
+            receiveShare: true,
+          },
+        },
+        bundlePolicy: undefined
+      });
+      assert.calledOnce(multistreamRoapMediaConnectionConstructorStub);
+      assert.calledWith(
+        multistreamRoapMediaConnectionConstructorStub,
+        {
+          iceServers: [],
+          enableMainAudio: true,
+          enableMainVideo: true,
+        },
+        'debug string'
+      );
+    });
   });
 
   it('passes empty ICE servers array to RoapMediaConnection if turnServerInfo is undefined (multistream disabled)', () => {
@@ -190,9 +286,9 @@ describe('createMediaConnection', () => {
       },
       {
         send: {
-          audio: fakeAudioTrack,
-          video: null,
-          screenShareVideo: fakeVideoTrack,
+          audio: fakeAudioTrack.underlyingTrack,
+          video: undefined,
+          screenShareVideo: fakeVideoTrack.underlyingTrack,
         },
         receive: {
           audio: true,

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

@@ -1,6 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState, Event} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
@@ -19,7 +19,7 @@ describe('MediaProperties', () => {
       getStats: sinon.stub().resolves([]),
       on: sinon.stub(),
       off: sinon.stub(),
-      getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+      getConnectionState: sinon.stub().returns(ConnectionState.Connected),
     };
 
     mediaProperties = new MediaProperties();
@@ -35,7 +35,7 @@ describe('MediaProperties', () => {
       await mediaProperties.waitForMediaConnectionConnected();
     });
     it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
 
       let promiseResolved = false;
       let promiseRejected = false;
@@ -60,15 +60,15 @@ describe('MediaProperties', () => {
 
       // check that listener was registered and removed
       assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
+      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
     });
 
     it(`resolves when media connection reaches "connected" state`, async () => {
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connecting);
+      mockMC.getConnectionState.returns(ConnectionState.Connecting);
 
       const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
 
@@ -89,11 +89,11 @@ describe('MediaProperties', () => {
 
       // check the right listener was registered
       assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], MC.Event.CONNECTION_STATE_CHANGED);
+      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
       const listener = mockMC.on.getCall(0).args[1];
 
       // call the listener and pretend we are now connected
-      mockMC.getConnectionState.returns(MC.ConnectionState.Connected);
+      mockMC.getConnectionState.returns(ConnectionState.Connected);
       listener();
       await testUtils.flushPromises();
 
@@ -102,7 +102,7 @@ describe('MediaProperties', () => {
 
       // check that listener was removed
       assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, MC.Event.CONNECTION_STATE_CHANGED, listener);
+      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
 
       assert.calledOnce(clearTimeoutSpy);
     });

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -1,7 +1,6 @@
 import {assert} from '@webex/test-helper-chai';
 import InMeetingActions from '@webex/plugin-meetings/src/meeting/in-meeting-actions';
 
-
 describe('plugin-meetings', () => {
   describe('in-meeting-actions', () => {
     const checkValues = (actions, expected?) => {
@@ -11,9 +10,17 @@ describe('plugin-meetings', () => {
         canLock: null,
         canUnlock: null,
         canAssignHost: null,
+        canSetPresenter: null,
+        canUnsetPresenter: null,
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
+        canSetMuteOnEntry: null,
+        canUnsetMuteOnEntry: null,
+        canSetDisallowUnmute: null,
+        canUnsetDisallowUnmute: null,
+        canSetMuted: null,
+        canUnsetMuted: null,
         canStopRecording: null,
         canRaiseHand: null,
         canLowerAllHands: null,
@@ -23,12 +30,37 @@ describe('plugin-meetings', () => {
         canStartTranscribing: null,
         canStopTranscribing: null,
         isClosedCaptionActive: null,
+        isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
         isRealTimeTranslationEnabled: null,
         canSelectSpokenLanguages: null,
         waitingForOthersToJoin: null,
-        ...expected
+        canSendReactions: null,
+        canManageBreakout: null,
+        canAdmitLobbyToBreakout: null,
+        canUserAskForHelp: null,
+        canUserRenameSelfAndObserved: null,
+        canUserRenameOthers: null,
+        isBreakoutPreassignmentsEnabled: null,
+        canMuteAll: null,
+        canUnmuteAll: null,
+        canEnableHardMute: null,
+        canDisableHardMute: null,
+        canEnableMuteOnEntry: null,
+        canDisableMuteOnEntry: null,
+        canEnableReactions: null,
+        canDisableReactions: null,
+        canEnableReactionDisplayNames: null,
+        canDisableReactionDisplayNames: null,
+        canUpdateShareControl: null,
+        canEnableViewTheParticipantsList: null,
+        canDisableViewTheParticipantsList: null,
+        canEnableRaiseHand: null,
+        canDisableRaiseHand: null,
+        canEnableVideo: null,
+        canDisableVideo: null,
+        ...expected,
       };
 
       // Check get retuns all the correct values at once
@@ -46,10 +78,16 @@ describe('plugin-meetings', () => {
       'canLock',
       'canUnlock',
       'canAssignHost',
+      'canSetPresenter',
+      'canUnsetPresenter',
       'canStartRecording',
       'canPauseRecording',
       'canResumeRecording',
       'canStopRecording',
+      'canSetMuteOnEntry',
+      'canUnsetMuteOnEntry',
+      'canSetDisallowUnmute',
+      'canUnsetDisallowUnmute',
       'canRaiseHand',
       'canLowerAllHands',
       'canLowerSomeoneElsesHand',
@@ -57,11 +95,36 @@ describe('plugin-meetings', () => {
       'canEnableClosedCaption',
       'canStopTranscribing',
       'isClosedCaptionActive',
+      'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',
       'isRealTimeTranslationEnabled',
       'canSelectSpokenLanguages',
-      'waitingForOthersToJoin'
+      'waitingForOthersToJoin',
+      'canSendReactions',
+      'canManageBreakout',
+      'canAdmitLobbyToBreakout',
+      'canUserAskForHelp',
+      'canUserRenameSelfAndObserved',
+      'canUserRenameOthers',
+      'isBreakoutPreassignmentsEnabled',
+      'canMuteAll',
+      'canUnmuteAll',
+      'canEnableHardMute',
+      'canDisableHardMute',
+      'canEnableMuteOnEntry',
+      'canDisableMuteOnEntry',
+      'canEnableReactions',
+      'canDisableReactions',
+      'canEnableReactionDisplayNames',
+      'canDisableReactionDisplayNames',
+      'canUpdateShareControl',
+      'canEnableViewTheParticipantsList',
+      'canDisableViewTheParticipantsList',
+      'canEnableRaiseHand',
+      'canDisableRaiseHand',
+      'canEnableVideo',
+      'canDisableVideo',
     ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();