@webex/plugin-meetings 3.9.0-webinar5k.1 → 3.10.0

package/test/unit/spec/locus-info/index.js

@@ -836,39 +836,6 @@ describe('plugin-meetings', () => {
         );
       });
 
-      it('should update the deltaParticipants object', () => {
-        const prev = locusInfo.deltaParticipants;
-
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        assert.notEqual(locusInfo.deltaParticipants, prev);
-      });
-
-      it('should update the delta property on all changed states', () => {
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        const [exampleParticipant] = locusInfo.deltaParticipants;
-
-        assert.isTrue(exampleParticipant.delta.audioStatus);
-        assert.isTrue(exampleParticipant.delta.videoSlidesStatus);
-        assert.isTrue(exampleParticipant.delta.videoStatus);
-      });
-
-      it('should include the person details of the changed participant', () => {
-        locusInfo.updateParticipantDeltas(newParticipants);
-
-        const [exampleParticipant] = locusInfo.deltaParticipants;
-
-        assert.equal(exampleParticipant.person, newParticipants[0].person);
-      });
-
-      it('should clear deltaParticipants when no changes occured', () => {
-        locusInfo.participants = [...newParticipants];
-
-        locusInfo.updateParticipantDeltas(locusInfo.participants);
-
-        assert.isTrue(locusInfo.deltaParticipants.length === 0);
-      });
 
       it('should call with participant display name', () => {
         const failureParticipant = [
@@ -1676,6 +1643,28 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should trigger MEETING_INFO_UPDATED even if the roles array is empty', () => {
+        const initialInfo = cloneDeep(meetingInfo);
+
+        const updateSelf = cloneDeep(self);
+        updateSelf.controls.role.roles = [];
+
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateMeetingInfo(initialInfo, updateSelf);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateMeetingInfo',
+          },
+          LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+          {
+            isInitializing: !self,
+          }
+          );
+        });
+
       const checkMeetingInfoUpdatedCalled = (expected, payload) => {
         const expectedArgs = [
           locusInfo.emitScoped,
@@ -2051,6 +2040,18 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#handleLocusAPIResponse', () => {
+      it('calls handleLocusDelta', () => {
+        const fakeLocus = {eventType: LOCUSEVENT.DIFFERENCE};
+
+        sinon.stub(locusInfo, 'handleLocusDelta');
+
+        locusInfo.handleLocusAPIResponse(mockMeeting, {locus: fakeLocus});
+
+        assert.calledWith(locusInfo.handleLocusDelta, fakeLocus, mockMeeting);
+      });
+    });
+
     describe('#LocusDeltaEvents', () => {
       const fakeMeeting = 'fakeMeeting';
       let sandbox = null;
@@ -2198,7 +2199,6 @@ describe('plugin-meetings', () => {
       it('onFullLocus() updates the working-copy of locus parser', () => {
         const eventType = 'fakeEvent';
 
-        sandbox.stub(locusInfo, 'updateParticipantDeltas');
         sandbox.stub(locusInfo, 'updateLocusInfo');
         sandbox.stub(locusInfo, 'updateParticipants');
         sandbox.stub(locusInfo, 'isMeetingActive');
@@ -2218,7 +2218,6 @@ describe('plugin-meetings', () => {
         const oldWorkingCopy = locusParser.workingCopy;
 
         const spies = [
-          sandbox.stub(locusInfo, 'updateParticipantDeltas'),
           sandbox.stub(locusInfo, 'updateLocusInfo'),
           sandbox.stub(locusInfo, 'updateParticipants'),
           sandbox.stub(locusInfo, 'isMeetingActive'),
@@ -2384,23 +2383,23 @@ describe('plugin-meetings', () => {
 
       it('applyLocusDeltaData handles LOCUS_URL_CHANGED action correctly', () => {
         const {LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
-        const fakeDeltaLocus = {id: 'fake delta locus'};
+        const fakeFullLocus = {
+          url: 'new full loci url',
+        };
         const meeting = {
           meetingRequest: {
-            getLocusDTO: sandbox.stub().resolves({body: fakeDeltaLocus}),
+            getLocusDTO: sandbox.stub().resolves({body: fakeFullLocus}),
           },
           locusInfo: {
             handleLocusDelta: sandbox.stub(),
           },
-          locusUrl: 'current locus url',
+          locusUrl: 'current BO session locus url',
         };
 
-        locusInfo.locusParser.workingCopy = {
-          syncUrl: 'current sync url',
-        };
+        locusInfo.locusParser.workingCopy = null;
 
         locusInfo.applyLocusDeltaData(LOCUS_URL_CHANGED, fakeLocus, meeting);
-        assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: 'current sync url'});
+        assert.calledOnceWithExactly(meeting.meetingRequest.getLocusDTO, {url: fakeLocus.url});
       });
 
       describe('edge cases for sync failing', () => {
@@ -3021,6 +3020,45 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#updateLocusUrl', () => {
+      it('trigger LOCUS_INFO_UPDATE_URL event with isMainLocus is true as default', () => {
+        const fakeUrl = "https://fake.com/locus";
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateLocusUrl(fakeUrl);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateLocusUrl',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_URL,
+          {
+            url: fakeUrl,
+            isMainLocus: true
+          },
+        );
+      });
+      it('trigger LOCUS_INFO_UPDATE_URL event with isMainLocus is false', () => {
+        const fakeUrl = "https://fake.com/locus";
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateLocusUrl(fakeUrl, false);
+
+        assert.calledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateLocusUrl',
+          },
+          EVENTS.LOCUS_INFO_UPDATE_URL,
+          {
+            url: fakeUrl,
+            isMainLocus: false
+          },
+        );
+      });
+    });
+
     // semi-integration tests that use real LocusInfo with real Parser
     // and test various scenarios related to handling out-of-order Locus delta events
     describe('handling of out-of-order Locus delta events', () => {
@@ -3066,7 +3104,6 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         clock = sinon.useFakeTimers();
 
-        sinon.stub(locusInfo, 'updateParticipantDeltas');
         sinon.stub(locusInfo, 'updateParticipants');
         sinon.stub(locusInfo, 'isMeetingActive');
           sinon.stub(locusInfo, 'handleOneOnOneEvent');
@@ -3239,7 +3276,6 @@ describe('plugin-meetings', () => {
         await testUtils.flushPromises();
 
         assert.calledOnceWithExactly(syncRequestStub, {url: mockMeeting.locusUrl});
-        assert.calledOnce(updateLocusInfoStub);
         assert.calledOnceWithExactly(updateLocusInfoStub, fullLocus);
       });
 
@@ -3315,322 +3351,5 @@ describe('plugin-meetings', () => {
         assert.calledWith(updateLocusInfoStub.getCall(2), deltaEvents[7]);
       });
     });
-
-    describe('Hash trees - webinar 5k', () => {
-      let mockFullLocus;
-      let clock;
-
-      beforeEach(() => {
-
-        sinon.stub(Math, 'random').returns(0.5); // to make sure the backoff timer is predictable
-
-        mockFullLocus = {
-          dataSets: [
-            {
-              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/session/a73e9f2c/datasets/main',
-              root: '9bb9d5a911a74d53a915b4dfbec7329f',
-              version: 51118,
-              leafCount: 16,
-              name: 'main',
-              idleMs : 5000,
-              backoff : {
-                maxMs : 500,
-                exponent : 0.5
-              },
-            },
-            {
-              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/session/a73e9f2c/participant/713e9f99/datasets/self',
-              root: '5b8cc7ffda1346d2bfb1c0b60b8ab601',
-              version: 89891,
-              leafCount: 1,
-              name: 'self',
-              idleMs : 10000,
-              backoff : {
-                maxMs : 500,
-                exponent : 0.5
-              },
-            },
-            {
-              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/session/a73e9f2c/datasets/atd-unmuted',
-              root: '9279d2e149da43a1b8e2cd7cbf77f9f0',
-              version: 91277,
-              leafCount: 16,
-              name: 'atd-unmuted',
-              idleMs : 15000,
-              backoff : {
-                maxMs : 500,
-                exponent : 0.5
-              },
-            },
-          ],
-          locus: {
-            url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f',
-            htMeta: {
-              elementId: {
-                type: 'LOCUS',
-                id: 0,
-                version: 5678,
-              },
-              dataSetNames: ['main'],
-            },
-            participants: [
-              {
-                url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-                person: {
-                  id: '111',
-                  name: '1st participant',
-                },
-                htMeta: {
-                  elementId: {
-                    type: 'PARTICIPANT',
-                    id: 2,
-                    version: 5678,
-                  },
-                  dataSetNames: ['atd-active', 'attendees', 'atd-unmuted'],
-                },
-              },
-              {
-                url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941034',
-                person: {
-                  id: '222',
-                  name: '2nd participant',
-                },
-                htMeta: {
-                  elementId: {
-                    type: 'PARTICIPANT',
-                    id: 3,
-                    version: 5678,
-                  },
-                  dataSetNames: ['attendees'],
-                },
-              },
-            ],
-            self: {
-              url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-              visibleDataSets: ['main', 'self', 'atd-unmuted'],
-              person: {
-                id: '333',
-                name: 'myself',
-              },
-              htMeta: {
-                elementId: {
-                  type: 'SELF',
-                  id: 4,
-                  version: 5678,
-                },
-                dataSetNames: ['self'],
-              },
-            },
-          },
-        };
-
-        clock = sinon.useFakeTimers();  
-
-      });
-
-      afterEach(() => {
-        clock.restore();
-      });
-
-      const getMaxBackoffTime = (dataSets) => {
-        return Object.values(dataSets).reduce((max, dataSet) => {
-          const maxBackOff = dataSet.idleMs + dataSet.backoff.maxMs;
-          return Math.max(max, maxBackOff);
-        }, 0);
-      }
-
-      const waitForMaxPossibleBackoffTime = async (dataSets) => {
-        const maxBackoffTime = getMaxBackoffTime(dataSets);
-        clock.tick(maxBackoffTime);
-        await testUtils.flushPromises();
-      }
-
-      it('initializes hash trees correctly from initial full locus', () => {
-        locusInfo.initialSetup(mockFullLocus.locus, mockFullLocus.dataSets);
-
-        // check that the hash tree parser is initialized correctly
-        assert.isDefined(locusInfo.hashTreeParser);
-        assert.deepEqual(Object.keys(locusInfo.hashTreeParser.dataSets), ['main', 'self', 'atd-unmuted']);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['main'].hashTree.getLeafData(0), [ { type: 'LOCUS', id: 0, version: 5678 } ]);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['self'].hashTree.getLeafData(0), [ { type: 'SELF', id: 4, version: 5678 } ]);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['atd-unmuted'].hashTree.getLeafData(2), [ { type: 'PARTICIPANT', id: 2, version: 5678 } ]);
-        
-        // participant with id=3 is not part of any of our datasets, so should be undefined
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['atd-unmuted'].hashTree.getLeafData(3), []); 
-      });
-
-      it('handles hash tree messages correctly', async () => {
-        locusInfo.initialSetup(mockFullLocus.locus, mockFullLocus.dataSets);
-
-        // simulate a hash tree message for a participant
-        locusInfo.parse(mockMeeting, {
-          "locusUrl" : "https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2",
-          "locusSessionId" : "fe3d019c-08ca-0f21-919f-f2cc646030ae",
-          "dataSets" : [ {
-            "url" : "https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2/session/fe3d019c-08ca-0f21-919f-f2cc646030ae/datasets/attendees",
-            "name" : "attendees",
-            "root" : "7cfc14bdae7909e6fe7acd37bebf66db",
-            "version" : 4739733700975,
-            "leafCount" : 16,
-            "idleMs" : 5000,
-            "backoff" : {
-              "maxMs" : 500,
-              "exponent" : 0.5
-            }
-          }, {
-            "url" : "https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2/session/fe3d019c-08ca-0f21-919f-f2cc646030ae/datasets/atd-active",
-            "name" : "atd-unmuted",
-            "root" : "178bff6e3344f551a811712c57a9eac3",
-            "version" : 5738696122316,
-            "leafCount" : 4,
-            "idleMs" : 5000,
-            "backoff" : {
-              "maxMs" : 500,
-              "exponent" : 0.5
-            }
-          } ],
-          "locusStateElements" : [ {
-            "htMeta" : {
-              "elementId" : {
-                "type" : "PARTICIPANT",
-                "id" : 2,
-                "version" : 5679
-              },
-              "dataSetNames" : [ "attendees", "atd-unmuted" ]
-            },
-            "data" : "{\"isCreator\":false,\"url\":\"https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2/participant/18ef210c-234a-49ac-83d6-1803bc401bc9\",\"id\":\"18ef210c-234a-49ac-83d6-1803bc401bc9\",\"guest\":false,\"resourceGuest\":false,\"moderator\":false,\"panelist\":false}"
-          }, {
-            "htMeta" : {
-              "elementId" : {
-                "type" : "PARTICIPANT",
-                "id" : 3,
-                "version" : 999999
-              },
-              "dataSetNames" : [ "attendees" ]
-            },
-            "data" : "{\"isCreator\":false,\"url\":\"https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2/participant/29c0751a-7ada-40a1-94a4-eb5f5c80c863\",\"id\":\"29c0751a-7ada-40a1-94a4-eb5f5c80c863\",\"guest\":false,\"resourceGuest\":false,\"moderator\":false,\"panelist\":false}"
-          } ]
-        });
-
-        // main and self should be unchanged
-        assert.deepEqual(Object.keys(locusInfo.hashTreeParser.dataSets), ['main', 'self', 'atd-unmuted']);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['main'].hashTree.getLeafData(0), [ { type: 'LOCUS', id: 0, version: 5678 } ]);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['self'].hashTree.getLeafData(0), [ { type: 'SELF', id: 4, version: 5678 } ]);
-
-        // participant should be updated
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['atd-unmuted'].hashTree.getLeafData(2), [ { type: 'PARTICIPANT', id: 2, version: 5679 } ]);
-
-        // there should be no requests to Locus sent
-        await waitForMaxPossibleBackoffTime(locusInfo.hashTreeParser.dataSets);
-        assert.notCalled(webex.request);
-      });
-
-      it('does a sync if hashes don\'t match after a timer fires', async () => {
-        const atdUnmutedDataSetUrl = mockFullLocus.dataSets[2].url;
-
-        locusInfo.initialSetup(mockFullLocus.locus, mockFullLocus.dataSets);
-
-        // simulate a hash tree message for a participant
-        locusInfo.parse(mockMeeting, {
-          "locusUrl" : "https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2",
-          "locusSessionId" : "fe3d019c-08ca-0f21-919f-f2cc646030ae",
-          "dataSets" : [ {
-            "url" : atdUnmutedDataSetUrl,
-            "name" : "atd-unmuted",
-            "root" : "deadbeef", // wrong to trigger a sync
-            "version" : 5738696122316,
-            "leafCount" : 4,
-            "idleMs" : 25000,
-            "backoff" : {
-              "maxMs" : 500,
-              "exponent" : 0.5
-            }
-          } ],
-          "locusStateElements" : [ {
-            "htMeta" : {
-              "elementId" : {
-                "type" : "PARTICIPANT",
-                "id" : 2,
-                "version" : 5679
-              },
-              "dataSetNames" : [ "attendees", "atd-unmuted" ]
-            },
-            "data" : "{\"isCreator\":false,\"url\":\"https://locus.wbx2.com/locus/api/v1/loci/dbe6eeb9-49c7-4727-bdb1-1c59fa6e56d2/participant/18ef210c-234a-49ac-83d6-1803bc401bc9\",\"id\":\"18ef210c-234a-49ac-83d6-1803bc401bc9\",\"guest\":false,\"resourceGuest\":false,\"moderator\":false,\"panelist\":false}"
-          }]
-        });
-
-        // main and self should be unchanged
-        assert.deepEqual(Object.keys(locusInfo.hashTreeParser.dataSets), ['main', 'self', 'atd-unmuted']);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['main'].hashTree.getLeafData(0), [ { type: 'LOCUS', id: 0, version: 5678 } ]);
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['self'].hashTree.getLeafData(0), [ { type: 'SELF', id: 4, version: 5678 } ]);
-
-        // participant should be updated
-        assert.deepEqual(locusInfo.hashTreeParser.dataSets['atd-unmuted'].hashTree.getLeafData(2), [ { type: 'PARTICIPANT', id: 2, version: 5679 } ]);
-
-        await testUtils.flushPromises();
-
-        // the root hash doesn't match, but we shouldn't send a request to Locus for hashes just yet
-        assert.notCalled(webex.request);
-
-        webex.request.callsFake(async (options) => {
-          if (options?.method === 'GET' && options?.uri?.endsWith('/hashtree')) {
-            return {
-              body: {
-                hashes: [
-                  '178bff6e3344f551a811712c57a9eac3',
-                  'b113a76304e3a7121afecfe1606ee1c1',
-                  'ae70773ebb3be3653209648071b9bdad',
-                  '99aa06d3014798d86001c324468d497f',
-                  '99aa06d3014798d86001c324468d497f',
-                  'deadbeef', // wrong hash that should cause the participant with id=2 to be deemed out of sync
-                  '99aa06d3014798d86001c324468d497f'
-                ]
-              }
-            };
-          } else if (options?.method === 'POST' && options?.uri?.endsWith('/sync')) {
-            return {
-              body: {},
-              statusCode: 202,
-            };
-          }
-          return {};
-        });
-
-        // only after timeout there should be requests to get hashes and sync sent to Locus
-        await waitForMaxPossibleBackoffTime(locusInfo.hashTreeParser.dataSets);
-        assert.calledTwice(webex.request);
-        
-        const firstCallArgs = webex.request.getCall(0).args[0];
-        const secondCallArgs = webex.request.getCall(1).args[0];
-
-        assert.deepEqual(firstCallArgs, {method: 'GET', uri: `${atdUnmutedDataSetUrl}/hashtree`});
-
-        assert.deepEqual(secondCallArgs, {method: 'POST', uri: `${atdUnmutedDataSetUrl}/sync`,
-          body: {
-            dataSet: {
-              name: 'atd-unmuted',
-              leafCount: 16,
-              root: '178bff6e3344f551a811712c57a9eac3',
-            },
-            leafDataEntries: [{
-              leafIndex: 2,
-              elementIds: [
-                {
-                  id: 2,
-                  type: "PARTICIPANT",
-                  version: 5679
-                }
-              ],
-            }]
-          }
-        });        
-      });
-
-      it('handles end meeting message correctly', async () => {
-      });
-      it('handles heartbeat messages correctly', async () => {
-      });
-
-    });
   });
 });

package/test/unit/spec/locus-info/parser.js

@@ -253,7 +253,8 @@ describe('locus-info/parser', () => {
     });
     
     it('replaces current loci when the locus URL changes and incoming sequence is later, even when baseSequence doesn\'t match', () => {
-      const {USE_INCOMING} = LocusDeltaParser.loci;
+      const {LOCUS_URL_CHANGED} = LocusDeltaParser.loci;
+      sandbox.stub(LocusDeltaParser, 'compare').returns(LOCUS_URL_CHANGED);
 
       parser.queue.dequeue = sandbox.stub().returns(NEW_LOCI);
       parser.onDeltaAction = sandbox.stub();
@@ -262,7 +263,7 @@ describe('locus-info/parser', () => {
 
       parser.processDeltaEvent();
 
-      assert.equal(parser.workingCopy, NEW_LOCI);
+      assert.equal(parser.workingCopy, null);
     });
 
     it('does not replace current loci when the locus URL changes but incoming sequence is not later', () => {

package/test/unit/spec/media/properties.ts

@@ -6,6 +6,8 @@ import * as tsSdpModule from '@webex/ts-sdp';
 import MediaProperties from '@webex/plugin-meetings/src/media/properties';
 import {Defer} from '@webex/common';
 import MediaConnectionAwaiter from '../../../../src/media/MediaConnectionAwaiter';
+import Metrics from '../../../../src/metrics';
+import BEHAVIORAL_METRICS from '../../../../src/metrics/constants';
 
 describe('MediaProperties', () => {
   let mediaProperties;
@@ -389,4 +391,139 @@ describe('MediaProperties', () => {
       });
     });
   });
+
+  // issue types and subtypes used in these tests are just examples
+  // they don't reflect real issue types/subtypes used in production
+  describe('sendMediaIssueMetric', () => {
+    let sendBehavioralMetricStub;
+    let clock;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+      sendBehavioralMetricStub = sinon.stub(Metrics, 'sendBehavioralMetric');
+    });
+
+    afterEach(() => {
+      clock.restore();
+    });
+
+    it('should send a behavioral metric with correct parameters', () => {
+      const issueType = 'audio';
+      const issueSubType = 'packet-loss';
+      const correlationId = 'test-correlation-id-123';
+
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+
+      assert.calledOnce(sendBehavioralMetricStub);
+      assert.calledWith(sendBehavioralMetricStub, BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED, {
+        correlationId,
+        'audio_packet-loss': 1,
+      });
+    });
+
+    it('should increment count while being throttled and reset it once metric goes out', () => {
+      const issueType = 'video';
+      const issueSubType = 'freeze';
+      const correlationId = 'test-correlation-id';
+
+      // Call multiple times with same issue type/subtype
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+
+      // First call should go through immediately, subsequent calls are throttled
+      assert.calledOnce(sendBehavioralMetricStub);
+      assert.calledWith(sendBehavioralMetricStub, BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED, {
+        correlationId,
+        video_freeze: 1, // Only the first call goes through due to throttling
+      });
+      sendBehavioralMetricStub.resetHistory();
+
+      assert.equal(mediaProperties.mediaIssueCounters['video_freeze'], 2); // counter should be reset after the first metric goes out, hence only 2 not 3 here
+
+      clock.tick(5 * 60 * 1000); // Advance time by 5 minutes to expire throttle
+
+      assert.calledOnceWithExactly(
+        sendBehavioralMetricStub,
+        BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED,
+        {
+          correlationId,
+          video_freeze: 2,
+        }
+      );
+    });
+
+    it('should track different issue types separately in counters', () => {
+      const correlationId = 'test-correlation-id';
+
+      // Send different issue types
+      mediaProperties.sendMediaIssueMetric('audio', 'packet-loss', correlationId);
+      mediaProperties.sendMediaIssueMetric('video', 'freeze', correlationId);
+      mediaProperties.sendMediaIssueMetric('audio', 'packet-loss', correlationId);
+      mediaProperties.sendMediaIssueMetric('audio', 'packet-loss', correlationId);
+      mediaProperties.sendMediaIssueMetric('audio', 'packet-loss', correlationId);
+      mediaProperties.sendMediaIssueMetric('video', 'freeze', correlationId);
+
+      // First call should go through immediately, subsequent calls are throttled
+      assert.calledOnceWithExactly(
+        sendBehavioralMetricStub,
+        BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED,
+        {
+          correlationId,
+          'audio_packet-loss': 1,
+        }
+      );
+
+      // But the counters should be tracked separately
+      assert.equal(mediaProperties.mediaIssueCounters['audio_packet-loss'], 3);
+      assert.equal(mediaProperties.mediaIssueCounters['video_freeze'], 2);
+
+      sendBehavioralMetricStub.resetHistory();
+
+      clock.tick(5 * 60 * 1000); // Advance time by 5 minutes to expire throttle
+
+      assert.calledOnceWithExactly(
+        sendBehavioralMetricStub,
+        BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED,
+        {
+          correlationId,
+          video_freeze: 2,
+          'audio_packet-loss': 3,
+        }
+      );
+    });
+
+    it('should flush throttled metrics when unsetPeerConnection is called', () => {
+      const issueType = 'share';
+      const issueSubType = 'connection-lost';
+      const correlationId = 'test-correlation-id';
+
+      // Send metrics multiple times
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+      mediaProperties.sendMediaIssueMetric(issueType, issueSubType, correlationId);
+
+      // First call should go through immediately
+      assert.calledOnceWithExactly(
+        sendBehavioralMetricStub,
+        BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED,
+        {
+          correlationId,
+          'share_connection-lost': 1,
+        }
+      );
+      sendBehavioralMetricStub.resetHistory();
+
+      // Call unsetPeerConnection which should flush throttled metrics
+      mediaProperties.unsetPeerConnection();
+
+      assert.calledOnceWithExactly(
+        sendBehavioralMetricStub,
+        BEHAVIORAL_METRICS.MEDIA_ISSUE_DETECTED,
+        {
+          correlationId,
+          'share_connection-lost': 1,
+        }
+      );
+    });
+  });
 });