@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -1,163 +0,0 @@
-/* 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

@@ -1,203 +0,0 @@
-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

@@ -1,255 +0,0 @@
-/* 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);
-        });
-      }
-    );
-  });
-});