@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

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();
+        });
+    });
+});

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

@@ -20,11 +20,11 @@ describe('plugin-meetings', () => {
     const initialConfig = {
       videoPacketLossRatioThreshold: 9,
       rttThreshold: 500,
-      jitterThreshold: 500
+      jitterThreshold: 500,
     };
 
     const configObject = {
-      mediaType: 'video',
+      mediaType: 'video-send',
       remoteRtpResults: {
         id: 'RTCRemoteInboundRtpVideoStream_2411086660',
         timestamp: 1624472676193.79,
@@ -39,20 +39,20 @@ describe('plugin-meetings', () => {
         roundTripTime: 0.648,
         fractionLost: 0,
         totalRoundTripTime: 3.554,
-        roundTripTimeMeasurements: 14
+        roundTripTimeMeasurements: 14,
       },
       statsAnalyzerCurrentStats: {
-        audio: {
+        'audio-send': {
           send: {
-            currentPacketLossRatio: 8
-          }
+            currentPacketLossRatio: 8,
+          },
         },
-        video: {
+        'video-send': {
           send: {
-            currentPacketLossRatio: 10
-          }
-        }
-      }
+            currentPacketLossRatio: 10,
+          },
+        },
+      },
     };
 
     const sandbox = sinon.createSandbox();
@@ -75,13 +75,19 @@ describe('plugin-meetings', () => {
 
     it('should emit a network quality judgement event with the proper payload', async () => {
       await networkQualityMonitor.determineUplinkNetworkQuality(configObject);
-      assert(sandBoxEmitSpy.calledWith(sinon.match({
-        file: 'networkQualityMonitor',
-        function: 'emitNetworkQuality'
-      }), sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY), sinon.match({
-        mediaType: 'video',
-        networkQualityScore: 0
-      })));
+      assert(
+        sandBoxEmitSpy.calledWith(
+          sinon.match({
+            file: 'networkQualityMonitor',
+            function: 'emitNetworkQuality',
+          }),
+          sinon.match(EVENT_TRIGGERS.NETWORK_QUALITY),
+          sinon.match({
+            mediaType: 'video-send',
+            networkQualityScore: 0,
+          })
+        )
+      );
     });
 
     it('should reset to default values after determineUplinkNetworkQuality call stack is complete', async () => {

package/test/unit/spec/personal-meeting-room/personal-meeting-room.js

@@ -5,9 +5,7 @@
 import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {
-  _PERSONAL_ROOM_
-} from '@webex/plugin-meetings/src/constants';
+import {_PERSONAL_ROOM_} from '@webex/plugin-meetings/src/constants';
 import PersonalMeetingRoom from '@webex/plugin-meetings/src/personal-meeting-room';
 
 describe('personal-meeting-room', () => {
@@ -16,14 +14,11 @@ describe('personal-meeting-room', () => {
 
   beforeEach(() => {
     meetingInfo = {
-      fetchMeetingInfo: sinon.stub().returns(Promise.resolve(
-        {body: {isPmr: true}}
-      ))
+      fetchMeetingInfo: sinon.stub().returns(Promise.resolve({body: {isPmr: true}})),
     };
     pmr = new PersonalMeetingRoom({meetingInfo}, {parent: {}});
   });
 
-
   describe('#get()', () => {
     it('returns personal meeting room info', async () => {
       await pmr.get();