@webex/plugin-meetings 3.0.0-beta.20 → 3.0.0-beta.201

package/test/unit/spec/locus-info/mediaSharesUtils.ts

@@ -0,0 +1,22 @@
+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();
+  });
+});
+

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;
@@ -272,27 +334,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);
-    });
   });
 });

package/test/unit/spec/locus-info/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,10 @@ export const self = {
       requestedToUnmute: false,
       meta: {},
     },
+    video: {
+      muted: false,
+      meta: {},
+    },
     breakout: {
       sessions: {
         active: [
@@ -116,7 +129,7 @@ export const self = {
             name: 'Breakout session 2',
             groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
             sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-            sessionType: 'BREAKOUT'
+            sessionType: 'BREAKOUT',
           },
         ],
         allowed: [
@@ -124,14 +137,24 @@ export const self = {
             name: 'Breakout session 2',
             groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
             sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-            sessionType: 'BREAKOUT'
+            sessionType: 'BREAKOUT',
           },
-        ]
+        ],
       },
       meta: {
         modifiedBy: '347ef89e-e1be-40a3-849c-731bdd935e62',
         lastModified: '2023-01-10T10:10:06.813Z',
-        readOnly: true
+        readOnly: true,
+      },
+    },
+    interpretation: {
+      originalLanguage: 'en',
+      sourceLanguage: 'en',
+      targetLanguage: 'cn',
+      order: 0,
+      isActive: true,
+      meta: {
+        lastModified: '2023-07-11T01:57:31.040Z',
       }
     },
     localRecord: {

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

@@ -39,7 +39,7 @@ describe('plugin-meetings', () => {
               name: 'Breakout session 2',
               groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
               sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-              sessionType: 'BREAKOUT'
+              sessionType: 'BREAKOUT',
             },
           ],
           allowed: [
@@ -47,9 +47,9 @@ describe('plugin-meetings', () => {
               name: 'Breakout session 2',
               groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
               sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-              sessionType: 'BREAKOUT'
+              sessionType: 'BREAKOUT',
             },
-          ]
+          ],
         });
       });
 
@@ -76,9 +76,12 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('getBreakouts', () => {
+    describe('getBreakoutSessions', () => {
       it('should return breakout sessions', () => {
-        assert.deepEqual(SelfUtils.getBreakouts({controls: {breakout: {sessions: 'SESSIONS'}}}), 'SESSIONS');
+        assert.deepEqual(
+          SelfUtils.getBreakoutSessions({controls: {breakout: {sessions: 'SESSIONS'}}}),
+          'SESSIONS'
+        );
       });
     });
 
@@ -91,10 +94,11 @@ describe('plugin-meetings', () => {
                 name: 'Breakout session 2',
                 groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
                 sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT'
+                sessionType: 'BREAKOUT',
               },
-            ]
-          }
+            ],
+          },
+          breakout: {},
         };
         const previous = {
           breakoutSessions: {
@@ -103,10 +107,11 @@ describe('plugin-meetings', () => {
                 name: 'Breakout session 2',
                 groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
                 sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT'
+                sessionType: 'BREAKOUT',
               },
-            ]
-          }
+            ],
+          },
+          breakout: {},
         };
 
         assert.isTrue(SelfUtils.breakoutsChanged(previous, current));
@@ -120,10 +125,11 @@ describe('plugin-meetings', () => {
                 name: 'Breakout session 2',
                 groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
                 sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT'
+                sessionType: 'BREAKOUT',
               },
-            ]
-          }
+            ],
+          },
+          breakout: {},
         };
         const previous = {
           breakoutSessions: {
@@ -132,10 +138,33 @@ describe('plugin-meetings', () => {
                 name: 'Breakout session 2',
                 groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
                 sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT'
+                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));
@@ -222,6 +251,55 @@ describe('plugin-meetings', () => {
           assert.equal(updates.canNotViewTheParticipantListChanged, false);
         });
       });
+
+      describe('localAudioUnmuteRequestedByServer', () => {
+        it('should return localAudioUnmuteRequestedByServer = false when requestedToUnmute = false', () => {
+          const clonedSelf = cloneDeep(self);
+
+          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+
+          assert.equal(updates.localAudioUnmuteRequestedByServer, false);
+        });
+
+        it('should return localAudioUnmuteRequestedByServer = true when first request is made with requestedToUnmute = true', () => {
+          const clonedSelf = cloneDeep(self);
+
+          //request to unmute with timestamp
+          clonedSelf.controls.audio.requestedToUnmute = true;
+          clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
+
+          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+
+          assert.equal(updates.localAudioUnmuteRequestedByServer, true);
+        });
+
+        it('should return localAudioUnmuteRequestedByServer = true when requestedToUnmute = true and new requests lastModifiedRequestedToUnmute timestamp is greater than old one', () => {
+          self.controls.audio.requestedToUnmute = true;
+          self.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
+          const clonedSelf = cloneDeep(self);
+
+          //request to unmute with timestamp
+          clonedSelf.controls.audio.requestedToUnmute = true;
+          clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T19:25:04.369Z';
+
+          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+
+          assert.equal(updates.localAudioUnmuteRequestedByServer, true);
+        });
+
+        it('should return localAudioUnmuteRequestedByServer = false when requestedToUnmute but lastModifiedRequestedToUnmute timestamps are same', () => {
+          self.controls.audio.requestedToUnmute = true;
+          self.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z';
+          const clonedSelf = cloneDeep(self);
+
+          clonedSelf.controls.audio.requestedToUnmute = true;
+          clonedSelf.controls.audio.lastModifiedRequestedToUnmute = '2023-06-16T18:25:04.369Z'
+
+          const {updates} = SelfUtils.getSelves(self, clonedSelf);
+
+          assert.equal(updates.localAudioUnmuteRequestedByServer, false);
+        });
+      });
     });
 
     describe('isSharingBlocked', () => {
@@ -266,4 +344,117 @@ 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('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);
+    });
+  });
+
+  describe('isRolesChanged', () => {
+    it('should return false if new self is null', () => {
+      const parsedSelf = SelfUtils.parse(self);
+
+      assert.deepEqual(SelfUtils.isRolesChanged(parsedSelf, null), false);
+    });
+
+    it('should return true if self roles has changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.roles = ['COHOST'];
+
+      assert.deepEqual(SelfUtils.isRolesChanged(parsedSelf, clonedSelf), true);
+    });
+
+    it('should return false if self roles has not changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.roles = ['PRESENTER'];
+
+      assert.deepEqual(SelfUtils.isRolesChanged(parsedSelf, clonedSelf), false);
+    });
+  });
+
+  describe('interpretationChanged', () => {
+    it('should return false if new self is null', () => {
+      const parsedSelf = SelfUtils.parse(self);
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, null), false);
+    });
+
+    it('should return true if interpretation info has changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.interpretation.sourceLanguage = 'ja';
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, clonedSelf), true);
+    });
+
+    it('should return false if interpretation info  has not changed', () => {
+      const parsedSelf = SelfUtils.parse(self);
+      const clonedSelf = cloneDeep(parsedSelf);
+
+      clonedSelf.interpretation.sourceLanguage = 'en';
+
+      assert.deepEqual(SelfUtils.interpretationChanged(parsedSelf, clonedSelf), false);
+    });
+  });
 });