@webex/plugin-meetings 3.0.0-beta.21 → 3.0.0-beta.211

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);
   });
 
@@ -83,22 +91,73 @@ describe('ReceiveSlot', () => {
     assert.strictEqual(receiveSlot.sourceState, 'live');
   });
 
-  it('resets source related properties when resetSourceState() is called', () => {
-    const csi = 123456;
-    const fakeMemberId = '00000001-5555-6666-9012-345678901234';
+  describe('findMemberId()', () => {
+    it('doesn\'t do anything if csi is not set', () => {
+      // by default the receiveSlot does not have any csi or member id
+      receiveSlot.findMemberId();
 
-    findMemberIdCallbackStub.returns(fakeMemberId);
+      assert.notCalled(findMemberIdCallbackStub);
+    });
 
-    fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+    it('finds a member id if member id is undefined and CSI is known', () => {
+      let emittedSourceUpdateEvent = null;
 
-    assert.strictEqual(receiveSlot.memberId, fakeMemberId);
-    assert.strictEqual(receiveSlot.csi, csi);
-    assert.strictEqual(receiveSlot.sourceState, 'live');
+      // setup receiveSlot to have a csi without a member id
+      const csi = 12345;
+      const fakeMemberId = 'aaa-bbb-ccc-ddd';
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+      findMemberIdCallbackStub.reset();
+      findMemberIdCallbackStub.returns(fakeMemberId);
 
-    receiveSlot.resetSourceState();
+      receiveSlot.on(ReceiveSlotEvents.SourceUpdate, (data) => {
+        emittedSourceUpdateEvent = data;
+      });
 
-    assert.strictEqual(receiveSlot.memberId, undefined);
-    assert.strictEqual(receiveSlot.csi, undefined);
-    assert.strictEqual(receiveSlot.sourceState, 'no source');
+      receiveSlot.findMemberId();
+
+      assert.calledOnce(findMemberIdCallbackStub);
+      assert.calledWith(findMemberIdCallbackStub, csi);
+
+      assert.deepEqual(emittedSourceUpdateEvent, {
+        state: 'live',
+        csi,
+        memberId: fakeMemberId,
+      });
+
+    });
+
+    it('doesn\'t do anything if member id already set', () => {
+      // setup receiveSlot to have a csi and a member id
+      const csi = 12345;
+      const memberId = '12345678-1234-5678-9012-345678901234';
+
+      findMemberIdCallbackStub.returns(memberId);
+
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+      findMemberIdCallbackStub.reset();
+
+      receiveSlot.findMemberId();
+
+      assert.notCalled(findMemberIdCallbackStub);
+    });
+  });
+
+  describe('setMaxFs()', () => {
+    it('emits the correct event', () => {
+      sinon.stub(receiveSlot, 'emit');
+      receiveSlot.setMaxFs(100);
+
+      assert.calledOnceWithExactly(
+        receiveSlot.emit,
+        {
+          file: 'meeting/receiveSlot',
+          function: 'findMemberId',
+        },
+        ReceiveSlotEvents.MaxFsUpdate,
+        {
+          maxFs: 100,
+        }
+      );
+    })
   });
 });

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

@@ -1,35 +1,29 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import {MediaType} from '@webex/internal-media-core';
+import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import {ReceiveSlotManager} from '@webex/plugin-meetings/src/multistream/receiveSlotManager';
 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) => {
       const fakeReceiveSlot = {
         id: `fake sdk receive slot ${fakeReceiveSlots.length + 1}`,
         mediaType,
+        findMemberId: sinon.stub(),
+        wcmeReceiveSlot: fakeWcmeSlot,
       };
 
       fakeReceiveSlots.push(fakeReceiveSlot);
@@ -37,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(() => {
@@ -45,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),
@@ -58,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(), {
@@ -77,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]);
 
@@ -89,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
@@ -110,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]);
 
@@ -119,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: {}});
@@ -127,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
@@ -142,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]);
@@ -170,4 +167,37 @@ describe('ReceiveSlotManager', () => {
       numFreeSlots: {'VIDEO-MAIN': 1},
     });
   });
+
+  describe('updateMemberIds', () => {
+    it('calls findMemberId() on all allocated receive slots', async () => {
+      const audioSlots: ReceiveSlot[] = [];
+      const videoSlots: ReceiveSlot[] = [];
+
+      // allocate a bunch of receive slots
+      audioSlots.push(await receiveSlotManager.allocateSlot(MediaType.AudioMain));
+      audioSlots.push(await receiveSlotManager.allocateSlot(MediaType.AudioMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+
+      receiveSlotManager.updateMemberIds();
+
+      assert.strictEqual(audioSlots.length, 2);
+      assert.strictEqual(videoSlots.length, 3);
+
+      assert.strictEqual(fakeReceiveSlots.length, audioSlots.length + videoSlots.length);
+
+      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

@@ -6,6 +6,7 @@ import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multist
 import {ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
+import { forEach } from 'lodash';
 
 describe('RemoteMedia', () => {
   let remoteMedia;
@@ -21,6 +22,7 @@ describe('RemoteMedia', () => {
     fakeReceiveSlot.csi = 999;
     fakeReceiveSlot.sourceState = 'avatar';
     fakeReceiveSlot.stream = fakeStream;
+    fakeReceiveSlot.setMaxFs = sinon.stub();
 
     fakeMediaRequestManager = {
       addRequest: sinon.stub(),
@@ -222,4 +224,32 @@ describe('RemoteMedia', () => {
       });
     });
   });
+
+  describe('setSizeHint()', () => {
+
+    it('works if the receive slot is undefined', () => {
+      remoteMedia.receiveSlot = undefined;
+      remoteMedia.setSizeHint(100, 100);
+    });
+
+    forEach(
+      [
+        {height: 134, fs: 60},
+        {height: 135, fs: 240},
+        {height: 269, fs: 240},
+        {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}`, () => {
+          remoteMedia.setSizeHint(100, height);
+
+          assert.calledOnceWithExactly(fakeReceiveSlot.setMaxFs, fs);
+        });
+      }
+    );
+  });
 });

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

@@ -97,6 +97,272 @@ 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('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;