@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.11

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

@@ -0,0 +1,173 @@
+import sinon from 'sinon';
+import {assert} from '@webex/test-helper-chai';
+import {MediaConnection as MC} from '@webex/internal-media-core';
+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;
+
+  beforeEach(() => {
+    fakeWcmeSlot = {
+      id: 'fake wcme slot',
+    };
+    fakeMeeting = {
+      mediaProperties: {
+        webrtcMediaConnection: {
+          createReceiveSlot: sinon.stub().resolves(fakeWcmeSlot),
+        },
+      },
+      members: {
+        findMemberByCsi: sinon.stub(),
+      },
+    };
+    fakeReceiveSlots = [];
+    mockReceiveSlotCtor = sinon.stub(ReceiveSlotModule, 'ReceiveSlot').callsFake((mediaType) => {
+      const fakeReceiveSlot = {
+        id: `fake sdk receive slot ${fakeReceiveSlots.length + 1}`,
+        mediaType,
+      };
+
+      fakeReceiveSlots.push(fakeReceiveSlot);
+
+      return fakeReceiveSlot;
+    });
+
+    receiveSlotManager = new ReceiveSlotManager(fakeMeeting);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('rejects if there is no media connection', async () => {
+    fakeMeeting.mediaProperties.webrtcMediaConnection = null;
+
+    assert.isRejected(
+      receiveSlotManager.allocateSlot(MC.MediaType.VideoMain),
+      'Webrtc media connection is missing'
+    );
+  });
+
+  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);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledWith(
+      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
+      MC.MediaType.VideoMain
+    );
+
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.calledWith(mockReceiveSlotCtor, MC.MediaType.VideoMain, fakeWcmeSlot, sinon.match.func);
+    assert.strictEqual(slot, fakeReceiveSlots[0]);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {'VIDEO-MAIN': 1},
+      numFreeSlots: {},
+    });
+  });
+
+  it('reuses previously freed slot when allocateSlot() is called and a free slot is available', async () => {
+    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.strictEqual(slot1, fakeReceiveSlots[0]);
+
+    // release the allocated slot
+    receiveSlotManager.releaseSlot(slot1);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {},
+      numFreeSlots: {'VIDEO-MAIN': 1},
+    });
+
+    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.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);
+
+    assert.notCalled(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.notCalled(mockReceiveSlotCtor);
+
+    // verify that in fact we got the same slot again
+    assert.strictEqual(slot1, slot2);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {'VIDEO-MAIN': 1},
+      numFreeSlots: {},
+    });
+  });
+
+  it('does not reuse any slots after reset() is called', async () => {
+    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.strictEqual(slot1, fakeReceiveSlots[0]);
+
+    // release the slot so we have 1 free slot, but also call reset() which should clear everything
+    receiveSlotManager.releaseSlot(slot1);
+    receiveSlotManager.reset();
+
+    // reset the mocks and set the ReceiveSlot constructor to return a different slot
+    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.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);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(mockReceiveSlotCtor);
+
+    // verify that in fact we got a brand new slot
+    assert.strictEqual(slot2, fakeReceiveSlots[1]);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {'VIDEO-MAIN': 1},
+      numFreeSlots: {},
+    });
+  });
+
+  it('does not reuse slots if they have different media type', async () => {
+    const slot1 = await receiveSlotManager.allocateSlot(MC.MediaType.VideoMain);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledOnce(mockReceiveSlotCtor);
+
+    receiveSlotManager.releaseSlot(slot1);
+
+    fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot.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);
+
+    assert.calledOnce(fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot);
+    assert.calledWith(
+      fakeMeeting.mediaProperties.webrtcMediaConnection.createReceiveSlot,
+      MC.MediaType.AudioMain
+    );
+
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.calledWith(mockReceiveSlotCtor, MC.MediaType.AudioMain, fakeWcmeSlot, sinon.match.func);
+
+    // verify that in fact we got a brand new slot
+    assert.strictEqual(slot2, fakeReceiveSlots[1]);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {'AUDIO-MAIN': 1},
+      numFreeSlots: {'VIDEO-MAIN': 1},
+    });
+  });
+});

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

@@ -0,0 +1,225 @@
+/* eslint-disable require-jsdoc */
+import EventEmitter from 'events';
+
+import {MediaConnection as MC} 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';
+
+describe('RemoteMedia', () => {
+  let remoteMedia;
+  let fakeReceiveSlot;
+  let fakeStream;
+  let fakeMediaRequestManager;
+
+  beforeEach(() => {
+    fakeStream = {id: 'fake stream'};
+    fakeReceiveSlot = new EventEmitter();
+    fakeReceiveSlot.mediaType = MC.MediaType.AudioMain;
+    fakeReceiveSlot.memberId = '12345678';
+    fakeReceiveSlot.csi = 999;
+    fakeReceiveSlot.sourceState = 'avatar';
+    fakeReceiveSlot.stream = fakeStream;
+
+    fakeMediaRequestManager = {
+      addRequest: sinon.stub(),
+      cancelRequest: sinon.stub(),
+    };
+    remoteMedia = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager, {resolution: 'medium'});
+  });
+
+  describe('forwards events from the underlying receive slot', () => {
+    [
+      {
+        receiveSlotEvent: ReceiveSlotEvents.SourceUpdate,
+        expectedEvent: RemoteMediaEvents.SourceUpdate,
+        title: 'SourceUpdate',
+      },
+    ].forEach(({receiveSlotEvent, expectedEvent, title}) =>
+      it(`forwards ${title}`, () => {
+        let eventEmittedCount = 0;
+        let eventData;
+        const fakeData = {something: 'some value'};
+
+        remoteMedia.on(expectedEvent, (data) => {
+          eventEmittedCount += 1;
+          eventData = data;
+        });
+
+        fakeReceiveSlot.emit(receiveSlotEvent, fakeData);
+
+        assert.strictEqual(eventEmittedCount, 1);
+        assert.strictEqual(eventData, fakeData);
+      })
+    );
+  });
+
+  it("exposes underlying receive slot's properties", () => {
+    assert.strictEqual(remoteMedia.mediaType, fakeReceiveSlot.mediaType);
+    assert.strictEqual(remoteMedia.memberId, fakeReceiveSlot.memberId);
+    assert.strictEqual(remoteMedia.csi, fakeReceiveSlot.csi);
+    assert.strictEqual(remoteMedia.sourceState, fakeReceiveSlot.sourceState);
+    assert.strictEqual(remoteMedia.stream, fakeReceiveSlot.stream);
+  });
+
+  describe('sendMediaRequest', () => {
+    it('sends correct media request', () => {
+      const csi = 987654321;
+      const csi2 = 12345;
+
+      remoteMedia.sendMediaRequest(csi, true);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'receiver-selected',
+            csi,
+          }),
+          receiveSlots: [fakeReceiveSlot],
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        }),
+        true
+      );
+
+      fakeMediaRequestManager.addRequest.resetHistory();
+
+      // now call again, with different csi and commit=false
+      remoteMedia.sendMediaRequest(csi2, false);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'receiver-selected',
+            csi: csi2,
+          }),
+          receiveSlots: [fakeReceiveSlot],
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        }),
+        false
+      );
+    });
+
+    it('cancels previous request', () => {
+      const fakeRequestId = 111;
+
+      fakeMediaRequestManager.addRequest.returns(fakeRequestId);
+
+      // send the 1st media request
+      remoteMedia.sendMediaRequest(1234, true);
+
+      fakeMediaRequestManager.addRequest.resetHistory();
+
+      // send a 2nd one (the 1st one should get cancelled)
+      remoteMedia.sendMediaRequest(5678, false);
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+      assert.calledWith(fakeMediaRequestManager.cancelRequest, fakeRequestId);
+
+      assert.calledOnce(fakeMediaRequestManager.addRequest);
+      assert.calledWith(
+        fakeMediaRequestManager.addRequest,
+        sinon.match({
+          policyInfo: sinon.match({
+            policy: 'receiver-selected',
+            csi: 5678,
+          }),
+          receiveSlots: [fakeReceiveSlot],
+          codecInfo: sinon.match({
+            codec: 'h264',
+            maxFs: 3600,
+          }),
+        }),
+        false
+      );
+    });
+
+    it('throws when called on a stopped RemoteMedia instance', () => {
+      remoteMedia.stop();
+      assert.throws(
+        () => remoteMedia.sendMediaRequest(1234, true),
+        'sendMediaRequest() called on an invalidated RemoteMedia instance'
+      );
+    });
+  });
+
+  describe('cancelMediaRequest', () => {
+    it('cancels the media request', () => {
+      const fakeRequestId = 11;
+
+      fakeMediaRequestManager.addRequest.returns(fakeRequestId);
+
+      // send a media request
+      remoteMedia.sendMediaRequest(1234, true);
+
+      fakeMediaRequestManager.addRequest.resetHistory();
+
+      // cancel it
+      remoteMedia.cancelMediaRequest();
+
+      assert.calledOnce(fakeMediaRequestManager.cancelRequest);
+      assert.calledWith(fakeMediaRequestManager.cancelRequest, fakeRequestId);
+
+      assert.notCalled(fakeMediaRequestManager.addRequest);
+    });
+    it('does not do anything if there was no request sent', () => {
+      remoteMedia.cancelMediaRequest();
+
+      assert.notCalled(fakeMediaRequestManager.cancelRequest);
+      assert.notCalled(fakeMediaRequestManager.addRequest);
+    });
+  });
+
+  describe('stop()', () => {
+    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);
+
+      assert.strictEqual(remoteMedia.mediaType, undefined);
+      assert.strictEqual(remoteMedia.memberId, undefined);
+      assert.strictEqual(remoteMedia.csi, undefined);
+      assert.strictEqual(remoteMedia.sourceState, undefined);
+      assert.strictEqual(remoteMedia.stream, undefined);
+
+      // check that events emitted from receive slot don't get forwarded anymore
+      [
+        {
+          receiveSlotEvent: ReceiveSlotEvents.SourceUpdate,
+          remoteMediaEvent: RemoteMediaEvents.SourceUpdate,
+        },
+      ].forEach(({receiveSlotEvent, remoteMediaEvent}) => {
+        let eventEmitted = false;
+
+        remoteMedia.on(remoteMediaEvent, () => {
+          eventEmitted = true;
+        });
+
+        fakeReceiveSlot.emit(receiveSlotEvent);
+
+        assert.strictEqual(eventEmitted, false);
+      });
+    });
+  });
+});