@webex/plugin-meetings 3.0.0-beta.3 → 3.0.0-beta.300

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

@@ -2,7 +2,7 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import {MediaConnection as MC} from '@webex/internal-media-core';
+import {ConnectionState} from '@webex/internal-media-core';
 
 import {StatsAnalyzer, EVENTS} from '../../../../src/statsAnalyzer';
 import NetworkQualityMonitor from '../../../../src/networkQualityMonitor';
@@ -20,31 +20,32 @@ describe('plugin-meetings', () => {
       let sandBoxSpy;
 
       const initialConfig = {
-        videoPacketLossRatioThreshold: 9
+        videoPacketLossRatioThreshold: 9,
       };
 
       const defaultStats = {
+        resolutions: {},
         internal: {
-          video: {
+          'video-send-1': {
             send: {
-              totalPacketsLostOnReceiver: 10
-            }
-          }
+              totalPacketsLostOnReceiver: 10,
+            },
+          },
         },
-        video: {
+        'video-send-1': {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
-            meanRoundTripTime: []
-          }
-        }
+            meanRoundTripTime: [],
+          },
+        },
       };
 
       const statusResult = {
         type: 'remote-inbound-rtp',
         packetsLost: 11,
         rttThreshold: 501,
-        jitterThreshold: 501
+        jitterThreshold: 501,
       };
 
       const sandbox = sinon.createSandbox();
@@ -52,9 +53,17 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
-
-        sandBoxSpy = sandbox.spy(statsAnalyzer.networkQualityMonitor, 'determineUplinkNetworkQuality');
+        statsAnalyzer = new StatsAnalyzer(
+          initialConfig,
+          () => ({}),
+          networkQualityMonitor,
+          defaultStats
+        );
+
+        sandBoxSpy = sandbox.spy(
+          statsAnalyzer.networkQualityMonitor,
+          'determineUplinkNetworkQuality'
+        );
       });
 
       afterEach(() => {
@@ -62,14 +71,16 @@ 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',
-          remoteRtpResults: statusResult,
-          statsAnalyzerCurrentStats: statsAnalyzer.statsResults
-        }));
+        assert(
+          sandBoxSpy.calledWith({
+            mediaType: 'video-send-1',
+            remoteRtpResults: statusResult,
+            statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
+          })
+        );
       });
     });
 
@@ -78,6 +89,7 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
+      let mqeData;
 
       let receivedEventsData = {
         local: {},
@@ -105,57 +117,143 @@ 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: [
+              {
+                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: [
+              {
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    framesSent: 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',
+                    framesDecoded: 0,
+                    bytesReceived: 1,
+                    frameHeight: 720,
+                    frameWidth: 1280,
+                    framesReceived: 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'
+                  },
+                ],
+              },
+            ],
+          },
         };
 
         pc = {
-          getConnectionState: sinon.stub().returns(MC.ConnectionState.Connected),
+          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
           getTransceiverStats: sinon.stub().resolves({
             audio: {
-              sender: [fakeStats.audio.sender],
-              receiver: [fakeStats.audio.receiver],
-              currentDirection: 'sendrecv',
-              localTrackLabel: 'fake mic',
+              senders: [fakeStats.audio.senders[0]],
+              receivers: [fakeStats.audio.receivers[0]],
             },
             video: {
-              sender: [fakeStats.video.sender],
-              receiver: [fakeStats.video.receiver],
-              currentDirection: 'sendrecv',
-              localTrackLabel: 'fake camera',
+              senders: [fakeStats.video.senders[0]],
+              receivers: [fakeStats.video.receivers[0]],
+            },
+            screenShareAudio: {
+              senders: [],
+              receivers: [],
             },
             screenShareVideo: {
-              sender: [],
-              receiver: [],
-              currentDirection: 'sendrecv'
-            }
-          })
+              senders: [],
+              receivers: [],
+            },
+          }),
         };
 
         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;
@@ -169,6 +267,9 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
+        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
+          mqeData = data;
+        });
       });
 
       afterEach(() => {
@@ -195,6 +296,12 @@ describe('plugin-meetings', () => {
         assert.deepEqual(receivedEventsData.remote.stopped, expected.remote?.stopped);
       };
 
+      const checkMqeData = () => {
+        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}});
 
@@ -202,7 +309,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();
 
@@ -222,7 +329,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();
 
@@ -242,7 +349,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
@@ -262,7 +369,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
@@ -274,6 +381,38 @@ describe('plugin-meetings', () => {
 
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
+
+      it('emits the correct MEDIA_QUALITY events', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        // Check that the mqe data has been emitted and is correctly computed.
+        checkMqeData();
+      });
+
+      it('emits the correct transportType in MEDIA_QUALITY events', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TCP');
+        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TCP');
+      });
+
+      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';
+
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TLS');
+        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TLS');
+      });
     });
   });
 });

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/cmr.js

@@ -1,4 +1,3 @@
-
 import uuid from 'uuid';
 import retry from '@webex/test-helper-retry';
 
@@ -23,16 +22,16 @@ CMR.reserve = (webex, claimed) => {
       authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
       'cisco-no-http-redirect': null,
       'spark-user-agent': null,
-      trackingid: `ITCLIENT_${uuid.v4()}_0_imi:true`
+      trackingid: `ITCLIENT_${uuid.v4()}_0_imi:true`,
     },
     body: {
       resourceType,
       requestMetaData: {
         emailAddress: `test${uuid.v4()}@wx2.example.com`,
-        loginType: 'loginGuest'
+        loginType: 'loginGuest',
       },
-      reservedBy: 'Webex JavaScript SDK Test Suite'
-    }
+      reservedBy: 'Webex JavaScript SDK Test Suite',
+    },
   };
 
   if (claimed) {
@@ -40,7 +39,8 @@ CMR.reserve = (webex, claimed) => {
   }
   console.log('USER ID ', webex.internal.device.userId);
 
-  return webex.request(requestBody)
+  return webex
+    .request(requestBody)
     .then((response) => {
       const cmr = response.body;
 
@@ -56,47 +56,49 @@ CMR.reserve = (webex, claimed) => {
 CMR.release = (webex, reservationUrl) => {
   console.log('releasing cmr');
 
-  return webex.request({
-    method: 'DELETE',
-    uri: reservationUrl,
-    headers: {
-      authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
-      'cisco-no-http-redirect': null,
-      'spark-user-agent': null
-    }
-  })
+  return webex
+    .request({
+      method: 'DELETE',
+      uri: reservationUrl,
+      headers: {
+        authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
+        'cisco-no-http-redirect': null,
+        'spark-user-agent': null,
+      },
+    })
     .then(() => console.log('released cmr'));
 };
 
-CMR.waitForHostToJoin = (webex, resourceUrl) => retry(() => {
-  console.log('checking if the host has joined');
-
-  return webex.request({
-    method: 'GET',
-    uri: resourceUrl,
-    headers: {
-      authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
-      'cisco-no-http-redirect': null,
-      'spark-user-agent': null
-    }
+CMR.waitForHostToJoin = (webex, resourceUrl) =>
+  retry(() => {
+    console.log('checking if the host has joined');
+
+    return webex
+      .request({
+        method: 'GET',
+        uri: resourceUrl,
+        headers: {
+          authorization: `Bearer ${webex.credentials.supertoken.access_token}`,
+          'cisco-no-http-redirect': null,
+          'spark-user-agent': null,
+        },
+      })
+      .then((res) => {
+        if (res.body && res.body.meeting.hostPresent) {
+          console.log('the host has joined');
+
+          return;
+        }
+
+        console.log('the host has not joined');
+        throw new Error('Meeting host has not yet joined');
+      });
   })
-    .then((res) => {
-      if (res.body && res.body.meeting.hostPresent) {
-        console.log('the host has joined');
+    .then(() => true)
+    .catch((reason) => {
+      console.warn(reason);
 
-        return;
-      }
-
-      console.log('the host has not joined');
-      throw new Error('Meeting host has not yet joined');
+      return false;
     });
-})
-  .then(() => true)
-  .catch((reason) => {
-    console.warn(reason);
-
-    return false;
-  });
-
 
 export default CMR;

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',
+};

package/test/utils/integrationTestUtils.js

@@ -0,0 +1,46 @@
+import {assert} from '@webex/test-helper-chai';
+import {Defer} from '@webex/common';
+
+const addMedia = async (user, options = {}) => {
+
+  const {microphone, camera} = options;
+
+  if (options.multistream) {
+    await user.meeting.addMedia({localStreams: {microphone, camera}});
+  } else {
+    const mediaReadyPromises = Array.isArray(options.expectedMediaReadyTypes)
+      ? options.expectedMediaReadyTypes.reduce((output, expectedMediaReadyType) => {
+        if (typeof expectedMediaReadyType !== 'string') {
+          return output;
+        }
+
+        output[expectedMediaReadyType] = new Defer();
+
+        return output;
+      }, {})
+      : {remoteAudio: new Defer(), remoteVideo: new Defer()};
+
+    const mediaReady = (media) => {
+      if (!media) {
+        return;
+      }
+      if (mediaReadyPromises[media.type]) {
+        mediaReadyPromises[media.type].resolve();
+      }
+    };
+
+    user.meeting.on('media:ready', mediaReady);
+
+    await user.meeting.addMedia({localStreams: {microphone, camera}});
+    await Promise.all(Object.values(mediaReadyPromises).map((defer) => defer.promise));
+ };
+
+
+  assert.exists(user.meeting.mediaProperties.audioStream, 'audioStream not present');
+  assert.exists(user.meeting.mediaProperties.videoStream, 'videoStream not present');
+
+};
+
+export default {
+  addMedia
+};