@webex/plugin-meetings 3.0.0-beta.39 → 3.0.0-beta.391

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

@@ -9,6 +9,8 @@ import {assert} from '@webex/test-helper-chai';
 class FakeWcmeSlot extends EventEmitter {
   public stream;
 
+  public id = 'fake id';
+
   constructor(stream) {
     super();
     this.stream = stream;
@@ -28,6 +30,12 @@ describe('ReceiveSlot', () => {
     receiveSlot = new ReceiveSlot(MediaType.VideoMain, fakeWcmeSlot, findMemberIdCallbackStub);
   });
 
+  describe('logString', () => {
+    it('has a log string', () => {
+      assert.equal(receiveSlot.logString, `ReceiveSlot - ${receiveSlot.id}: "fake id"`);
+    });
+  })
+
   describe('forwards events from underlying wcme receive slot', () => {
     it('forwards SourceUpdate', () => {
       let eventEmitted = false;
@@ -57,7 +65,7 @@ describe('ReceiveSlot', () => {
   });
 
   it('has public properties', () => {
-    assert.strictEqual(receiveSlot.id, 'r1');
+    assert.isTrue(receiveSlot.id.startsWith('r'));
     assert.strictEqual(receiveSlot.mediaType, MediaType.VideoMain);
   });
 

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

@@ -6,25 +6,16 @@ import {ReceiveSlotManager} from '@webex/plugin-meetings/src/multistream/receive
 import * as ReceiveSlotModule from '@webex/plugin-meetings/src/multistream/receiveSlot';
 
 describe('ReceiveSlotManager', () => {
-  let fakeMeeting;
   let fakeWcmeSlot;
   let fakeReceiveSlots;
   let mockReceiveSlotCtor;
   let receiveSlotManager;
+  let createSlotCallbackStub;
+  let findMemberIdCallbackStub;
 
   beforeEach(() => {
     fakeWcmeSlot = {
-      id: 'fake wcme slot',
-    };
-    fakeMeeting = {
-      mediaProperties: {
-        webrtcMediaConnection: {
-          createReceiveSlot: sinon.stub().resolves(fakeWcmeSlot),
-        },
-      },
-      members: {
-        findMemberByCsi: sinon.stub(),
-      },
+      id: {ssrc: 1},
     };
     fakeReceiveSlots = [];
     mockReceiveSlotCtor = sinon.stub(ReceiveSlotModule, 'ReceiveSlot').callsFake((mediaType) => {
@@ -32,6 +23,7 @@ describe('ReceiveSlotManager', () => {
         id: `fake sdk receive slot ${fakeReceiveSlots.length + 1}`,
         mediaType,
         findMemberId: sinon.stub(),
+        wcmeReceiveSlot: fakeWcmeSlot,
       };
 
       fakeReceiveSlots.push(fakeReceiveSlot);
@@ -39,7 +31,10 @@ describe('ReceiveSlotManager', () => {
       return fakeReceiveSlot;
     });
 
-    receiveSlotManager = new ReceiveSlotManager(fakeMeeting);
+    createSlotCallbackStub = sinon.stub().resolves(fakeWcmeSlot);
+    findMemberIdCallbackStub = sinon.stub();
+
+    receiveSlotManager = new ReceiveSlotManager(createSlotCallbackStub, findMemberIdCallbackStub);
   });
 
   afterEach(() => {
@@ -47,7 +42,7 @@ describe('ReceiveSlotManager', () => {
   });
 
   it('rejects if there is no media connection', async () => {
-    fakeMeeting.mediaProperties.webrtcMediaConnection = null;
+    createSlotCallbackStub.rejects(new Error('Webrtc media connection is missing'));
 
     assert.isRejected(
       receiveSlotManager.allocateSlot(MediaType.VideoMain),
@@ -60,14 +55,14 @@ describe('ReceiveSlotManager', () => {
 
     const slot = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledWith(
-      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
+      createSlotCallbackStub,
       MediaType.VideoMain
     );
 
     assert.calledOnce(mockReceiveSlotCtor);
-    assert.calledWith(mockReceiveSlotCtor, MediaType.VideoMain, fakeWcmeSlot, sinon.match.func);
+    assert.calledWith(mockReceiveSlotCtor, MediaType.VideoMain, fakeWcmeSlot, findMemberIdCallbackStub);
     assert.strictEqual(slot, fakeReceiveSlots[0]);
 
     assert.deepEqual(receiveSlotManager.getStats(), {
@@ -79,7 +74,7 @@ describe('ReceiveSlotManager', () => {
   it('reuses previously freed slot when allocateSlot() is called and a free slot is available', async () => {
     const slot1 = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledOnce(mockReceiveSlotCtor);
     assert.strictEqual(slot1, fakeReceiveSlots[0]);
 
@@ -91,13 +86,13 @@ describe('ReceiveSlotManager', () => {
       numFreeSlots: {'VIDEO-MAIN': 1},
     });
 
-    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.resetHistory();
+    createSlotCallbackStub.resetHistory();
     mockReceiveSlotCtor.resetHistory();
 
     // allocate another slot, this time the previous one should be returned instead of allocating any new ones
     const slot2 = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.notCalled(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.notCalled(createSlotCallbackStub);
     assert.notCalled(mockReceiveSlotCtor);
 
     // verify that in fact we got the same slot again
@@ -112,7 +107,7 @@ describe('ReceiveSlotManager', () => {
   it('does not reuse any slots after reset() is called', async () => {
     const slot1 = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledOnce(mockReceiveSlotCtor);
     assert.strictEqual(slot1, fakeReceiveSlots[0]);
 
@@ -121,7 +116,7 @@ describe('ReceiveSlotManager', () => {
     receiveSlotManager.reset();
 
     // reset the mocks and set the ReceiveSlot constructor to return a different slot
-    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.resetHistory();
+    createSlotCallbackStub.resetHistory();
     mockReceiveSlotCtor.resetHistory();
 
     assert.deepEqual(receiveSlotManager.getStats(), {numAllocatedSlots: {}, numFreeSlots: {}});
@@ -129,7 +124,7 @@ describe('ReceiveSlotManager', () => {
     // allocate another slot, because we called reset(), the old free slot should not be reused
     const slot2 = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledOnce(mockReceiveSlotCtor);
 
     // verify that in fact we got a brand new slot
@@ -144,25 +139,25 @@ describe('ReceiveSlotManager', () => {
   it('does not reuse slots if they have different media type', async () => {
     const slot1 = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledOnce(mockReceiveSlotCtor);
 
     receiveSlotManager.releaseSlot(slot1);
 
-    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.resetHistory();
+    createSlotCallbackStub.resetHistory();
     mockReceiveSlotCtor.resetHistory();
 
     // allocate another slot, this time for main audio, so it should be a completely new slot
     const slot2 = await receiveSlotManager.allocateSlot(MediaType.AudioMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledWith(
-      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
+      createSlotCallbackStub,
       MediaType.AudioMain
     );
 
     assert.calledOnce(mockReceiveSlotCtor);
-    assert.calledWith(mockReceiveSlotCtor, MediaType.AudioMain, fakeWcmeSlot, sinon.match.func);
+    assert.calledWith(mockReceiveSlotCtor, MediaType.AudioMain, fakeWcmeSlot, findMemberIdCallbackStub);
 
     // verify that in fact we got a brand new slot
     assert.strictEqual(slot2, fakeReceiveSlots[1]);
@@ -174,7 +169,6 @@ describe('ReceiveSlotManager', () => {
   });
 
   describe('updateMemberIds', () => {
-
     it('calls findMemberId() on all allocated receive slots', async () => {
       const audioSlots: ReceiveSlot[] = [];
       const videoSlots: ReceiveSlot[] = [];
@@ -193,9 +187,17 @@ describe('ReceiveSlotManager', () => {
 
       assert.strictEqual(fakeReceiveSlots.length, audioSlots.length + videoSlots.length);
 
-      fakeReceiveSlots.forEach(slot => {
+      fakeReceiveSlots.forEach((slot) => {
         assert.calledOnce(slot.findMemberId);
       });
     });
   });
+
+  describe('findReceiveSlotBySsrc', () => {
+    it('finds a receive slot with a specific id', async () => {
+      await receiveSlotManager.allocateSlot(MediaType.VideoMain);
+      assert.exists(receiveSlotManager.findReceiveSlotBySsrc(1));
+      assert.strictEqual(receiveSlotManager.findReceiveSlotBySsrc(2), undefined);
+    });
+  });
 });

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

@@ -240,6 +240,8 @@ describe('RemoteMedia', () => {
         {height: 270, fs: 920},
         {height: 539, fs: 920},
         {height: 540, fs: 3600},
+        {height: 720, fs: 3600},
+        {height: 721, fs: 8192},
       ],
       ({height, fs}) => {
         it(`sets the max fs to ${fs} correctly when height is ${height}`, () => {

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

@@ -6,6 +6,7 @@ import {RemoteMedia} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
+import { NamedMediaGroup } from "@webex/json-multistream";
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;
@@ -24,6 +25,7 @@ describe('RemoteMediaGroup', () => {
 
   let fakeMediaRequestManager;
   let fakeReceiveSlots;
+  let fakeNamedMediaSlots;
 
   let activeSpeakerRequestCounter;
   let receiverSelectedRequestCounter;
@@ -50,6 +52,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 = () =>
@@ -97,6 +103,345 @@ describe('RemoteMediaGroup', () => {
     });
   });
 
+  describe('setPreferLiveVideo', () => {
+    it('updates prefer live video', () => {
+
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: false,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setPreferLiveVideo(true, false);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+            preferLiveVideo: true
+          }),
+          receiveSlots: fakeReceiveSlots,
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        }),
+        false,
+      );
+    });
+
+    it('does not call add request when prefer live video has not changed', () => {
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+      fakeMediaRequestManager.addRequest.resetHistory();
+      group.setPreferLiveVideo(true, false);
+
+      assert.notCalled(fakeMediaRequestManager.cancelRequest);
+
+      assert.notCalled(fakeMediaRequestManager.addRequest);
+    });
+
+  });
+
+  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;
+      const CSI = 11111;
+
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+
+      // initially nothing should be pinned
+      assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS); // by default should return 'all'
+      assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('pinned').length, 0);
+
+      const remoteMedia = group.getRemoteMedia('all')[PINNED_INDEX];
+
+      resetHistory();
+
+      group.setActiveSpeakerCsis([{remoteMedia, csi: CSI}], false);
+
+      assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS); // by default should return 'all'
+      assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS - 1);
+      assert.strictEqual(group.getRemoteMedia('pinned').length, 1);
+
+      assert.strictEqual(group.isPinned(remoteMedia), true);
+      // now check that correct media requests were sent...
+
+      const expectedReceiverSelectedSlots = [fakeReceiveSlots[PINNED_INDEX]];
+      const expectedActiveSpeakerReceiveSlots = fakeReceiveSlots.filter(
+        (_, idx) => idx !== PINNED_INDEX
+      );
+
+      // the previous active speaker media request for the group should have been cancelled
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+      assert.calledWith(fakeMediaRequestManager.cancelRequest, 'fake active speaker request 1');
+      // a new one should be sent for active speaker and for receiver selected
+      assert.calledTwice(fakeMediaRequestManager.addRequest);
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'active-speaker',
+            priority: 255,
+          }),
+          receiveSlots: expectedActiveSpeakerReceiveSlots,
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        })
+      );
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'receiver-selected',
+            csi: CSI,
+          }),
+          receiveSlots: expectedReceiverSelectedSlots,
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        })
+      );
+      assert.notCalled(fakeMediaRequestManager.commit);
+    });
+
+    it('checks when there is csi and remoteMedia is in pinned array', () => {
+      const PINNED_INDEX = 4;
+
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+
+      // take one instance of remote media from the group
+      const remoteMedia = group.getRemoteMedia('all')[PINNED_INDEX];
+
+      resetHistory();
+
+      // pin it so that it is in pinned array
+      group.setActiveSpeakerCsis([{remoteMedia, csi: 1234}], false);
+
+      assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS); // by default should return 'all'
+      assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS - 1);
+      assert.strictEqual(group.getRemoteMedia('pinned').length, 1);
+
+      resetHistory();
+      // normally this would result in the underlying receive slot csi to be updated, because we're using fake
+      // receive slots, we have to do that manually:
+      fakeReceiveSlots[PINNED_INDEX].csi = 1234;
+      const expectedReceiverSelectedSlots = [fakeReceiveSlots[PINNED_INDEX]];
+
+      // pin again to same CSI
+      group.setActiveSpeakerCsis([{remoteMedia, csi: 1234}], false);
+
+      assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS); // by default should return 'all'
+      assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS - 1);
+      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');
+
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'receiver-selected',
+            csi: 1234,
+          }),
+          receiveSlots: expectedReceiverSelectedSlots,
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        })
+      );
+      assert.notCalled(fakeMediaRequestManager.commit);
+    });
+
+    it('checks setActiveSpeakerCsis with array of remoteMedia to pin and unpin', () => {
+      const PINNED_INDEX = 2;
+      const PINNED_INDEX2 = 0;
+      const CSI = 11111;
+      const CSI2 = 12345;
+
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+
+      // initially nothing should be pinned
+      assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS); // by default should return 'all'
+      assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS);
+      assert.strictEqual(group.getRemoteMedia('pinned').length, 0);
+
+      const remoteMedia = group.getRemoteMedia('all')[PINNED_INDEX];
+
+      const remoteMedia2 = group.getRemoteMedia('all')[PINNED_INDEX2];
+
+      const remoteMedisCsis = [{remoteMedia, csi: CSI}, {remoteMedia: remoteMedia2, csi: CSI2}];
+
+      group.setActiveSpeakerCsis(remoteMedisCsis, false);
+
+     assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS);
+     assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+     assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS - 2);
+     assert.strictEqual(group.getRemoteMedia('pinned').length, 2);
+
+     assert.strictEqual(group.isPinned(remoteMedia), true);
+     assert.strictEqual(group.isPinned(remoteMedia2), true);
+
+     resetHistory();
+
+     group.setActiveSpeakerCsis([{remoteMedia}], false);
+
+     // one pane should still remain pinned
+     assert.strictEqual(group.getRemoteMedia().length, NUM_SLOTS);
+     assert.strictEqual(group.getRemoteMedia('all').length, NUM_SLOTS);
+     assert.strictEqual(group.getRemoteMedia('unpinned').length, NUM_SLOTS - 1);
+     assert.strictEqual(group.getRemoteMedia('pinned').length, 1);
+     assert.strictEqual(group.isPinned(remoteMedia), false);
+     assert.strictEqual(group.isPinned(remoteMedia2), true);
+
+     assert.calledTwice(fakeMediaRequestManager.cancelRequest);
+     assert.calledWith(fakeMediaRequestManager.cancelRequest, 'fake receiver selected request 1');
+     assert.notCalled(fakeMediaRequestManager.commit);
+    });
+
+    it('check commit is only called once', () => {
+      const PINNED_INDEX = 2;
+      const PINNED_INDEX2 = 0;
+      const CSI = 11111;
+      const CSI2 = 12345;
+
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+
+      const remoteMedia = group.getRemoteMedia('all')[PINNED_INDEX];
+
+      resetHistory();
+
+      const remoteMedia2 = group.getRemoteMedia('all')[PINNED_INDEX2];
+
+      const remoteMedisCsis = [{remoteMedia, csi: CSI}, {remoteMedia: remoteMedia2, csi: CSI2}, {remoteMedia}];
+
+      group.setActiveSpeakerCsis(remoteMedisCsis, true);
+
+      assert.calledOnce(fakeMediaRequestManager.commit);
+    });
+
+    it('throws when remoteMedia id is not in unpinned and pinned array - csi is there', () => {
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+      assert.throws(() => group.setActiveSpeakerCsis([{remoteMedia: {id: 'r1'} as any, csi: 123}], false), 'failed to pin a remote media object r1, because it is not found in this remote media group');
+    });
+
+    it('throws when remoteMedia id is not in unpinned and pinned array - csi is not there', () => {
+      const group = new RemoteMediaGroup(fakeMediaRequestManager, fakeReceiveSlots, 255, true, {
+        resolution: 'medium',
+        preferLiveVideo: true,
+      });
+      assert.throws(() => group.setActiveSpeakerCsis([{remoteMedia: {id: 'r1'} as any}], false), 'failed to unpin a remote media object r1, because it is not found in this remote media group');
+    });
+  });
+
   describe('pinning', () => {
     it('works as expected', () => {
       const PINNED_INDEX = 2;