@webex/plugin-meetings 2.59.4-next.1 → 2.59.5

package/src/statsAnalyzer/index.ts

@@ -25,6 +25,8 @@ import {
 
 export const EVENTS = {
   MEDIA_QUALITY: 'MEDIA_QUALITY',
+  NO_FRAMES_SENT: 'NO_FRAMES_SENT',
+  NO_VIDEO_ENCODED: 'NO_VIDEO_ENCODED',
   LOCAL_MEDIA_STARTED: 'LOCAL_MEDIA_STARTED',
   LOCAL_MEDIA_STOPPED: 'LOCAL_MEDIA_STOPPED',
   REMOTE_MEDIA_STARTED: 'REMOTE_MEDIA_STARTED',
@@ -420,9 +422,6 @@ export class StatsAnalyzer extends EventsScope {
       case 'inbound-rtp':
         this.processInboundRTPResult(getStatsResult, type);
         break;
-      case 'track':
-        this.processTrackResult(getStatsResult, type);
-        break;
       case 'remote-inbound-rtp':
       case 'remote-outbound-rtp':
         // @ts-ignore
@@ -520,7 +519,7 @@ export class StatsAnalyzer extends EventsScope {
 
     if (currentValue - previousValue > 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STARTED : EVENTS.REMOTE_MEDIA_STARTED;
-    } else if (currentValue === previousValue && currentValue > 0) {
+    } else if (currentValue === previousValue && currentValue >= 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STOPPED : EVENTS.REMOTE_MEDIA_STOPPED;
     }
 
@@ -635,14 +634,25 @@ export class StatsAnalyzer extends EventsScope {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames Encoded`
             );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
+            );
           }
 
           if (
@@ -654,8 +664,28 @@ export class StatsAnalyzer extends EventsScope {
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent`
             );
           }
-        }
 
+          // Video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent even though frames are encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
+            );
+          }
+        }
         this.emitStartStopEvents(
           mediaType,
           previousStats.framesSent,
@@ -731,14 +761,25 @@ export class StatsAnalyzer extends EventsScope {
           LoggerProxy.logger.info(
             `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames getting encoded`
             );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
+            );
           }
 
           if (
@@ -750,6 +791,27 @@ export class StatsAnalyzer extends EventsScope {
               `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent`
             );
           }
+
+          // Share video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent even though frames are being encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
+            );
+          }
         }
 
         // TODO:need to check receive share value
@@ -881,6 +943,7 @@ export class StatsAnalyzer extends EventsScope {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.SEND_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesSent) {
       let kilobytes = 0;
 
@@ -904,7 +967,6 @@ export class StatsAnalyzer extends EventsScope {
 
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
       this.statsResults[mediaType].bytesSent = kilobytes;
-
       this.statsResults[mediaType][sendrecvType].framesEncoded =
         result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
       this.statsResults[mediaType][sendrecvType].keyFramesEncoded =
@@ -955,6 +1017,7 @@ export class StatsAnalyzer extends EventsScope {
     const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.RECEIVE_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesReceived) {
       let kilobytes = 0;
 
@@ -1158,29 +1221,29 @@ export class StatsAnalyzer extends EventsScope {
    * @private
    * @param {*} result
    * @param {*} mediaType
+   * @param {*} sendrecvType
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  private processTrackResult(result: any, mediaType: any) {
-    if (!result || result.type !== 'track') {
+  private processTrackResult(result: any, mediaType: any, sendrecvType: any) {
+    if (!result || mediaType === STATS.AUDIO_CORRELATE) {
+      return;
+    }
+    if (result.type !== 'inbound-rtp' && result.type !== 'outbound-rtp') {
       return;
     }
-    if (result.type !== 'track') return;
-
-    const sendrecvType =
-      result.remoteSource === true ? STATS.RECEIVE_DIRECTION : STATS.SEND_DIRECTION;
-
     if (result.frameWidth && result.frameHeight) {
       this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
       this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
-      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
-      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
     }
 
     if (sendrecvType === STATS.RECEIVE_DIRECTION) {
       this.statsResults.resolutions[mediaType][sendrecvType].framesReceived = result.framesReceived;
       this.statsResults.resolutions[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
       this.statsResults.resolutions[mediaType][sendrecvType].framesDropped = result.framesDropped;
+    } else if (sendrecvType === STATS.SEND_DIRECTION) {
+      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
+      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
     }
 
     if (result.trackIdentifier && mediaType !== STATS.AUDIO_CORRELATE) {

package/test/unit/spec/meeting/index.js

@@ -1329,6 +1329,71 @@ describe('plugin-meetings', () => {
               data: {intervalData: fakeData, networkType: 'wifi'},
             });
           });
+          it('NO_FRAMES_SENT triggers "meeting:noFramesSent" event and sends metrics', async () => {
+            meeting.mediaProperties.mediaDirection = {sendVideo: true};
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_FRAMES_SENT,
+              {mediaType: 'video'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_FRAMES_SENT,
+              {
+                mediaType: 'video',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_FRAMES_SENT);
+          });
+          it('NO_FRAMES_SENT triggers "meeting:noFramesSent" event and sends metrics for share', async () => {
+            meeting.mediaProperties.mediaDirection = {sendShare: true};
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_FRAMES_SENT,
+              {mediaType: 'share'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_FRAMES_SENT,
+              {
+                mediaType: 'share',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_FRAMES_SENT);
+          });
+          it('NO_VIDEO_ENCODED triggers "meeting:noVideoEncoded" event and sends metrics', async () => {
+            statsAnalyzerStub.emit(
+              {file: 'test', function: 'test'},
+              StatsAnalyzerModule.EVENTS.NO_VIDEO_ENCODED,
+              {mediaType: 'video'}
+            );
+
+            assert.calledWith(
+              TriggerProxy.trigger,
+              sinon.match.instanceOf(Meeting),
+              {
+                file: 'meeting/index',
+                function: 'compareLastStatsResult',
+              },
+              EVENT_TRIGGERS.MEETING_NO_VIDEO_ENCODED,
+              {
+                mediaType: 'video',
+              }
+            );
+            assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.NO_VIDEO_ENCODED);
+          });
         });
       });
       describe('#acknowledge', () => {
@@ -3605,14 +3670,17 @@ describe('plugin-meetings', () => {
       describe('#setUpLocusServicesListener', () => {
         it('listens to the locus services update event', (done) => {
           const newLocusServices = {
-              services: {
-                record: {
-                  url: 'url',
-                }
+            services: {
+              record: {
+                url: 'url',
               },
+            },
           };
 
-          meeting.recordingController = {setServiceUrl: sinon.stub().returns(undefined), setSessionId: sinon.stub().returns(undefined)};
+          meeting.recordingController = {
+            setServiceUrl: sinon.stub().returns(undefined),
+            setSessionId: sinon.stub().returns(undefined),
+          };
 
           meeting.locusInfo.emit(
             {function: 'test', file: 'test'},
@@ -3620,7 +3688,10 @@ describe('plugin-meetings', () => {
             newLocusServices
           );
 
-          assert.calledWith(meeting.recordingController.setServiceUrl, newLocusServices.services.record.url);
+          assert.calledWith(
+            meeting.recordingController.setServiceUrl,
+            newLocusServices.services.record.url
+          );
           assert.calledOnce(meeting.recordingController.setSessionId);
           done();
         });

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

@@ -41,88 +41,92 @@ describe('Roap', () => {
   describe('sendRoapMediaRequest', () => {
     let sendRoapStub;
     let roapHandlerSubmitStub;
-
-    const meeting = {
-      id: 'some meeting id',
-      correlationId: 'correlation id',
-      selfUrl: 'self url',
-      mediaId: 'media id',
-      audio:{
-        isLocallyMuted: () => true,
-      },
-      video:{
-        isLocallyMuted: () => false,
-      },
-      setRoapSeq: sinon.stub(),
-      config: {experimental: {enableTurnDiscovery: false}},
-    };
+    let meeting;
 
     beforeEach(() => {
-      sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
-      roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
-      meeting.setRoapSeq.resetHistory();
+      meeting = {
+        id: 'some meeting id',
+        correlationId: 'correlation id',
+        selfUrl: 'self url',
+        mediaId: 'media id',
+        audio: {
+          isLocallyMuted: () => true,
+        },
+        video: {
+          isLocallyMuted: () => false,
+        },
+        setRoapSeq: sinon.stub(),
+        config: {experimental: {enableTurnDiscovery: false}},
+        webex: {meetings: {reachability: {isAnyClusterReachable: () => true}}},
+      };
+
+      beforeEach(() => {
+        sendRoapStub = sinon.stub(RoapRequest.prototype, 'sendRoap').resolves({});
+        roapHandlerSubmitStub = sinon.stub(RoapHandler.prototype, 'submit');
+        meeting.setRoapSeq.resetHistory();
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      [
+        {reconnect: true, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+        {reconnect: true, turnDiscoverySkipped: true, expectEmptyMediaId: true},
+        {reconnect: false, turnDiscoverySkipped: false, expectEmptyMediaId: false},
+        {reconnect: false, turnDiscoverySkipped: true, expectEmptyMediaId: false},
+      ].forEach(({reconnect, turnDiscoverySkipped, expectEmptyMediaId}) =>
+        it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
+          reconnect ? '' : 'not '
+        }reconnecting and TURN discovery is ${
+          turnDiscoverySkipped ? 'skipped' : 'not skipped'
+        }`, async () => {
+          const roap = new Roap({}, {parent: 'fake'});
+
+          sinon.stub(roap.turnDiscovery, 'isSkipped').resolves(turnDiscoverySkipped);
+
+          await roap.sendRoapMediaRequest({
+            meeting,
+            sdp: 'sdp',
+            reconnect,
+            roapSeq: 1,
+          });
+
+          const expectedRoapMessage = {
+            messageType: 'OFFER',
+            sdps: ['sdp'],
+            version: '2',
+            seq: 2,
+            tieBreaker: 4294967294,
+          };
+
+          assert.calledOnce(sendRoapStub);
+          assert.calledWith(sendRoapStub, {
+            roapMessage: expectedRoapMessage,
+            correlationId: meeting.correlationId,
+            locusSelfUrl: meeting.selfUrl,
+            mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
+            audioMuted: meeting.audio?.isLocallyMuted(),
+            videoMuted: meeting.video?.isLocallyMuted(),
+            meetingId: meeting.id,
+          });
+
+          assert.calledTwice(roapHandlerSubmitStub);
+          assert.calledWith(roapHandlerSubmitStub, {
+            type: ROAP.SEND_ROAP_MSG,
+            msg: expectedRoapMessage,
+            correlationId: meeting.correlationId,
+          });
+          assert.calledWith(roapHandlerSubmitStub, {
+            type: ROAP.SEND_ROAP_MSG_SUCCESS,
+            seq: 2,
+            correlationId: meeting.correlationId,
+          });
+
+          assert.calledOnce(meeting.setRoapSeq);
+          assert.calledWith(meeting.setRoapSeq, 2);
+        })
+      );
     });
-
-    afterEach(() => {
-      sinon.restore();
-    });
-
-    [
-      {reconnect: true, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: true, enableTurnDiscovery: false, expectEmptyMediaId: true},
-      {reconnect: false, enableTurnDiscovery: true, expectEmptyMediaId: false},
-      {reconnect: false, enableTurnDiscovery: false, expectEmptyMediaId: false},
-    ].forEach(({reconnect, enableTurnDiscovery, expectEmptyMediaId}) =>
-      it(`sends roap OFFER with ${expectEmptyMediaId ? 'empty ' : ''}mediaId when ${
-        reconnect ? '' : 'not '
-      }reconnecting and TURN discovery is ${
-        enableTurnDiscovery ? 'enabled' : 'disabled'
-      }`, async () => {
-        meeting.config.experimental.enableTurnDiscovery = enableTurnDiscovery;
-
-        const roap = new Roap({}, {parent: 'fake'});
-
-        await roap.sendRoapMediaRequest({
-          meeting,
-          sdp: 'sdp',
-          reconnect,
-          roapSeq: 1,
-        });
-
-        const expectedRoapMessage = {
-          messageType: 'OFFER',
-          sdps: ['sdp'],
-          version: '2',
-          seq: 2,
-          tieBreaker: 4294967294,
-        };
-
-        assert.calledOnce(sendRoapStub);
-        assert.calledWith(sendRoapStub, {
-          roapMessage: expectedRoapMessage,
-          correlationId: meeting.correlationId,
-          locusSelfUrl: meeting.selfUrl,
-          mediaId: expectEmptyMediaId ? '' : meeting.mediaId,
-          audioMuted: meeting.audio?.isLocallyMuted(),
-          videoMuted: meeting.video?.isLocallyMuted(),
-          meetingId: meeting.id,
-        });
-
-        assert.calledTwice(roapHandlerSubmitStub);
-        assert.calledWith(roapHandlerSubmitStub, {
-          type: ROAP.SEND_ROAP_MSG,
-          msg: expectedRoapMessage,
-          correlationId: meeting.correlationId,
-        });
-        assert.calledWith(roapHandlerSubmitStub, {
-          type: ROAP.SEND_ROAP_MSG_SUCCESS,
-          seq: 2,
-          correlationId: meeting.correlationId,
-        });
-
-        assert.calledOnce(meeting.setRoapSeq);
-        assert.calledWith(meeting.setRoapSeq, 2);
-      })
-    );
   });
 });

package/test/unit/spec/roap/turnDiscovery.ts

@@ -352,6 +352,27 @@ describe('TurnDiscovery', () => {
     });
   });
 
+  describe('isSkipped', () => {
+    [
+      {enabledInConfig: true, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: true, isAnyClusterReachable: false, expectedIsSkipped: false},
+      {enabledInConfig: false, isAnyClusterReachable: true, expectedIsSkipped: true},
+      {enabledInConfig: false, isAnyClusterReachable: false, expectedIsSkipped: true},
+    ].forEach(({enabledInConfig, isAnyClusterReachable, expectedIsSkipped}) => {
+      it(`returns ${expectedIsSkipped} when TURN discovery is ${enabledInConfig ? '' : 'not '} enabled in config and isAnyClusterReachable() returns ${isAnyClusterReachable ? 'true' : 'false'}`, async () => {
+        testMeeting.config.experimental.enableTurnDiscovery = enabledInConfig;
+
+        sinon.stub(testMeeting.webex.meetings.reachability, 'isAnyClusterReachable').resolves(isAnyClusterReachable);
+
+        const td = new TurnDiscovery(mockRoapRequest);
+
+        const isSkipped = await td.isSkipped(testMeeting);
+
+        assert.equal(isSkipped, expectedIsSkipped);
+      })
+    })
+  })
+
   describe('handleTurnDiscoveryResponse', () => {
     it("doesn't do anything if turn discovery was not started", () => {
       const td = new TurnDiscovery(mockRoapRequest);

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

@@ -82,6 +82,22 @@ describe('plugin-meetings', () => {
       let pc;
       let networkQualityMonitor;
       let statsAnalyzer;
+      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: {},
@@ -177,6 +193,12 @@ describe('plugin-meetings', () => {
         statsAnalyzer.on(EVENTS.REMOTE_MEDIA_STOPPED, (data) => {
           receivedEventsData.remote.stopped = data;
         });
+        statsAnalyzer.on(EVENTS.NO_FRAMES_SENT, (data) => {
+          receivedEventsData.noFramesSent = data;
+        });
+        statsAnalyzer.on(EVENTS.NO_VIDEO_ENCODED, (data) => {
+          receivedEventsData.noVideoEncoded = data;
+        });
       });
 
       afterEach(() => {
@@ -282,6 +304,135 @@ describe('plugin-meetings', () => {
 
         checkReceivedEvent({expected: {remote: {stopped: {type: 'video'}}}});
       });
+
+      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('processes track results and populate statsResults.resolutions object when type is inbound-rtp with video', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+        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('processes track results and populate statsResults.resolutions object when type is outbound-rtp with video', async () => {
+        await startStatsAnalyzer({expected: {receiveVideo: true}});
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+        checkStats('outbound-rtp');
+      });
+
+      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('emits NO_FRAMES_ENCODED when frames are not being encoded', async () => {
+        const expected = {mediaType: 'video'};
+        await startStatsAnalyzer({expected: {sendVideo: true}});
+
+        statsAnalyzer.lastStatsResults.video.send = {framesEncoded: 102, totalPacketsSent: 106};
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
+      });
+
+      it('emits NO_FRAMES_SENT when frames are not being sent but frames are being encoded', async () => {
+        await startStatsAnalyzer({expected: {sendVideo: true}});
+
+        const expected = {mediaType: 'video'};
+
+        statsAnalyzer.lastStatsResults.video.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
+      });
+
+      it('doesnot emits NO_FRAMES_SENT when last emitted event is LOCAL_MEDIA_STOPPED', async () => {
+        statsAnalyzer.lastEmittedStartStopEvent.video.local = EVENTS.LOCAL_MEDIA_STOPPED;
+
+        await startStatsAnalyzer({expected: {sendVideo: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'video');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
+      });
+
+      it('emits NO_FRAMES_ENCODED when frames are not being encoded for share', async () => {
+        const expected = {mediaType: 'share'};
+        await startStatsAnalyzer({expected: {sendShare: true}});
+
+        statsAnalyzer.lastStatsResults.share.send = {framesEncoded: 102, totalPacketsSent: 106};
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noVideoEncoded, expected);
+      });
+
+      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}});
+
+        statsAnalyzer.lastStatsResults.share.send = {
+          framesEncoded: 10,
+          framesSent: 105,
+          totalPacketsSent: 106,
+        };
+
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, expected);
+      });
+
+      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;
+
+        await startStatsAnalyzer({expected: {sendShare: true}});
+        await statsAnalyzer.parseGetStatsResult(statusResultOutboundRTP, 'share');
+
+        statsAnalyzer.compareLastStatsResult();
+        assert.deepEqual(receivedEventsData.noFramesSent, undefined);
+      });
     });
   });
 });