@webex/plugin-meetings 2.59.8-next.2 → 2.60.0-next.1

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

@@ -0,0 +1,163 @@
+/* eslint-disable require-jsdoc */
+import EventEmitter from 'events';
+
+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';
+
+class FakeWcmeSlot extends EventEmitter {
+  public stream;
+
+  public id = 'fake id';
+
+  constructor(stream) {
+    super();
+    this.stream = stream;
+  }
+}
+
+describe('ReceiveSlot', () => {
+  let receiveSlot;
+  let fakeWcmeSlot;
+  let findMemberIdCallbackStub;
+  let fakeStream;
+
+  beforeEach(() => {
+    fakeStream = {id: 'fake stream'};
+    fakeWcmeSlot = new FakeWcmeSlot(fakeStream);
+    findMemberIdCallbackStub = sinon.stub();
+    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;
+      let eventData;
+
+      const csi = 10203040;
+      const fakeMemberId = '12345678-1234-5678-9012-345678901234';
+
+      findMemberIdCallbackStub.returns(fakeMemberId);
+
+      receiveSlot.on(ReceiveSlotEvents.SourceUpdate, (data) => {
+        eventEmitted = true;
+        eventData = data;
+      });
+
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+
+      assert.strictEqual(eventEmitted, true);
+      assert.deepEqual(eventData, {
+        state: 'live',
+        csi,
+        memberId: fakeMemberId,
+      });
+      assert.calledOnce(findMemberIdCallbackStub);
+      assert.calledWith(findMemberIdCallbackStub, csi);
+    });
+  });
+
+  it('has public properties', () => {
+    assert.isTrue(receiveSlot.id.startsWith('r'));
+    assert.strictEqual(receiveSlot.mediaType, MediaType.VideoMain);
+  });
+
+  it("exposes underlying wcme receive slot's properties", () => {
+    assert.strictEqual(receiveSlot.stream, fakeStream);
+    assert.strictEqual(receiveSlot.wcmeReceiveSlot, fakeWcmeSlot);
+  });
+
+  it("caches some underlying wcme receive slot's properties", () => {
+    assert.strictEqual(receiveSlot.memberId, undefined);
+    assert.strictEqual(receiveSlot.csi, undefined);
+    assert.strictEqual(receiveSlot.sourceState, 'no source');
+
+    const csi = 987654321;
+    const fakeMemberId = '00000001-1234-5678-9012-345678901234';
+
+    findMemberIdCallbackStub.returns(fakeMemberId);
+
+    fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+
+    assert.strictEqual(receiveSlot.memberId, fakeMemberId);
+    assert.strictEqual(receiveSlot.csi, csi);
+    assert.strictEqual(receiveSlot.sourceState, 'live');
+  });
+
+  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();
+
+      assert.notCalled(findMemberIdCallbackStub);
+    });
+
+    it('finds a member id if member id is undefined and CSI is known', () => {
+      let emittedSourceUpdateEvent = null;
+
+      // 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.on(ReceiveSlotEvents.SourceUpdate, (data) => {
+        emittedSourceUpdateEvent = data;
+      });
+
+      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

@@ -0,0 +1,203 @@
+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 fakeWcmeSlot;
+  let fakeReceiveSlots;
+  let mockReceiveSlotCtor;
+  let receiveSlotManager;
+  let createSlotCallbackStub;
+  let findMemberIdCallbackStub;
+
+  beforeEach(() => {
+    fakeWcmeSlot = {
+      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);
+
+      return fakeReceiveSlot;
+    });
+
+    createSlotCallbackStub = sinon.stub().resolves(fakeWcmeSlot);
+    findMemberIdCallbackStub = sinon.stub();
+
+    receiveSlotManager = new ReceiveSlotManager(createSlotCallbackStub, findMemberIdCallbackStub);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('rejects if there is no media connection', async () => {
+    createSlotCallbackStub.rejects(new Error('Webrtc media connection is missing'));
+
+    assert.isRejected(
+      receiveSlotManager.allocateSlot(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(MediaType.VideoMain);
+
+    assert.calledOnce(createSlotCallbackStub);
+    assert.calledWith(
+      createSlotCallbackStub,
+      MediaType.VideoMain
+    );
+
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.calledWith(mockReceiveSlotCtor, MediaType.VideoMain, fakeWcmeSlot, findMemberIdCallbackStub);
+    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(MediaType.VideoMain);
+
+    assert.calledOnce(createSlotCallbackStub);
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.strictEqual(slot1, fakeReceiveSlots[0]);
+
+    // release the allocated slot
+    receiveSlotManager.releaseSlot(slot1);
+
+    assert.deepEqual(receiveSlotManager.getStats(), {
+      numAllocatedSlots: {},
+      numFreeSlots: {'VIDEO-MAIN': 1},
+    });
+
+    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(createSlotCallbackStub);
+    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(MediaType.VideoMain);
+
+    assert.calledOnce(createSlotCallbackStub);
+    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
+    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(MediaType.VideoMain);
+
+    assert.calledOnce(createSlotCallbackStub);
+    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(MediaType.VideoMain);
+
+    assert.calledOnce(createSlotCallbackStub);
+    assert.calledOnce(mockReceiveSlotCtor);
+
+    receiveSlotManager.releaseSlot(slot1);
+
+    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(createSlotCallbackStub);
+    assert.calledWith(
+      createSlotCallbackStub,
+      MediaType.AudioMain
+    );
+
+    assert.calledOnce(mockReceiveSlotCtor);
+    assert.calledWith(mockReceiveSlotCtor, MediaType.AudioMain, fakeWcmeSlot, findMemberIdCallbackStub);
+
+    // 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},
+    });
+  });
+
+  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

@@ -0,0 +1,255 @@
+/* eslint-disable require-jsdoc */
+import EventEmitter from 'events';
+
+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;
+  let fakeReceiveSlot;
+  let fakeStream;
+  let fakeMediaRequestManager;
+
+  beforeEach(() => {
+    fakeStream = {id: 'fake stream'};
+    fakeReceiveSlot = new EventEmitter();
+    fakeReceiveSlot.mediaType = MediaType.AudioMain;
+    fakeReceiveSlot.memberId = '12345678';
+    fakeReceiveSlot.csi = 999;
+    fakeReceiveSlot.sourceState = 'avatar';
+    fakeReceiveSlot.stream = fakeStream;
+    fakeReceiveSlot.setMaxFs = sinon.stub();
+
+    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);
+      });
+    });
+  });
+
+  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);
+        });
+      }
+    );
+  });
+});