@webex/plugin-meetings 3.0.0 → 3.1.0

package/test/unit/spec/meetings/index.js

@@ -253,6 +253,19 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleTlsReachability', () => {
+      it('should have _toggleTlsReachability', () => {
+        assert.equal(typeof webex.meetings._toggleTlsReachability, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to do TLS reachability', () => {
+          webex.meetings._toggleTlsReachability(true);
+          assert.equal(webex.meetings.config.experimental.enableTlsReachability, true);
+        });
+      });
+    });
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
         it('emits an event and resolves when register succeeds', async () => {
@@ -412,9 +425,13 @@ describe('plugin-meetings', () => {
           assert.exists(result);
           assert.instanceOf(result, NoiseReductionEffect);
           assert.containsAllKeys(result, ['audioContext', 'isEnabled', 'isReady', 'options']);
+          assert.equal(result.options.authToken, 'fake_token');
           assert.deepEqual(result.options, {
-            authToken: 'fake_token',
             audioContext: {},
+            authToken: 'fake_token',
+            mode: 'WORKLET',
+            env: 'prod',
+            avoidSimd: false,
           });
           assert.exists(result.enable);
           assert.exists(result.disable);
@@ -424,8 +441,9 @@ describe('plugin-meetings', () => {
         it('creates noise reduction effect with custom options passed', async () => {
           const effectOptions = {
             audioContext: {},
-            mode: 'WORKLET',
-            env: 'prod',
+            mode: 'LEGACY',
+            env: 'int',
+            avoidSimd: true,
           };
 
           const result = await webex.meetings.createNoiseReductionEffect(effectOptions);
@@ -2003,24 +2021,27 @@ describe('plugin-meetings', () => {
           assert.notCalled(loggerProxySpy);
         });
 
-        forEach([
-          {user: undefined},
-          {user: {userPreferences: {}}},
-          {user: {userPreferences: {userPreferencesItems: {}}}},
-          {user: {userPreferences: {userPreferencesItems: {preferredWebExSite: undefined}}}},
-        ], ({user}) => {
-          it(`should handle invalid user data ${user}`, async () => {
-            setup({user});
+        forEach(
+          [
+            {user: undefined},
+            {user: {userPreferences: {}}},
+            {user: {userPreferences: {userPreferencesItems: {}}}},
+            {user: {userPreferences: {userPreferencesItems: {preferredWebExSite: undefined}}}},
+          ],
+          ({user}) => {
+            it(`should handle invalid user data ${user}`, async () => {
+              setup({user});
 
-            await webex.meetings.fetchUserPreferredWebexSite();
+              await webex.meetings.fetchUserPreferredWebexSite();
 
-            assert.equal(webex.meetings.preferredWebexSite, '');
-            assert.calledOnceWithExactly(
-              loggerProxySpy,
-              'Failed to fetch preferred site from user - no site will be set'
-            );
-          });
-        });
+              assert.equal(webex.meetings.preferredWebexSite, '');
+              assert.calledOnceWithExactly(
+                loggerProxySpy,
+                'Failed to fetch preferred site from user - no site will be set'
+              );
+            });
+          }
+        );
 
         it('should handle a get user failure', async () => {
           setup();
@@ -2035,7 +2056,6 @@ describe('plugin-meetings', () => {
             'Failed to fetch preferred site from user - no site will be set'
           );
         });
-
       });
     });
 

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -14,6 +14,7 @@ type ExpectedActiveSpeaker = {
   receiveSlots: Array<ReceiveSlot>;
   maxFs?: number;
   maxMbps?: number;
+  namedMediaGroups?:[{type: number, value: number}];
 };
 type ExpectedReceiverSelected = {
   policy: 'receiver-selected';
@@ -80,7 +81,7 @@ describe('MediaRequestManager', () => {
   });
 
   // helper function for adding an active speaker request
-  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true) =>
+  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true, namedMediaGroups = undefined) =>
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -89,6 +90,7 @@ describe('MediaRequestManager', () => {
           crossPriorityDuplication: CROSS_PRIORITY_DUPLICATION,
           crossPolicyDuplication: CROSS_POLICY_DUPLICATION,
           preferLiveVideo,
+          namedMediaGroups,
         },
         receiveSlots,
         codecInfo: {
@@ -590,7 +592,14 @@ describe('MediaRequestManager', () => {
       MAX_FS_720p,
       false
     );
-
+    addActiveSpeakerRequest(
+      254,
+      [fakeReceiveSlots[8], fakeReceiveSlots[9], fakeReceiveSlots[10]],
+      MAX_FS_720p,
+      false,
+      true,
+      [{type: 1, value: 20}],
+    );
     // nothing should be sent out as we didn't commit the requests
     assert.notCalled(sendMediaRequestsCallback);
 
@@ -631,6 +640,15 @@ describe('MediaRequestManager', () => {
         maxFs: MAX_FS_720p,
         maxMbps: MAX_MBPS_720p,
       },
+      {
+        policy: 'active-speaker',
+        priority: 254,
+        receiveSlots: [fakeWcmeSlots[8], fakeWcmeSlots[9], fakeWcmeSlots[10]],
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_720p,
+        maxFs: MAX_FS_720p,
+        maxMbps: MAX_MBPS_720p,
+        namedMediaGroups: [{type: 1, value: 20}],
+      },
     ]);
   });
 

package/test/unit/spec/multistream/remoteMediaGroup.ts

@@ -24,6 +24,7 @@ describe('RemoteMediaGroup', () => {
 
   let fakeMediaRequestManager;
   let fakeReceiveSlots;
+  let fakeNamedMediaSlots;
 
   let activeSpeakerRequestCounter;
   let receiverSelectedRequestCounter;
@@ -50,6 +51,10 @@ describe('RemoteMediaGroup', () => {
     fakeReceiveSlots = Array(NUM_SLOTS)
       .fill(null)
       .map((_, index) => new FakeSlot(MediaType.VideoMain, `fake receive slot ${index}`));
+
+    fakeNamedMediaSlots = Array(1)
+      .fill(null)
+      .map((_, index) => new FakeSlot(MediaType.AudioMain, `fake named media receive slot ${index}`));
   });
 
   const getLastActiveSpeakerRequestId = () =>
@@ -144,6 +149,79 @@ describe('RemoteMediaGroup', () => {
 
   });
 
+  describe('setNamedMediaGroup', () => {
+    it('updates named media group', () => {
+
+      const nameGroup1 = { type: 1, value: 20 };
+      const nameGroup2 = { type: 1, value: 24 };
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: nameGroup1,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup(nameGroup2, false);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+            namedMediaGroups: sinon.match([{type: 1, value: 24}]),
+          }),
+          receiveSlots: fakeNamedMediaSlots,
+          codecInfo: undefined,
+        }),
+        false,
+      );
+    });
+
+    it('does not call add request when named media group has not changed', () => {
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: { type: 1, value: 20 },
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup({ type: 1, value: 20 }, false);
+
+      assert.notCalled(fakeMediaRequestManager.cancelRequest);
+
+      assert.notCalled(fakeMediaRequestManager.addRequest);
+    });
+
+    it('remove named media group', () => {
+
+      const nameGroup1 = { type: 1, value: 20 };
+      const nameGroup2 = { type: 1, value: 0 };
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeNamedMediaSlots, 255, true, {
+        namedMediaGroup: nameGroup1,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setNamedMediaGroup(nameGroup2, true);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+            nameMediaGroups: undefined,
+          }),
+          receiveSlots: fakeNamedMediaSlots,
+          codecInfo: undefined,
+        }),
+        true,
+      );
+    });
+
+  });
+
   describe('setActiveSpeakerCsis', () => {
     it('checks when there is a csi and remote media is not in pinned array', () => {
       const PINNED_INDEX = 2;
@@ -251,7 +329,7 @@ describe('RemoteMediaGroup', () => {
       assert.strictEqual(group.getRemoteMedia('pinned').length, 1);
 
       assert.strictEqual(group.isPinned(remoteMedia), true);
-      
+
       assert.calledTwice(fakeMediaRequestManager.cancelRequest);
       assert.calledWith(fakeMediaRequestManager.cancelRequest, 'fake receiver selected request 1');
 

package/test/unit/spec/multistream/remoteMediaManager.ts

@@ -299,6 +299,204 @@ describe('RemoteMediaManager', () => {
       );
     });
 
+    it('creates a RemoteMediaGroup for named media group audio correctly', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 20},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+      });
+
+      remoteMediaManager.start();
+
+      await testUtils.flushPromises();
+
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+      assert.alwaysCalledWith(fakeReceiveSlotManager.allocateSlot, MediaType.AudioMain);
+
+      assert.isNotNull(createdInterpretationAudioGroup);
+      if (createdInterpretationAudioGroup) {
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia().length, 1);
+        assert.isTrue(
+          createdInterpretationAudioGroup
+            .getRemoteMedia()
+            .every((remoteMedia) => remoteMedia.mediaType === MediaType.AudioMain)
+        );
+        assert.strictEqual(createdInterpretationAudioGroup.getRemoteMedia('pinned').length, 0);
+        assert.calledTwice(fakeMediaRequestManagers.audio.addRequest);
+        assert.calledWith(
+          fakeMediaRequestManagers.audio.addRequest,
+          sinon.match({
+            policyInfo: sinon.match({
+              policy: 'active-speaker',
+              priority: 255,
+              namedMediaGroups: sinon.match([{type: 1, value: 20}]),
+            }),
+            receiveSlots: Array(1).fill(fakeAudioSlot),
+            codecInfo: undefined,
+          }),
+          false,
+        );
+      }
+    });
+
+    it('creates new media request when call setReceiveNamedMediaGroup', async () => {
+      let createdInterpretationAudioGroup: RemoteMediaGroup | null = null;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.InterpretationAudioCreated, (audio: RemoteMediaGroup) => {
+        createdInterpretationAudioGroup = audio;
+        createdInterpretationAudioGroup.setNamedMediaGroup = sinon.stub();
+      });
+
+      await remoteMediaManager.start();
+
+      // requires 3 main audio slots and one interpretation audio slot
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 28);
+
+      // check that setNamedMediaGroup has been called
+      assert.calledOnce(createdInterpretationAudioGroup.setNamedMediaGroup);
+      assert.calledWith(
+        createdInterpretationAudioGroup.setNamedMediaGroup,
+        {type: 1, value: 28},
+        true,
+      );
+
+    });
+
+    it('ignore duplicated group when call setReceiveNamedMediaGroup', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.AudioCreated, (audio: RemoteMediaGroup) => {
+        audioStopStub = sinon.stub(audio, 'stop');
+      });
+
+      await remoteMediaManager.start();
+
+      // we're using the default config that requires 3 main audio slots
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 4);
+
+
+      resetHistory();
+
+      remoteMediaManager.setReceiveNamedMediaGroup(MediaType.AudioMain, 24);
+
+      assert.notCalled(audioStopStub);
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 0);
+
+      await testUtils.flushPromises();
+      assert.callCount(fakeReceiveSlotManager.allocateSlot, 0);
+      assert.notCalled(fakeReceiveSlotManager.allocateSlot);
+
+    });
+
+
+    it('should throw error if set receive named media group which type is not audio', async () => {
+      let createdAudioGroup: RemoteMediaGroup | null = null;
+      let audioStopStub;
+      // create a config with just audio, no video at all and no screen share
+      const config: Configuration = {
+        audio: {
+          numOfActiveSpeakerStreams: 3,
+          numOfScreenShareStreams: 0,
+        },
+        video: {
+          preferLiveVideo: false,
+          initialLayoutId: 'empty',
+          layouts: {
+            empty: {},
+          },
+        },
+        namedMediaGroup: {type: 1, value: 24},
+      };
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      // Assuming setReceiveNamedMediaGroup returns a promise
+      it('should throw error when media type is not audio-main', async () => {
+        try {
+          await remoteMediaManager.setReceiveNamedMediaGroup(MediaType.VideoMain, 0);
+          // If the promise resolves successfully, we should fail the test
+          throw new Error('Expected an error but none was thrown');
+        } catch (error) {
+          // Check if the error message matches the expected one
+          expect(error.message).to.equal('cannot set receive named media group which media type is not audio-main');
+        }
+      });
+    });
+
     it('pre-allocates receive slots based on the biggest layout', async () => {
       const config = cloneDeep(DefaultTestConfiguration);
 
@@ -693,7 +891,7 @@ describe('RemoteMediaManager', () => {
       });
 
       expect(config.video.preferLiveVideo).to.equal(true);
-      
+
       assert.calledOnce(fakeMediaRequestManagers.video.commit);
     });
   });

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -10,11 +10,11 @@ describe('SendSlotsManager', () => {
             info: sinon.stub(),
         },
     };
-    
+
     beforeEach(() => {
         sendSlotsManager = new SendSlotManager(LoggerProxy);
     });
-    
+
     describe('createSlot', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -27,19 +27,19 @@ describe('SendSlotsManager', () => {
 
         it('should create a slot for the given mediaType', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             expect(mediaConnection.createSendSlot.calledWith(mediaType, true));
         });
 
         it('should create a slot for the given mediaType & active state', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType, false);
-        
+
             expect(mediaConnection.createSendSlot.calledWith(mediaType, false));
         });
-    
+
         it('should throw an error if a slot for the given mediaType already exists', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             expect(() => sendSlotsManager.createSlot(mediaConnection, mediaType)).to.throw(`Slot for ${mediaType} already exists`);
         });
     });
@@ -56,7 +56,7 @@ describe('SendSlotsManager', () => {
 
         it('should return the slot for the given mediaType', () => {
             const slot = sendSlotsManager.createSlot(mediaConnection,mediaType);
-        
+
             expect(sendSlotsManager.getSlot(mediaType)).to.equal(slot);
         });
 
@@ -64,7 +64,7 @@ describe('SendSlotsManager', () => {
             expect(() => sendSlotsManager.getSlot(mediaType)).to.throw(`Slot for ${mediaType} does not exist`);
         });
     });
-    
+
     describe('publishStream', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -82,9 +82,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.publishStream(mediaType, stream);
-        
+
             expect(slot.publishStream.calledWith(stream));
         });
 
@@ -112,9 +112,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.unpublishStream(mediaType);
-        
+
             expect(slot.unpublishStream.called);
         });
 
@@ -126,6 +126,38 @@ describe('SendSlotsManager', () => {
         });
     });
 
+  describe('setNamedMediaGroups', () => {
+    let mediaConnection;
+    const mediaType = MediaType.AudioMain;
+    const groups = [{type: 1, value: 20}];
+
+    beforeEach(() => {
+      mediaConnection = {
+        createSendSlot: sinon.stub(),
+      } as MultistreamRoapMediaConnection;
+    });
+
+    it('should publish the given stream to the sendSlot for the given mediaType', async () => {
+      const slot = {
+        setNamedMediaGroups: sinon.stub().resolves(),
+      };
+      mediaConnection.createSendSlot.returns(slot);
+      sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+      await sendSlotsManager.setNamedMediaGroups(mediaType, groups);
+
+      expect(slot.setNamedMediaGroups.calledWith(groups));
+    });
+
+    it('should throw an error if the given mediaType is not audio', () => {
+      expect(() => sendSlotsManager.setNamedMediaGroups(MediaType.VideoMain, groups)).to.throw(`sendSlotManager cannot set named media group which media type is ${MediaType.VideoMain}`)
+    });
+
+    it('should throw an error if a slot for the given mediaType does not exist', () => {
+      expect(() => sendSlotsManager.setNamedMediaGroups(mediaType, groups)).to.throw(`Slot for ${mediaType} does not exist`)
+    });
+  });
+
     describe('setActive', () => {
         let mediaConnection;
         const mediaType = MediaType.AudioMain;
@@ -142,9 +174,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.setActive(mediaType,true);
-        
+
             expect(slot.setActive.called);
         });
 
@@ -170,9 +202,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
-        
+
             expect(slot.setCodecParameters.calledWith(codecParameters));
         });
 
@@ -200,9 +232,9 @@ describe('SendSlotsManager', () => {
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
-        
+
             await sendSlotsManager.deleteCodecParameters(mediaType,[]);
-        
+
             expect(slot.deleteCodecParameters.called);
         });