@webex/plugin-meetings 3.0.0-beta.9 → 3.0.0-bnr.0

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

@@ -82,6 +82,7 @@ describe('plugin-meetings', () => {
             meetingContainerUrl: 'http://new-url.com',
           },
           entryExitTone: {enabled: true, mode: 'foo'},
+          video: {enabled: true},
         };
       });
 
@@ -277,6 +278,25 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should update the breakout state', () => {
+        locusInfo.emitScoped = sinon.stub();
+        newControls.breakout = 'new breakout';
+
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_BREAKOUT_UPDATED,
+          {
+            breakout: 'new breakout',
+          }
+        );
+      });
+
       it('should update the transcript state', () => {
         locusInfo.emitScoped = sinon.stub();
         locusInfo.controls = {
@@ -398,6 +418,39 @@ describe('plugin-meetings', () => {
           assert.notEqual(x.args[1], LOCUSINFO.EVENTS.CONTROLS_ENTRY_EXIT_TONE_UPDATED);
         });
       });
+
+      it('should update videoEnabled when changed', () => {
+        locusInfo.controls = {};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateControls',
+          },
+          LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+          {unmuteAllowed: true}
+        );
+
+        assert.equal(mockMeeting.unmuteVideoAllowed, true);
+      });
+
+      it('should not update videoEnabled when unchanged', () => {
+        locusInfo.controls = {videoEnabled: true};
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateControls(newControls);
+
+        locusInfo.emitScoped.getCalls().forEach((x) => {
+          // check that no calls in emitScoped are for SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED
+          assert.notEqual(x.args[1], LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED);
+        });
+
+        assert.equal(mockMeeting.unmuteVideoAllowed, undefined);
+      });
     });
 
     describe('#updateParticipants()', () => {
@@ -451,6 +504,7 @@ describe('plugin-meetings', () => {
             selfIdentity: '123',
             selfId: '2',
             hostId: '3',
+            isReplace: undefined,
           }
         );
         // note: in a real use case, recordingId, selfId, and hostId would all be the same
@@ -458,6 +512,43 @@ describe('plugin-meetings', () => {
         // are being correctly grabbed from locusInfo.parsedLocus within updateParticipants
       });
 
+      it('should call with breakout control info', () => {
+        locusInfo.parsedLocus = {
+          controls: {
+            record: {
+              modifiedBy: '1',
+            },
+          },
+          self: {
+            selfIdentity: '123',
+            selfId: '2',
+          },
+          host: {
+            hostId: '3',
+          },
+        };
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateParticipants({}, true);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateParticipants',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_PARTICIPANTS,
+          {
+            participants: {},
+            recordingId: '1',
+            selfIdentity: '123',
+            selfId: '2',
+            hostId: '3',
+            isReplace: true,
+          }
+        );
+      });
+
       it('should update the deltaParticipants object', () => {
         const prev = locusInfo.deltaParticipants;
 
@@ -664,6 +755,143 @@ describe('plugin-meetings', () => {
         );
       });
 
+      describe('SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED', () => {
+        it('should emit event when video muted on entry', () => {
+          // usually "previous self" is just undefined when we get first self from locus
+          locusInfo.self = undefined;
+          const selfWithMutedByOthers = cloneDeep(self);
+
+          // remoteVideoMuted
+          selfWithMutedByOthers.controls.video.muted = true;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+
+          // but sometimes "previous self" is defined, but without controls.audio.muted, so we test this here:
+          locusInfo.self = cloneDeep(self);
+          locusInfo.self.controls.video = {};
+
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+        });
+
+        it('should not emit event when not muted on entry', () => {
+          locusInfo.self = undefined;
+          const selfWithMutedByOthersFalse = cloneDeep(self);
+
+          selfWithMutedByOthersFalse.controls.video.muted = false;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthersFalse, []);
+
+          // we might get some calls to emitScoped, but we need to check that none of them are for SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED
+          locusInfo.emitScoped.getCalls().forEach((x) => {
+            assert.notEqual(x.args[1], LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED);
+          });
+        });
+
+        it('should emit event when remoteVideoMuted changed', () => {
+          locusInfo.self = self;
+          const selfWithMutedByOthers = cloneDeep(self);
+
+          selfWithMutedByOthers.controls.video.muted = true;
+
+          locusInfo.webex.internal.device.url = self.deviceUrl;
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithMutedByOthers, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {
+              file: 'locus-info',
+              function: 'updateSelf',
+            },
+            LOCUSINFO.EVENTS.SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED,
+            {muted: true}
+          );
+        });
+      });
+
+      it('should trigger SELF_MEETING_BREAKOUTS_CHANGED when breakouts changed', () => {
+        locusInfo.self = self;
+        const selfWithBreakoutsChanged = cloneDeep(self);
+
+        selfWithBreakoutsChanged.controls.breakout.sessions.active[0].name = 'new name';
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateSelf(selfWithBreakoutsChanged, []);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED,
+          {
+            breakoutSessions: {
+              active: [
+                {
+                  name: 'new name',
+                  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('should trigger upgradeToModeratorOrCohost for breakouts', () => {
+
+        locusInfo.self = self;
+        const upgradeToModeratorOrCohost = cloneDeep(self);
+        upgradeToModeratorOrCohost.roles = ['ATTENDEE','COHOST'];
+
+        locusInfo.webex.internal.device.url = self.deviceUrl;
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateSelf(upgradeToModeratorOrCohost, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE,
+          self
+        );
+      });
+
       it('should trigger SELF_REMOTE_MUTE_STATUS_UPDATED if muted and disallowUnmute changed', () => {
         locusInfo.self = self;
         const selfWithMutedByOthersAndDissalowUnmute = cloneDeep(self);
@@ -967,8 +1195,7 @@ describe('plugin-meetings', () => {
 
         if (expected) {
           assert.calledWith(...expectedArgs);
-        }
-        else {
+        } else {
           assert.neverCalledWith(...expectedArgs);
         }
         locusInfo.emitScoped.resetHistory();
@@ -1148,6 +1375,55 @@ describe('plugin-meetings', () => {
         assert.isFunction(locusParser.onDeltaAction);
       });
 
+      it('#updateLocusInfo ignores breakout LEFT message', () => {
+        const newLocus = {
+          self: {
+            reason: 'MOVED',
+            state: 'LEFT',
+          },
+        };
+
+        locusInfo.updateControls = sinon.stub();
+        locusInfo.updateConversationUrl = sinon.stub();
+        locusInfo.updateCreated = sinon.stub();
+        locusInfo.updateFullState = sinon.stub();
+        locusInfo.updateHostInfo = sinon.stub();
+        locusInfo.updateMeetingInfo = sinon.stub();
+        locusInfo.updateMediaShares = sinon.stub();
+        locusInfo.updateParticipantsUrl = sinon.stub();
+        locusInfo.updateReplace = sinon.stub();
+        locusInfo.updateSelf = sinon.stub();
+        locusInfo.updateLocusUrl = sinon.stub();
+        locusInfo.updateAclUrl = sinon.stub();
+        locusInfo.updateBasequence = sinon.stub();
+        locusInfo.updateSequence = sinon.stub();
+        locusInfo.updateMemberShip = sinon.stub();
+        locusInfo.updateIdentifiers = sinon.stub();
+        locusInfo.updateEmbeddedApps = sinon.stub();
+        locusInfo.compareAndUpdate = sinon.stub();
+
+        locusInfo.updateLocusInfo(newLocus);
+
+        assert.notCalled(locusInfo.updateControls);
+        assert.notCalled(locusInfo.updateConversationUrl);
+        assert.notCalled(locusInfo.updateCreated);
+        assert.notCalled(locusInfo.updateFullState);
+        assert.notCalled(locusInfo.updateHostInfo);
+        assert.notCalled(locusInfo.updateMeetingInfo);
+        assert.notCalled(locusInfo.updateMediaShares);
+        assert.notCalled(locusInfo.updateParticipantsUrl);
+        assert.notCalled(locusInfo.updateReplace);
+        assert.notCalled(locusInfo.updateSelf);
+        assert.notCalled(locusInfo.updateLocusUrl);
+        assert.notCalled(locusInfo.updateAclUrl);
+        assert.notCalled(locusInfo.updateBasequence);
+        assert.notCalled(locusInfo.updateSequence);
+        assert.notCalled(locusInfo.updateMemberShip);
+        assert.notCalled(locusInfo.updateIdentifiers);
+        assert.notCalled(locusInfo.updateEmbeddedApps);
+        assert.notCalled(locusInfo.compareAndUpdate);
+      });
+
       it('onFullLocus() updates the working-copy of locus parser', () => {
         const eventType = 'fakeEvent';
 
@@ -1227,6 +1503,31 @@ describe('plugin-meetings', () => {
           assert.calledOnce(locusInfo.locusParser.resume);
         });
       });
+
+      it('onDeltaLocus handle delta data', () => {
+        fakeLocus.participants = {};
+        const fakeBreakout = {
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+        };
+
+        fakeLocus.controls = {
+          breakout: fakeBreakout
+        };
+        locusInfo.controls = {
+          breakout: {
+            sessionId: 'sessionId',
+            groupId: 'groupId',
+          }
+        }
+        locusInfo.updateParticipants = sinon.stub();
+        locusInfo.onDeltaLocus(fakeLocus);
+        assert.calledWith(locusInfo.updateParticipants, {}, false);
+
+        fakeBreakout.sessionId = 'sessionId2';
+        locusInfo.onDeltaLocus(fakeLocus);
+        assert.calledWith(locusInfo.updateParticipants, {}, false);
+      });
     });
 
     describe('#handleOneonOneEvent', () => {

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

@@ -1,20 +1,15 @@
 import {assert} from '@webex/test-helper-chai';
 import Sinon from 'sinon';
-
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 
-
 describe('plugin-meetings', () => {
   describe('infoUtils', () => {
     const info = {
       displayHints: {
-        moderator: [
-          'HINT_1',
-          'HINT_2'
-        ],
+        moderator: ['HINT_1', 'HINT_2'],
         joined: ['HINT_3'],
-        coHost: ['HINT_4']
-      }
+        coHost: ['HINT_4'],
+      },
     };
 
     describe('getInfos', () => {
@@ -35,28 +30,28 @@ describe('plugin-meetings', () => {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND']
+          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR', 'COHOST']), {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND', 'HINT_1', 'HINT_2']
+          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND', 'HINT_1', 'HINT_2'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['COHOST']), {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND']
+          userDisplayHints: ['HINT_3', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, []), {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_3']
+          userDisplayHints: ['HINT_3'],
         });
       });
 
@@ -65,39 +60,47 @@ describe('plugin-meetings', () => {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND']
+          userDisplayHints: ['HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR'], true), {
           policy: {HINT_3: true},
           moderator: {HINT_1: true, HINT_2: true, LOWER_SOMEONE_ELSES_HAND: true},
           coHost: {HINT_4: true, LOWER_SOMEONE_ELSES_HAND: true},
-          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND']
+          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND'],
+        });
+      });
+
+      it('only adds datachannel url when present', () => {
+        assert.deepEqual(InfoUtils.parse({datachannelUrl: 'some url'}, []), {
+          coHost: {LOWER_SOMEONE_ELSES_HAND: true},
+          moderator: {LOWER_SOMEONE_ELSES_HAND: true},
+          datachannelUrl: 'some url',
+          policy: {},
+          userDisplayHints: [],
+        });
+
+        assert.deepEqual(InfoUtils.parse({}, []), {
+          coHost: {LOWER_SOMEONE_ELSES_HAND: true},
+          moderator: {LOWER_SOMEONE_ELSES_HAND: true},
+          policy: {},
+          userDisplayHints: [],
         });
       });
     });
 
     describe('parseDisplayHintsSection', () => {
       it('returns the correct hints', () => {
-        assert.deepEqual(
-          InfoUtils.parseDisplayHintSection(info, 'moderator'),
-          {HINT_1: true, HINT_2: true}
-        );
+        assert.deepEqual(InfoUtils.parseDisplayHintSection(info, 'moderator'), {
+          HINT_1: true,
+          HINT_2: true,
+        });
 
-        assert.deepEqual(
-          InfoUtils.parseDisplayHintSection(info, 'joined'),
-          {HINT_3: true}
-        );
+        assert.deepEqual(InfoUtils.parseDisplayHintSection(info, 'joined'), {HINT_3: true});
 
-        assert.deepEqual(
-          InfoUtils.parseDisplayHintSection({}, 'joined'),
-          {}
-        );
+        assert.deepEqual(InfoUtils.parseDisplayHintSection({}, 'joined'), {});
 
-        assert.deepEqual(
-          InfoUtils.parseDisplayHintSection({displayHints: {}}, 'joined'),
-          {}
-        );
+        assert.deepEqual(InfoUtils.parseDisplayHintSection({displayHints: {}}, 'joined'), {});
 
         assert.deepEqual(
           InfoUtils.parseDisplayHintSection({displayHints: {joined: {}}}, 'joined'),
@@ -122,7 +125,10 @@ describe('plugin-meetings', () => {
 
         assert.calledWith(parseDisplayHintSectionSpy, info, 'moderator');
 
-        assert.deepEqual(result, {...parseDisplayHintSectionSpy.firstCall.returnValue, LOWER_SOMEONE_ELSES_HAND: true});
+        assert.deepEqual(result, {
+          ...parseDisplayHintSectionSpy.firstCall.returnValue,
+          LOWER_SOMEONE_ELSES_HAND: true,
+        });
       });
 
       it('parsePolicy calls parseDisplayHintSection correctly and returns the result', () => {
@@ -138,7 +144,10 @@ describe('plugin-meetings', () => {
 
         assert.calledWith(parseDisplayHintSectionSpy, info, 'coHost');
 
-        assert.deepEqual(result, {...parseDisplayHintSectionSpy.firstCall.returnValue, LOWER_SOMEONE_ELSES_HAND: true});
+        assert.deepEqual(result, {
+          ...parseDisplayHintSectionSpy.firstCall.returnValue,
+          LOWER_SOMEONE_ELSES_HAND: true,
+        });
       });
     });
   });