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

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/clusterReachability.ts

@@ -1,279 +0,0 @@
-import {assert} from '@webex/test-helper-chai';
-import MockWebex from '@webex/test-helper-mock-webex';
-import sinon from 'sinon';
-import testUtils from '../../../utils/testUtils';
-
-// packages/@webex/plugin-meetings/test/unit/spec/reachability/clusterReachability.ts
-import { ClusterReachability } from '@webex/plugin-meetings/src/reachability/clusterReachability'; // replace with actual path
-
-describe('ClusterReachability', () => {
-  let previousRTCPeerConnection;
-  let clusterReachability;
-  let fakePeerConnection;
-
-  const FAKE_OFFER = {type: 'offer', sdp: 'fake sdp'};
-
-  beforeEach(() => {
-    fakePeerConnection = {
-      createOffer: sinon.stub().resolves(FAKE_OFFER),
-      setLocalDescription: sinon.stub().resolves(),
-      close: sinon.stub(),
-      iceGatheringState: 'new',
-    };
-
-    previousRTCPeerConnection = global.RTCPeerConnection;
-    global.RTCPeerConnection = sinon.stub().returns(fakePeerConnection);
-
-    clusterReachability = new ClusterReachability('testName', {
-      isVideoMesh: false,
-      udp: ['stun:udp1', 'stun:udp2'],
-      tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-      xtls: ['xtls1', 'xtls2'],
-    });
-
-  });
-
-  afterEach(() => {
-    global.RTCPeerConnection = previousRTCPeerConnection;
-  });
-
-  it('should create an instance correctly', () => {
-    assert.instanceOf(clusterReachability, ClusterReachability);
-    assert.equal(clusterReachability.name, 'testName');
-    assert.equal(clusterReachability.isVideoMesh, false);
-    assert.equal(clusterReachability.numUdpUrls, 2);
-    assert.equal(clusterReachability.numTcpUrls, 2);
-  });
-
-  it('should create a peer connection with the right config', () => {
-    assert.calledOnceWithExactly(global.RTCPeerConnection, {
-      iceServers: [
-        {username: '', credential: '', urls: ['stun:udp1']},
-        {username: '', credential: '', urls: ['stun:udp2']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp1.webex.com?transport=tcp']},
-        {username: 'webexturnreachuser', credential: 'webexturnreachpwd', urls: ['turn:tcp2.webex.com:5004?transport=tcp']}
-      ],
-      iceCandidatePoolSize: 0,
-      iceTransportPolicy: 'all',
-    });
-  });
-
-  it('should create a peer connection with the right config even if lists of urls are empty', () => {
-    (global.RTCPeerConnection as any).resetHistory();
-
-    clusterReachability = new ClusterReachability('testName', {
-      isVideoMesh: false,
-      udp: [],
-      tcp: [],
-      xtls: [],
-    });
-
-    assert.calledOnceWithExactly(global.RTCPeerConnection, {
-      iceServers: [],
-      iceCandidatePoolSize: 0,
-      iceTransportPolicy: 'all',
-    });
-  });
-
-  it('returns correct results before start() is called', () => {
-    assert.deepEqual(clusterReachability.getResult(), {
-      udp: {result: 'untested'},
-      tcp: {result: 'untested'},
-      xtls: {result: 'untested'}
-    });
-  });
-
-  describe('#start', () => {
-    let clock;
-
-    beforeEach(() => {
-      clock = sinon.useFakeTimers();
-    });
-
-    afterEach(() => {
-      clock.restore();
-    })
-
-    it('should initiate the ICE gathering process', async () => {
-      const promise = clusterReachability.start();
-
-      await testUtils.flushPromises();
-
-      // check that the right listeners are setup
-      assert.isFunction(fakePeerConnection.onicecandidate);
-      assert.isFunction(fakePeerConnection.onicegatheringstatechange);
-
-      // check that the right webrtc APIs are called
-      assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
-      assert.calledOnce(fakePeerConnection.setLocalDescription);
-
-      await clock.tickAsync(3000);// move the clock so that reachability times out
-      await promise;
-    });
-
-    it('resolves and has correct result as soon as it finds that both udp and tcp is reachable', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp'}});
-
-      await clock.tickAsync(100);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 100, clientMediaIPs: ['somePublicIp']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 200},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('times out correctly', async () => {
-      const promise = clusterReachability.start();
-
-      // progress time without any candidates
-      await clock.tickAsync(3000);
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('times out correctly for video mesh nodes', async () => {
-      clusterReachability = new ClusterReachability('testName', {
-        isVideoMesh: true,
-        udp: ['stun:udp1', 'stun:udp2'],
-        tcp: ['stun:tcp1.webex.com', 'stun:tcp2.webex.com:5004'],
-        xtls: ['xtls1', 'xtls2'],
-      });
-
-      const promise = clusterReachability.start();
-
-      // video mesh nodes have shorter timeout of just 1s
-      await clock.tickAsync(1000);
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('resolves when ICE gathering is completed', async () => {
-      const promise = clusterReachability.start();
-
-      await testUtils.flushPromises();
-
-      fakePeerConnection.iceConnectionState = 'complete';
-      fakePeerConnection.onicegatheringstatechange();
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('resolves with the right result when ICE gathering is completed', async () => {
-      const promise = clusterReachability.start();
-
-      // send 1 candidate
-      await clock.tickAsync(30);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
-
-      fakePeerConnection.iceConnectionState = 'complete';
-      fakePeerConnection.onicegatheringstatechange();
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 30, clientMediaIPs: ['somePublicIp1']},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('should store latency only for the first srflx candidate, but IPs from all of them', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
-
-      // generate more candidates
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp3'}});
-
-      await clock.tickAsync(3000);// move the clock so that reachability times out
-
-      await promise;
-
-      // latency should be from only the first candidates, but the clientMediaIps should be from all UDP candidates (not TCP)
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2', 'somePublicIp3']},
-        tcp: {result: 'unreachable'},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('should store latency only for the first relay candidate', async () => {
-      const promise = clusterReachability.start();
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp1'}});
-
-      // generate more candidates
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp2'}});
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp3'}});
-
-      await clock.tickAsync(3000);// move the clock so that reachability times out
-
-      await promise;
-
-      // latency should be from only the first candidates, but the clientMediaIps should be from only from UDP candidates
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'unreachable'},
-        tcp: {result: 'reachable', latencyInMilliseconds: 10},
-        xtls: {result: 'untested'}
-      });
-    });
-
-    it('ignores duplicate clientMediaIps', async () => {
-      const promise = clusterReachability.start();
-
-      // generate candidates with duplicate addresses
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp1'}});
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
-
-      await clock.tickAsync(10);
-      fakePeerConnection.onicecandidate({candidate: {type: 'srflx', address: 'somePublicIp2'}});
-
-      // send also a relay candidate so that the reachability check finishes
-      fakePeerConnection.onicecandidate({candidate: {type: 'relay', address: 'someTurnRelayIp'}});
-
-      await promise;
-
-      assert.deepEqual(clusterReachability.getResult(), {
-        udp: {result: 'reachable', latencyInMilliseconds: 10, clientMediaIPs: ['somePublicIp1', 'somePublicIp2']},
-        tcp: {result: 'reachable', latencyInMilliseconds: 40},
-        xtls: {result: 'untested'}
-      });
-    });
-  });
-});

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/reachability/util.ts

@@ -1,40 +0,0 @@
-import {assert} from '@webex/test-helper-chai';
-
-import {convertStunUrlToTurn} from '@webex/plugin-meetings/src/reachability/util';
-
-describe('plugin-meetings/src/reachability/util', () => {
-  describe('#convertStunUrlToTurn()', () => {
-    [
-      {
-        title: 'a stun url with port',
-        stunUrl: 'stun:external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
-        expectedUrlPart: 'external-media91.public.wjfkm-a-10.prod.infra.webex.com:5004',
-      },
-      {
-        title: 'a stun url without port',
-        stunUrl: 'stun:something.somewhere.com',
-        expectedUrlPart: 'something.somewhere.com',
-      },
-    ].forEach(({title, stunUrl, expectedUrlPart}) => {
-      it(`should convert ${title} to a TCP turn url`, () => {
-        const turnUrl = convertStunUrlToTurn(stunUrl, 'tcp');
-
-        assert.equal(turnUrl, `turn:${expectedUrlPart}?transport=tcp`);
-      });
-
-      it(`should convert ${title} to a UDP turn url`, () => {
-        const turnUrl = convertStunUrlToTurn(stunUrl, 'udp');
-
-        assert.equal(turnUrl, `turn:${expectedUrlPart}`);
-      });
-    });
-
-    it('show fail if stunUrl is not a valid url', () => {
-      assert.throws(() => convertStunUrlToTurn('not a url', 'tcp'), 'Invalid URL: not a url');
-    });
-
-    it('show fail if stunUrl is not a STUN url', () => {
-      assert.throws(() => convertStunUrlToTurn('http://webex.com', 'tcp'), 'Not a STUN URL: http://webex.com');
-    });
-  });
-});