@webex/plugin-meetings 2.60.1-next.13 → 2.60.1-next.15

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

@@ -4,10 +4,15 @@ 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 FAKE_METRICS_ITEM = {payload: ['{"type":"string","value":"fake-metrics","id":""}']};
+const FAILURE_METRICS_ITEM = {
+  name: "onconnectionstatechange",
+  payload: ['{"type":"string","value":"failed","id":""}'],
+  timestamp: 1707929986667
+};
 
-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}';
+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;
@@ -82,6 +87,30 @@ describe('RtcMetrics', () => {
     assert.callCount(webex.request, 1);
   });
 
+  it('should clear out metrics on failure', () => {
+    assert.notCalled(webex.request);
+
+    metrics.addMetrics(FAILURE_METRICS_ITEM);
+
+    assert.callCount(webex.request, 1);
+  });
+
+  it('should have the same connectionId on success', () => {
+    const originalId = metrics.connectionId;
+
+    metrics.addMetrics(FAKE_METRICS_ITEM);
+
+    assert.strictEqual(originalId, metrics.connectionId);
+  });
+
+  it('should have a new connectionId on failure', () => {
+    const originalId = metrics.connectionId;
+
+    metrics.addMetrics(FAILURE_METRICS_ITEM);
+
+    assert.notEqual(originalId, metrics.connectionId);
+  });
+
   it('should anonymize IP addresses', () => {
     assert.strictEqual(metrics.anonymizeIp(STATS_WITH_IP), STATS_WITH_IP_RESULT);
   });

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

@@ -244,6 +244,7 @@ describe('plugin-meetings', () => {
       let statsAnalyzer;
       let mqeData;
       let loggerSpy;
+      let receiveSlot;
 
       let receivedEventsData = {
         local: {},
@@ -273,6 +274,7 @@ describe('plugin-meetings', () => {
 
       beforeEach(() => {
         clock = sinon.useFakeTimers();
+        receiveSlot = undefined;
 
         resetReceivedEvents();
 
@@ -437,7 +439,7 @@ describe('plugin-meetings', () => {
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, () => ({}), networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, () => (receiveSlot), networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -912,6 +914,442 @@ describe('plugin-meetings', () => {
 
         assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
       });
+
+      it('logs a message when no packets are recieved for a receive slot with sourceState "live"', async () => {
+        receiveSlot = {
+          sourceState:  'live',
+          csi: 2,
+          id: "4",
+        };
+
+        await startStatsAnalyzer();
+
+        // don't increase the packets when time progresses.
+        await progressTime();
+
+        assert.calledWith(loggerSpy, 'StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot id: "4" and csi: 2. Total packets received on slot: ', 0);
+      });
+
+      ["avatar", "invalid", "no source", "bandwidth limited", "policy violation"].forEach((sourceState) => {
+        it(`does not log a message when no packets are recieved for a receive slot with sourceState "${sourceState}"`, async () => {
+          receiveSlot = {
+            sourceState,
+            csi: 2,
+            id: "4",
+          };
+  
+          await startStatsAnalyzer();
+  
+          // don't increase the packets when time progresses.
+          await progressTime();
+  
+          assert.neverCalledWith(loggerSpy, 'StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot id: "4" and csi: 2. Total packets received on slot: ', 0);
+        });
+      });
+
+      it(`does not log a message if receiveSlot is undefined`, async () => {
+        await startStatsAnalyzer();
+
+        // don't increase the packets when time progresses.
+        await progressTime();
+
+        assert.neverCalledWith(loggerSpy, 'StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot "". Total packets received on slot: ', 0);
+      });
+
+      it('has the correct number of senders and receivers (2)', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.lengthOf(mqeData.audioTransmit, 2);
+        assert.lengthOf(mqeData.audioReceive, 2);
+        assert.lengthOf(mqeData.videoTransmit, 2);
+        assert.lengthOf(mqeData.videoReceive, 2);
+      });
+
+      it('has one stream per sender/reciever', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.deepEqual(
+          mqeData.audioTransmit[0].streams,
+          [
+            {
+              common: {
+                codec: 'opus',
+                csi: [],
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                transmittedBitrate: 0.13333333333333333,
+                transmittedFrameRate: 0
+              },
+              transmittedKeyFrames: 0,
+              requestedKeyFrames: 0
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.audioTransmit[1].streams,
+          [
+            {
+              common: {
+                codec: 'opus',
+                csi: [],
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                transmittedBitrate: 0.13333333333333333,
+                transmittedFrameRate: 0
+              },
+              transmittedKeyFrames: 0,
+              requestedKeyFrames: 0
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.audioReceive[0].streams,
+          [
+            {
+              common: {
+                codec: 'opus',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                maxRtpJitter: 0,
+                meanRtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                rtpJitter: 0,
+                framesDropped: 0,
+                framesReceived: 0
+              }
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.audioReceive[1].streams,
+          [
+            {
+              common: {
+                codec: 'opus',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                maxRtpJitter: 0,
+                meanRtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                rtpJitter: 0,
+                framesDropped: 0,
+                framesReceived: 0
+              }
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.videoTransmit[0].streams,
+          [
+            {
+              common: {
+                codec: 'H264',
+                csi: [],
+                duplicateSsci: 0,
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                transmittedBitrate: 0.13333333333333333,
+                transmittedFrameRate: 0
+              },
+              h264CodecProfile: 'BP',
+              isAvatar: false,
+              isHardwareEncoded: false,
+              localConfigurationChanges: 2,
+              maxFrameQp: 0,
+              maxNoiseLevel: 0,
+              minRegionQp: 0,
+              remoteConfigurationChanges: 0,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0,
+              transmittedFrameSize: 0,
+              transmittedHeight: 0,
+              transmittedKeyFrames: 0,
+              transmittedKeyFramesClient: 0,
+              transmittedKeyFramesConfigurationChange: 0,
+              transmittedKeyFramesFeedback: 0,
+              transmittedKeyFramesLocalDrop: 0,
+              transmittedKeyFramesOtherLayer: 0,
+              transmittedKeyFramesPeriodic: 0,
+              transmittedKeyFramesSceneChange: 0,
+              transmittedKeyFramesStartup: 0,
+              transmittedKeyFramesUnknown: 0,
+              transmittedWidth: 0
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.videoTransmit[1].streams,
+          [
+            {
+              common: {
+                codec: 'H264',
+                csi: [],
+                duplicateSsci: 0,
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                transmittedBitrate: 0.13333333333333333,
+                transmittedFrameRate: 0
+              },
+              h264CodecProfile: 'BP',
+              isAvatar: false,
+              isHardwareEncoded: false,
+              localConfigurationChanges: 2,
+              maxFrameQp: 0,
+              maxNoiseLevel: 0,
+              minRegionQp: 0,
+              remoteConfigurationChanges: 0,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0,
+              transmittedFrameSize: 0,
+              transmittedHeight: 0,
+              transmittedKeyFrames: 0,
+              transmittedKeyFramesClient: 0,
+              transmittedKeyFramesConfigurationChange: 0,
+              transmittedKeyFramesFeedback: 0,
+              transmittedKeyFramesLocalDrop: 0,
+              transmittedKeyFramesOtherLayer: 0,
+              transmittedKeyFramesPeriodic: 0,
+              transmittedKeyFramesSceneChange: 0,
+              transmittedKeyFramesStartup: 0,
+              transmittedKeyFramesUnknown: 0,
+              transmittedWidth: 0
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.videoReceive[0].streams,
+          [
+            {
+              common: {
+                codec: 'H264',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                rtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                framesDropped: 0
+              },
+              h264CodecProfile: 'BP',
+              isActiveSpeaker: true,
+              optimalFrameSize: 0,
+              receivedFrameSize: 3600,
+              receivedHeight: 720,
+              receivedKeyFrames: 0,
+              receivedKeyFramesForRequest: 0,
+              receivedKeyFramesSourceChange: 0,
+              receivedKeyFramesUnknown: 0,
+              receivedWidth: 1280,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0
+            }
+          ]
+        );
+        assert.deepEqual(
+          mqeData.videoReceive[1].streams,
+          [
+            {
+              common: {
+                codec: 'H264',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                rtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                framesDropped: 0
+              },
+              h264CodecProfile: 'BP',
+              isActiveSpeaker: true,
+              optimalFrameSize: 0,
+              receivedFrameSize: 3600,
+              receivedHeight: 720,
+              receivedKeyFrames: 0,
+              receivedKeyFramesForRequest: 0,
+              receivedKeyFramesSourceChange: 0,
+              receivedKeyFramesUnknown: 0,
+              receivedWidth: 1280,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0
+            }
+          ]
+        );
+      });
+      
+      it('has three streams for video receivers when three exist', async () => {
+        pc.getTransceiverStats = sinon.stub().resolves({
+          audio: {
+            senders: [fakeStats.audio.senders[0]],
+            receivers: [fakeStats.audio.receivers[0]],
+          },
+          video: {
+            senders: [fakeStats.video.senders[0]],
+            receivers: [fakeStats.video.receivers[0], fakeStats.video.receivers[0], fakeStats.video.receivers[0]],
+          },
+          screenShareAudio: {
+            senders: [fakeStats.audio.senders[0]],
+            receivers: [fakeStats.audio.receivers[0]],
+          },
+          screenShareVideo: {
+            senders: [fakeStats.video.senders[0]],
+            receivers: [fakeStats.video.receivers[0]],
+          },
+        });
+
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await progressTime();
+
+        assert.deepEqual(
+          mqeData.videoReceive[0].streams,
+          [
+            {
+              common: {
+                codec: 'H264',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                rtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                framesDropped: 0
+              },
+              h264CodecProfile: 'BP',
+              isActiveSpeaker: true,
+              optimalFrameSize: 0,
+              receivedFrameSize: 3600,
+              receivedHeight: 720,
+              receivedKeyFrames: 0,
+              receivedKeyFramesForRequest: 0,
+              receivedKeyFramesSourceChange: 0,
+              receivedKeyFramesUnknown: 0,
+              receivedWidth: 1280,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0
+            },
+            {
+              common: {
+                codec: 'H264',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                rtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                framesDropped: 0
+              },
+              h264CodecProfile: 'BP',
+              isActiveSpeaker: true,
+              optimalFrameSize: 0,
+              receivedFrameSize: 3600,
+              receivedHeight: 720,
+              receivedKeyFrames: 0,
+              receivedKeyFramesForRequest: 0,
+              receivedKeyFramesSourceChange: 0,
+              receivedKeyFramesUnknown: 0,
+              receivedWidth: 1280,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0
+            },
+            {
+              common: {
+                codec: 'H264',
+                concealedFrames: 0,
+                csi: [],
+                maxConcealRunLength: 0,
+                optimalBitrate: 0,
+                optimalFrameRate: 0,
+                receivedBitrate: 0.13333333333333333,
+                receivedFrameRate: 0,
+                renderedFrameRate: 0,
+                requestedBitrate: 0,
+                requestedFrameRate: 0,
+                rtpEndToEndLost: 0,
+                rtpJitter: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                framesDropped: 0
+              },
+              h264CodecProfile: 'BP',
+              isActiveSpeaker: true,
+              optimalFrameSize: 0,
+              receivedFrameSize: 3600,
+              receivedHeight: 720,
+              receivedKeyFrames: 0,
+              receivedKeyFramesForRequest: 0,
+              receivedKeyFramesSourceChange: 0,
+              receivedKeyFramesUnknown: 0,
+              receivedWidth: 1280,
+              requestedFrameSize: 0,
+              requestedKeyFrames: 0
+            }
+          ]
+        );
+      });
     });
   });
 });

package/test/utils/webex-test-users.js

@@ -17,7 +17,7 @@ require('@webex/plugin-people');
 require('@webex/plugin-rooms');
 require('@webex/plugin-meetings');
 
-const generateTestUsers = (options = {}) => {
+const generateTestUsers = async (options = {}) => {
   options.config = options.config || {};
   options.config.orgId = options.config.orgId || process.env.WEBEX_CONVERGED_ORG_ID;
 
@@ -30,7 +30,8 @@ const generateTestUsers = (options = {}) => {
       // Pause for 5 seconds for CI
       await new Promise((done) => setTimeout(done, 5000));
 
-      const userRegisterPromises = [];
+      const webexRegisterPromises = [];
+      const userWebexMeetings = [];
 
       userSet.forEach((user) => {
         // eslint-disable-next-line no-param-reassign
@@ -44,12 +45,19 @@ const generateTestUsers = (options = {}) => {
           },
         });
 
+        webexRegisterPromises.push(new Promise((resolve) => {
+          user.webex.on('ready', resolve);
+        }));
+
         user.webex.internal.support.submitLogs = sinon.stub().returns(Promise.resolve());
 
-        userRegisterPromises.push(user.webex.meetings.register());
+        userWebexMeetings.push(user.webex.meetings);
       });
 
-      return Promise.all(userRegisterPromises).then(() => userSet);
+      // wait for webex to be ready before registering meetings
+      return Promise.all(webexRegisterPromises).then(() => {
+        return Promise.all(userWebexMeetings.map(m => m.register())).then(() => userSet);
+      })
     })
     .catch((error) => {
       console.error('#generateTestUsers=>ERROR', error);