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

package/test/unit/spec/stats-analyzer/index.js

@@ -2,10 +2,12 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
+import {ConnectionState} from '@webex/internal-media-core';
 
 import {StatsAnalyzer, EVENTS} from '../../../../src/statsAnalyzer';
 import NetworkQualityMonitor from '../../../../src/networkQualityMonitor';
 import testUtils from '../../../utils/testUtils';
+import {MEDIA_DEVICES, _UNKNOWN_} from '@webex/plugin-meetings/src/constants';
 
 const {assert} = chai;
 
@@ -23,14 +25,15 @@ describe('plugin-meetings', () => {
       };
 
       const defaultStats = {
+        resolutions: {},
         internal: {
-          video: {
+          'video-send-1': {
             send: {
               totalPacketsLostOnReceiver: 10,
             },
           },
         },
-        video: {
+        'video-send-1': {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
@@ -51,7 +54,12 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
+        statsAnalyzer = new StatsAnalyzer(
+          initialConfig,
+          () => ({}),
+          networkQualityMonitor,
+          defaultStats
+        );
 
         sandBoxSpy = sandbox.spy(
           statsAnalyzer.networkQualityMonitor,
@@ -64,12 +72,12 @@ describe('plugin-meetings', () => {
       });
 
       it('should trigger determineUplinkNetworkQuality with specific arguments', async () => {
-        await statsAnalyzer.parseGetStatsResult(statusResult, 'video');
+        await statsAnalyzer.parseGetStatsResult(statusResult, 'video-send-1', true);
 
         assert.calledOnce(statsAnalyzer.networkQualityMonitor.determineUplinkNetworkQuality);
         assert(
           sandBoxSpy.calledWith({
-            mediaType: 'video',
+            mediaType: 'video-send-1',
             remoteRtpResults: statusResult,
             statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
           })
@@ -82,22 +90,7 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
-      const statusResultOutboundRTP = {
-        type: 'outbound-rtp',
-        frameHeight: 720,
-        frameWidth: 1280,
-        packetsLost: 11,
-        framesSent: 105,
-        hugeFramesSent: 1,
-        framesEncoded: 102,
-        rttThreshold: 501,
-        jitterThreshold: 501,
-        jitterBufferDelay: 288.131459,
-        jitterBufferEmittedCount: 4013,
-        trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
-        bytesSent: 1233,
-        totalPacketsSent: 100,
-      };
+      let mqeData;
 
       let receivedEventsData = {
         local: {},
@@ -125,61 +118,145 @@ describe('plugin-meetings', () => {
         // bytesReceived and bytesSent need to be non-zero in order for StatsAnalyzer to parse any other values
         fakeStats = {
           audio: {
-            receiver: {
-              type: 'inbound-rtp',
-              packetsReceived: 0,
-              bytesReceived: 1,
-            },
-            sender: {
-              type: 'outbound-rtp',
-              packetsSent: 0,
-              bytesSent: 1,
-            },
+            senders: [
+              {
+                localTrackLabel: 'fake-microphone',
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    packetsSent: 0,
+                    bytesSent: 1,
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'succeeded',
+                    localCandidateId: 'fake-candidate-id',
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'failed',
+                    localCandidateId: 'bad-candidate-id',
+                  },
+                  {
+                    type: 'local-candidate',
+                    id: 'fake-candidate-id',
+                    protocol: 'tcp',
+                  },
+                ],
+              },
+            ],
+            receivers: [
+              {
+                report: [
+                  {
+                    type: 'inbound-rtp',
+                    packetsReceived: 0,
+                    bytesReceived: 1,
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'succeeded',
+                    localCandidateId: 'fake-candidate-id',
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'failed',
+                    localCandidateId: 'bad-candidate-id',
+                  },
+                  {
+                    type: 'local-candidate',
+                    id: 'fake-candidate-id',
+                    protocol: 'tcp',
+                  },
+                ],
+              },
+            ],
           },
           video: {
-            receiver: {
-              type: 'inbound-rtp',
-              framesDecoded: 0,
-              bytesReceived: 1,
-            },
-            sender: {
-              type: 'outbound-rtp',
-              framesSent: 0,
-              bytesSent: 1,
-            },
+            senders: [
+              {
+                localTrackLabel: 'fake-camera',
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    framesSent: 1500,
+                    bytesSent: 1,
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'succeeded',
+                    localCandidateId: 'fake-candidate-id',
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'failed',
+                    localCandidateId: 'bad-candidate-id',
+                  },
+                  {
+                    type: 'local-candidate',
+                    id: 'fake-candidate-id',
+                    protocol: 'tcp',
+                  },
+                ],
+              },
+            ],
+            receivers: [
+              {
+                report: [
+                  {
+                    type: 'inbound-rtp',
+                    framesDecoded: 0,
+                    bytesReceived: 1,
+                    frameHeight: 720,
+                    frameWidth: 1280,
+                    framesReceived: 1500,
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'succeeded',
+                    localCandidateId: 'fake-candidate-id',
+                  },
+                  {
+                    type: 'candidate-pair',
+                    state: 'failed',
+                    localCandidateId: 'bad-candidate-id',
+                  },
+                  {
+                    type: 'local-candidate',
+                    id: 'fake-candidate-id',
+                    protocol: 'tcp',
+                  },
+                ],
+              },
+            ],
           },
         };
 
         pc = {
-          audioTransceiver: {
-            sender: {
-              getStats: sinon.stub().resolves([fakeStats.audio.sender]),
-            },
-            receiver: {
-              getStats: sinon.stub().resolves([fakeStats.audio.receiver]),
-            },
-          },
-          videoTransceiver: {
-            sender: {
-              getStats: sinon.stub().resolves([fakeStats.video.sender]),
+          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
+          getTransceiverStats: sinon.stub().resolves({
+            audio: {
+              senders: [fakeStats.audio.senders[0]],
+              receivers: [fakeStats.audio.receivers[0]],
             },
-            receiver: {
-              getStats: sinon.stub().resolves([fakeStats.video.receiver]),
+            video: {
+              senders: [fakeStats.video.senders[0]],
+              receivers: [fakeStats.video.receivers[0]],
             },
-          },
-          shareTransceiver: {
-            sender: {
-              getStats: sinon.stub().resolves([]),
+            screenShareAudio: {
+              senders: [fakeStats.audio.senders[0]],
+              receivers: [fakeStats.audio.receivers[0]],
             },
-            receiver: {
-              getStats: sinon.stub().resolves([]),
+            screenShareVideo: {
+              senders: [fakeStats.video.senders[0]],
+              receivers: [fakeStats.video.receivers[0]],
             },
-          },
+          }),
         };
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, () => ({}), networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -193,11 +270,8 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
-        statsAnalyzer.on(EVENTS.NO_FRAMES_SENT, (data) => {
-          receivedEventsData.noFramesSent = data;
-        });
-        statsAnalyzer.on(EVENTS.NO_VIDEO_ENCODED, (data) => {
-          receivedEventsData.noVideoEncoded = data;
+        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
+          mqeData = data;
         });
       });
 
@@ -212,6 +286,19 @@ describe('plugin-meetings', () => {
         await testUtils.flushPromises();
       };
 
+      const mergeProperties = (target, properties, keyValue = 'fake-candidate-id', matchKey= 'type', matchValue = 'local-candidate') => {
+        for (let key in target) {
+            if (target.hasOwnProperty(key)) {
+                if (typeof target[key] === 'object') {
+                    mergeProperties(target[key], properties, keyValue, matchKey, matchValue);
+                }
+                if (key === 'id' && target[key] === keyValue && target[matchKey] === matchValue) {
+                    Object.assign(target, properties);
+                }
+            }
+        }
+    }
+
       const progressTime = async () => {
         await clock.tickAsync(initialConfig.analyzerInterval);
         await testUtils.flushPromises();
@@ -225,6 +312,23 @@ describe('plugin-meetings', () => {
         assert.deepEqual(receivedEventsData.remote.stopped, expected.remote?.stopped);
       };
 
+      const checkMqeData = () => {
+        for (const data of [
+          mqeData.audioTransmit,
+          mqeData.audioReceive,
+          mqeData.videoTransmit,
+          mqeData.videoReceive,
+        ]) {
+          assert.strictEqual(data.length, 2);
+          assert.strictEqual(data[0].common.common.isMain, true);
+          assert.strictEqual(data[1].common.common.isMain, false);
+        }
+
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedFrameSize, 3600);
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedHeight, 720);
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedWidth, 1280);
+      };
+
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for audio', async () => {
         await startStatsAnalyzer({expected: {sendAudio: true}});
 
@@ -232,7 +336,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.sender.packetsSent += 10;
+        fakeStats.audio.senders[0].report[0].packetsSent += 10;
 
         await progressTime();
 
@@ -252,7 +356,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.sender.framesSent += 1;
+        fakeStats.video.senders[0].report[0].framesSent += 1;
 
         await progressTime();
 
@@ -272,7 +376,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.receiver.packetsReceived += 5;
+        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for audio
@@ -292,7 +396,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.receiver.framesDecoded += 1;
+        fakeStats.video.receivers[0].report[0].framesDecoded += 1;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for video
@@ -305,133 +409,123 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
 
-      const checkStats = (type) => {
-        const statsResult = {
-          height: 720,
-          width: 1280,
-          jitterBufferDelay: 288.131459,
-          jitterBufferEmittedCount: 4013,
-          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
-          avgJitterDelay: 0.07179951632195365,
-        };
-        if (type === 'inbound-rtp') {
-          statsResult.framesDecoded = 4013;
-          statsResult.framesDropped = 0;
-          statsResult.framesReceived = 4016;
-          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.recv, statsResult);
-        } else if (type === 'outbound-rtp') {
-          statsResult.framesSent = 105;
-          statsResult.hugeFramesSent = 1;
-          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.send, statsResult);
-        }
-      };
-
-      it('processes track results and populate statsResults.resolutions object when type is inbound-rtp with video', async () => {
+      it('emits the correct MEDIA_QUALITY events', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
-        const statusResultInboundRTP = {
-          type: 'inbound-rtp',
-          frameHeight: 720,
-          frameWidth: 1280,
-          packetsLost: 11,
-          rttThreshold: 501,
-          jitterThreshold: 501,
-          framesDecoded: 4013,
-          framesDropped: 0,
-          framesReceived: 4016,
-          jitterBufferDelay: 288.131459,
-          jitterBufferEmittedCount: 4013,
-          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
-        };
-        await statsAnalyzer.parseGetStatsResult(statusResultInboundRTP, 'video');
-        checkStats('inbound-rtp');
+
+        await progressTime();
+
+        // Check that the mqe data has been emitted and is correctly computed.
+        checkMqeData();
       });
-      it('processes track results and populate statsResults.resolutions object when type is outbound-rtp with video', async () => {
+
+      it('emits the correct transportType in MEDIA_QUALITY events', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
-        checkStats('outbound-rtp');
-      });
+        await progressTime();
 
-      it('doesnot processes track results with audio', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'audio');
-        assert.deepEqual(statsAnalyzer.statsResults.resolutions.audio, undefined);
+        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TCP');
+        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TCP');
       });
 
-      it('emits NO_FRAMES_ENCODED when frames are not being encoded', async () => {
-        const expected = {mediaType: 'video'};
-        await startStatsAnalyzer({expected: {sendVideo: true}});
+      it('emits the correct transportType in MEDIA_QUALITY events when using a TURN server', async () => {
+        fakeStats.audio.senders[0].report[3].relayProtocol = 'tls';
+        fakeStats.video.senders[0].report[3].relayProtocol = 'tls';
+        fakeStats.audio.receivers[0].report[3].relayProtocol = 'tls';
+        fakeStats.video.receivers[0].report[3].relayProtocol = 'tls';
 
-        statsAnalyzer.lastStatsResults.video.send = {framesEncoded: 102, totalPacketsSent: 106};
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        await progressTime();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
+        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TLS');
+        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TLS');
       });
 
-      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
-
-        const expected = {mediaType: 'video'};
+      it('emits the correct peripherals in MEDIA_QUALITY events', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        statsAnalyzer.lastStatsResults.video.send = {
-          framesEncoded: 10,
-          framesSent: 105,
-          totalPacketsSent: 106,
-        };
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        await progressTime();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noFramesSent, expected);
+        assert.strictEqual(
+          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
+            .information,
+          'fake-microphone'
+        );
+        assert.strictEqual(
+          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
+            .information,
+          'fake-camera'
+        );
       });
 
-      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED', async () => {
-        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
+      it('emits the correct peripherals in MEDIA_QUALITY events when localTrackLabel is undefined', async () => {
+        fakeStats.audio.senders[0].localTrackLabel = undefined;
+        fakeStats.video.senders[0].localTrackLabel = undefined;
 
-        await startStatsAnalyzer({expected: {sendVideo: true}});
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
+        assert.strictEqual(
+          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
+            .information,
+          _UNKNOWN_
+        );
+        assert.strictEqual(
+          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
+            .information,
+          _UNKNOWN_
+        );
       });
 
-      it('emits NO_FRAMES_ENCODED when frames are not being encoded for share', async () => {
-        const expected = {mediaType: 'share'};
-        await startStatsAnalyzer({expected: {sendShare: true}});
+      it('emits the correct frameRate', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        statsAnalyzer.lastStatsResults.share.send = {framesEncoded: 102, totalPacketsSent: 106};
+        await progressTime();
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 25);
+        fakeStats.video.receivers[0].framesReceived = 3000;
+        await progressTime();
+        assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 25);
+      });
 
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+      it('has the correct localIpAddress set when the candidateType is host', async () => {
+        await startStatsAnalyzer();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
+        mergeProperties(fakeStats, {address: 'test', candidateType: 'host'});
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'test');
       });
 
-      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded for share', async () => {
-        const expected = {mediaType: 'share'};
-        await startStatsAnalyzer({expected: {sendShare: true}});
+      it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is set', async () => {
+        await startStatsAnalyzer();
 
-        statsAnalyzer.lastStatsResults.share.send = {
-          framesEncoded: 10,
-          framesSent: 105,
-          totalPacketsSent: 106,
-        };
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
+        mergeProperties(fakeStats, {relayProtocol: 'test', address: 'test2', candidateType: 'prflx'});
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'test2');
+      });
 
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+      it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is not set', async () => {
+        await startStatsAnalyzer();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noFramesSent, expected);
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
+        mergeProperties(fakeStats, {relatedAddress: 'relatedAddress', address: 'test2', candidateType: 'prflx'});
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'relatedAddress');
       });
 
-      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED for share', async () => {
-        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
-
-        await startStatsAnalyzer({expected: {sendShare: true}});
-        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+      it('has no localIpAddress set when the candidateType is invalid', async () => {
+        await startStatsAnalyzer();
 
-        statsAnalyzer.compareLastStatsResult();
-        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
+        mergeProperties(fakeStats, {candidateType: 'invalid'});
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
       });
     });
   });

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

@@ -0,0 +1,13 @@
+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');
+        });
+    });
+});

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

@@ -0,0 +1,60 @@
+import {assert, expect} from '@webex/test-helper-chai';
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+import Webinar from '@webex/plugin-meetings/src/webinar';
+import MockWebex from '@webex/test-helper-mock-webex';
+import sinon from 'sinon';
+
+describe('plugin-meetings', () => {
+    describe('Webinar', () => {
+
+        let webex;
+        let webinar;
+
+        beforeEach(() => {
+            // @ts-ignore
+            webex = new MockWebex({});
+            webex.internal.mercury.on = sinon.stub();
+            webinar = new Webinar({}, {parent: webex});
+            webinar.locusUrl = 'locusUrl';
+            webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+            webex.meetings = {};
+            webex.meetings.getMeetingByType = sinon.stub();
+        });
+
+        describe('#locusUrlUpdate', () => {
+            it('sets the locus url', () => {
+                webinar.locusUrlUpdate('newUrl');
+
+                assert.equal(webinar.locusUrl, 'newUrl');
+            });
+        });
+
+        describe('#webcastUrlUpdate', () => {
+            it('sets the webcast url', () => {
+                webinar.webcastUrlUpdate('newUrl');
+
+                assert.equal(webinar.webcastUrl, 'newUrl');
+            });
+        });
+
+        describe('#webinarAttendeesSearchingUrlUpdate', () => {
+            it('sets the webinarAttendeesSearching url', () => {
+                webinar.webinarAttendeesSearchingUrlUpdate('newUrl');
+
+                assert.equal(webinar.webinarAttendeesSearchingUrl, 'newUrl');
+            });
+        });
+
+        describe('#updateCanManageWebcast', () => {
+          it('update canManageWebcast', () => {
+            webinar.updateCanManageWebcast(true);
+
+            assert.equal(webinar.canManageWebcast, true);
+
+            webinar.updateCanManageWebcast(false);
+
+            assert.equal(webinar.canManageWebcast, false);
+          });
+        });
+    })
+})

package/test/utils/constants.js

@@ -0,0 +1,9 @@
+// MOVE TO TEST CONSTANTS
+export const MEDIA_SERVERS = {
+  // The homer media server for converged multistream meetings.
+  HOMER: 'homer',
+  // The linus media server
+  LINUS: 'linus',
+  // The calliope media server for transcoded meetings
+  CALLIOPE: 'calliope',
+};