@webex/plugin-meetings 3.0.0-beta.4 → 3.0.0-beta.400

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

@@ -1,7 +1,7 @@
 /* eslint-disable require-jsdoc */
 import EventEmitter from 'events';
 
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {MediaType, ReceiveSlotEvents as WcmeReceiveSlotEvents} from '@webex/internal-media-core';
 import {ReceiveSlot, ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
@@ -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;
@@ -25,9 +27,15 @@ describe('ReceiveSlot', () => {
     fakeStream = {id: 'fake stream'};
     fakeWcmeSlot = new FakeWcmeSlot(fakeStream);
     findMemberIdCallbackStub = sinon.stub();
-    receiveSlot = new ReceiveSlot(MC.MediaType.VideoMain, fakeWcmeSlot, findMemberIdCallbackStub);
+    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;
@@ -43,7 +51,7 @@ describe('ReceiveSlot', () => {
         eventData = data;
       });
 
-      fakeWcmeSlot.emit(MC.ReceiveSlotEvents.SourceUpdate, 'live', csi);
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
 
       assert.strictEqual(eventEmitted, true);
       assert.deepEqual(eventData, {
@@ -57,8 +65,8 @@ describe('ReceiveSlot', () => {
   });
 
   it('has public properties', () => {
-    assert.strictEqual(receiveSlot.id, 'r1');
-    assert.strictEqual(receiveSlot.mediaType, MC.MediaType.VideoMain);
+    assert.isTrue(receiveSlot.id.startsWith('r'));
+    assert.strictEqual(receiveSlot.mediaType, MediaType.VideoMain);
   });
 
   it("exposes underlying wcme receive slot's properties", () => {
@@ -76,29 +84,80 @@ describe('ReceiveSlot', () => {
 
     findMemberIdCallbackStub.returns(fakeMemberId);
 
-    fakeWcmeSlot.emit(MC.ReceiveSlotEvents.SourceUpdate, 'live', csi);
+    fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
 
     assert.strictEqual(receiveSlot.memberId, fakeMemberId);
     assert.strictEqual(receiveSlot.csi, csi);
     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(MC.ReceiveSlotEvents.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 {MediaConnection as MC} from '@webex/internal-media-core';
+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,10 +42,10 @@ 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(MC.MediaType.VideoMain),
+      receiveSlotManager.allocateSlot(MediaType.VideoMain),
       'Webrtc media connection is missing'
     );
   });
@@ -56,16 +53,16 @@ describe('ReceiveSlotManager', () => {
   it('allocates a slot when allocateSlot() is called and there are no free slots', async () => {
     assert.deepEqual(receiveSlotManager.getStats(), {numAllocatedSlots: {}, numFreeSlots: {}});
 
-    const slot = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+    const slot = await receiveSlotManager.allocateSlot(MediaType.VideoMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledWith(
-      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
-      MC.MediaType.VideoMain
+      createSlotCallbackStub,
+      MediaType.VideoMain
     );
 
     assert.calledOnce(mockReceiveSlotCtor);
-    assert.calledWith(mockReceiveSlotCtor, MC.MediaType.VideoMain, fakeWcmeSlot, sinon.match.func);
+    assert.calledWith(mockReceiveSlotCtor, MediaType.VideoMain, fakeWcmeSlot, findMemberIdCallbackStub);
     assert.strictEqual(slot, fakeReceiveSlots[0]);
 
     assert.deepEqual(receiveSlotManager.getStats(), {
@@ -75,9 +72,9 @@ describe('ReceiveSlotManager', () => {
   });
 
   it('reuses previously freed slot when allocateSlot() is called and a free slot is available', async () => {
-    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+    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(MC.MediaType.VideoMain);
+    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
@@ -108,9 +105,9 @@ describe('ReceiveSlotManager', () => {
   });
 
   it('does not reuse any slots after reset() is called', async () => {
-    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+    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,15 +116,15 @@ 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: {}});
 
     // allocate another slot, because we called reset(), the old free slot should not be reused
-    const slot2 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+    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
@@ -140,27 +137,27 @@ describe('ReceiveSlotManager', () => {
   });
 
   it('does not reuse slots if they have different media type', async () => {
-    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+    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(MC.MediaType.AudioMain);
+    const slot2 = await receiveSlotManager.allocateSlot(MediaType.AudioMain);
 
-    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(createSlotCallbackStub);
     assert.calledWith(
-      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
-      MC.MediaType.AudioMain
+      createSlotCallbackStub,
+      MediaType.AudioMain
     );
 
     assert.calledOnce(mockReceiveSlotCtor);
-    assert.calledWith(mockReceiveSlotCtor, MC.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

@@ -1,11 +1,12 @@
 /* eslint-disable require-jsdoc */
 import EventEmitter from 'events';
 
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {MediaType} from '@webex/internal-media-core';
 import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 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;
@@ -16,11 +17,12 @@ describe('RemoteMedia', () => {
   beforeEach(() => {
     fakeStream = {id: 'fake stream'};
     fakeReceiveSlot = new EventEmitter();
-    fakeReceiveSlot.mediaType = MC.MediaType.AudioMain;
+    fakeReceiveSlot.mediaType = MediaType.AudioMain;
     fakeReceiveSlot.memberId = '12345678';
     fakeReceiveSlot.csi = 999;
     fakeReceiveSlot.sourceState = 'avatar';
     fakeReceiveSlot.stream = fakeStream;
+    fakeReceiveSlot.setMaxFs = sinon.stub();
 
     fakeMediaRequestManager = {
       addRequest: sinon.stub(),
@@ -184,8 +186,16 @@ describe('RemoteMedia', () => {
     it('cancels media request, unsets the receive slot and removes all the listeners from it', () => {
       const cancelMediaRequestSpy = sinon.spy(remoteMedia, 'cancelMediaRequest');
 
+      let stoppedListenerCalled = false;
+
+      remoteMedia.on(RemoteMediaEvents.Stopped, () => {
+        stoppedListenerCalled = true;
+      });
+
       remoteMedia.stop(true);
 
+      assert.isTrue(stoppedListenerCalled);
+
       assert.calledOnce(cancelMediaRequestSpy);
       assert.calledWith(cancelMediaRequestSpy, true);
 
@@ -214,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);
+        });
+      }
+    );
+  });
 });