@webex/plugin-meetings 2.60.0 → 2.60.1-next.2

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

@@ -1,6 +1,5 @@
 import {assert} from '@webex/test-helper-chai';
 import Sinon from 'sinon';
-
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 
 describe('plugin-meetings', () => {
@@ -8,7 +7,7 @@ describe('plugin-meetings', () => {
     const info = {
       displayHints: {
         moderator: ['HINT_1', 'HINT_2'],
-        joined: ['HINT_3'],
+        joined: ['HINT_3', 'VOIP_IS_ENABLED'],
         coHost: ['HINT_4'],
       },
     };
@@ -28,47 +27,83 @@ describe('plugin-meetings', () => {
     describe('parse', () => {
       it('only gives includes display hints when user has the correct role', () => {
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR']), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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',
+            'VOIP_IS_ENABLED',
+            'HINT_1',
+            'HINT_2',
+            'LOWER_SOMEONE_ELSES_HAND',
+          ],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR', 'COHOST']), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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',
+            'VOIP_IS_ENABLED',
+            'HINT_4',
+            'LOWER_SOMEONE_ELSES_HAND',
+            'HINT_1',
+            'HINT_2',
+          ],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['COHOST']), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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', 'VOIP_IS_ENABLED', 'HINT_4', 'LOWER_SOMEONE_ELSES_HAND'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, []), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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', 'VOIP_IS_ENABLED'],
         });
       });
 
-      it('only gives includes display hints when user has joined the meeting role', () => {
+      it('only includes interstitial display hints when user has not joined the meeting', () => {
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR'], false), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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: ['VOIP_IS_ENABLED', 'HINT_1', 'HINT_2', 'LOWER_SOMEONE_ELSES_HAND'],
         });
 
         assert.deepEqual(InfoUtils.parse(info, ['MODERATOR'], true), {
-          policy: {HINT_3: true},
+          policy: {HINT_3: true, VOIP_IS_ENABLED: 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',
+            'VOIP_IS_ENABLED',
+            '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: [],
         });
       });
     });
@@ -80,7 +115,10 @@ describe('plugin-meetings', () => {
           HINT_2: true,
         });
 
-        assert.deepEqual(InfoUtils.parseDisplayHintSection(info, 'joined'), {HINT_3: true});
+        assert.deepEqual(InfoUtils.parseDisplayHintSection(info, 'joined'), {
+          HINT_3: true,
+          VOIP_IS_ENABLED: true,
+        });
 
         assert.deepEqual(InfoUtils.parseDisplayHintSection({}, 'joined'), {});
 

package/test/unit/spec/locus-info/lib/SeqCmp.json

@@ -517,6 +517,22 @@
       "new": "seq4g",
       "result": "DESYNC",
       "description": "New seq is greater than current, but both current and new base have some unique entries."
+    },
+    "updt25": {
+      "current": "seq4",
+      "newbase": "seq5c",
+      "new": "seq5b",
+      "result": "WAIT",
+      "description": "Both new seq and new base are newer than current but are not equal"
+    },
+    "updt26": {
+      "current": "seq4",
+      "currentUrl": "locus url 1",
+      "newbase": "seq5c",
+      "new": "seq5b",
+      "newUrl": "locus url 2",
+      "result": "LOCUS_URL_CHANGED",
+      "description": "Locus url changes in incoming"
     }
   }
 }

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

@@ -66,6 +66,15 @@ export const self = {
         },
       ],
       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',
       intent: {type: ''},
       intents: [null],
@@ -109,6 +118,45 @@ export const self = {
       requestedToUnmute: false,
       meta: {},
     },
+    video: {
+      muted: false,
+      meta: {},
+    },
+    breakout: {
+      sessions: {
+        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',
+          },
+        ],
+      },
+      meta: {
+        modifiedBy: '347ef89e-e1be-40a3-849c-731bdd935e62',
+        lastModified: '2023-01-10T10:10:06.813Z',
+        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/mediaSharesUtils.ts

@@ -0,0 +1,32 @@
+import MediaSharesUtils from '@webex/plugin-meetings/src/locus-info/mediaSharesUtils';
+import {assert} from "chai";
+import Sinon from "sinon";
+
+describe('getShareInstanceId', () => {
+  it('getShareInstanceId return correct shareInstanceId value', () => {
+    const stub = Sinon.stub(MediaSharesUtils, 'extractContent').returns({ floor:{shareInstanceId:'shareInstanceId'}});
+    const shareInstanceId = MediaSharesUtils.getShareInstanceId();
+    assert.equal(shareInstanceId,'shareInstanceId');
+    stub.restore();
+  });
+});
+
+describe('getContentUrl', () => {
+  it('getContentUrl return correct url value', () => {
+    const stub = Sinon.stub(MediaSharesUtils, 'extractContent').returns({url:'url'});
+    const url = MediaSharesUtils.getContentUrl();
+    assert.equal(url,'url');
+    stub.restore();
+  });
+});
+
+describe('getContentBeneficiaryDeviceUrl', () => {
+  it('getContentBeneficiaryDeviceUrl return correct deviceUrl value', () => {
+    const mockContentBeneficiaryDeviceUrl = "https://wdm-a.wbx2.com/wdm/api/v1/devices/e9ffd8a1-1fae-42d1-afbe-013e951f93ab"
+    const stub = Sinon.stub(MediaSharesUtils, 'extractContentFloor').returns({ beneficiary: {deviceUrl : mockContentBeneficiaryDeviceUrl}});
+    const contentBeneficiaryDeviceUrl = MediaSharesUtils.getContentBeneficiaryDeviceUrl();
+    assert.equal(contentBeneficiaryDeviceUrl, mockContentBeneficiaryDeviceUrl);
+    stub.restore();
+  });
+});
+

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

@@ -5,6 +5,7 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import basicSequenceComparisons from './lib/BasicSeqCmp.json';
 import sequenceComparisons from './lib/SeqCmp';
@@ -50,9 +51,11 @@ describe('locus-info/parser', () => {
     });
 
     describe('delta sequence comparisons', () => {
-      const {DESYNC, USE_CURRENT, USE_INCOMING} = LocusDeltaParser.loci;
+      const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
       const {extractComparisonState: extract} = LocusDeltaParser;
 
+      sinon.stub(Metrics, 'sendBehavioralMetric');
+      
       function translate(action) {
         switch (action) {
           case 'ACCEPT_NEW':
@@ -61,6 +64,10 @@ describe('locus-info/parser', () => {
             return USE_CURRENT;
           case 'DESYNC':
             return DESYNC;
+          case 'WAIT':
+            return WAIT;
+          case 'LOCUS_URL_CHANGED':
+            return LOCUS_URL_CHANGED;
           default:
             throw new Error(`${action} not recognized`);
         }
@@ -73,10 +80,12 @@ describe('locus-info/parser', () => {
 
         const current = {
           sequence: sequenceComparisons.sequences[currentKey],
+          url: sequenceComparisons.update_actions[key].currentUrl,
         };
         const incoming = {
           sequence: sequenceComparisons.sequences[incomingKey],
           baseSequence: sequenceComparisons.sequences[baseKey],
+          url: sequenceComparisons.update_actions[key].incomingUrl,
         };
         const comparison = LocusDeltaParser.compare(current, incoming);
         const action = extract(comparison);
@@ -87,6 +96,8 @@ describe('locus-info/parser', () => {
           assert.equal(action, translate(result));
         });
       });
+
+      Metrics.sendBehavioralMetric.restore();
     });
   });
 
@@ -106,7 +117,7 @@ describe('locus-info/parser', () => {
         return burst;
       })();
 
-      parser.onDeltaAction = true;
+      parser.onDeltaAction = sinon.stub();
       parser.processDeltaEvent = function () {
         const fakeLoci = this.queue.dequeue();
 
@@ -133,7 +144,11 @@ describe('locus-info/parser', () => {
   });
 
   describe('Processes delta events correctly', () => {
-    const NEW_LOCI = 'NEW LOCI';
+    const CURRENT_LOCI = {sequence: {entries: [100]}, url: 'CURRENT LOCI', baseSequence: {
+      "entries": [100], "rangeStart": 100, "rangeEnd": 100}};
+    const NEW_LOCI = {sequence: {entries: [200]}, url: 'NEW LOCI', baseSequence: {
+      "entries": [200], "rangeStart": 200, "rangeEnd": 200}};
+
     let sandbox = null;
     let parser;
 
@@ -142,6 +157,7 @@ describe('locus-info/parser', () => {
       parser = new LocusDeltaParser();
       sandbox.stub(parser, 'isValidLocus').returns(true);
       parser.queue.dequeue = sandbox.stub().returns(NEW_LOCI);
+      parser.onDeltaAction = sandbox.stub();
     });
 
     afterEach(() => {
@@ -153,7 +169,7 @@ describe('locus-info/parser', () => {
       const {DESYNC} = LocusDeltaParser.loci;
 
       parser.pause = sandbox.stub();
-      LocusDeltaParser.compare = sandbox.stub().returns(DESYNC);
+      sandbox.stub(LocusDeltaParser, 'compare').returns(DESYNC);
 
       parser.processDeltaEvent();
 
@@ -164,7 +180,7 @@ describe('locus-info/parser', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
       parser.workingCopy = null;
-      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
+      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
 
       parser.processDeltaEvent();
 
@@ -175,8 +191,7 @@ describe('locus-info/parser', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
       const lociComparison = USE_INCOMING;
 
-      LocusDeltaParser.compare = sandbox.stub().returns(lociComparison);
-      parser.onDeltaAction = sandbox.stub();
+      sandbox.stub(LocusDeltaParser, 'compare').returns(lociComparison);
 
       parser.processDeltaEvent();
 
@@ -186,7 +201,7 @@ describe('locus-info/parser', () => {
     it('should call nextEvent()', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
-      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
+      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
       parser.nextEvent = sandbox.stub();
 
       parser.processDeltaEvent();
@@ -197,7 +212,8 @@ describe('locus-info/parser', () => {
     it('should not call compare() if locus is invalid', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
-      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
+      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
+
       // restore the original method
       parser.isValidLocus.restore();
       parser.isValidLocus.bind(parser);
@@ -208,9 +224,8 @@ describe('locus-info/parser', () => {
     });
 
     it('processDeltaEvent() should take next item in queue', () => {
-      // restore the original method
-      parser.queue.dequeue = sandbox.stub();
-
+      parser.workingCopy = CURRENT_LOCI;
+      
       parser.processDeltaEvent();
 
       assert.calledOnce(parser.queue.dequeue);
@@ -228,7 +243,7 @@ describe('locus-info/parser', () => {
       assert.equal(comparisonResults, expectedResults);
     });
 
-    it('shoud be able to unpack comparison results', () => {
+    it('should be able to unpack comparison results', () => {
       const {extractComparisonState: extract} = LocusDeltaParser;
 
       const comparisonResults = 'value04:value03:value:02:value01';
@@ -236,6 +251,94 @@ describe('locus-info/parser', () => {
 
       assert.equal(lastResult, 'value04');
     });
+    
+    it('replaces current loci when the locus URL changes and incoming sequence is later, even when baseSequence doesn\'t match', () => {
+      const {USE_INCOMING} = LocusDeltaParser.loci;
+
+      parser.queue.dequeue = sandbox.stub().returns(NEW_LOCI);
+      parser.onDeltaAction = sandbox.stub();
+      parser.workingCopy = CURRENT_LOCI;
+      parser.triggerSync = sandbox.stub();
+
+      parser.processDeltaEvent();
+
+      assert.equal(parser.workingCopy, NEW_LOCI);
+    });
+
+    it('does not replace current loci when the locus URL changes but incoming sequence is not later', () => {
+      const {USE_INCOMING} = LocusDeltaParser.loci;
+      const laterLoci = {...CURRENT_LOCI, sequence: {entries: [300]}};
+
+      parser.queue.dequeue = sandbox.stub().returns(NEW_LOCI);
+      parser.onDeltaAction = sandbox.stub();
+      parser.workingCopy = laterLoci;
+
+      parser.processDeltaEvent();
+
+      assert.equal(parser.workingCopy, laterLoci);
+    });
+  });
+
+  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', () => {
@@ -272,27 +375,5 @@ describe('locus-info/parser', () => {
 
       assert.isFalse(result);
     });
-
-    it('sets parser status to IDLE if workingCopy is invalid', () => {
-      const {IDLE, WORKING} = LocusDeltaParser.status;
-
-      parser.workingCopy = null;
-      parser.status = WORKING;
-
-      parser.isValidLocus(loci);
-
-      assert.equal(parser.status, IDLE);
-    });
-
-    it('sets parser status to IDLE if new loci is invalid', () => {
-      const {IDLE, WORKING} = LocusDeltaParser.status;
-
-      parser.workingCopy = loci;
-      parser.status = WORKING;
-
-      parser.isValidLocus(null);
-
-      assert.equal(parser.status, IDLE);
-    });
   });
 });