@webex/plugin-meetings 3.0.0-beta.180 → 3.0.0-beta.182

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

@@ -1648,12 +1648,39 @@ describe('plugin-meetings', () => {
         sandbox.stub(locusInfo, 'updateParticipants');
         sandbox.stub(locusInfo, 'isMeetingActive');
         sandbox.stub(locusInfo, 'handleOneOnOneEvent');
+        sandbox.stub(locusParser, 'isNewFullLocus').returns(true);
 
         locusInfo.onFullLocus(fakeLocus, eventType);
 
         assert.equal(fakeLocus, locusParser.workingCopy);
       });
 
+      it('onFullLocus() does not do anything if the incoming full locus DTO is old', () => {
+        const eventType = 'fakeEvent';
+
+        locusParser.workingCopy = {};
+
+        const oldWorkingCopy = locusParser.workingCopy;
+
+        const spies = [
+          sandbox.stub(locusInfo, 'updateParticipantDeltas'),
+          sandbox.stub(locusInfo, 'updateLocusInfo'),
+          sandbox.stub(locusInfo, 'updateParticipants'),
+          sandbox.stub(locusInfo, 'isMeetingActive'),
+          sandbox.stub(locusInfo, 'handleOneOnOneEvent'),
+        ];
+
+        sandbox.stub(locusParser, 'isNewFullLocus').returns(false);
+
+        locusInfo.onFullLocus(fakeLocus, eventType);
+
+        spies.forEach((spy) => {
+          assert.notCalled(spy);
+        })
+
+        assert.equal(oldWorkingCopy, locusParser.workingCopy);
+      });
+
       it('onDeltaAction applies locus delta data to meeting', () => {
         const action = 'fake action';
         const parsedLoci = 'fake loci';

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

@@ -238,6 +238,68 @@ describe('locus-info/parser', () => {
     });
   });
 
+  describe('Full Locus handling', () => {
+    describe('isNewFullLocus', () => {
+      let parser;
+
+      beforeEach(() => {
+        parser = new LocusDeltaParser();
+      })
+      it('returns false if incoming Locus is not valid', () => {
+        const fakeInvalidIncomingLocus = {};
+
+        parser.workingCopy = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [1]}};
+
+        assert.isFalse(parser.isNewFullLocus(fakeInvalidIncomingLocus));
+      });
+
+      const runCheck = (incomingSequence, currentSequence, expectedResult) => {
+        parser.workingCopy = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [1, 2, currentSequence]}};
+
+        const fakeIncomingLocus = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [1, 10, incomingSequence]}};
+
+        assert.strictEqual(parser.isNewFullLocus(fakeIncomingLocus), expectedResult);
+      }
+      it('returns true if there is no working copy', () => {
+        const fakeIncomingLocus = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [10]}};
+
+        // sanity check that we initially have no working copy 
+        assert.isNull(parser.workingCopy);
+
+        assert.isTrue(parser.isNewFullLocus(fakeIncomingLocus));
+      });
+
+      it('returns true if new sequence is higher than existing one', () => {
+        runCheck(101, 100, true);
+      });
+
+      it('returns false if new sequence is same than existing one', () => {
+        runCheck(100, 100, false);
+      });
+
+      it('returns false if new sequence is older than existing one', () => {
+        runCheck(99, 100, false);
+      });
+
+      it('returns true if incoming Locus has empty sequence', () => {
+        parser.workingCopy = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [1, 2, 3]}};
+
+        const fakeIncomingLocus = { sequence: {rangeStart: 0, rangeEnd: 0, entries: []}};
+
+        assert.isTrue(parser.isNewFullLocus(fakeIncomingLocus));
+      });
+
+      it('returns true if working copy has empty sequence', () => {
+        parser.workingCopy = { sequence: {rangeStart: 0, rangeEnd: 0, entries: []}};
+
+        const fakeIncomingLocus = { sequence: {rangeStart: 0, rangeEnd: 0, entries: [1,2,3]}};
+
+        assert.isTrue(parser.isNewFullLocus(fakeIncomingLocus));
+      });
+
+    })
+  });
+
   describe('Invalid Locus objects', () => {
     let sandbox = null;
     let parser;

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

@@ -26,6 +26,7 @@ import {
   LOCUSINFO,
   PC_BAIL_TIMEOUT,
   DISPLAY_HINTS,
+  SELF_POLICY,
 } from '@webex/plugin-meetings/src/constants';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import {
@@ -5664,10 +5665,99 @@ describe('plugin-meetings', () => {
           waitingForOthersToJoinSpy.restore();
         });
 
+        forEach(
+          [
+            {
+              actionName: 'canShareFile',
+              requiredDisplayHints: [DISPLAY_HINTS.SHARE_FILE],
+              requiredPolicies: [SELF_POLICY.SUPPORT_FILE_SHARE],
+            },
+            {
+              actionName: 'canShareApplication',
+              requiredDisplayHints: [DISPLAY_HINTS.SHARE_APPLICATION],
+              requiredPolicies: [SELF_POLICY.SUPPORT_APP_SHARE],
+            },
+            {
+              actionName: 'canShareCamera',
+              requiredDisplayHints: [DISPLAY_HINTS.SHARE_CAMERA],
+              requiredPolicies: [SELF_POLICY.SUPPORT_CAMERA_SHARE],
+            },
+            {
+              actionName: 'canShareDesktop',
+              requiredDisplayHints: [DISPLAY_HINTS.SHARE_DESKTOP],
+              requiredPolicies: [SELF_POLICY.SUPPORT_DESKTOP_SHARE],
+            },
+          ],
+          ({actionName, requiredDisplayHints, requiredPolicies}) => {
+            it(`${actionName} is enabled when the conditions are met`, () => {
+              meeting.selfUserPolicies = {};
+
+              forEach(requiredPolicies, (policy) => {
+                meeting.selfUserPolicies[policy] = true;
+              });
+
+              meeting.setUpLocusInfoMeetingInfoListener();
+
+              const callback = locusInfoOnSpy.thirdCall.args[1];
+
+              const payload = {
+                info: {
+                  userDisplayHints: requiredDisplayHints,
+                },
+              };
+
+              callback(payload);
+
+              assert.isTrue(meeting.inMeetingActions.get()[actionName]);
+            });
+
+            it(`${actionName} is disabled when the required display hints are missing`, () => {
+              meeting.selfUserPolicies = {};
+
+              forEach(requiredPolicies, (policy) => {
+                meeting.selfUserPolicies[policy] = true;
+              });
+
+              meeting.setUpLocusInfoMeetingInfoListener();
+
+              const callback = locusInfoOnSpy.thirdCall.args[1];
+
+              const payload = {
+                info: {
+                  userDisplayHints: [],
+                },
+              };
+
+              callback(payload);
+
+              assert.isFalse(meeting.inMeetingActions.get()[actionName]);
+            });
+
+            it(`${actionName} is disabled when the required policies are missing`, () => {
+              meeting.selfUserPolicies = {};
+
+              meeting.setUpLocusInfoMeetingInfoListener();
+
+              const callback = locusInfoOnSpy.thirdCall.args[1];
+
+              const payload = {
+                info: {
+                  userDisplayHints: requiredDisplayHints,
+                },
+              };
+
+              callback(payload);
+
+              assert.isFalse(meeting.inMeetingActions.get()[actionName]);
+            });
+          }
+        );
+
         it('registers the correct MEETING_INFO_UPDATED event', () => {
           // Due to import tree issues, hasHints must be stubed within the scope of the `it`.
           const restorableHasHints = ControlsOptionsUtil.hasHints;
           ControlsOptionsUtil.hasHints = sinon.stub().returns(true);
+          ControlsOptionsUtil.hasPolicies = sinon.stub().returns(true);
 
           const setUserPolicySpy = sinon.spy(meeting.recordingController, 'setUserPolicy');
           meeting.selfUserPolicies = {a: true};
@@ -5766,18 +5856,34 @@ describe('plugin-meetings', () => {
             requiredHints: [DISPLAY_HINTS.SHARE_FILE],
             displayHints: payload.info.userDisplayHints,
           });
+          assert.calledWith(ControlsOptionsUtil.hasPolicies, {
+            requiredPolicies: [SELF_POLICY.SUPPORT_FILE_SHARE],
+            policies: {a: true},
+          });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_APPLICATION],
             displayHints: payload.info.userDisplayHints,
           });
+          assert.calledWith(ControlsOptionsUtil.hasPolicies, {
+            requiredPolicies: [SELF_POLICY.SUPPORT_APP_SHARE],
+            policies: {a: true},
+          });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_CAMERA],
             displayHints: payload.info.userDisplayHints,
           });
+          assert.calledWith(ControlsOptionsUtil.hasPolicies, {
+            requiredPolicies: [SELF_POLICY.SUPPORT_CAMERA_SHARE],
+            policies: {a: true},
+          });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_DESKTOP],
             displayHints: payload.info.userDisplayHints,
           });
+          assert.calledWith(ControlsOptionsUtil.hasPolicies, {
+            requiredPolicies: [SELF_POLICY.SUPPORT_DESKTOP_SHARE],
+            policies: {a: true},
+          });
           assert.calledWith(ControlsOptionsUtil.hasHints, {
             requiredHints: [DISPLAY_HINTS.SHARE_CONTENT],
             displayHints: payload.info.userDisplayHints,