@webex/plugin-meetings 3.0.0-beta.31 → 3.0.0-beta.310

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

@@ -15,6 +15,9 @@ import {cloneDeep} from 'lodash';
 import {MediaRequest} from '@webex/plugin-meetings/src/multistream/mediaRequestManager';
 import {CSI, ReceiveSlotId} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import testUtils from '../../../utils/testUtils';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import LoggerConfig from '@webex/plugin-meetings/src/common/logs/logger-config';
+import { expect } from 'chai';
 
 class FakeSlot extends EventEmitter {
   public mediaType: MediaType;
@@ -32,6 +35,10 @@ class FakeSlot extends EventEmitter {
     // Calling setMaxListeners() fixes the warning.
     this.setMaxListeners(50);
   }
+
+  public get logString() {
+    return this.id;
+  }
 }
 
 const DefaultTestConfiguration: Configuration = {
@@ -120,7 +127,23 @@ describe('RemoteMediaManager', () => {
   let fakeScreenShareAudioSlot;
   let fakeScreenShareVideoSlot;
 
+  const logger = {
+    log: sinon.fake(),
+    error: () => {},
+    warn: () => {},
+    trace: () => {},
+    debug: () => {},
+  };
+
+  afterEach(() => {
+    LoggerConfig.set({enable: false});
+    LoggerProxy.set();
+  });
+
   beforeEach(() => {
+    LoggerConfig.set({enable: true});
+    LoggerProxy.set(logger);
+
     fakeAudioSlot = new FakeSlot(MediaType.AudioMain, 'fake audio slot');
     fakeVideoSlot = new FakeSlot(MediaType.VideoMain, 'fake video slot');
     fakeScreenShareAudioSlot = new FakeSlot(
@@ -191,6 +214,7 @@ describe('RemoteMediaManager', () => {
     fakeMediaRequestManagers.video.commit.resetHistory();
     fakeMediaRequestManagers.screenShareVideo.commit.resetHistory();
     fakeMediaRequestManagers.screenShareAudio.commit.resetHistory();
+    logger.log.resetHistory();
   };
 
   describe('start', () => {
@@ -639,6 +663,41 @@ describe('RemoteMediaManager', () => {
       remoteMediaManager.stop();
     });
   });
+
+  describe('setPreferLiveVideo', () => {
+
+    it('sets preferLiveVideo', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+      let stubs = [];
+
+      config.video.initialLayoutId = 'OnePlusFive';
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        Object.values(layoutInfo.activeSpeakerVideoPanes).forEach((group) => stubs.push(sinon.stub(group, 'setPreferLiveVideo')));
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+      assert(stubs.length > 0);
+      await remoteMediaManager.setPreferLiveVideo(true);
+
+
+      stubs.forEach((stub) => {
+        assert.calledWith(stub, true, false)
+      });
+
+      expect(config.video.preferLiveVideo).to.equal(true);
+      
+      assert.calledOnce(fakeMediaRequestManagers.video.commit);
+    });
+  });
+
   describe('setLayout', () => {
     it('rejects if called with invalid layoutId', async () => {
       await assert.isRejected(remoteMediaManager.setLayout('invalid value'));
@@ -671,6 +730,58 @@ describe('RemoteMediaManager', () => {
       assert.alwaysCalledWith(fakeReceiveSlotManager.allocateSlot, MediaType.VideoMain);
     });
 
+    it('logs layout changes - receiver selected', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      await remoteMediaManager.setLayout('Stage');
+
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#setLayout --> new layout selected: Stage'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=6, receiverSelected=4\ngroup: thumbnails\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n stage-1: fake video slot\n stage-2: fake video slot\n stage-3: fake video slot\n stage-4: fake video slot\n'
+      );
+    });
+
+    it('logs layout changes - active speaker', async () => {
+      const config = cloneDeep(DefaultTestConfiguration);
+      config.video.initialLayoutId = 'OnePlusFive'
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      await remoteMediaManager.setLayout('AllEqual');
+
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#setLayout --> new layout selected: AllEqual'
+      );
+      assert.calledWith(
+        logger.log,
+        'RemoteMediaManager#logMainVideoReceiveSlots --> MAIN VIDEO receive slots: unused=0, activeSpeaker=9, receiverSelected=0\ngroup: main\nfake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot, fake video slot\nreceiverSelected:\n'
+      );
+    });
+
+
     it('releases slots when switching to layout that requires less active speaker slots', async () => {
       // start with "AllEqual" layout that needs just 9 video slots
       const config = cloneDeep(DefaultTestConfiguration);
@@ -699,6 +810,133 @@ describe('RemoteMediaManager', () => {
       });
     });
 
+    it('releases slots and reallocates slots when switching to layouts in correct order', async () => {
+
+      const config = cloneDeep(DefaultTestConfiguration);
+      let count = 0;
+
+      fakeReceiveSlotManager.allocateSlot = sinon.stub().callsFake((mediaType) => {
+        switch (mediaType) {
+          case MediaType.AudioMain:
+            return Promise.resolve(fakeAudioSlot);
+          case MediaType.VideoMain:
+            return Promise.resolve(new FakeSlot(MediaType.VideoMain, `fake video ${count++}`));
+          case MediaType.AudioSlides:
+            return Promise.resolve(fakeScreenShareAudioSlot);
+          case MediaType.VideoSlides:
+            return Promise.resolve(fakeScreenShareVideoSlot);
+        }
+        throw new Error(`invalid mediaType: ${mediaType}`);
+      })
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      await remoteMediaManager.start();
+
+      resetHistory();
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 6",
+        "fake video 7",
+        "fake video 8",
+      ])
+
+      // switch to "OnePlusFive" layout that requires 3 less video slots (6)
+      await remoteMediaManager.setLayout('OnePlusFive');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ]);
+
+      // we're checking that the slots are in the same order as in the previous layout
+      // first one goes into main
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["mainBigOne"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+      ])
+      // and rest go in the pips
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["secondarySetOfSmallPanes"].slots.map((slot: any) => slot.id), [
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5"
+      ])
+
+      // verify that 3 main video slots were released
+      assert.callCount(fakeReceiveSlotManager.releaseSlot, 3);
+      fakeReceiveSlotManager.releaseSlot.getCalls().forEach((call) => {
+        const slot = call.args[0];
+
+        assert.strictEqual(slot.mediaType, MediaType.VideoMain);
+      });
+
+      await remoteMediaManager.setLayout('AllEqual');
+
+      assert.deepEqual(remoteMediaManager.slots.video.unused, []);
+
+      // checking that slots are in the same order as in previous layout + 3 new ones
+      assert.deepEqual(remoteMediaManager.slots.video.activeSpeaker.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12",
+      ]);
+
+      assert.deepEqual(remoteMediaManager.receiveSlotAllocations.activeSpeaker["main"].slots.map((slot: any) => slot.id), [
+        "fake video 0",
+        "fake video 1",
+        "fake video 2",
+        "fake video 3",
+        "fake video 4",
+        "fake video 5",
+        "fake video 10",
+        "fake video 11",
+        "fake video 12"
+      ])
+
+       // verify that 3 main video slots were allocated
+       assert.callCount(fakeReceiveSlotManager.allocateSlot, 3);
+       fakeReceiveSlotManager.allocateSlot.getCalls().forEach((call) => {
+         const mediaType = call.args[0];
+
+         assert.strictEqual(mediaType, MediaType.VideoMain);
+       });
+    });
+
     it('stops all current video remoteMedia instances when switching to new layout', async () => {
       const audioStopStubs = [];
       const videoStopStubs = [];
@@ -1494,6 +1732,94 @@ describe('RemoteMediaManager', () => {
     });
   });
 
+  describe('setActiveSpeakerCsis', () => {
+    it('calls setActiveSpeakerCsis on the correct remote media group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      let setCsisStub;
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        setCsisStub = sinon.stub(layoutInfo.activeSpeakerVideoPanes.main, 'setActiveSpeakerCsis');
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+        const remoteVideo = currentLayoutInfo.activeSpeakerVideoPanes.main.getRemoteMedia()[0];
+
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: remoteVideo}]);
+
+        assert.calledOnce(setCsisStub);
+        assert.calledWith(setCsisStub, [{remoteMedia: remoteVideo}], false);
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+
+    it('does not call setActiveSpeakerCsis on the incorrect media group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      let setCsisStub;
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        setCsisStub = sinon.stub(layoutInfo.activeSpeakerVideoPanes.main, 'setActiveSpeakerCsis');
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: {}}]);
+
+        assert.notCalled(setCsisStub);
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+
+    it('checking when there is more than one group', async () => {
+      let currentLayoutInfo: VideoLayoutChangedEventData | null = null;
+      const config = cloneDeep(DefaultTestConfiguration);
+      let stubs = [];
+
+      config.video.initialLayoutId = 'OnePlusFive';
+
+      remoteMediaManager = new RemoteMediaManager(
+        fakeReceiveSlotManager,
+        fakeMediaRequestManagers,
+        config
+      );
+
+      remoteMediaManager.on(Event.VideoLayoutChanged, (layoutInfo: VideoLayoutChangedEventData) => {
+        currentLayoutInfo = layoutInfo;
+        Object.values(layoutInfo.activeSpeakerVideoPanes).forEach((group) => stubs.push(sinon.stub(group, 'setActiveSpeakerCsis')));
+      });
+
+      await remoteMediaManager.start();
+      resetHistory();
+
+      assert.isNotNull(currentLayoutInfo);
+
+      if (currentLayoutInfo) {
+
+        const remoteMedia1 = currentLayoutInfo.activeSpeakerVideoPanes.mainBigOne.getRemoteMedia()[0];
+        const remoteMedia2 = currentLayoutInfo.activeSpeakerVideoPanes.secondarySetOfSmallPanes.getRemoteMedia()[0];
+
+        const remoteMediaCsis = [{remoteMedia: remoteMedia1}, {remoteMedia: remoteMedia2}];
+
+        remoteMediaManager.setActiveSpeakerCsis([{remoteMedia: remoteMedia1}, {remoteMedia: remoteMedia2}]);
+
+        stubs.forEach((stub, index) => {
+          assert.calledWith(stub, [remoteMediaCsis[index]], false)
+        });
+        assert.calledOnce(fakeMediaRequestManagers.video.commit);
+      }
+    });
+  });
+
   describe('pinActiveSpeakerVideoPane() and isPinned()', () => {
     it('throws if called on a pane not belonging to an active speaker group', async () => {
       let currentLayoutInfo: VideoLayoutChangedEventData | null = null;

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

@@ -0,0 +1,242 @@
+import SendSlotManager from '@webex/plugin-meetings/src/multistream/sendSlotManager';
+import { LocalStream, MediaType, MultistreamRoapMediaConnection } from "@webex/internal-media-core";
+import {expect} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+
+describe('SendSlotsManager', () => {
+    let sendSlotsManager: SendSlotManager;
+    const LoggerProxy = {
+        logger: {
+            info: sinon.stub(),
+        },
+    };
+    
+    beforeEach(() => {
+        sendSlotsManager = new SendSlotManager(LoggerProxy);
+    });
+    
+    describe('createSlot', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        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`);
+        });
+    });
+
+    describe('getSlot', () => {
+        const mediaType = MediaType.AudioMain;
+        let mediaConnection;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub().returns({}),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should return the slot for the given mediaType', () => {
+            const slot = sendSlotsManager.createSlot(mediaConnection,mediaType);
+        
+            expect(sendSlotsManager.getSlot(mediaType)).to.equal(slot);
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', () => {
+            expect(() => sendSlotsManager.getSlot(mediaType)).to.throw(`Slot for ${mediaType} does not exist`);
+        });
+    });
+    
+    describe('publishStream', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const stream = {} as LocalStream;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should publish the given stream to the sendSlot for the given mediaType', async () => {
+            const slot = {
+                publishStream: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+        
+            await sendSlotsManager.publishStream(mediaType, stream);
+        
+            expect(slot.publishStream.calledWith(stream));
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.publishStream(mediaType, stream).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
+        });
+    });
+
+    describe('unpublishStream', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should unpublish the stream from the sendSlot of the given mediaType', async () => {
+            const slot = {
+                unpublishStream: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+        
+            await sendSlotsManager.unpublishStream(mediaType);
+        
+            expect(slot.unpublishStream.called);
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist',(done) => {
+            sendSlotsManager.unpublishStream(mediaType).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
+        });
+    });
+
+    describe('setActive', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should set the active state of the sendSlot for the given mediaType', async () => {
+            const slot = {
+                setActive: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+        
+            await sendSlotsManager.setActive(mediaType,true);
+        
+            expect(slot.setActive.called);
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', () => {
+            expect(() => sendSlotsManager.setActive(mediaType)).to.throw(`Slot for ${mediaType} does not exist`)
+        });
+    });
+
+    describe('setCodecParameters', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+        const codecParameters = {};
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should set the codec parameters of the sendSlot for the given mediaType', async () => {
+            const slot = {
+                setCodecParameters: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+        
+            await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
+        
+            expect(slot.setCodecParameters.calledWith(codecParameters));
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.setCodecParameters(mediaType, codecParameters).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
+        });
+    });
+
+    describe('deleteCodecParameters', () => {
+        let mediaConnection;
+        const mediaType = MediaType.AudioMain;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub(),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should delete the codec parameters of the sendSlot for the given mediaType', async () => {
+            const slot = {
+                deleteCodecParameters: sinon.stub().resolves(),
+            };
+            mediaConnection.createSendSlot.returns(slot);
+            sendSlotsManager.createSlot(mediaConnection, mediaType);
+        
+            await sendSlotsManager.deleteCodecParameters(mediaType,[]);
+        
+            expect(slot.deleteCodecParameters.called);
+        });
+
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.deleteCodecParameters(mediaType,[]).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
+        });
+    });
+
+    describe('reset', () => {
+        let mediaConnection;
+
+        beforeEach(() => {
+            mediaConnection = {
+                createSendSlot: sinon.stub().returns({}),
+            } as MultistreamRoapMediaConnection;
+        });
+
+        it('should reset the send slot manager', () => {
+            const AudioSlot = sendSlotsManager.createSlot(mediaConnection, MediaType.AudioMain);
+            const VideoSlot = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+            const AudioSlidesSlot = sendSlotsManager.createSlot(mediaConnection, MediaType.AudioSlides);
+            const VideoSlidesSlot = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoSlides);
+            expect(sendSlotsManager.getSlot(MediaType.AudioMain)).to.equal(AudioSlot);
+            expect(sendSlotsManager.getSlot(MediaType.VideoMain)).to.equal(VideoSlot);
+            expect(sendSlotsManager.getSlot(MediaType.AudioSlides)).to.equal(AudioSlidesSlot);
+            expect(sendSlotsManager.getSlot(MediaType.VideoSlides)).to.equal(VideoSlidesSlot);
+            sendSlotsManager.reset();
+            expect(() => sendSlotsManager.getSlot(MediaType.AudioMain)).to.throw();
+            expect(() => sendSlotsManager.getSlot(MediaType.VideoMain)).to.throw();
+            expect(() => sendSlotsManager.getSlot(MediaType.AudioSlides)).to.throw();
+            expect(() => sendSlotsManager.getSlot(MediaType.VideoSlides)).to.throw();
+        });
+    });
+});