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

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

@@ -33,24 +33,6 @@ describe('plugin-meetings', () => {
         assert.calledWith(getRolesSpy, self);
 
         assert.deepEqual(parsedSelf.roles, ['PRESENTER']);
-        assert.deepEqual(parsedSelf.breakoutSessions, {
-          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',
-            },
-          ],
-        });
       });
 
       it('calls getLayout and returns the resulting layout', () => {
@@ -76,101 +58,6 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('getBreakoutSessions', () => {
-      it('should return breakout sessions', () => {
-        assert.deepEqual(
-          SelfUtils.getBreakoutSessions({controls: {breakout: {sessions: 'SESSIONS'}}}),
-          'SESSIONS'
-        );
-      });
-    });
-
-    describe('breakoutsChanged', () => {
-      it('should return true if breakouts have changed', () => {
-        const current = {
-          breakoutSessions: {
-            allowed: [
-              {
-                name: 'Breakout session 2',
-                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
-                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT',
-              },
-            ],
-          },
-          breakout: {},
-        };
-        const previous = {
-          breakoutSessions: {
-            active: [
-              {
-                name: 'Breakout session 2',
-                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
-                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT',
-              },
-            ],
-          },
-          breakout: {},
-        };
-
-        assert.isTrue(SelfUtils.breakoutsChanged(previous, current));
-      });
-
-      it('should return false if breakouts have not changed', () => {
-        const current = {
-          breakoutSessions: {
-            active: [
-              {
-                name: 'Breakout session 2',
-                groupId: '0e73abb8-5584-49d8-be8d-806d2a8247ca',
-                sessionId: '1cf41ab1-2e57-4d95-b7e9-5613acddfb0f',
-                sessionType: 'BREAKOUT',
-              },
-            ],
-          },
-          breakout: {},
-        };
-        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));
-      });
-
-      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));
-      });
-    });
-
     describe('canNotViewTheParticipantList', () => {
       it('should return the correct value', () => {
         assert.equal(
@@ -251,55 +138,6 @@ 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', () => {
@@ -344,117 +182,4 @@ 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);
-    });
-  });
 });

package/test/unit/spec/media/properties.ts

@@ -1,47 +1,54 @@
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {ConnectionState, Event} from '@webex/internal-media-core';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import MediaUtil from '@webex/plugin-meetings/src/media/util';
 import testUtils from '../../../utils/testUtils';
-import {ICE_AND_DTLS_CONNECTION_TIMEOUT} from '@webex/plugin-meetings/src/constants';
+import {PC_BAIL_TIMEOUT} from '@webex/plugin-meetings/src/constants';
 import {Defer} from '@webex/common';
 
 describe('MediaProperties', () => {
   let mediaProperties;
-  let mockMC;
+  let mockPc;
   let clock;
 
   beforeEach(() => {
     clock = sinon.useFakeTimers();
 
-    mockMC = {
+    mockPc = {
       getStats: sinon.stub().resolves([]),
-      on: sinon.stub(),
-      off: sinon.stub(),
-      getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+      addEventListener: sinon.stub(),
+      removeEventListener: sinon.stub(),
+      iceConnectionState: 'connected',
     };
 
+    sinon.stub(MediaUtil, 'createPeerConnection').returns(mockPc);
+
     mediaProperties = new MediaProperties();
-    mediaProperties.setMediaPeerConnection(mockMC);
   });
 
   afterEach(() => {
     clock.restore();
     sinon.restore();
   });
-  describe('waitForMediaConnectionConnected', () => {
+  describe('waitForIceConnectedState', () => {
     it('resolves immediately if ice state is connected', async () => {
-      await mediaProperties.waitForMediaConnectionConnected();
+      mockPc.iceConnectionState = 'connected';
+
+      await mediaProperties.waitForIceConnectedState();
+    });
+    it('resolves immediately if ice state is completed', async () => {
+      mockPc.iceConnectionState = 'completed';
+
+      await mediaProperties.waitForIceConnectedState();
     });
     it('rejects after timeout if ice state does not reach connected/completed', async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+      mockPc.iceConnectionState = 'connecting';
 
       let promiseResolved = false;
       let promiseRejected = false;
 
       mediaProperties
-        .waitForMediaConnectionConnected()
+        .waitForIceConnectedState()
         .then(() => {
           promiseResolved = true;
         })
@@ -52,133 +59,135 @@ describe('MediaProperties', () => {
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, false);
 
-      await clock.tickAsync(ICE_AND_DTLS_CONNECTION_TIMEOUT);
+      await clock.tickAsync(PC_BAIL_TIMEOUT);
       await testUtils.flushPromises();
 
       assert.equal(promiseResolved, false);
       assert.equal(promiseRejected, true);
 
       // check that listener was registered and removed
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      const listener = mockMC.on.getCall(0).args[1];
+      assert.calledOnce(mockPc.addEventListener);
+      assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+      const listener = mockPc.addEventListener.getCall(0).args[1];
 
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+      assert.calledOnce(mockPc.removeEventListener);
+      assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
     });
 
-    it(`resolves when media connection reaches "connected" state`, async () => {
-      mockMC.getConnectionState.returns(ConnectionState.Connecting);
+    ['connected', 'completed'].forEach((successIceState) =>
+      it(`resolves when ice state reaches ${successIceState}`, async () => {
+        mockPc.iceConnectionState = 'connecting';
 
-      const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
+        const clearTimeoutSpy = sinon.spy(clock, 'clearTimeout');
 
-      let promiseResolved = false;
-      let promiseRejected = false;
+        let promiseResolved = false;
+        let promiseRejected = false;
 
-      mediaProperties
-        .waitForMediaConnectionConnected()
-        .then(() => {
-          promiseResolved = true;
-        })
-        .catch(() => {
-          promiseRejected = true;
-        });
+        mediaProperties
+          .waitForIceConnectedState()
+          .then(() => {
+            promiseResolved = true;
+          })
+          .catch(() => {
+            promiseRejected = true;
+          });
 
-      assert.equal(promiseResolved, false);
-      assert.equal(promiseRejected, false);
+        assert.equal(promiseResolved, false);
+        assert.equal(promiseRejected, false);
 
-      // check the right listener was registered
-      assert.calledOnce(mockMC.on);
-      assert.equal(mockMC.on.getCall(0).args[0], Event.CONNECTION_STATE_CHANGED);
-      const listener = mockMC.on.getCall(0).args[1];
+        // check the right listener was registered
+        assert.calledOnce(mockPc.addEventListener);
+        assert.equal(mockPc.addEventListener.getCall(0).args[0], 'iceconnectionstatechange');
+        const listener = mockPc.addEventListener.getCall(0).args[1];
 
-      // call the listener and pretend we are now connected
-      mockMC.getConnectionState.returns(ConnectionState.Connected);
-      listener();
-      await testUtils.flushPromises();
+        // call the listener and pretend we are now connected
+        mockPc.iceConnectionState = successIceState;
+        listener();
+        await testUtils.flushPromises();
 
-      assert.equal(promiseResolved, true);
-      assert.equal(promiseRejected, false);
+        assert.equal(promiseResolved, true);
+        assert.equal(promiseRejected, false);
 
-      // check that listener was removed
-      assert.calledOnce(mockMC.off);
-      assert.calledWith(mockMC.off, Event.CONNECTION_STATE_CHANGED, listener);
+        // check that listener was removed
+        assert.calledOnce(mockPc.removeEventListener);
+        assert.calledWith(mockPc.removeEventListener, 'iceconnectionstatechange', listener);
 
-      assert.calledOnce(clearTimeoutSpy);
-    });
+        assert.calledOnce(clearTimeoutSpy);
+      })
+    );
   });
 
   describe('getCurrentConnectionType', () => {
-    it('calls waitForMediaConnectionConnected', async () => {
-      const spy = sinon.stub(mediaProperties, 'waitForMediaConnectionConnected');
+    it('calls waitForIceConnectedState', async () => {
+      const spy = sinon.stub(mediaProperties, 'waitForIceConnectedState');
 
       await mediaProperties.getCurrentConnectionType();
 
       assert.calledOnce(spy);
     });
-    it('calls getStats() only after waitForMediaConnectionConnected resolves', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
+    it('calls getStats() only after waitForIceConnectedState resolves', async () => {
+      const waitForIceConnectedStateResult = new Defer();
 
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
 
       const result = mediaProperties.getCurrentConnectionType();
 
       await testUtils.flushPromises();
 
-      assert.called(waitForMediaConnectionConnectedStub);
-      assert.notCalled(mockMC.getStats);
+      assert.called(waitForIceConnectedStateStub);
+      assert.notCalled(mockPc.getStats);
 
-      waitForMediaConnectionConnectedResult.resolve();
+      waitForIceConnectedStateResult.resolve();
       await testUtils.flushPromises();
 
-      assert.called(mockMC.getStats);
+      assert.called(mockPc.getStats);
       await result;
     });
-    it('rejects if waitForMediaConnectionConnected rejects', async () => {
-      const waitForMediaConnectionConnectedResult = new Defer();
+    it('rejects if waitForIceConnectedState rejects', async () => {
+      const waitForIceConnectedStateResult = new Defer();
 
-      const waitForMediaConnectionConnectedStub = sinon
-        .stub(mediaProperties, 'waitForMediaConnectionConnected')
-        .returns(waitForMediaConnectionConnectedResult.promise);
+      const waitForIceConnectedStateStub = sinon
+        .stub(mediaProperties, 'waitForIceConnectedState')
+        .returns(waitForIceConnectedStateResult.promise);
 
       const result = mediaProperties.getCurrentConnectionType();
 
       await testUtils.flushPromises();
 
-      assert.called(waitForMediaConnectionConnectedStub);
+      assert.called(waitForIceConnectedStateStub);
 
-      waitForMediaConnectionConnectedResult.reject(new Error('fake error'));
+      waitForIceConnectedStateResult.reject(new Error('fake error'));
       await testUtils.flushPromises();
 
-      assert.notCalled(mockMC.getStats);
+      assert.notCalled(mockPc.getStats);
 
       await assert.isRejected(result);
     });
     it('returns "unknown" if getStats() fails', async () => {
-      mockMC.getStats.rejects(new Error());
+      mockPc.getStats.rejects(new Error());
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns no candidate pairs', async () => {
-      mockMC.getStats.resolves([{type: 'something', id: '1234'}]);
+      mockPc.getStats.resolves([{type: 'something', id: '1234'}]);
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns no successful candidate pair', async () => {
-      mockMC.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
+      mockPc.getStats.resolves([{type: 'candidate-pair', id: '1234', state: 'inprogress'}]);
 
       const connectionType = await mediaProperties.getCurrentConnectionType();
       assert.equal(connectionType, 'unknown');
     });
 
     it('returns "unknown" if getStats() returns a successful candidate pair but local candidate is missing', async () => {
-      mockMC.getStats.resolves([
+      mockPc.getStats.resolves([
         {type: 'candidate-pair', id: '1234', state: 'succeeded', localCandidateId: 'wrong id'},
       ]);
 
@@ -187,7 +196,7 @@ describe('MediaProperties', () => {
     });
 
     it('returns "UDP" if getStats() returns a successful candidate pair with udp local candidate', async () => {
-      mockMC.getStats.resolves([
+      mockPc.getStats.resolves([
         {
           type: 'candidate-pair',
           id: 'some candidate pair id',
@@ -203,7 +212,7 @@ describe('MediaProperties', () => {
     });
 
     it('returns "TCP" if getStats() returns a successful candidate pair with tcp local candidate', async () => {
-      mockMC.getStats.resolves([
+      mockPc.getStats.resolves([
         {
           type: 'candidate-pair',
           id: 'some candidate pair id',
@@ -224,7 +233,7 @@ describe('MediaProperties', () => {
       {relayProtocol: 'udp', expectedConnectionType: 'TURN-UDP'},
     ].forEach(({relayProtocol, expectedConnectionType}) =>
       it(`returns "${expectedConnectionType}" if getStats() returns a successful candidate pair with a local candidate with relayProtocol=${relayProtocol}`, async () => {
-        mockMC.getStats.resolves([
+        mockPc.getStats.resolves([
           {
             type: 'candidate-pair',
             id: 'some candidate pair id',
@@ -256,7 +265,7 @@ describe('MediaProperties', () => {
       // in real life this will never happen and all active candidate pairs will have same transport,
       // but here we're simulating a situation where they have different transports and just checking
       // that the code still works and just returns the first one
-      mockMC.getStats.resolves([
+      mockPc.getStats.resolves([
         {
           type: 'inbound-rtp',
           id: 'whatever',