@webex/plugin-meetings 3.7.0 → 3.8.0

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

@@ -1,6 +1,6 @@
 import 'jsdom-global/register';
 import sinon from 'sinon';
-import {cloneDeep} from 'lodash';
+import {cloneDeep, forEach} from 'lodash';
 import {assert} from '@webex/test-helper-chai';
 import MockWebex from '@webex/test-helper-mock-webex';
 import testUtils from '../../../utils/testUtils';
@@ -9,6 +9,7 @@ import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import EmbeddedAppsUtils from '@webex/plugin-meetings/src/locus-info/embeddedAppsUtils';
+import MediaSharesUtils from '@webex/plugin-meetings/src/locus-info//mediaSharesUtils';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 
@@ -22,6 +23,8 @@ import {
   LOCUS,
   MEETING_STATE,
   _MEETING_,
+  _SIP_BRIDGE_,
+  _SPACE_SHARE_,
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
@@ -101,7 +104,11 @@ describe('plugin-meetings', () => {
           },
           entryExitTone: {enabled: true, mode: 'foo'},
           video: {enabled: true},
-          videoLayout: {overrideDefault: true, lockAttendeeViewOnStageOnly:false, stageParameters: {}},
+          videoLayout: {
+            overrideDefault: true,
+            lockAttendeeViewOnStageOnly: false,
+            stageParameters: {},
+          },
           webcastControl: {streaming: false},
           practiceSession: {enabled: true},
         };
@@ -528,7 +535,7 @@ describe('plugin-meetings', () => {
           manualCaptionControl: {enabled: false},
         };
 
-        locusInfo.updateControls({manualCaptionControl: { enabled: true, }});
+        locusInfo.updateControls({manualCaptionControl: {enabled: true}});
 
         assert.calledWith(
           locusInfo.emitScoped,
@@ -793,6 +800,75 @@ describe('plugin-meetings', () => {
     });
 
     describe('#updateSelf', () => {
+      it('should trigger SELF_MEETING_BRB_CHANGED when brb state changed', () => {
+        locusInfo.self = undefined;
+
+        const assertBrb = (enabled) => {
+          const selfWithBrbChanged = cloneDeep(self);
+          selfWithBrbChanged.controls.brb = enabled;
+
+          locusInfo.emitScoped = sinon.stub();
+          locusInfo.updateSelf(selfWithBrbChanged, []);
+
+          assert.calledWith(
+            locusInfo.emitScoped,
+            {file: 'locus-info', function: 'updateSelf'},
+            LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+            {brb: enabled}
+          );
+        };
+
+        assertBrb(true);
+        assertBrb(false);
+      });
+
+      it('should not trigger SELF_MEETING_BRB_CHANGED when brb state did not change', () => {
+        const assertBrbUnchanged = (value) => {
+          locusInfo.self = undefined;
+
+          const selfWithBrbChanged = cloneDeep(self);
+          selfWithBrbChanged.controls.brb = value;
+          locusInfo.self = selfWithBrbChanged;
+
+          locusInfo.emitScoped = sinon.stub();
+
+          const newSelf = cloneDeep(self);
+          newSelf.controls.brb = value;
+
+          locusInfo.updateSelf(newSelf, []);
+
+          assert.neverCalledWith(
+            locusInfo.emitScoped,
+            {file: 'locus-info', function: 'updateSelf'},
+            LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+            {brb: value}
+          );
+        };
+
+        assertBrbUnchanged(true);
+        assertBrbUnchanged(false);
+      });
+
+      it('should not trigger SELF_MEETING_BRB_CHANGED when brb state is undefined', () => {
+        const selfWithBrbChanged = cloneDeep(self);
+        selfWithBrbChanged.controls.brb = false;
+        locusInfo.self = selfWithBrbChanged;
+
+        locusInfo.emitScoped = sinon.stub();
+
+        const newSelf = cloneDeep(self);
+        newSelf.controls.brb = undefined;
+
+        locusInfo.updateSelf(newSelf, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {file: 'locus-info', function: 'updateSelf'},
+          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+          {brb: undefined}
+        );
+      });
+
       it('should trigger CONTROLS_MEETING_LAYOUT_UPDATED when the meeting layout controls change', () => {
         const layoutType = 'EXAMPLE TYPE';
 
@@ -1388,6 +1464,30 @@ describe('plugin-meetings', () => {
           }
         );
       });
+
+      it('should not trigger any events if controls is undefined', () => {
+        locusInfo.self = self;
+        locusInfo.emitScoped = sinon.stub();
+        const newSelf = cloneDeep(self);
+        newSelf.controls = undefined;
+
+        locusInfo.updateSelf(newSelf, []);
+
+        const eventsSet = new Set([
+          LOCUSINFO.EVENTS.CONTROLS_MEETING_LAYOUT_UPDATED,
+          LOCUSINFO.EVENTS.SELF_MEETING_BREAKOUTS_CHANGED,
+          LOCUSINFO.EVENTS.SELF_MEETING_BRB_CHANGED,
+          LOCUSINFO.EVENTS.SELF_MEETING_INTERPRETATION_CHANGED,
+          LOCUSINFO.EVENTS.LOCAL_UNMUTE_REQUIRED,
+          LOCUSINFO.EVENTS.SELF_REMOTE_MUTE_STATUS_UPDATED,
+        ]);
+
+        // check all events that contain logic on controls existence
+        locusInfo.emitScoped.getCalls().forEach((call) => {
+          const eventName = call.args[1];
+          assert.isFalse(eventsSet.has(eventName));
+        });
+      });
     });
 
     describe('#updateMeetingInfo', () => {
@@ -1637,6 +1737,134 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateMediaShares', () => {
+      let getMediaSharesSpy;
+
+      beforeEach(() => {
+        // Spy on MediaSharesUtils.getMediaShares
+        getMediaSharesSpy = sinon.stub(MediaSharesUtils, 'getMediaShares');
+
+        // Stub the emitScoped method to monitor its calls
+        sinon.stub(locusInfo, 'emitScoped');
+      });
+
+      afterEach(() => {
+        getMediaSharesSpy.restore();
+        locusInfo.emitScoped.restore();
+      });
+
+      it('should update media shares and emit LOCUS_INFO_UPDATE_MEDIA_SHARES when mediaShares change', () => {
+        const initialMediaShares = { audio: true, video: false };
+        const newMediaShares = { audio: false, video: true };
+
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: newMediaShares,
+          previous: initialMediaShares,
+        };
+
+        // Stub MediaSharesUtils.getMediaShares to return the expected parsedMediaShares
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function
+        locusInfo.updateMediaShares(newMediaShares);
+
+        // Assert that MediaSharesUtils.getMediaShares was called with correct arguments
+        assert.calledWith(getMediaSharesSpy, initialMediaShares, newMediaShares);
+
+        // Assert that updateMeeting was called with the parsed current media shares
+        assert.deepEqual(locusInfo.parsedLocus.mediaShares, newMediaShares);
+        assert.deepEqual(locusInfo.mediaShares, newMediaShares);
+
+        // Assert that emitScoped was called with the correct event
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMediaShares',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
+          {
+            current: newMediaShares,
+            previous: initialMediaShares,
+            forceUpdate: false,
+          }
+        );
+      });
+
+      it('should force update media shares and emit LOCUS_INFO_UPDATE_MEDIA_SHARES even if shares are the same', () => {
+        const initialMediaShares = { audio: true, video: false };
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: initialMediaShares,
+          previous: initialMediaShares,
+        };
+
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function with forceUpdate = true
+        locusInfo.updateMediaShares(initialMediaShares, true);
+
+        // Assert that MediaSharesUtils.getMediaShares was called
+        assert.calledWith(getMediaSharesSpy, initialMediaShares, initialMediaShares);
+
+        // Assert that emitScoped was called with the correct event
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMediaShares',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_MEDIA_SHARES,
+          {
+            current: initialMediaShares,
+            previous: initialMediaShares,
+            forceUpdate: true,
+          }
+        );
+      });
+
+      it('should not emit LOCUS_INFO_UPDATE_MEDIA_SHARES if mediaShares do not change and forceUpdate is false', () => {
+        const initialMediaShares = { audio: true, video: false };
+        locusInfo.mediaShares = initialMediaShares;
+
+        // Call the function with the same mediaShares and forceUpdate = false
+        locusInfo.updateMediaShares(initialMediaShares);
+
+        // Assert that MediaSharesUtils.getMediaShares was not called
+        assert.notCalled(getMediaSharesSpy);
+
+        // Assert that emitScoped was not called
+        assert.notCalled(locusInfo.emitScoped);
+      });
+
+      it('should update internal state correctly when mediaShares are updated', () => {
+        const initialMediaShares = { audio: true, video: false };
+        const newMediaShares = { audio: false, video: true };
+
+        locusInfo.mediaShares = initialMediaShares;
+        locusInfo.parsedLocus = { mediaShares: null };
+
+        const parsedMediaShares = {
+          current: newMediaShares,
+          previous: initialMediaShares,
+        };
+
+        getMediaSharesSpy.returns(parsedMediaShares);
+
+        // Call the function
+        locusInfo.updateMediaShares(newMediaShares);
+
+        // Assert that the internal state was updated correctly
+        assert.deepEqual(locusInfo.parsedLocus.mediaShares, newMediaShares);
+        assert.deepEqual(locusInfo.mediaShares, newMediaShares);
+      });
+    });
+
     describe('#updateEmbeddedApps()', () => {
       const newEmbeddedApps = [
         {
@@ -2414,65 +2642,69 @@ describe('plugin-meetings', () => {
     });
 
     describe('#isMeetingActive', () => {
-      it('sends client event correctly for state = inactive', () => {
-        locusInfo.parsedLocus = {
-          fullState: {
-            type: _CALL_,
-          },
-        };
-
-        locusInfo.fullState = {
-          state: LOCUS.STATE.INACTIVE,
-        };
-
-        locusInfo.isMeetingActive();
-
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.call.remote-ended',
-          options: {
-            meetingId: locusInfo.meetingId,
-          },
-        });
-      });
-
-      it('sends client event correctly for state = PARTNER_LEFT', () => {
-        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
-        locusInfo.parsedLocus = {
-          fullState: {
-            type: _CALL_,
-          },
-          self: {
-            state: MEETING_STATE.STATES.DECLINED,
-          },
-        };
-        locusInfo.isMeetingActive();
-
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.call.remote-ended',
-          options: {
-            meetingId: locusInfo.meetingId,
-          },
-        });
-      });
-
-      it('sends client event correctly for state = SELF_LEFT', () => {
-        locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
-        locusInfo.parsedLocus = {
-          fullState: {
-            type: _CALL_,
-          },
-          self: {
-            state: MEETING_STATE.STATES.LEFT,
-          },
-        };
+      forEach([_CALL_, _SIP_BRIDGE_, _SPACE_SHARE_], (type) => {
+        describe(`type = ${type}`, () => {
+          it('sends client event correctly for state = inactive', () => {
+            locusInfo.parsedLocus = {
+              fullState: {
+                type: type,
+              },
+            };
+
+            locusInfo.fullState = {
+              state: LOCUS.STATE.INACTIVE,
+            };
+
+            locusInfo.isMeetingActive();
+
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.call.remote-ended',
+              options: {
+                meetingId: locusInfo.meetingId,
+              },
+            });
+          });
 
-        locusInfo.isMeetingActive();
+          it('sends client event correctly for state = PARTNER_LEFT', () => {
+            locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+            locusInfo.parsedLocus = {
+              fullState: {
+                type: type,
+              },
+              self: {
+                state: MEETING_STATE.STATES.DECLINED,
+              },
+            };
+            locusInfo.isMeetingActive();
+
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.call.remote-ended',
+              options: {
+                meetingId: locusInfo.meetingId,
+              },
+            });
+          });
 
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.call.remote-ended',
-          options: {
-            meetingId: locusInfo.meetingId,
-          },
+          it('sends client event correctly for state = SELF_LEFT', () => {
+            locusInfo.getLocusPartner = sinon.stub().returns({state: MEETING_STATE.STATES.LEFT});
+            locusInfo.parsedLocus = {
+              fullState: {
+                type: type,
+              },
+              self: {
+                state: MEETING_STATE.STATES.LEFT,
+              },
+            };
+
+            locusInfo.isMeetingActive();
+
+            assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
+              name: 'client.call.remote-ended',
+              options: {
+                meetingId: locusInfo.meetingId,
+              },
+            });
+          });
         });
       });
 

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

@@ -304,6 +304,13 @@ export const selfWithInactivity = {
     localRecord: {
       recording: false,
     },
+    brb: {
+      enabled: true,
+      meta: {
+        lastModified: '2024-10-24T14:05:58.526Z',
+        modifiedBy: '70978427-8238-4ffc-9227-8baf4b80b831',
+      },
+    },
     layouts: [
       {
         type: 'activePresence',

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

@@ -1,9 +1,10 @@
 import {assert} from '@webex/test-helper-chai';
 import Sinon from 'sinon';
-import {cloneDeep} from 'lodash';
+import {cloneDeep, defaultsDeep} from 'lodash';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
 
 import {self} from './selfConstant';
+import {_IDLE_, _WAIT_} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('selfUtils', () => {
@@ -60,6 +61,14 @@ describe('plugin-meetings', () => {
         assert.calledWith(spy, self);
         assert.deepEqual(parsedSelf.layout, self.controls.layouts[0].type);
       });
+
+      it('calls getBrb and returns the resulting brb value', () => {
+        const spy = Sinon.spy(SelfUtils, 'getBrb');
+        const parsedSelf = SelfUtils.parse(self);
+
+        assert.calledWith(spy, self);
+        assert.deepEqual(parsedSelf.brb, self.controls.brb);
+      });
     });
 
     describe('getLayout', () => {
@@ -170,6 +179,37 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('brbChanged', () => {
+      it('should return true if brb have changed', () => {
+        const current = {
+          brb: {enabled: true},
+        };
+        const previous = {
+          brb: {enabled: false},
+        };
+
+        assert.isTrue(SelfUtils.brbChanged(previous, current));
+      });
+
+      it('should return false if brb have not changed', () => {
+        const current = {
+          brb: {enabled: true},
+        };
+        const previous = {
+          brb: {enabled: true},
+        };
+
+        assert.isFalse(SelfUtils.brbChanged(previous, current));
+      });
+
+      it('should return false if brb in current is undefined', () => {
+        const current = {};
+        const previous = {brb: {enabled: true}};
+
+        assert.isFalse(SelfUtils.brbChanged(previous, current));
+      });
+    });
+
     describe('canNotViewTheParticipantList', () => {
       it('should return the correct value', () => {
         assert.equal(
@@ -299,6 +339,56 @@ describe('plugin-meetings', () => {
           assert.equal(updates.localAudioUnmuteRequestedByServer, false);
         });
       });
+
+      describe('updates.isUserUnadmitted', () => {
+        const testIsUserUnadmitted = (previousObjectDelta, currentObjectDelta, expected) => function () {
+          const previous =
+            previousObjectDelta === undefined ? undefined : defaultsDeep(previousObjectDelta, self);
+          const current = defaultsDeep(currentObjectDelta, self);
+
+          const {updates} = SelfUtils.getSelves(previous, current, self.devices[0].url);
+
+          assert.equal(updates.isUserUnadmitted, expected);
+        };
+
+        it(
+          'should return true when previous is undefined and current is in lobby',
+          testIsUserUnadmitted(
+            undefined,
+            {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
+            true
+          )
+        );
+
+        it(
+          'should return false when previous is undefined and user is not in meeting',
+          testIsUserUnadmitted(undefined, {devices: [], state: _IDLE_}, false)
+        );
+
+        it(
+          'should return false when previous is undefined and current is in meeting',
+          testIsUserUnadmitted(undefined, {}, false)
+        );
+
+        it(
+          'should return false when previous is in lobby and current is in lobby',
+          testIsUserUnadmitted(
+            {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
+            {devices: [{intent: {type: _WAIT_}}], state: _IDLE_},
+            false
+          )
+        );
+
+        it(
+          'should return false when previous is in lobby and current is in meeting',
+          testIsUserUnadmitted({devices: [{intent: {type: _WAIT_}}], state: _IDLE_}, {}, false)
+        );
+
+        it(
+          'should return true when previous is in meeting and current is in lobby',
+          testIsUserUnadmitted({}, {devices: [{intent: {type: _WAIT_}}], state: _IDLE_}, true)
+        );
+      });
     });
 
     describe('isSharingBlocked', () => {
@@ -360,6 +450,16 @@ describe('plugin-meetings', () => {
       assert.equal(SelfUtils.mutedByOthersChanged(null, {remoteMuted: true}), true);
     });
 
+    it('should return false when selfIdentity and modifiedBy are the same', function () {
+      assert.equal(
+        SelfUtils.mutedByOthersChanged(
+          {remoteMuted: false},
+          {remoteMuted: true, selfIdentity: 'user1', modifiedBy: 'user1'}
+        ),
+        false
+      );
+    });
+
     it('should return true when remoteMuted values are different', function () {
       assert.equal(
         SelfUtils.mutedByOthersChanged(

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

@@ -66,6 +66,21 @@ describe('MediaProperties', () => {
       assert.equal(numTransports, 0);
     });
 
+    it('handles time out in the case when getStats() is not resolving', async () => {
+      // Promise that never resolves
+      mockMC.getStats = new Promise(() => {});
+
+      const promise = mediaProperties.getCurrentConnectionInfo();
+
+      await clock.tickAsync(1000);
+
+      const {connectionType, selectedCandidatePairChanges, numTransports} = await promise;
+
+      assert.equal(connectionType, 'unknown');
+      assert.equal(selectedCandidatePairChanges, -1);
+      assert.equal(numTransports, 0);
+    });
+
     describe('selectedCandidatePairChanges and numTransports', () => {
       it('returns correct values when getStats() returns no transport stats at all', async () => {
         mockMC.getStats.resolves([{type: 'something', id: '1234'}]);

package/test/unit/spec/meeting/brbState.ts

@@ -0,0 +1,114 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+
+import testUtils from '../../../utils/testUtils';
+import {BrbState, createBrbState} from '@webex/plugin-meetings/src/meeting/brbState';
+
+describe('plugin-meetings', () => {
+  let meeting: any;
+  let brbState: BrbState;
+
+  beforeEach(async () => {
+    meeting = {
+      isMultistream: true,
+      locusUrl: 'locus url',
+      deviceUrl: 'device url',
+      selfId: 'self id',
+      mediaProperties: {
+        webrtcMediaConnection: true,
+      },
+      sendSlotManager: {
+        setSourceStateOverride: sinon.stub(),
+      },
+      meetingRequest: {
+        setBrb: sinon.stub().resolves(),
+      },
+    };
+
+    brbState = new BrbState(meeting, false);
+    await testUtils.flushPromises();
+  });
+
+  describe('brbState library', () => {
+    it('takes into account current status when instantiated', async () => {
+      // create a new BrbState instance
+      brbState = createBrbState(meeting, true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+
+      // now check the opposite case
+      brbState = createBrbState(meeting, false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+    });
+
+    it('can be enabled', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.client.enabled);
+      assert.isTrue(brbState.state.server.enabled);
+    });
+
+    it('can be disabled', async () => {
+      brbState.enable(false, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(false);
+      await testUtils.flushPromises();
+
+      assert.isFalse(brbState.state.client.enabled);
+      assert.isFalse(brbState.state.server.enabled);
+    });
+
+    it('does not send local brb state to server if it is not a multistream meeting', async () => {
+      meeting.isMultistream = false;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send local brb state to server if webrtc media connection is not defined', async () => {
+      meeting.mediaProperties.webrtcMediaConnection = undefined;
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('does not send request twice when in progress', async () => {
+      brbState.state.syncToServerInProgress = true;
+      brbState.enable(true, meeting.sendSlotManager);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.notCalled);
+    });
+
+    it('syncs with server when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.meetingRequest.setBrb.calledOnce);
+    });
+
+    it('sets source state override when client state does not match server state', async () => {
+      brbState.enable(true, meeting.sendSlotManager);
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(meeting.sendSlotManager.setSourceStateOverride.calledOnce);
+    });
+
+    it('handles server update', async () => {
+      brbState.handleServerBrbUpdate(true);
+      await testUtils.flushPromises();
+
+      assert.isTrue(brbState.state.server.enabled);
+    });
+  });
+});