@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

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

@@ -2,14 +2,10 @@ import 'jsdom-global/register';
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import sinon from 'sinon';
-import {ConnectionState} from '@webex/internal-media-core';
 
 import {StatsAnalyzer, EVENTS} from '../../../../src/statsAnalyzer';
 import NetworkQualityMonitor from '../../../../src/networkQualityMonitor';
 import testUtils from '../../../utils/testUtils';
-import {MEDIA_DEVICES, 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';
 
 const {assert} = chai;
 
@@ -18,156 +14,6 @@ sinon.assert.expose(chai.assert, {prefix: ''});
 
 describe('plugin-meetings', () => {
   describe('StatsAnalyzer', () => {
-    describe('parseStatsResult', () => {
-      const sandbox = sinon.createSandbox();
-      let statsAnalyzer;
-
-      const initialConfig = {};
-      const defaultStats = {};
-
-      beforeEach(() => {
-        const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
-
-        statsAnalyzer = new StatsAnalyzer(
-          initialConfig,
-          () => ({}),
-          networkQualityMonitor,
-          defaultStats
-        );
-      });
-
-      afterEach(() => {
-        sandbox.reset();
-      });
-
-      it('should call processOutboundRTPResult', () => {
-        const calledSpy = sandbox.spy(statsAnalyzer, 'processOutboundRTPResult');
-        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');
-        assert(calledSpy.calledOnce);
-      });
-
-      it('should call compareSentAndReceived', () => {
-        const calledSpy = sandbox.spy(statsAnalyzer, 'compareSentAndReceived');
-        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');
-        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);
-
-        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);
-      });
-
-      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);
-        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.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.totalSamplesDecoded, 0);
-        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);
-
-        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.audioLevel, 0.03);
-        assert.strictEqual(statsAnalyzer.statsResults['audio-send'].send.totalAudioEnergy, 0.001);
-      });
-    });
-
     describe('compareSentAndReceived()', () => {
       let statsAnalyzer;
       let sandBoxSpy;
@@ -177,15 +23,14 @@ describe('plugin-meetings', () => {
       };
 
       const defaultStats = {
-        resolutions: {},
         internal: {
-          'video-send-1': {
+          video: {
             send: {
               totalPacketsLostOnReceiver: 10,
             },
           },
         },
-        'video-send-1': {
+        video: {
           send: {
             packetsSent: 2,
             meanRemoteJitter: [],
@@ -206,12 +51,7 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         const networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(
-          initialConfig,
-          () => ({}),
-          networkQualityMonitor,
-          defaultStats
-        );
+        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor, defaultStats);
 
         sandBoxSpy = sandbox.spy(
           statsAnalyzer.networkQualityMonitor,
@@ -224,12 +64,12 @@ describe('plugin-meetings', () => {
       });
 
       it('should trigger determineUplinkNetworkQuality with specific arguments', async () => {
-        await statsAnalyzer.parseGetStatsResult(statusResult, 'video-send-1', true);
+        await statsAnalyzer.parseGetStatsResult(statusResult, 'video');
 
         assert.calledOnce(statsAnalyzer.networkQualityMonitor.determineUplinkNetworkQuality);
         assert(
           sandBoxSpy.calledWith({
-            mediaType: 'video-send-1',
+            mediaType: 'video',
             remoteRtpResults: statusResult,
             statsAnalyzerCurrentStats: statsAnalyzer.statsResults,
           })
@@ -242,8 +82,22 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
-      let mqeData;
-      let loggerSpy;
+      const statusResultOutboundRTP = {
+        type: 'outbound-rtp',
+        frameHeight: 720,
+        frameWidth: 1280,
+        packetsLost: 11,
+        framesSent: 105,
+        hugeFramesSent: 1,
+        framesEncoded: 102,
+        rttThreshold: 501,
+        jitterThreshold: 501,
+        jitterBufferDelay: 288.131459,
+        jitterBufferEmittedCount: 4013,
+        trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+        bytesSent: 1233,
+        totalPacketsSent: 100,
+      };
 
       let receivedEventsData = {
         local: {},
@@ -256,8 +110,6 @@ describe('plugin-meetings', () => {
 
       let fakeStats;
 
-      const sandbox = sinon.createSandbox();
-
       const resetReceivedEvents = () => {
         receivedEventsData = {
           local: {},
@@ -265,12 +117,6 @@ describe('plugin-meetings', () => {
         };
       };
 
-      before(() => {
-        LoggerConfig.set({ enable: false });
-        LoggerProxy.set();
-        loggerSpy = sandbox.spy(LoggerProxy.logger, 'info');
-      });
-
       beforeEach(() => {
         clock = sinon.useFakeTimers();
 
@@ -279,165 +125,61 @@ describe('plugin-meetings', () => {
         // bytesReceived and bytesSent need to be non-zero in order for StatsAnalyzer to parse any other values
         fakeStats = {
           audio: {
-            senders: [
-              {
-                localTrackLabel: 'fake-microphone',
-                report: [
-                  {
-                    type: 'outbound-rtp',
-                    bytesSent: 1,
-                    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,
-                    fecPacketsDiscarded: 0,
-                    fecPacketsReceived: 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',
-                  },
-                ],
-              },
-            ],
+            receiver: {
+              type: 'inbound-rtp',
+              packetsReceived: 0,
+              bytesReceived: 1,
+            },
+            sender: {
+              type: 'outbound-rtp',
+              packetsSent: 0,
+              bytesSent: 1,
+            },
           },
           video: {
-            senders: [
-              {
-                localTrackLabel: 'fake-camera',
-                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',
-                  },
-                ],
-              },
-            ],
+            receiver: {
+              type: 'inbound-rtp',
+              framesDecoded: 0,
+              bytesReceived: 1,
+            },
+            sender: {
+              type: 'outbound-rtp',
+              framesSent: 0,
+              bytesSent: 1,
+            },
           },
         };
 
         pc = {
-          getConnectionState: sinon.stub().returns(ConnectionState.Connected),
-          getTransceiverStats: sinon.stub().resolves({
-            audio: {
-              senders: [fakeStats.audio.senders[0]],
-              receivers: [fakeStats.audio.receivers[0]],
+          audioTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([fakeStats.audio.sender]),
+            },
+            receiver: {
+              getStats: sinon.stub().resolves([fakeStats.audio.receiver]),
             },
-            video: {
-              senders: [fakeStats.video.senders[0]],
-              receivers: [fakeStats.video.receivers[0]],
+          },
+          videoTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([fakeStats.video.sender]),
+            },
+            receiver: {
+              getStats: sinon.stub().resolves([fakeStats.video.receiver]),
             },
-            screenShareAudio: {
-              senders: [fakeStats.audio.senders[0]],
-              receivers: [fakeStats.audio.receivers[0]],
+          },
+          shareTransceiver: {
+            sender: {
+              getStats: sinon.stub().resolves([]),
             },
-            screenShareVideo: {
-              senders: [fakeStats.video.senders[0]],
-              receivers: [fakeStats.video.receivers[0]],
+            receiver: {
+              getStats: sinon.stub().resolves([]),
             },
-          }),
+          },
         };
 
         networkQualityMonitor = new NetworkQualityMonitor(initialConfig);
 
-        statsAnalyzer = new StatsAnalyzer(initialConfig, () => ({}), networkQualityMonitor);
+        statsAnalyzer = new StatsAnalyzer(initialConfig, networkQualityMonitor);
 
         statsAnalyzer.on(EVENTS.LOCAL_MEDIA_STARTED, (data) => {
           receivedEventsData.local.started = data;
@@ -451,13 +193,15 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
-        statsAnalyzer.on(EVENTS.MEDIA_QUALITY, ({data}) => {
-          mqeData = data;
+        statsAnalyzer.on(EVENTS.NO_FRAMES_SENT, (data) => {
+          receivedEventsData.noFramesSent = data;
+        });
+        statsAnalyzer.on(EVENTS.NO_VIDEO_ENCODED, (data) => {
+          receivedEventsData.noVideoEncoded = data;
         });
       });
 
       afterEach(() => {
-        sandbox.reset();
         clock.restore();
       });
 
@@ -468,27 +212,8 @@ describe('plugin-meetings', () => {
         await testUtils.flushPromises();
       };
 
-      const mergeProperties = (
-        target,
-        properties,
-        keyValue = 'fake-candidate-id',
-        matchKey = 'type',
-        matchValue = 'local-candidate'
-      ) => {
-        for (let key in target) {
-          if (target.hasOwnProperty(key)) {
-            if (typeof target[key] === 'object') {
-              mergeProperties(target[key], properties, keyValue, matchKey, matchValue);
-            }
-            if (key === 'id' && target[key] === keyValue && target[matchKey] === matchValue) {
-              Object.assign(target, properties);
-            }
-          }
-        }
-      };
-
-      const progressTime = async (time = initialConfig.analyzerInterval) => {
-        await clock.tickAsync(time);
+      const progressTime = async () => {
+        await clock.tickAsync(initialConfig.analyzerInterval);
         await testUtils.flushPromises();
       };
 
@@ -500,23 +225,6 @@ describe('plugin-meetings', () => {
         assert.deepEqual(receivedEventsData.remote.stopped, expected.remote?.stopped);
       };
 
-      const checkMqeData = () => {
-        for (const data of [
-          mqeData.audioTransmit,
-          mqeData.audioReceive,
-          mqeData.videoTransmit,
-          mqeData.videoReceive,
-        ]) {
-          assert.strictEqual(data.length, 2);
-          assert.strictEqual(data[0].common.common.isMain, true);
-          assert.strictEqual(data[1].common.common.isMain, false);
-        }
-
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedFrameSize, 3600);
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedHeight, 720);
-        assert.strictEqual(mqeData.videoReceive[0].streams[0].receivedWidth, 1280);
-      };
-
       it('emits LOCAL_MEDIA_STARTED and LOCAL_MEDIA_STOPPED events for audio', async () => {
         await startStatsAnalyzer({expected: {sendAudio: true}});
 
@@ -524,7 +232,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.senders[0].report[0].packetsSent += 10;
+        fakeStats.audio.sender.packetsSent += 10;
 
         await progressTime();
 
@@ -544,7 +252,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.senders[0].report[0].framesSent += 1;
+        fakeStats.video.sender.framesSent += 1;
 
         await progressTime();
 
@@ -564,7 +272,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
+        fakeStats.audio.receiver.packetsReceived += 5;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for audio
@@ -584,7 +292,7 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {}});
 
         // setup a mock to return some values higher the previous ones
-        fakeStats.video.receivers[0].report[0].framesDecoded += 1;
+        fakeStats.video.receiver.framesDecoded += 1;
 
         await progressTime();
         // check that we got the REMOTE_MEDIA_STARTED event for video
@@ -597,320 +305,133 @@ describe('plugin-meetings', () => {
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
 
-      it('emits the correct MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
-
-        await progressTime();
-
-        // Check that the mqe data has been emitted and is correctly computed.
-        checkMqeData();
-      });
-
-      it('emits the correct transportType in MEDIA_QUALITY events', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
-
-        await progressTime();
-
-        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TCP');
-        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TCP');
-      });
-
-      it('emits the correct transportType in MEDIA_QUALITY events when using a TURN server', async () => {
-        fakeStats.audio.senders[0].report[4].relayProtocol = 'tls';
-        fakeStats.video.senders[0].report[4].relayProtocol = 'tls';
-        fakeStats.audio.receivers[0].report[4].relayProtocol = 'tls';
-        fakeStats.video.receivers[0].report[4].relayProtocol = 'tls';
-
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
-
-        await progressTime();
-
-        assert.strictEqual(mqeData.audioTransmit[0].common.transportType, 'TLS');
-        assert.strictEqual(mqeData.videoReceive[0].common.transportType, 'TLS');
-      });
+      const checkStats = (type) => {
+        const statsResult = {
+          height: 720,
+          width: 1280,
+          jitterBufferDelay: 288.131459,
+          jitterBufferEmittedCount: 4013,
+          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+          avgJitterDelay: 0.07179951632195365,
+        };
+        if (type === 'inbound-rtp') {
+          statsResult.framesDecoded = 4013;
+          statsResult.framesDropped = 0;
+          statsResult.framesReceived = 4016;
+          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.recv, statsResult);
+        } else if (type === 'outbound-rtp') {
+          statsResult.framesSent = 105;
+          statsResult.hugeFramesSent = 1;
+          assert.deepEqual(statsAnalyzer.statsResults.resolutions.video.send, statsResult);
+        }
+      };
 
-      it('emits the correct peripherals in MEDIA_QUALITY events', async () => {
+      it('processes track results and populate statsResults.resolutions object when type is inbound-rtp with video', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
-
-        await progressTime();
-
-        assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
-            .information,
-          'fake-microphone'
-        );
-        assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
-            .information,
-          'fake-camera'
-        );
+        const statusResultInboundRTP = {
+          type: 'inbound-rtp',
+          frameHeight: 720,
+          frameWidth: 1280,
+          packetsLost: 11,
+          rttThreshold: 501,
+          jitterThreshold: 501,
+          framesDecoded: 4013,
+          framesDropped: 0,
+          framesReceived: 4016,
+          jitterBufferDelay: 288.131459,
+          jitterBufferEmittedCount: 4013,
+          trackIdentifier: '6bbf5506-6a7e-4397-951c-c05b72ab0ace',
+        };
+        await statsAnalyzer.parseGetStatsResult(statusResultInboundRTP, 'video');
+        checkStats('inbound-rtp');
       });
-
-      it('emits the correct peripherals in MEDIA_QUALITY events when localTrackLabel is undefined', async () => {
-        fakeStats.audio.senders[0].localTrackLabel = undefined;
-        fakeStats.video.senders[0].localTrackLabel = undefined;
-
+      it('processes track results and populate statsResults.resolutions object when type is outbound-rtp with video', async () => {
         await startStatsAnalyzer({expected: {receiveVideo: true}});
 
-        await progressTime();
-
-        assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.MICROPHONE)
-            .information,
-          _UNKNOWN_
-        );
-        assert.strictEqual(
-          mqeData.intervalMetadata.peripherals.find((val) => val.name === MEDIA_DEVICES.CAMERA)
-            .information,
-          _UNKNOWN_
-        );
-      });
-
-      it('emits the correct transmittedFrameRate/receivedFrameRate', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
-          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 () => {
-          fakeStats.video.senders[0].report[0].framesSent += 300;
-          fakeStats.video.receivers[0].report[0].framesReceived += 300;
-          await progressTime(MQA_INTERVAL);
-
-          // 300 frames in 60 seconds = 5 frames per second
-          assert.strictEqual(mqeData.videoTransmit[0].streams[0].common.transmittedFrameRate, 5);
-          assert.strictEqual(mqeData.videoReceive[0].streams[0].common.receivedFrameRate, 5);
-        });
-      });
-
-      it('emits the correct rtpPackets', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
-          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);
-          assert.strictEqual(mqeData.audioReceive[0].streams[0].common.rtpPackets, 0);
-          assert.strictEqual(mqeData.videoTransmit[0].common.rtpPackets, 0);
-          assert.strictEqual(mqeData.videoTransmit[0].streams[0].common.rtpPackets, 0);
-          assert.strictEqual(mqeData.videoReceive[0].common.rtpPackets, 0);
-          assert.strictEqual(mqeData.videoReceive[0].streams[0].common.rtpPackets, 0);
-        });
-
-        it('after packets are sent', async () => {
-          fakeStats.audio.senders[0].report[0].packetsSent += 5;
-          fakeStats.video.senders[0].report[0].packetsSent += 5;
-          await progressTime(MQA_INTERVAL);
-
-          assert.strictEqual(mqeData.audioTransmit[0].common.rtpPackets, 5);
-          assert.strictEqual(mqeData.audioTransmit[0].streams[0].common.rtpPackets, 5);
-          assert.strictEqual(mqeData.videoTransmit[0].common.rtpPackets, 5);
-          assert.strictEqual(mqeData.videoTransmit[0].streams[0].common.rtpPackets, 5);
-        });
-
-        it('after 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;
-          fakeStats.video.receivers[0].report[0].packetsReceived += 10;
-          await progressTime(MQA_INTERVAL);
-
-          assert.strictEqual(mqeData.audioReceive[0].common.rtpPackets, 10);
-          assert.strictEqual(mqeData.audioReceive[0].streams[0].common.rtpPackets, 10);
-          assert.strictEqual(mqeData.videoReceive[0].common.rtpPackets, 10);
-          assert.strictEqual(mqeData.videoReceive[0].streams[0].common.rtpPackets, 10);
-        });
-      });
-
-      it('emits the correct fecPackets', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
-          assert.strictEqual(mqeData.audioReceive[0].common.fecPackets, 0);
-        });
-
-        it('after FEC packets are 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 () => {
-          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, 10);
-        });
-      });
-
-      it('emits the correct mediaHopByHopLost/rtpHopByHopLost', async () => {
-        it('at the start of the stats analyzer', async () => {
-          await startStatsAnalyzer();
-          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 () => {
-          fakeStats.audio.receivers[0].report[0].packetsLost += 5;
-          fakeStats.video.receivers[0].report[0].packetsLost += 5;
-          await progressTime(MQA_INTERVAL);
-
-          assert.strictEqual(mqeData.audioReceive[0].common.mediaHopByHopLost, 5);
-          assert.strictEqual(mqeData.audioReceive[0].common.rtpHopByHopLost, 5);
-          assert.strictEqual(mqeData.videoReceive[0].common.mediaHopByHopLost, 5);
-          assert.strictEqual(mqeData.videoReceive[0].common.rtpHopByHopLost, 5);
-        });
-      });
-
-      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);
-        });
-
-        it('after packets are sent', 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);
-        });
-
-        it('after packets are sent and some packets are lost', 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);
-        });
-      });
-
-      it('has the correct localIpAddress set when the candidateType is host', async () => {
-        await startStatsAnalyzer();
-
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
-        mergeProperties(fakeStats, {address: 'test', candidateType: 'host'});
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'test');
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        checkStats('outbound-rtp');
       });
 
-      it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is set', async () => {
-        await startStatsAnalyzer();
-
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
-        mergeProperties(fakeStats, {
-          relayProtocol: 'test',
-          address: 'test2',
-          candidateType: 'prflx',
-        });
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'test2');
+      it('doesnot processes track results with audio', async () => {
+        await startStatsAnalyzer({expected: {receiveAudio: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'audio');
+        assert.deepEqual(statsAnalyzer.statsResults.resolutions.audio, undefined);
       });
 
-      it('has the correct localIpAddress set when the candidateType is prflx and relayProtocol is not set', async () => {
-        await startStatsAnalyzer();
+      it('emits NO_FRAMES_ENCODED when frames are not being encoded', async () => {
+        const expected = {mediaType: 'video'};
+        await startStatsAnalyzer({expected: {sendVideo: true}});
 
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
-        mergeProperties(fakeStats, {
-          relatedAddress: 'relatedAddress',
-          address: 'test2',
-          candidateType: 'prflx',
-        });
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), 'relatedAddress');
-      });
+        statsAnalyzer.lastStatsResults.video.send = {framesEncoded: 102, totalPacketsSent: 106};
 
-      it('has no localIpAddress set when the candidateType is invalid', async () => {
-        await startStatsAnalyzer();
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
-        mergeProperties(fakeStats, {candidateType: 'invalid'});
-        await progressTime();
-        assert.strictEqual(statsAnalyzer.getLocalIpAddress(), '');
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
       });
 
-      it('logs a message when audio send packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {sendAudio: true}});
-
-        // don't increase the packets when time progresses.
-        await progressTime();
+      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded', async () => {
+        await startStatsAnalyzer({expected: {sendVideo: true}});
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'));
-      });
+        const expected = {mediaType: 'video'};
 
-      it('does not log a message when audio send packets increase', async () => {
-        await startStatsAnalyzer({expected: {sendAudio: true}});
-
-        fakeStats.audio.senders[0].report[0].packetsSent += 5;
-        await progressTime();
+        statsAnalyzer.lastStatsResults.video.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent'));
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
       });
 
-      it('logs a message when audio receive packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
+      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED', async () => {
+        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
 
-        // don't increase the packets when time progresses.
-        await progressTime();
+        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
       });
 
-      it('does not log a message when audio receive packets increase', async () => {
-        await startStatsAnalyzer({expected: {receiveAudio: true}});
+      it('emits NO_FRAMES_ENCODED when frames are not being encoded for share', async () => {
+        const expected = {mediaType: 'share'};
+        await startStatsAnalyzer({expected: {sendShare: true}});
 
-        fakeStats.audio.receivers[0].report[0].packetsReceived += 5;
-        await progressTime();
+        statsAnalyzer.lastStatsResults.share.send = {framesEncoded: 102, totalPacketsSent: 106};
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
-      });
-
-      it('logs a message when video send packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
-
-        // don't increase the packets when time progresses.
-        await progressTime();
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'));
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
       });
 
-      it('does not log a message when video send packets increase', async () => {
-        await startStatsAnalyzer({expected: {sendVideo: true}});
-
-        fakeStats.video.senders[0].report[0].packetsSent += 5;
-        await progressTime();
-
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent'));
-      });
+      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded for share', async () => {
+        const expected = {mediaType: 'share'};
+        await startStatsAnalyzer({expected: {sendShare: true}});
 
-      it('logs a message when video receive packets do not increase', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        statsAnalyzer.lastStatsResults.share.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
 
-        // don't increase the packets when time progresses.
-        await progressTime();
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
 
-        assert(loggerSpy.calledWith('StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received'));
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
       });
 
-      it('does not log a message when video receive packets increase', async () => {
-        await startStatsAnalyzer({expected: {receiveVideo: true}});
+      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED for share', async () => {
+        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
 
-        fakeStats.video.receivers[0].report[0].packetsReceived += 5;
-        await progressTime();
+        await startStatsAnalyzer({expected: {sendShare: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
 
-        assert(loggerSpy.neverCalledWith('StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received'));
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
       });
     });
   });