@webex/plugin-meetings 2.60.1-next.16 → 2.60.1-next.18

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

@@ -42,126 +42,156 @@ describe('plugin-meetings', () => {
 
       it('should call processOutboundRTPResult', () => {
         const calledSpy = sandbox.spy(statsAnalyzer, 'processOutboundRTPResult');
-        statsAnalyzer.parseGetStatsResult({ type: 'outbound-rtp' }, 'video-send');
+        statsAnalyzer.parseGetStatsResult({type: 'outbound-rtp'}, 'video-send');
         assert(calledSpy.calledOnce);
       });
 
       it('should call processInboundRTPResult', () => {
         const calledSpy = sandbox.spy(statsAnalyzer, 'processInboundRTPResult');
-        statsAnalyzer.parseGetStatsResult({ type: 'inbound-rtp' }, 'video-recv');
+        statsAnalyzer.parseGetStatsResult({type: 'inbound-rtp'}, 'video-recv');
         assert(calledSpy.calledOnce);
       });
 
       it('should call compareSentAndReceived', () => {
         const calledSpy = sandbox.spy(statsAnalyzer, 'compareSentAndReceived');
-        statsAnalyzer.parseGetStatsResult({ type: 'remote-outbound-rtp' }, 'video-send');
+        statsAnalyzer.parseGetStatsResult({type: 'remote-outbound-rtp'}, 'video-send');
         assert(calledSpy.calledOnce);
       });
 
       it('should call parseCandidate', () => {
         const calledSpy = sandbox.spy(statsAnalyzer, 'parseCandidate');
-        statsAnalyzer.parseGetStatsResult({ type: 'local-candidate' }, 'video-send');
+        statsAnalyzer.parseGetStatsResult({type: 'local-candidate'}, 'video-send');
         assert(calledSpy.calledOnce);
       });
 
       it('processOutboundRTPResult should create the correct stats results', () => {
         // establish the `statsResults` object.
-        statsAnalyzer.parseGetStatsResult({ type: 'none' }, 'audio-send', true);
-
-        statsAnalyzer.processOutboundRTPResult({
-          bytesSent: 50000,
-          codecId: "RTCCodec_1_Outbound_111",
-          headerBytesSent: 25000,
-          id: "RTCOutboundRTPAudioStream_123456789",
-          kind: "audio",
-          mediaSourceId: "RTCAudioSource_2",
-          mediaType: "audio",
-          nackCount: 1,
-          packetsSent: 3600,
-          remoteId: "RTCRemoteInboundRtpAudioStream_123456789",
-          retransmittedBytesSent: 100,
-          retransmittedPacketsSent: 2,
-          ssrc: 123456789,
-          targetBitrate: 256000,
-          timestamp: 1707341489336,
-          trackId: "RTCMediaStreamTrack_sender_2",
-          transportId: "RTCTransport_0_1",
-          type: "outbound-rtp",
-        }, 'audio-send', true);
+        statsAnalyzer.parseGetStatsResult({type: 'none'}, 'audio-send', true);
+
+        statsAnalyzer.processOutboundRTPResult(
+          {
+            bytesSent: 50000,
+            codecId: 'RTCCodec_1_Outbound_111',
+            headerBytesSent: 25000,
+            id: 'RTCOutboundRTPAudioStream_123456789',
+            kind: 'audio',
+            mediaSourceId: 'RTCAudioSource_2',
+            mediaType: 'audio',
+            nackCount: 1,
+            packetsSent: 3600,
+            remoteId: 'RTCRemoteInboundRtpAudioStream_123456789',
+            retransmittedBytesSent: 100,
+            retransmittedPacketsSent: 2,
+            ssrc: 123456789,
+            targetBitrate: 256000,
+            timestamp: 1707341489336,
+            trackId: 'RTCMediaStreamTrack_sender_2',
+            transportId: 'RTCTransport_0_1',
+            type: 'outbound-rtp',
+          },
+          'audio-send',
+          true
+        );
 
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.headerBytesSent, 25000);
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalBytesSent, 50000);
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalNackCount, 1);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalPacketsSent, 3600)
-        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.retransmittedPacketsSent, 2);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.retransmittedBytesSent, 100);
+        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalPacketsSent, 3600);
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-send'].send.retransmittedPacketsSent,
+          2
+        );
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-send'].send.retransmittedBytesSent,
+          100
+        );
       });
 
       it('processInboundRTPResult should create the correct stats results', () => {
         // establish the `statsResults` object.
-        statsAnalyzer.parseGetStatsResult({ type: 'none' }, 'audio-recv-1', false);
-
-        statsAnalyzer.processInboundRTPResult({
-          audioLevel: 0,
-          bytesReceived: 509,
-          codecId: "RTCCodec_6_Inbound_111",
-          concealedSamples: 200000,
-          concealmentEvents: 13,
-          fecPacketsDiscarded: 1,
-          fecPacketsReceived: 1,
-          headerBytesReceived: 250,
-          id: "RTCInboundRTPAudioStream_123456789",
-          insertedSamplesForDeceleration: 0,
-          jitter: 0.012,
-          jitterBufferDelay: 1000,
-          jitterBufferEmittedCount: 10000,
-          kind: "audio",
-          lastPacketReceivedTimestamp: 1707341488529,
-          mediaType: "audio",
-          packetsDiscarded: 0,
-          packetsLost: 0,
-          packetsReceived: 12,
-          remoteId: "RTCRemoteOutboundRTPAudioStream_123456789",
-          removedSamplesForAcceleration: 0,
-          silentConcealedSamples: 200000,
-          ssrc: 123456789,
-          timestamp: 1707341489419,
-          totalAudioEnergy: 133,
-          totalSamplesDuration: 7,
-          totalSamplesReceived: 300000,
-          trackId: "RTCMediaStreamTrack_receiver_76",
-          transportId: "RTCTransport_0_1",
-          type: "inbound-rtp",
-        }, 'audio-recv-1', false);
-
-        assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalPacketsReceived, 12);
+        statsAnalyzer.parseGetStatsResult({type: 'none'}, 'audio-recv-1', false);
+
+        statsAnalyzer.processInboundRTPResult(
+          {
+            audioLevel: 0,
+            bytesReceived: 509,
+            codecId: 'RTCCodec_6_Inbound_111',
+            concealedSamples: 200000,
+            concealmentEvents: 13,
+            fecPacketsDiscarded: 1,
+            fecPacketsReceived: 1,
+            headerBytesReceived: 250,
+            id: 'RTCInboundRTPAudioStream_123456789',
+            insertedSamplesForDeceleration: 0,
+            jitter: 0.012,
+            jitterBufferDelay: 1000,
+            jitterBufferEmittedCount: 10000,
+            kind: 'audio',
+            lastPacketReceivedTimestamp: 1707341488529,
+            mediaType: 'audio',
+            packetsDiscarded: 0,
+            packetsLost: 0,
+            packetsReceived: 12,
+            remoteId: 'RTCRemoteOutboundRTPAudioStream_123456789',
+            removedSamplesForAcceleration: 0,
+            silentConcealedSamples: 200000,
+            ssrc: 123456789,
+            timestamp: 1707341489419,
+            totalAudioEnergy: 133,
+            totalSamplesDuration: 7,
+            totalSamplesReceived: 300000,
+            trackId: 'RTCMediaStreamTrack_receiver_76',
+            transportId: 'RTCTransport_0_1',
+            type: 'inbound-rtp',
+          },
+          'audio-recv-1',
+          false
+        );
+
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-recv-1'].recv.totalPacketsReceived,
+          12
+        );
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsDiscarded, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsReceived, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalBytesReceived, 509);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.headerBytesReceived, 250);
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-recv-1'].recv.headerBytesReceived,
+          250
+        );
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.audioLevel, 0);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalAudioEnergy, 133);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalSamplesReceived, 300000);
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-recv-1'].recv.totalSamplesReceived,
+          300000
+        );
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalSamplesDecoded, 0);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.concealedSamples, 200000);
+        assert.strictEqual(
+          statsAnalyzer.statsResults['audio-recv-1'].recv.concealedSamples,
+          200000
+        );
       });
 
       it('parseAudioSource should create the correct stats results', () => {
         // establish the `statsResults` object.
-        statsAnalyzer.parseGetStatsResult({ type: 'none' }, 'audio-send', true);
-
-        statsAnalyzer.parseAudioSource({
-          audioLevel: 0.03,
-          echoReturnLoss: -30,
-          echoReturnLossEnhancement: 0.17,
-          id: "RTCAudioSource_2",
-          kind: "audio",
-          timestamp: 1707341488160.012,
-          totalAudioEnergy: 0.001,
-          totalSamplesDuration: 4.5,
-          trackIdentifier: "2207e5bf-c595-4301-93f7-283994d8143f",
-          type: "media-source",
-        }, 'audio-send', true);
+        statsAnalyzer.parseGetStatsResult({type: 'none'}, 'audio-send', true);
+
+        statsAnalyzer.parseAudioSource(
+          {
+            audioLevel: 0.03,
+            echoReturnLoss: -30,
+            echoReturnLossEnhancement: 0.17,
+            id: 'RTCAudioSource_2',
+            kind: 'audio',
+            timestamp: 1707341488160.012,
+            totalAudioEnergy: 0.001,
+            totalSamplesDuration: 4.5,
+            trackIdentifier: '2207e5bf-c595-4301-93f7-283994d8143f',
+            type: 'media-source',
+          },
+          'audio-send',
+          true
+        );
 
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.audioLevel, 0.03);
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalAudioEnergy, 0.001);
@@ -267,7 +297,7 @@ describe('plugin-meetings', () => {
       };
 
       before(() => {
-        LoggerConfig.set({ enable: false });
+        LoggerConfig.set({enable: false});
         LoggerProxy.set();
         loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
       });
@@ -413,6 +443,74 @@ describe('plugin-meetings', () => {
               },
             ],
           },
+          share: {
+            senders: [
+              {
+                localTrackLabel: 'fake-share',
+                report: [
+                  {
+                    type: 'outbound-rtp',
+                    bytesSent: 1,
+                    framesSent: 0,
+                    packetsSent: 0,
+                  },
+                  {
+                    type: 'remote-inbound-rtp',
+                    packetsLost: 0,
+                  },
+                  {
+                    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',
+                    bytesReceived: 1,
+                    frameHeight: 720,
+                    frameWidth: 1280,
+                    framesDecoded: 0,
+                    framesReceived: 0,
+                    packetsLost: 0,
+                    packetsReceived: 0,
+                  },
+                  {
+                    type: 'remote-outbound-rtp',
+                  },
+                  {
+                    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 = {
@@ -431,15 +529,15 @@ describe('plugin-meetings', () => {
               receivers: [fakeStats.audio.receivers[0]],
             },
             screenShareVideo: {
-              senders: [fakeStats.video.senders[0]],
-              receivers: [fakeStats.video.receivers[0]],
+              senders: [fakeStats.share.senders[0]],
+              receivers: [fakeStats.share.receivers[0]],
             },
           }),
         };
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, () => (receiveSlot), networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, () => receiveSlot, networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -463,9 +561,10 @@ describe('plugin-meetings', () => {
         clock.restore();
       });
 
-      const startStatsAnalyzer = async (mediaStatus) => {
+      const startStatsAnalyzer = async (mediaStatus, lastEmittedEvents) => {
         statsAnalyzer.updateMediaStatus(mediaStatus);
         statsAnalyzer.startAnalyzer(pc);
+        statsAnalyzer.lastEmittedStartStopEvent = lastEmittedEvents || {};
 
         await testUtils.flushPromises();
       };
@@ -559,6 +658,26 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {local: {stopped: {type: 'video'}}}});
       });
 
+      it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for share', async () => {
+        await startStatsAnalyzer({expected: {sendShare: true}});
+
+        // check that we haven't received any events yet
+        checkReceivedEvent({expected: {}});
+
+        // setup a mock to return some values higher the previous ones
+        fakeStats.share.senders[0].report[0].framesSent += 1;
+
+        await progressTime();
+
+        // check that we got the LOCAL_MEDIA_STARTED event for audio
+        checkReceivedEvent({expected: {local: {started: {type: 'share'}}}});
+
+        // now advance the clock and the mock still returns same values, so only "stopped" event should be triggered
+        resetReceivedEvents();
+        await progressTime();
+        checkReceivedEvent({expected: {local: {stopped: {type: 'share'}}}});
+      });
+
       it('emits REMOTE_MEDIA_STARTED and REMOTE_MEDIA_STOPPED events for audio', async () => {
         await startStatsAnalyzer({expected: {receiveAudio: true}});
 
@@ -599,6 +718,26 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
 
+      it('emits REMOTE_MEDIA_STARTED and REMOTE_MEDIA_STOPPED events for share', async () => {
+        await startStatsAnalyzer({expected: {receiveShare: true}});
+
+        // check that we haven't received any events yet
+        checkReceivedEvent({expected: {}});
+
+        // setup a mock to return some values higher the previous ones
+        fakeStats.share.receivers[0].report[0].framesDecoded += 1;
+
+        await progressTime();
+        // check that we got the REMOTE_MEDIA_STARTED event for video
+        checkReceivedEvent({expected: {remote: {started: {type: 'share'}}}});
+
+        // now advance the clock and the mock still returns same values, so only "stopped" event should be triggered
+        resetReceivedEvents();
+        await progressTime();
+
+        checkReceivedEvent({expected: {remote: {stopped: {type: 'share'}}}});
+      });
+
       it('emits the correct MEDIA_QUALITY events', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
 
@@ -844,107 +983,180 @@ describe('plugin-meetings', () => {
       });
 
       it('logs a message when audio send packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {sendAudio: true}});
+        await startStatsAnalyzer(
+          {expected: {sendAudio: true}},
+          {audio: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+        );
 
         // don't increase the packets when time progresses.
         await progressTime();
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'));
+        assert(
+          loggerSpy.calledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'
+          )
+        );
       });
 
       it('does not log a message when audio send packets increase', async () => {
-        await startStatsAnalyzer({expected: {sendAudio: true}});
+        await startStatsAnalyzer(
+          {expected: {sendAudio: true}},
+          {audio: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
+        );
 
         fakeStats.audio.senders[0].report[0].packetsSent += 5;
         await progressTime();
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'));
-      });
-
-      it('logs a message when audio receive packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
-
-        // don't increase the packets when time progresses.
-        await progressTime();
-
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
-      });
-
-      it('does not log a message when audio receive packets increase', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
-
-        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
-        await progressTime();
-
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
+        assert(
+          loggerSpy.neverCalledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'
+          )
+        );
       });
 
       it('logs a message when video send packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await startStatsAnalyzer(
+          {expected: {sendVideo: true}},
+          {video: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+        );
 
         // don't increase the packets when time progresses.
         await progressTime();
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'));
+        assert(
+          loggerSpy.calledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'
+          )
+        );
       });
 
       it('does not log a message when video send packets increase', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await startStatsAnalyzer(
+          {expected: {sendVideo: true}},
+          {video: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
+        );
 
         fakeStats.video.senders[0].report[0].packetsSent += 5;
         await progressTime();
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'));
+        assert(
+          loggerSpy.neverCalledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'
+          )
+        );
       });
 
-      it('logs a message when video receive packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('logs a message when share send packets do not increase', async () => {
+        await startStatsAnalyzer(
+          {expected: {sendShare: true}},
+          {share: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+        );
 
         // don't increase the packets when time progresses.
         await progressTime();
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received'));
+        assert(
+          loggerSpy.calledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent'
+          )
+        );
       });
 
-      it('does not log a message when video receive packets increase', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('does not log a message when share send packets increase', async () => {
+        await startStatsAnalyzer(
+          {expected: {sendShare: true}},
+          {share: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
+        );
 
-        fakeStats.video.receivers[0].report[0].packetsReceived += 5;
+        fakeStats.share.senders[0].report[0].packetsSent += 5;
         await progressTime();
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
+        assert(
+          loggerSpy.neverCalledWith(
+            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent'
+          )
+        );
       });
 
-      it('logs a message when no packets are recieved for a receive slot with sourceState "live"', async () => {
+      ['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(`logs a message if no packets are sent`, async () => {
         receiveSlot = {
-          sourceState:  'live',
+          sourceState: 'live',
           csi: 2,
-          id: "4",
+          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);
-      });
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No packets received for mediaType: video-recv-0, 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);
-        });
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No frames received for mediaType: video-recv-0,  receive slot id: "4" and csi: 2. Total frames received on slot: ',
+          0
+        );
+
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No frames decoded for mediaType: video-recv-0,  receive slot id: "4" and csi: 2. Total frames decoded on slot: ',
+          0
+        );
+
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No packets received for mediaType: audio-recv-0, receive slot id: "4" and csi: 2. Total packets received on slot: ',
+          0
+        );
+
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No packets received for mediaType: video-share-recv-0, receive slot id: "4" and csi: 2. Total packets received on slot: ',
+          0
+        );
+
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No frames received for mediaType: video-share-recv-0,  receive slot id: "4" and csi: 2. Total frames received on slot: ',
+          0
+        );
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No frames decoded for mediaType: video-share-recv-0,  receive slot id: "4" and csi: 2. Total frames decoded on slot: ',
+          0
+        );
+        assert.calledWith(
+          loggerSpy,
+          'StatsAnalyzer:index#processInboundRTPResult --> No packets received for mediaType: audio-share-recv-0, receive slot id: "4" and csi: 2. Total packets received on slot: ',
+          0
+        );
       });
 
       it(`does not log a message if receiveSlot is undefined`, async () => {
@@ -953,7 +1165,11 @@ describe('plugin-meetings', () => {
         // 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);
+        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 () => {
@@ -972,258 +1188,234 @@ describe('plugin-meetings', () => {
 
         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
-            }
-          ]
-        );
+        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: {
@@ -1232,7 +1424,11 @@ describe('plugin-meetings', () => {
           },
           video: {
             senders: [fakeStats.video.senders[0]],
-            receivers: [fakeStats.video.receivers[0], fakeStats.video.receivers[0], fakeStats.video.receivers[0]],
+            receivers: [
+              fakeStats.video.receivers[0],
+              fakeStats.video.receivers[0],
+              fakeStats.video.receivers[0],
+            ],
           },
           screenShareAudio: {
             senders: [fakeStats.audio.senders[0]],
@@ -1248,107 +1444,104 @@ describe('plugin-meetings', () => {
 
         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
+        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,
             },
-            {
-              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
+            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,
             },
-            {
-              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
-            }
-          ]
-        );
+            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,
+          },
+        ]);
       });
     });
   });