@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

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

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

@@ -517,22 +517,6 @@
       "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,15 +66,6 @@ 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],
@@ -118,45 +109,6 @@ 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/parser.js

@@ -5,7 +5,6 @@
 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';
@@ -51,11 +50,9 @@ describe('locus-info/parser', () => {
     });
 
     describe('delta sequence comparisons', () => {
-      const {DESYNC, USE_CURRENT, USE_INCOMING, WAIT, LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
+      const {DESYNC, USE_CURRENT, USE_INCOMING} = LocusDeltaParser.loci;
       const {extractComparisonState: extract} = LocusDeltaParser;
 
-      sinon.stub(Metrics, 'sendBehavioralMetric');
-      
       function translate(action) {
         switch (action) {
           case 'ACCEPT_NEW':
@@ -64,10 +61,6 @@ 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`);
         }
@@ -80,12 +73,10 @@ 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);
@@ -96,8 +87,6 @@ describe('locus-info/parser', () => {
           assert.equal(action, translate(result));
         });
       });
-
-      Metrics.sendBehavioralMetric.restore();
     });
   });
 
@@ -117,7 +106,7 @@ describe('locus-info/parser', () => {
         return burst;
       })();
 
-      parser.onDeltaAction = sinon.stub();
+      parser.onDeltaAction = true;
       parser.processDeltaEvent = function () {
         const fakeLoci = this.queue.dequeue();
 
@@ -144,11 +133,7 @@ describe('locus-info/parser', () => {
   });
 
   describe('Processes delta events correctly', () => {
-    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}};
-
+    const NEW_LOCI = 'NEW LOCI';
     let sandbox = null;
     let parser;
 
@@ -157,7 +142,6 @@ 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(() => {
@@ -169,7 +153,7 @@ describe('locus-info/parser', () => {
       const {DESYNC} = LocusDeltaParser.loci;
 
       parser.pause = sandbox.stub();
-      sandbox.stub(LocusDeltaParser, 'compare').returns(DESYNC);
+      LocusDeltaParser.compare = sandbox.stub().returns(DESYNC);
 
       parser.processDeltaEvent();
 
@@ -180,7 +164,7 @@ describe('locus-info/parser', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
       parser.workingCopy = null;
-      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
+      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
 
       parser.processDeltaEvent();
 
@@ -191,7 +175,8 @@ describe('locus-info/parser', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
       const lociComparison = USE_INCOMING;
 
-      sandbox.stub(LocusDeltaParser, 'compare').returns(lociComparison);
+      LocusDeltaParser.compare = sandbox.stub().returns(lociComparison);
+      parser.onDeltaAction = sandbox.stub();
 
       parser.processDeltaEvent();
 
@@ -201,7 +186,7 @@ describe('locus-info/parser', () => {
     it('should call nextEvent()', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
-      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
+      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
       parser.nextEvent = sandbox.stub();
 
       parser.processDeltaEvent();
@@ -212,8 +197,7 @@ describe('locus-info/parser', () => {
     it('should not call compare() if locus is invalid', () => {
       const {USE_INCOMING} = LocusDeltaParser.loci;
 
-      sandbox.stub(LocusDeltaParser, 'compare').returns(USE_INCOMING);
-
+      LocusDeltaParser.compare = sandbox.stub().returns(USE_INCOMING);
       // restore the original method
       parser.isValidLocus.restore();
       parser.isValidLocus.bind(parser);
@@ -224,8 +208,9 @@ describe('locus-info/parser', () => {
     });
 
     it('processDeltaEvent() should take next item in queue', () => {
-      parser.workingCopy = CURRENT_LOCI;
-      
+      // restore the original method
+      parser.queue.dequeue = sandbox.stub();
+
       parser.processDeltaEvent();
 
       assert.calledOnce(parser.queue.dequeue);
@@ -243,7 +228,7 @@ describe('locus-info/parser', () => {
       assert.equal(comparisonResults, expectedResults);
     });
 
-    it('should be able to unpack comparison results', () => {
+    it('shoud be able to unpack comparison results', () => {
       const {extractComparisonState: extract} = LocusDeltaParser;
 
       const comparisonResults = 'value04:value03:value:02:value01';
@@ -251,94 +236,6 @@ 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', () => {
@@ -375,5 +272,27 @@ 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);
+    });
   });
 });