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

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

@@ -1,242 +0,0 @@
-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/reachability/request.js

@@ -1,68 +0,0 @@
-import sinon from 'sinon';
-import {assert} from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
-import ReachabilityRequest from '@webex/plugin-meetings/src/reachability/request';
-import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
-
-
-describe('plugin-meetings/reachability', () => {
-  let reachabilityRequest;
-  let webex;
-
-  beforeEach(() => {
-    webex = new MockWebex({
-      children: {
-        meetings: Meetings,
-      },
-    });
-
-    webex.meetings.clientRegion = {
-      countryCode: 'US',
-      regionCode: 'WEST-COAST',
-    };
-
-    webex.internal = {
-      services: {
-        get: sinon.mock().returns('locusUrl'),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
-      },
-    };
-
-
-    reachabilityRequest = new ReachabilityRequest(webex);
-
-  });
-
-  describe('#getClusters', () => {
-    it('sends a GET request with the correct params', async () => {
-      webex.request = sinon.mock().returns(Promise.resolve({
-        body: {
-          clusterClasses: {
-            hybridMedia: ["clusterId"]
-          },
-          clusters: {"clusterId": {
-            udp: "testUDP"
-          }},
-          joinCookie: {anycastEntryPoint: "aws-eu-west-1"}
-        }
-      }));
-
-      const res = await reachabilityRequest.getClusters(IP_VERSION.only_ipv4);
-
-      const requestParams = webex.request.getCall(0).args[0];
-
-      assert.equal(requestParams.method, 'GET');
-      assert.equal(requestParams.resource, `clusters`);
-      assert.equal(requestParams.api, 'calliopeDiscovery');
-      assert.equal(requestParams.shouldRefreshAccessToken, false);
-
-      assert.deepEqual(requestParams.qs, {
-        JCSupport: 1,
-        ipver: 4,
-      });
-      assert.deepEqual(res.clusters.clusterId, {udp: "testUDP", isVideoMesh: true})
-      assert.deepEqual(res.joinCookie, {anycastEntryPoint: "aws-eu-west-1"})
-    });
-  });
-});

package/test/unit/spec/roap/request.ts

@@ -1,232 +0,0 @@
-import sinon from 'sinon';
-import {assert} from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
-import RoapRequest from '@webex/plugin-meetings/src/roap/request';
-import {IP_VERSION, REACHABILITY} from '@webex/plugin-meetings/src/constants';
-
-describe('plugin-meetings/roap', () => {
-  let roapRequest;
-  let webex;
-  const locusUrl = 'locusUrl';
-
-  beforeEach(async () => {
-    webex = new MockWebex({
-      children: {
-        meetings: Meetings,
-      },
-    });
-
-    webex.meetings.clientRegion = {
-      countryCode: 'US',
-      regionCode: 'WEST-COAST',
-    };
-
-    webex.internal = {
-      services: {
-        get: sinon.mock().returns(locusUrl),
-        waitForCatalog: sinon.mock().returns(Promise.resolve({})),
-      },
-      device: {
-        url: 'url',
-      },
-      newMetrics: {
-        submitClientEvent: sinon.stub()
-      },
-    };
-
-    // @ts-ignore
-    roapRequest = new RoapRequest({webex});
-
-    roapRequest.request = sinon.mock().returns(
-      Promise.resolve({
-        body: {
-          locus: {
-            roapSeq: '',
-            id: '',
-            url: 'url/path',
-            fullState: {
-              lastActive: 'lastActive',
-            },
-          },
-        },
-      })
-    );
-
-    await webex.boundedStorage.put(
-      REACHABILITY.namespace,
-      REACHABILITY.localStorageJoinCookie,
-      JSON.stringify({
-        anycastEntryPoint: 'aws-eu-west-1',
-      })
-    );
-    await webex.boundedStorage.put(
-      REACHABILITY.namespace,
-      REACHABILITY.localStorageResult,
-      JSON.stringify({
-        clusterId: {
-          udp: 'test',
-          isVideoMesh: false,
-        },
-      })
-    );
-  });
-
-  describe('#attachReachabilityData', () => {
-    it('returns the correct reachability data', async () => {
-      const res = await roapRequest.attachReachabilityData({});
-
-      assert.deepEqual(res.localSdp, {
-        reachability: {
-          clusterId: {
-            udp: 'test',
-          },
-        },
-      });
-      assert.deepEqual(res.joinCookie, {
-        anycastEntryPoint: 'aws-eu-west-1',
-      });
-    });
-
-    it('handles the case when reachability data does not exist', async () => {
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageJoinCookie);
-
-      await webex.boundedStorage.del(REACHABILITY.namespace, REACHABILITY.localStorageResult);
-      const sdp = {
-        some: 'attribute',
-      };
-
-      const result = await roapRequest.attachReachabilityData(sdp);
-
-      assert.deepEqual(result, {
-        joinCookie: undefined,
-        localSdp: {
-          some: 'attribute',
-        },
-      });
-    });
-  });
-
-  describe('sendRoap', () => {
-    it('includes joinCookie in the request correctly', async () => {
-      const locusMediaRequest = {send: sinon.stub().resolves({body: {locus: {}}})};
-      const ipVersion = IP_VERSION.unknown;
-
-      await roapRequest.sendRoap({
-        locusSelfUrl: locusUrl,
-        ipVersion,
-        mediaId: 'mediaId',
-        roapMessage: {
-          seq: 'seq',
-        },
-        meetingId: 'meeting-id',
-        locusMediaRequest,
-      });
-
-      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.request',
-        options: {
-          meetingId: 'meeting-id',
-        },
-      });
-
-      assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-        name: 'client.locus.media.response',
-        options: {
-          meetingId: 'meeting-id',
-        },
-      });
-
-      const requestParams = locusMediaRequest.send.getCall(0).args[0];
-      assert.deepEqual(requestParams, {
-        type: 'RoapMessage',
-        selfUrl: locusUrl,
-        ipVersion,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
-        },
-        mediaId: 'mediaId',
-        roapMessage: {
-          seq: 'seq',
-        },
-        reachability: {clusterId: {udp: 'test'}},
-      });
-    });
-
-    it('sends correct client event when fails', async () => {
-      const locusMediaRequest = {send: sinon.stub().rejects({code: 300, message: 'error'})};
-      try {
-        await roapRequest.sendRoap({
-          locusSelfUrl: locusUrl,
-          mediaId: 'mediaId',
-          roapMessage: {
-            seq: 'seq',
-          },
-          meetingId: 'meeting-id',
-          locusMediaRequest,
-        });
-      } catch (err) {
-        assert.calledWith(webex.internal.newMetrics.submitClientEvent, {
-          name: 'client.locus.media.response',
-          options: {
-            meetingId: 'meeting-id',
-            rawError: {code: 300, message: 'error'},
-          },
-        });
-      }
-    });
-  });
-
-  it('calls attachReachabilityData when sendRoap', async () => {
-    const locusMediaRequest = { send: sinon.stub().resolves({body: {locus: {}}})};
-
-    const newSdp = {
-      new: 'sdp',
-      reachability: { someResult: 'whatever' }
-    };
-    const ipVersion = IP_VERSION.only_ipv6;
-
-    roapRequest.attachReachabilityData = sinon.stub().returns(
-      Promise.resolve({
-        localSdp: newSdp,
-        joinCookie: {
-          anycastEntryPoint: 'aws-eu-west-1',
-        },
-      })
-    );
-
-    await roapRequest.sendRoap({
-      roapMessage: {
-        seq: 1,
-      },
-      locusSelfUrl: 'locusSelfUrl',
-      ipVersion,
-      mediaId: 'mediaId',
-      meetingId: 'meetingId',
-      preferTranscoding: true,
-      locusMediaRequest
-    });
-
-    const requestParams = locusMediaRequest.send.getCall(0).args[0];
-
-    assert.deepEqual(requestParams, {
-      type: 'RoapMessage',
-      selfUrl: 'locusSelfUrl',
-      ipVersion,
-      joinCookie: {
-        anycastEntryPoint: 'aws-eu-west-1',
-      },
-      mediaId: 'mediaId',
-      roapMessage: {
-        seq: 1,
-      },
-      reachability: { someResult: 'whatever' },
-    });
-
-    assert.calledOnceWithExactly(roapRequest.attachReachabilityData, {
-      roapMessage: {
-        seq: 1,
-      },
-    });
-  });
-});

package/test/unit/spec/rtcMetrics/index.ts

@@ -1,93 +0,0 @@
-import RtcMetrics from '@webex/plugin-meetings/src/rtcMetrics';
-import MockWebex from '@webex/test-helper-mock-webex';
-import {assert} from '@webex/test-helper-chai';
-import sinon from 'sinon';
-import RTC_METRICS from '../../../../src/rtcMetrics/constants';
-
-const FAKE_METRICS_ITEM = {payload: ['fake-metrics']};
-
-const STATS_WITH_IP = '{\"id\":\"RTCIceCandidate_/kQs0ZNU\",\"type\":\"remote-candidate\",\"transportId\":\"RTCTransport_0_1\",\"isRemote\":true,\"ip\":\"11.22.111.255\",\"address\":\"11.22.111.255\",\"port\":5004,\"protocol\":\"udp\",\"candidateType\":\"host\",\"priority\":2130706431}';
-const STATS_WITH_IP_RESULT = '{\"id\":\"RTCIceCandidate_/kQs0ZNU\",\"type\":\"remote-candidate\",\"transportId\":\"RTCTransport_0_1\",\"isRemote\":true,\"ip\":\"11.22.111.240\",\"address\":\"11.22.111.240\",\"port\":5004,\"protocol\":\"udp\",\"candidateType\":\"host\",\"priority\":2130706431}';
-
-describe('RtcMetrics', () => {
-  let metrics: RtcMetrics;
-  let webex: MockWebex;
-  let clock;
-  let anonymizeIpSpy;
-
-  const sandbox = sinon.createSandbox();
-
-  beforeEach(() => {
-    clock = sinon.useFakeTimers();
-    webex = new MockWebex();
-    metrics = new RtcMetrics(webex, 'mock-meeting-id', 'mock-correlation-id');
-    anonymizeIpSpy = sandbox.spy(metrics, 'anonymizeIp');
-  });
-
-  afterEach(() => {
-    sandbox.restore();
-  });
-
-  it('sendMetrics should send a webex request', () => {
-    assert.notCalled(webex.request);
-
-    metrics.addMetrics(FAKE_METRICS_ITEM);
-    (metrics as any).sendMetrics();
-
-    assert.callCount(webex.request, 1);
-    assert.calledWithMatch(webex.request, sinon.match.has('headers', {
-      type: 'webrtcMedia',
-      appId: RTC_METRICS.APP_ID,
-    }));
-    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].data[0].payload', FAKE_METRICS_ITEM.payload));
-    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].meetingId', 'mock-meeting-id'));
-    assert.calledWithMatch(webex.request, sinon.match.hasNested('body.metrics[0].correlationId', 'mock-correlation-id'));
-  });
-
-  it('should have a defined sendMetricsInQueue function which is public', () => {
-    assert.isDefined(metrics.sendMetricsInQueue);
-    assert.isFunction(metrics.sendMetricsInQueue);
-  });
-
-  it('should send metrics requests over time', () => {
-    assert.notCalled(webex.request);
-
-    metrics.addMetrics(FAKE_METRICS_ITEM);
-    assert.deepEqual(metrics.metricsQueue, [FAKE_METRICS_ITEM]);
-    clock.tick(60 * 1000);
-
-    assert.callCount(webex.request, 1);
-  });
-
-  it('should not send requests with no items in the queue', () => {
-    clock.tick(60 * 1000);
-    assert.notCalled(webex.request);
-  });
-
-  it('sendMetricsInQueue should send metrics if any exist in the queue', () => {
-    assert.notCalled(webex.request);
-
-    metrics.addMetrics(FAKE_METRICS_ITEM);
-    (metrics as any).sendMetricsInQueue();
-
-    assert.callCount(webex.request, 1);
-  });
-
-  it('should clear out metrics on close', () => {
-    assert.notCalled(webex.request);
-
-    metrics.addMetrics(FAKE_METRICS_ITEM);
-    metrics.closeMetrics();
-
-    assert.callCount(webex.request, 1);
-  });
-
-  it('should anonymize IP addresses', () => {
-    assert.strictEqual(metrics.anonymizeIp(STATS_WITH_IP), STATS_WITH_IP_RESULT);
-  });
-
-  it('should call anonymizeIp', () => {
-    metrics.addMetrics({ name: 'stats-report', payload: [STATS_WITH_IP] });
-    assert.calledOnce(anonymizeIpSpy);
-  })
-});

package/test/unit/spec/webinar/collection.ts

@@ -1,13 +0,0 @@
-import {assert} from '@webex/test-helper-chai';
-import WebinarCollection from '@webex/plugin-meetings/src/webinar/collection';
-
-describe('plugin-meetings', () => {
-    describe('WebinarCollection', () => {
-        it('the webinar collection is as expected', () => {
-            const collection = new WebinarCollection();
-
-            assert.equal(collection.namespace, 'Meetings');
-            assert.equal(collection.mainIndex, 'sessionId');
-        });
-    });
-});