@webex/plugin-meetings 3.3.1-next.2 → 3.3.1-next.21

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

@@ -10,12 +10,21 @@ import testUtils from '../../../utils/testUtils';
 import {MEDIA_DEVICES, MQA_INTERVAL, _UNKNOWN_} from '@webex/plugin-meetings/src/constants';
 import LoggerProxy from '../../../../src/common/logs/logger-proxy';
 import LoggerConfig from '../../../../src/common/logs/logger-config';
+import {CpuInfo} from '@webex/web-capabilities';
 
 const {assert} = chai;
 
 chai.use(chaiAsPromised);
 sinon.assert.expose(chai.assert, {prefix: ''});
 
+const startStatsAnalyzer = async ({statsAnalyzer, mediaStatus, lastEmittedEvents = {}, pc}) => {
+  statsAnalyzer.updateMediaStatus(mediaStatus);
+  statsAnalyzer.startAnalyzer(pc);
+  statsAnalyzer.lastEmittedStartStopEvent = lastEmittedEvents;
+
+  await testUtils.flushPromises();
+};
+
 describe('plugin-meetings', () => {
   describe('StatsAnalyzer', () => {
     describe('parseStatsResult', () => {
@@ -29,10 +38,12 @@ describe('plugin-meetings', () => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
         statsAnalyzer = new StatsAnalyzer(
-          initialConfig,
-          () => ({}),
-          networkQualityMonitor,
-          defaultStats
+          {
+            config: initialConfig,
+            receiveSlotCallback: () => ({}),
+            networkQualityMonitor,
+            statsResults: defaultStats,
+          },
         );
       });
 
@@ -89,7 +100,7 @@ describe('plugin-meetings', () => {
             requestedBitrate: 10000,
           },
           'audio-send',
-          true
+          true,
         );
 
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.headerBytesSent, 25000);
@@ -126,7 +137,7 @@ describe('plugin-meetings', () => {
             requestedBitrate: 50000,
           },
           'video-send',
-          true
+          true,
         );
 
         assert.strictEqual(statsAnalyzer.statsResults['video-send'].send.headerBytesSent, 50000);
@@ -136,11 +147,11 @@ describe('plugin-meetings', () => {
         assert.strictEqual(statsAnalyzer.statsResults['video-send'].send.requestedBitrate, 50000);
         assert.strictEqual(
           statsAnalyzer.statsResults['video-send'].send.totalRtxPacketsSent,
-          10
+          10,
         );
         assert.strictEqual(
           statsAnalyzer.statsResults['video-send'].send.totalRtxBytesSent,
-          500
+          500,
         );
       });
 
@@ -183,12 +194,12 @@ describe('plugin-meetings', () => {
             requestedBitrate: 10000,
           },
           'audio-recv-1',
-          false
+          false,
         );
 
         assert.strictEqual(
           statsAnalyzer.statsResults['audio-recv-1'].recv.totalPacketsReceived,
-          12
+          12,
         );
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsDiscarded, 1);
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.fecPacketsReceived, 1);
@@ -196,18 +207,18 @@ describe('plugin-meetings', () => {
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.requestedBitrate, 10000);
         assert.strictEqual(
           statsAnalyzer.statsResults['audio-recv-1'].recv.headerBytesReceived,
-          250
+          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
+          300000,
         );
         assert.strictEqual(statsAnalyzer.statsResults['audio-recv-1'].recv.totalSamplesDecoded, 0);
         assert.strictEqual(
           statsAnalyzer.statsResults['audio-recv-1'].recv.concealedSamples,
-          200000
+          200000,
         );
       });
 
@@ -243,7 +254,7 @@ describe('plugin-meetings', () => {
             retransmittedPacketsReceived: 10,
           },
           'video-recv',
-          false
+          false,
         );
 
         assert.strictEqual(statsAnalyzer.statsResults['video-recv'].recv.totalPacketsReceived, 1500);
@@ -275,7 +286,7 @@ describe('plugin-meetings', () => {
             type: 'media-source',
           },
           'audio-send',
-          true
+          true,
         );
 
         assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.audioLevel, 0.03);
@@ -322,15 +333,17 @@ describe('plugin-meetings', () => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
         statsAnalyzer = new StatsAnalyzer(
-          initialConfig,
-          () => ({}),
-          networkQualityMonitor,
-          defaultStats
+          {
+            config: initialConfig,
+            receiveSlotCallback: () => ({}),
+            networkQualityMonitor,
+            statsResults: defaultStats,
+          },
         );
 
         sandBoxSpy = sandbox.spy(
           statsAnalyzer.networkQualityMonitor,
-          'determineUplinkNetworkQuality'
+          'determineUplinkNetworkQuality',
         );
       });
 
@@ -347,7 +360,7 @@ describe('plugin-meetings', () => {
             mediaType: 'video-send-1',
             remoteRtpResults: statusResult,
             statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
-          })
+          }),
         );
       });
     });
@@ -381,6 +394,24 @@ describe('plugin-meetings', () => {
         };
       };
 
+      const registerStatsAnalyzerEvents = (statsAnalyzer) => {
+        statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
+          receivedEventsData.local.started = data;
+        });
+        statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STOPPED, (data) => {
+          receivedEventsData.local.stopped = data;
+        });
+        statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STARTED, (data) => {
+          receivedEventsData.remote.started = data;
+        });
+        statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
+          receivedEventsData.remote.stopped = data;
+        });
+        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
+          mqeData = data;
+        });
+      };
+
       before(() => {
         LoggerConfig.set({enable: false});
         LoggerProxy.set();
@@ -404,6 +435,7 @@ describe('plugin-meetings', () => {
                     type: 'outbound-rtp',
                     bytesSent: 1,
                     packetsSent: 0,
+                    isRequested: true,
                   },
                   {
                     type: 'remote-inbound-rtp',
@@ -437,6 +469,8 @@ describe('plugin-meetings', () => {
                     fecPacketsReceived: 0,
                     packetsLost: 0,
                     packetsReceived: 0,
+                    isRequested: true,
+                    lastRequestedUpdateTimestamp: 0,
                   },
                   {
                     type: 'remote-outbound-rtp',
@@ -470,6 +504,8 @@ describe('plugin-meetings', () => {
                     bytesSent: 1,
                     framesSent: 0,
                     packetsSent: 0,
+                    isRequested: true,
+                    lastRequestedUpdateTimestamp: 0,
                   },
                   {
                     type: 'remote-inbound-rtp',
@@ -505,6 +541,10 @@ describe('plugin-meetings', () => {
                     framesReceived: 0,
                     packetsLost: 0,
                     packetsReceived: 0,
+                    isRequested: true,
+                    lastRequestedUpdateTimestamp: 0,
+                    isActiveSpeaker: false,
+                    lastActiveSpeakerUpdateTimestamp: 0,
                   },
                   {
                     type: 'remote-outbound-rtp',
@@ -538,6 +578,9 @@ describe('plugin-meetings', () => {
                     bytesSent: 1,
                     framesSent: 0,
                     packetsSent: 0,
+                    isRequested: true,
+                    lastRequestedUpdateTimestamp: 0,
+                    encoderImplementation: 'fake-encoder',
                   },
                   {
                     type: 'remote-inbound-rtp',
@@ -573,6 +616,8 @@ describe('plugin-meetings', () => {
                     framesReceived: 0,
                     packetsLost: 0,
                     packetsReceived: 0,
+                    isRequested: true,
+                    lastRequestedUpdateTimestamp: 0,
                   },
                   {
                     type: 'remote-outbound-rtp',
@@ -622,23 +667,11 @@ describe('plugin-meetings', () => {
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, () => receiveSlot, networkQualityMonitor);
-
-        statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
-          receivedEventsData.local.started = data;
-        });
-        statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STOPPED, (data) => {
-          receivedEventsData.local.stopped = data;
-        });
-        statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STARTED, (data) => {
-          receivedEventsData.remote.started = data;
-        });
-        statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
-          receivedEventsData.remote.stopped = data;
-        });
-        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
-          mqeData = data;
+        statsAnalyzer = new StatsAnalyzer({
+          config: initialConfig, receiveSlotCallback: () => receiveSlot, networkQualityMonitor,
         });
+
+        registerStatsAnalyzerEvents(statsAnalyzer);
       });
 
       afterEach(() => {
@@ -646,20 +679,12 @@ describe('plugin-meetings', () => {
         clock.restore();
       });
 
-      const startStatsAnalyzer = async (mediaStatus, lastEmittedEvents) => {
-        statsAnalyzer.updateMediaStatus(mediaStatus);
-        statsAnalyzer.startAnalyzer(pc);
-        statsAnalyzer.lastEmittedStartStopEvent = lastEmittedEvents || {};
-
-        await testUtils.flushPromises();
-      };
-
       const mergeProperties = (
         target,
         properties,
         keyValue = 'fake-candidate-id',
         matchKey = 'type',
-        matchValue = 'local-candidate'
+        matchValue = 'local-candidate',
       ) => {
         for (let key in target) {
           if (target.hasOwnProperty(key)) {
@@ -704,7 +729,15 @@ describe('plugin-meetings', () => {
       };
 
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for audio', async () => {
-        await startStatsAnalyzer({expected: {sendAudio: true}});
+        await startStatsAnalyzer({
+          statsAnalyzer,
+          pc,
+          mediaStatus: {
+            expected: {
+              sendAudio: true,
+            },
+          },
+        });
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -724,7 +757,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for video', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {sendVideo: true}}});
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -744,7 +777,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for share', async () => {
-        await startStatsAnalyzer({expected: {sendShare: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {sendShare: true}}});
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -764,7 +797,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits REMOTE_MEDIA_STARTED and REMOTE_MEDIA_STOPPED events for audio', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveAudio: true}}});
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -784,7 +817,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits REMOTE_MEDIA_STARTED and REMOTE_MEDIA_STOPPED events for video', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -804,7 +837,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits REMOTE_MEDIA_STARTED and REMOTE_MEDIA_STOPPED events for share', async () => {
-        await startStatsAnalyzer({expected: {receiveShare: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveShare: true}}});
 
         // check that we haven't received any events yet
         checkReceivedEvent({expected: {}});
@@ -824,7 +857,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits the correct MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -833,7 +866,7 @@ describe('plugin-meetings', () => {
       });
 
       it('emits the correct transportType in MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -847,7 +880,7 @@ describe('plugin-meetings', () => {
         fakeStats.audio.receivers[0].report[4].relayProtocol = 'tls';
         fakeStats.video.receivers[0].report[4].relayProtocol = 'tls';
 
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -856,19 +889,19 @@ describe('plugin-meetings', () => {
       });
 
       it('emits the correct peripherals in MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
         assert.strictEqual(
           mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
             .information,
-          'fake-microphone'
+          'fake-microphone',
         );
         assert.strictEqual(
           mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
             .information,
-          'fake-camera'
+          'fake-camera',
         );
       });
 
@@ -876,30 +909,33 @@ describe('plugin-meetings', () => {
         fakeStats.audio.senders[0].localTrackLabel = undefined;
         fakeStats.video.senders[0].localTrackLabel = undefined;
 
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
         assert.strictEqual(
           mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
             .information,
-          _UNKNOWN_
+          _UNKNOWN_,
         );
         assert.strictEqual(
           mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
             .information,
-          _UNKNOWN_
+          _UNKNOWN_,
         );
       });
 
-      it('emits the correct transmittedFrameRate/receivedFrameRate', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
+      describe('frame rate reporting in stats analyzer', () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should report a zero frame rate for both transmitted and received video at the start', async () => {
           assert.strictEqual(mqeData.videoTransmit[0].streams[0].common.transmittedFrameRate, 0);
           assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 0);
         });
 
-        it('after frames are sent and received', async () => {
+        it('should accurately report the transmitted and received frame rate after video frames are processed', async () => {
           fakeStats.video.senders[0].report[0].framesSent += 300;
           fakeStats.video.receivers[0].report[0].framesReceived += 300;
           await progressTime(MQA_INTERVAL);
@@ -910,9 +946,12 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('emits the correct rtpPackets', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
+      describe('RTP packets count in stats analyzer', () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should report zero RTP packets for all streams at the start of the stats analyzer', async () => {
           assert.strictEqual(mqeData.audioTransmit[0].common.rtpPackets, 0);
           assert.strictEqual(mqeData.audioTransmit[0].streams[0].common.rtpPackets, 0);
           assert.strictEqual(mqeData.audioReceive[0].common.rtpPackets, 0);
@@ -923,7 +962,7 @@ describe('plugin-meetings', () => {
           assert.strictEqual(mqeData.videoReceive[0].streams[0].common.rtpPackets, 0);
         });
 
-        it('after packets are sent', async () => {
+        it('should update the RTP packets count correctly after audio and video packets are sent', async () => {
           fakeStats.audio.senders[0].report[0].packetsSent += 5;
           fakeStats.video.senders[0].report[0].packetsSent += 5;
           await progressTime(MQA_INTERVAL);
@@ -934,7 +973,7 @@ describe('plugin-meetings', () => {
           assert.strictEqual(mqeData.videoTransmit[0].streams[0].common.rtpPackets, 5);
         });
 
-        it('after packets are received', async () => {
+        it('should update the RTP packets count correctly after audio and video packets are received', async () => {
           fakeStats.audio.senders[0].report[0].packetsSent += 10;
           fakeStats.video.senders[0].report[0].packetsSent += 10;
           fakeStats.audio.receivers[0].report[0].packetsReceived += 10;
@@ -948,38 +987,83 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('emits the correct fecPackets', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
+      describe('FEC packet reporting in stats analyzer', () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should initially report zero FEC packets at the start of the stats analyzer', async () => {
           assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 0);
         });
 
-        it('after FEC packets are received', async () => {
+        it('should accurately report the count of FEC packets received', async () => {
           fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 5;
           await progressTime(MQA_INTERVAL);
 
           assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 5);
         });
 
-        it('after FEC packets are received and some FEC packets are discarded', async () => {
+        it('should accurately update and reset the FEC packet count based on received packets over MQA intervals', async () => {
           fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 15;
-          fakeStats.audio.receivers[0].report[0].fecPacketsDiscarded += 5;
           await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 15);
 
-          assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 10);
+          fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 45;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 45);
+
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 0);
         });
       });
 
-      it('emits the correct mediaHopByHopLost/rtpHopByHopLost', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
+      describe('RTP recovered packets emission', async() => {
+        beforeEach(async() => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should initially report zero RTP recovered packets', async() => {
+          assert.strictEqual(mqeData.audioReceive[0].common.rtpRecovered, 0);
+        })
+
+        it('should report RTP recovered packets equal to FEC packets received', async() => {
+          fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 10;
+
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.rtpRecovered, 10);
+        })
+
+        it('should reset RTP recovered packets count after each interval', async () => {
+          fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 100;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.rtpRecovered, 100);
+
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.rtpRecovered, 0);
+        })
+
+        it('should correctly calculate RTP recovered packets after discarding FEC packets', async () => {
+          fakeStats.audio.receivers[0].report[0].fecPacketsReceived += 100;
+          fakeStats.audio.receivers[0].report[0].fecPacketsDiscarded += 20;
+
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].common.rtpRecovered, 80);
+        })
+      })
+
+      describe('packet loss metrics reporting in stats analyzer', () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should report zero packet loss for both audio and video at the start of the stats analyzer', async () => {
           assert.strictEqual(mqeData.audioReceive[0].common.mediaHopByHopLost, 0);
           assert.strictEqual(mqeData.audioReceive[0].common.rtpHopByHopLost, 0);
           assert.strictEqual(mqeData.videoReceive[0].common.mediaHopByHopLost, 0);
           assert.strictEqual(mqeData.videoReceive[0].common.rtpHopByHopLost, 0);
         });
 
-        it('after packets are lost', async () => {
+        it('should update packet loss metrics correctly for both audio and video after packet loss is detected', async () => {
           fakeStats.audio.receivers[0].report[0].packetsLost += 5;
           fakeStats.video.receivers[0].report[0].packetsLost += 5;
           await progressTime(MQA_INTERVAL);
@@ -991,36 +1075,56 @@ describe('plugin-meetings', () => {
         });
       });
 
-      it('emits the correct remoteLossRate', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
-          assert.strictEqual(mqeData.audioTransmit[0].common.remoteLossRate, 0);
-          assert.strictEqual(mqeData.videoTransmit[0].common.remoteLossRate, 0);
+      describe('maximum remote loss rate reporting in stats analyzer', () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
         });
 
-        it('after packets are sent', async () => {
+        it('should report a zero maximum remote loss rate for both audio and video at the start', async () => {
+          assert.strictEqual(mqeData.audioTransmit[0].common.maxRemoteLossRate, 0);
+          assert.strictEqual(mqeData.videoTransmit[0].common.maxRemoteLossRate, 0);
+        });
+
+        it('should maintain a zero maximum remote loss rate for both audio and video after packets are sent without loss', async () => {
           fakeStats.audio.senders[0].report[0].packetsSent += 100;
           fakeStats.video.senders[0].report[0].packetsSent += 100;
           await progressTime(MQA_INTERVAL);
 
-          assert.strictEqual(mqeData.audioTransmit[0].common.remoteLossRate, 0);
-          assert.strictEqual(mqeData.videoTransmit[0].common.remoteLossRate, 0);
+          assert.strictEqual(mqeData.audioTransmit[0].common.maxRemoteLossRate, 0);
+          assert.strictEqual(mqeData.videoTransmit[0].common.maxRemoteLossRate, 0);
         });
 
-        it('after packets are sent and some packets are lost', async () => {
+        it('should accurately calculate the maximum remote loss rate for both audio and video after packet loss is detected', async () => {
           fakeStats.audio.senders[0].report[0].packetsSent += 200;
           fakeStats.audio.senders[0].report[1].packetsLost += 10;
           fakeStats.video.senders[0].report[0].packetsSent += 200;
           fakeStats.video.senders[0].report[1].packetsLost += 10;
           await progressTime(MQA_INTERVAL);
 
-          assert.strictEqual(mqeData.audioTransmit[0].common.remoteLossRate, 5);
-          assert.strictEqual(mqeData.videoTransmit[0].common.remoteLossRate, 5);
+          assert.strictEqual(mqeData.audioTransmit[0].common.maxRemoteLossRate, 5);
+          assert.strictEqual(mqeData.videoTransmit[0].common.maxRemoteLossRate, 5);
         });
+
+        it('should reset the maximum remote loss rate across MQA intervals', async() => {
+          fakeStats.audio.senders[0].report[0].packetsSent += 100;
+          fakeStats.audio.senders[0].report[1].packetsLost += 10;
+          fakeStats.video.senders[0].report[0].packetsSent += 50;
+          fakeStats.video.senders[0].report[1].packetsLost += 5;
+          await progressTime(MQA_INTERVAL);
+
+          assert.strictEqual(mqeData.audioTransmit[0].common.maxRemoteLossRate, 10);
+          assert.strictEqual(mqeData.videoTransmit[0].common.maxRemoteLossRate, 10);
+
+          await progressTime(MQA_INTERVAL);
+
+          assert.strictEqual(mqeData.audioTransmit[0].common.maxRemoteLossRate, 0);
+          assert.strictEqual(mqeData.videoTransmit[0].common.maxRemoteLossRate, 0);
+
+        })
       });
 
       it('has the correct localIpAddress set when the candidateType is host', async () => {
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         await progressTime();
         assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
@@ -1030,7 +1134,7 @@ describe('plugin-meetings', () => {
       });
 
       it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is set', async () => {
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         await progressTime();
         assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
@@ -1044,7 +1148,7 @@ describe('plugin-meetings', () => {
       });
 
       it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is not set', async () => {
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         await progressTime();
         assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
@@ -1058,7 +1162,7 @@ describe('plugin-meetings', () => {
       });
 
       it('has no localIpAddress set when the candidateType is invalid', async () => {
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         await progressTime();
         assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
@@ -1067,10 +1171,19 @@ describe('plugin-meetings', () => {
         assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
       });
 
+      it('has the correct share video encoder implementation as provided by the stats', async () => {
+        await startStatsAnalyzer({pc, statsAnalyzer});
+
+        await progressTime();
+        assert.strictEqual(statsAnalyzer.shareVideoEncoderImplementation, 'fake-encoder');
+      });
+
       it('logs a message when audio send packets do not increase', async () => {
         await startStatsAnalyzer(
-          {expected: {sendAudio: true}},
-          {audio: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+          {
+            statsAnalyzer, pc, mediaStatus: {expected: {sendAudio: true}},
+            lastEmittedEvents: {audio: {local: EVENTS.LOCAL_MEDIA_STARTED}},
+          },
         );
 
         // don't increase the packets when time progresses.
@@ -1078,15 +1191,17 @@ describe('plugin-meetings', () => {
 
         assert(
           loggerSpy.calledWith(
-            'StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'
-          )
+            '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}},
-          {audio: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
+        await startStatsAnalyzer({
+            statsAnalyzer, pc,
+            mediaStatus: {expected: {sendAudio: true}},
+            lastEmittedEvents: {audio: {local: EVENTS.LOCAL_MEDIA_STOPPED}},
+          },
         );
 
         fakeStats.audio.senders[0].report[0].packetsSent += 5;
@@ -1094,15 +1209,16 @@ describe('plugin-meetings', () => {
 
         assert(
           loggerSpy.neverCalledWith(
-            'StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'
-          )
+            '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}},
-          {video: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+        await startStatsAnalyzer({
+            statsAnalyzer, pc, mediaStatus: {expected: {sendVideo: true}},
+            lastEmittedEvents: {video: {local: EVENTS.LOCAL_MEDIA_STARTED}},
+          },
         );
 
         // don't increase the packets when time progresses.
@@ -1110,31 +1226,42 @@ describe('plugin-meetings', () => {
 
         assert(
           loggerSpy.calledWith(
-            'StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'
-          )
+            '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}},
-          {video: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
-        );
+          {
+            statsAnalyzer, pc,
+            mediaStatus: {
+              expected: {
+                sendVideo: true,
+              },
+            },
+            lastEmittedEvents: {
+              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'
-          )
+            'StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent',
+          ),
         );
       });
 
       it('logs a message when share send packets do not increase', async () => {
-        await startStatsAnalyzer(
-          {expected: {sendShare: true}},
-          {share: {local: EVENTS.LOCAL_MEDIA_STARTED}}
+        await startStatsAnalyzer({
+            pc, mediaStatus: {expected: {sendShare: true}},
+            lastEmittedEvents: {share: {local: EVENTS.LOCAL_MEDIA_STARTED}}, statsAnalyzer,
+          },
         );
 
         // don't increase the packets when time progresses.
@@ -1142,15 +1269,16 @@ describe('plugin-meetings', () => {
 
         assert(
           loggerSpy.calledWith(
-            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent'
-          )
+            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent',
+          ),
         );
       });
 
       it('does not log a message when share send packets increase', async () => {
-        await startStatsAnalyzer(
-          {expected: {sendShare: true}},
-          {share: {local: EVENTS.LOCAL_MEDIA_STOPPED}}
+        await startStatsAnalyzer({
+            pc, statsAnalyzer, mediaStatus: {expected: {sendShare: true}},
+            lastEmittedEvents: {share: {local: EVENTS.LOCAL_MEDIA_STOPPED}},
+          },
         );
 
         fakeStats.share.senders[0].report[0].packetsSent += 5;
@@ -1158,8 +1286,8 @@ describe('plugin-meetings', () => {
 
         assert(
           loggerSpy.neverCalledWith(
-            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent'
-          )
+            'StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent',
+          ),
         );
       });
 
@@ -1172,7 +1300,7 @@ describe('plugin-meetings', () => {
               id: '4',
             };
 
-            await startStatsAnalyzer();
+            await startStatsAnalyzer({pc, statsAnalyzer});
 
             // don't increase the packets when time progresses.
             await progressTime();
@@ -1180,10 +1308,10 @@ describe('plugin-meetings', () => {
             assert.neverCalledWith(
               loggerSpy,
               'StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot id: "4" and csi: 2. Total packets received on slot: ',
-              0
+              0,
             );
           });
-        }
+        },
       );
 
       it(`logs a message if no packets are sent`, async () => {
@@ -1192,7 +1320,7 @@ describe('plugin-meetings', () => {
           csi: 2,
           id: '4',
         };
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         // don't increase the packets when time progresses.
         await progressTime();
@@ -1200,52 +1328,52 @@ describe('plugin-meetings', () => {
         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
+          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
+          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
+          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
+          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
+          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
+          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
+          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
+          0,
         );
       });
 
       it(`does not log a message if receiveSlot is undefined`, async () => {
-        await startStatsAnalyzer();
+        await startStatsAnalyzer({pc, statsAnalyzer});
 
         // don't increase the packets when time progresses.
         await progressTime();
@@ -1253,12 +1381,12 @@ describe('plugin-meetings', () => {
         assert.neverCalledWith(
           loggerSpy,
           'StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot "". Total packets received on slot: ',
-          0
+          0,
         );
       });
 
       it('has the correct number of senders and receivers (2)', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -1269,7 +1397,7 @@ describe('plugin-meetings', () => {
       });
 
       it('has one stream per sender/reciever', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -1456,7 +1584,7 @@ describe('plugin-meetings', () => {
               framesDropped: 0,
             },
             h264CodecProfile: 'BP',
-            isActiveSpeaker: true,
+            isActiveSpeaker: false,
             optimalFrameSize: 0,
             receivedFrameSize: 3600,
             receivedHeight: 720,
@@ -1490,7 +1618,7 @@ describe('plugin-meetings', () => {
               framesDropped: 0,
             },
             h264CodecProfile: 'BP',
-            isActiveSpeaker: true,
+            isActiveSpeaker: false,
             optimalFrameSize: 0,
             receivedFrameSize: 3600,
             receivedHeight: 720,
@@ -1529,7 +1657,7 @@ describe('plugin-meetings', () => {
           },
         });
 
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
 
         await progressTime();
 
@@ -1554,7 +1682,7 @@ describe('plugin-meetings', () => {
               framesDropped: 0,
             },
             h264CodecProfile: 'BP',
-            isActiveSpeaker: true,
+            isActiveSpeaker: false,
             optimalFrameSize: 0,
             receivedFrameSize: 3600,
             receivedHeight: 720,
@@ -1586,7 +1714,7 @@ describe('plugin-meetings', () => {
               framesDropped: 0,
             },
             h264CodecProfile: 'BP',
-            isActiveSpeaker: true,
+            isActiveSpeaker: false,
             optimalFrameSize: 0,
             receivedFrameSize: 3600,
             receivedHeight: 720,
@@ -1618,7 +1746,7 @@ describe('plugin-meetings', () => {
               framesDropped: 0,
             },
             h264CodecProfile: 'BP',
-            isActiveSpeaker: true,
+            isActiveSpeaker: false,
             optimalFrameSize: 0,
             receivedFrameSize: 3600,
             receivedHeight: 720,
@@ -1633,187 +1761,387 @@ describe('plugin-meetings', () => {
         ]);
       });
 
-      it('has three streams for video senders for simulcast', async () => {
-        pc.getTransceiverStats = sinon.stub().resolves({
-          audio: {
-            senders: [fakeStats.audio.senders[0]],
-            receivers: [fakeStats.audio.receivers[0]],
-          },
-          video: {
-            senders: [
-              {
-                localTrackLabel: 'fake-camera',
-                report: [
-                  {
-                    type: 'outbound-rtp',
-                    bytesSent: 1,
-                    framesSent: 0,
-                    packetsSent: 0,
-                  },
-                  {
-                    type: 'outbound-rtp',
-                    bytesSent: 0,
-                    framesSent: 0,
-                    packetsSent: 0,
-                  },
-                  {
-                    type: 'outbound-rtp',
-                    bytesSent: 1000,
-                    framesSent: 1,
-                    packetsSent: 1,
-                  },
-                  {
-                    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: [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}});
+      describe('stream count for simulcast', async () => {
+        it('has three streams for video senders for simulcast', async () => {
+          pc.getTransceiverStats = sinon.stub().resolves({
+            audio: {
+              senders: [fakeStats.audio.senders[0]],
+              receivers: [fakeStats.audio.receivers[0]],
+            },
+            video: {
+              senders: [
+                {
+                  localTrackLabel: 'fake-camera',
+                  report: [
+                    {
+                      type: 'outbound-rtp',
+                      bytesSent: 1,
+                      framesSent: 0,
+                      packetsSent: 0,
+                      isRequested: true,
+                    },
+                    {
+                      type: 'outbound-rtp',
+                      bytesSent: 1,
+                      framesSent: 0,
+                      packetsSent: 1,
+                      isRequested: true,
+                    },
+                    {
+                      type: 'outbound-rtp',
+                      bytesSent: 1000,
+                      framesSent: 1,
+                      packetsSent: 0,
+                      isRequested: true,
+                    },
+                    {
+                      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: [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 progressTime();
+          await startStatsAnalyzer({
+            pc,
+            statsAnalyzer,
+            mediaStatus: {
+              expected: {
+                receiveVideo: true,
+              },
+            },
+          });
 
-        assert.deepEqual(mqeData.videoTransmit[0].streams, [
-          {
-            common: {
-              codec: 'H264',
-              csi: [],
-              duplicateSsci: 0,
+          await progressTime();
+
+          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,
               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,
-            requestedBitrate: 0,
-          },
-          {
-            common: {
-              codec: 'H264',
-              csi: [],
-              duplicateSsci: 0,
+            {
+              common: {
+                codec: 'H264',
+                csi: [],
+                duplicateSsci: 0,
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 1,
+                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,
               requestedBitrate: 0,
-              requestedFrames: 0,
-              rtpPackets: 0,
-              ssci: 0,
-              transmittedBitrate: 0,
-              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,
-            requestedBitrate: 0,
-          },
-          {
-            common: {
-              codec: 'H264',
-              csi: [],
-              duplicateSsci: 0,
+            {
+              common: {
+                codec: 'H264',
+                csi: [],
+                duplicateSsci: 0,
+                requestedBitrate: 0,
+                requestedFrames: 0,
+                rtpPackets: 0,
+                ssci: 0,
+                transmittedBitrate: 133.33333333333334,
+                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,
               requestedBitrate: 0,
-              requestedFrames: 0,
-              rtpPackets: 1,
-              ssci: 0,
-              transmittedBitrate: 133.33333333333334,
-              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,
-            requestedBitrate: 0,
+          ]);
+        });
+      });
+      describe('active speaker status emission', async () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+          performance.timeOrigin = 1;
+        });
+
+        it('reports active speaker as true when the participant has been speaking', async () => {
+          fakeStats.video.receivers[0].report[0].isActiveSpeaker = true;
+          await progressTime(5 * MQA_INTERVAL);
+          assert.strictEqual(mqeData.videoReceive[0].streams[0].isActiveSpeaker, true);
+        });
+
+        it('reports active speaker as false when the participant has not spoken', async () => {
+          fakeStats.video.receivers[0].report[0].isActiveSpeaker = false;
+          await progressTime(5 * MQA_INTERVAL);
+          assert.strictEqual(mqeData.videoReceive[0].streams[0].isActiveSpeaker, false);
+        });
+
+        it('defaults to false when active speaker status is indeterminate', async () => {
+          fakeStats.video.receivers[0].report[0].isActiveSpeaker = undefined;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.videoReceive[0].streams[0].isActiveSpeaker, false);
+        });
+
+        it('updates active speaker to true following a recent status change to speaking', async () => {
+          fakeStats.video.receivers[0].report[0].isActiveSpeaker = false;
+          fakeStats.video.receivers[0].report[0].lastActiveSpeakerUpdateTimestamp = performance.timeOrigin + performance.now() + (30 * 1000);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.videoReceive[0].streams[0].isActiveSpeaker, true);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.videoReceive[0].streams[0].isActiveSpeaker, false);
+        });
+      });
+      describe('sends streams according to their is requested flag', async () => {
+
+        beforeEach(async () => {
+          performance.timeOrigin = 0;
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should send a stream if it is requested', async () => {
+          fakeStats.audio.senders[0].report[0].isRequested = true;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioTransmit[0].streams.length, 1);
+        });
+
+        it('should not sent a stream if its is requested flag is undefined', async () => {
+          fakeStats.audio.senders[0].report[0].isRequested = undefined;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioTransmit[0].streams.length, 0);
+        });
+
+        it('should not send a stream if it is not requested', async () => {
+          fakeStats.audio.receivers[0].report[0].isRequested = false;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].streams.length, 0);
+        });
+
+        it('should send the stream if it was recently requested', async () => {
+          fakeStats.audio.receivers[0].report[0].lastRequestedUpdateTimestamp = performance.timeOrigin + performance.now() + (30 * 1000);
+          fakeStats.audio.receivers[0].report[0].isRequested = false;
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].streams.length, 1);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.audioReceive[0].streams.length, 0);
+        });
+      });
+
+      describe('window and screen size emission', async () => {
+        beforeEach(async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer});
+        });
+
+        it('should record the screen size from window.screen properties', async () => {
+          sinon.stub(window.screen, 'width').get(() => 1280);
+          sinon.stub(window.screen, 'height').get(() => 720);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.intervalMetadata.screenWidth, 1280);
+          assert.strictEqual(mqeData.intervalMetadata.screenHeight, 720);
+          assert.strictEqual(mqeData.intervalMetadata.screenResolution, 3600);
+        });
+
+        it('should record the initial app window size from window properties', async () => {
+          sinon.stub(window, 'innerWidth').get(() => 720);
+          sinon.stub(window, 'innerHeight').get(() => 360);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowWidth, 720);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowHeight, 360);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowSize, 1013);
+
+          sinon.stub(window, 'innerWidth').get(() => 1080);
+          sinon.stub(window, 'innerHeight').get(() => 720);
+          await progressTime(MQA_INTERVAL);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowWidth, 1080);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowHeight, 720);
+          assert.strictEqual(mqeData.intervalMetadata.appWindowSize, 3038);
+        });
+      });
+
+      describe('sends multistreamEnabled', async () => {
+        it('false if StatsAnalyzer initialized with default value for isMultistream', async () => {
+          await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
+
+          await progressTime();
+
+          for (const data of [
+            mqeData.audioTransmit,
+            mqeData.audioReceive,
+            mqeData.videoTransmit,
+            mqeData.videoReceive,
+          ]) {
+            assert.strictEqual(data[0].common.common.multistreamEnabled, false);
           }
-        ]);
+        });
+
+        it('false if StatsAnalyzer initialized with false', async () => {
+          statsAnalyzer = new StatsAnalyzer({
+            config: initialConfig,
+            receiveSlotCallback: () => receiveSlot,
+            networkQualityMonitor,
+            isMultistream: false,
+          });
+          registerStatsAnalyzerEvents(statsAnalyzer);
+          await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: false}}});
+
+          await progressTime();
+
+          for (const data of [
+            mqeData.audioTransmit,
+            mqeData.audioReceive,
+            mqeData.videoTransmit,
+            mqeData.videoReceive,
+          ]) {
+            assert.strictEqual(data[0].common.common.multistreamEnabled, false);
+          }
+        });
+
+        it('true if StatsAnalyzer initialized with multistream', async () => {
+          statsAnalyzer = new StatsAnalyzer({
+            config: initialConfig,
+            receiveSlotCallback: () => receiveSlot,
+            networkQualityMonitor,
+            isMultistream: true,
+          });
+          registerStatsAnalyzerEvents(statsAnalyzer);
+          await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
+
+          await progressTime();
+
+          for (const data of [
+            mqeData.audioTransmit,
+            mqeData.audioReceive,
+            mqeData.videoTransmit,
+            mqeData.videoReceive,
+          ]) {
+            assert.strictEqual(data[0].common.common.multistreamEnabled, true);
+          }
+        });
       });
-    });
+
+      describe('CPU Information Reporting', async () => {
+        let getNumLogicalCoresStub;
+
+        beforeEach(async () => {
+          getNumLogicalCoresStub = sinon.stub(CpuInfo, 'getNumLogicalCores');
+        });
+
+        afterEach(() => {
+          getNumLogicalCoresStub.restore();
+        });
+
+        it('reports 1 of logical CPU cores when not available', async () => {
+          getNumLogicalCoresStub.returns(undefined);
+          await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
+
+          await progressTime();
+          assert.equal(mqeData.intervalMetadata.cpuInfo.numberOfCores, 1);
+        });
+
+        it('reports the number of logical CPU cores', async () => {
+          getNumLogicalCoresStub.returns(12);
+          await startStatsAnalyzer({pc, statsAnalyzer, mediaStatus: {expected: {receiveVideo: true}}});
+
+          await progressTime();
+          assert.equal(mqeData.intervalMetadata.cpuInfo.numberOfCores, 12);
+        });
+      });
+    })
   });
 });