@webex/plugin-meetings 3.8.1-web-workers-keepalive.1 → 3.9.0-multipleLLM.1

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -3,7 +3,7 @@ import {MediaRequestManager} from '@webex/plugin-meetings/src/multistream/mediaR
 import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
-import {getMaxFs} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {getMaxFs, MAX_FS_VALUES} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import FakeTimers from '@sinonjs/fake-timers';
 import * as InternalMediaCoreModule from '@webex/internal-media-core';
 import { expect } from 'chai';
@@ -36,12 +36,15 @@ describe('MediaRequestManager', () => {
   const CROSS_POLICY_DUPLICATION = true;
   const MAX_FPS = 3000;
   const MAX_FS_360p = 920;
+  const MAX_FS_540p = 2040;
   const MAX_FS_720p = 3600;
   const MAX_FS_1080p = 8192;
   const MAX_MBPS_360p = 27600;
+  const MAX_MBPS_540p = 61200;
   const MAX_MBPS_720p = 108000;
   const MAX_MBPS_1080p = 245760;
   const MAX_PAYLOADBITSPS_360p = 640000;
+  const MAX_PAYLOADBITSPS_540p = 880000;
   const MAX_PAYLOADBITSPS_720p = 2500000;
   const MAX_PAYLOADBITSPS_1080p = 4000000;
 
@@ -82,7 +85,14 @@ describe('MediaRequestManager', () => {
   });
 
   // helper function for adding an active speaker request
-  const addActiveSpeakerRequest = (priority, receiveSlots, maxFs, commit = false, preferLiveVideo = true, namedMediaGroups = undefined) =>
+  const addActiveSpeakerRequest = (
+    priority,
+    receiveSlots,
+    maxFs,
+    commit = false,
+    preferLiveVideo = true,
+    namedMediaGroups = undefined
+  ) =>
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -216,6 +226,9 @@ describe('MediaRequestManager', () => {
       },
       false
     );
+
+
+
     mediaRequestManager.addRequest(
       {
         policyInfo: {
@@ -892,15 +905,15 @@ describe('MediaRequestManager', () => {
     // request 10 "large" 1080p streams
     addActiveSpeakerRequest(255, fakeReceiveSlots.slice(0, 10), getMaxFs('large'), true);
 
-    // check that resulting requests are 10 "small" 360p streams
+    // check that resulting requests are 10 540p streams
     checkMediaRequestsSent([
       {
         policy: 'active-speaker',
         priority: 255,
         receiveSlots: fakeWcmeSlots.slice(0, 10),
-        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_360p,
-        maxFs: getMaxFs('small'),
-        maxMbps: MAX_MBPS_360p,
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_540p,
+        maxFs:  MAX_FS_VALUES['540p'],
+        maxMbps: MAX_MBPS_540p,
       },
     ]);
   });

package/test/unit/spec/multistream/remoteMedia.ts

@@ -3,7 +3,7 @@ import 'jsdom-global/register';
 import EventEmitter from 'events';
 
 import {MediaType} from '@webex/internal-media-core';
-import {RemoteMedia, RemoteMediaEvents} from '@webex/plugin-meetings/src/multistream/remoteMedia';
+import {RemoteMedia, RemoteMediaEvents, RemoteVideoResolution} from '@webex/plugin-meetings/src/multistream/remoteMedia';
 import {ReceiveSlotEvents} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
@@ -257,7 +257,9 @@ describe('RemoteMedia', () => {
         {height: 198, fs: 920}, // 360p
         {height: 360, fs: 920},
         {height: 395, fs: 920},
-        {height: 396, fs: 3600}, // 720p
+        {height: 396, fs: 2040}, // 540p
+        {height: 540, fs: 2040},
+        {height: 610, fs: 3600}, // 720p
         {height: 720, fs: 3600},
         {height: 721, fs: 8192}, // 1080p
         {height: 1080, fs: 8192},
@@ -271,4 +273,66 @@ describe('RemoteMedia', () => {
       }
     );
   });
+
+  describe('getEffectiveMaxFs()', () => {
+    it('returns maxFrameSize when it is greater than 0', () => {
+      remoteMedia.setSizeHint(960, 540);
+
+      const result = remoteMedia.getEffectiveMaxFs();
+
+      assert.strictEqual(result, 2040);
+    });
+
+    it('returns getMaxFs result when maxFrameSize is 0 and resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // 'medium' resolution should map to 720p which is 3600
+      assert.strictEqual(result, 3600);
+    });
+
+    it('returns undefined when maxFrameSize is 0 and no resolution is provided', () => {
+      remoteMedia.setSizeHint(0, 0);
+
+      // Create a new RemoteMedia without resolution option
+      const remoteMediaWithoutResolution = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager);
+      
+      const result = remoteMediaWithoutResolution.getEffectiveMaxFs();
+      
+      assert.strictEqual(result, undefined);
+    });
+
+    it('prioritizes maxFrameSize over resolution option', () => {
+      remoteMedia.setSizeHint(640, 360);
+      // remoteMedia was created with {resolution: 'medium'} in beforeEach
+
+      const result = remoteMedia.getEffectiveMaxFs();
+      
+      // Should return maxFrameSize (500) instead of resolution-based value (3600)
+      assert.strictEqual(result, 920);
+    });
+
+    it('works correctly with different resolution options', () => {
+      const testCases: Array<{ resolution: RemoteVideoResolution; expected: number }> = [
+        { resolution: 'thumbnail', expected: 60 },
+        { resolution: 'very small', expected: 240 },
+        { resolution: 'small', expected: 920 },
+        { resolution: 'medium', expected: 3600 },
+        { resolution: 'large', expected: 8192 },
+        { resolution: 'best', expected: 8192 },
+      ];
+
+      testCases.forEach(({ resolution, expected }) => {
+        const testRemoteMedia = new RemoteMedia(fakeReceiveSlot, fakeMediaRequestManager, { resolution });
+        testRemoteMedia.setSizeHint(0, 0); // Ensure maxFrameSize doesn't interfere
+
+        const result = testRemoteMedia.getEffectiveMaxFs();
+        
+        assert.strictEqual(result, expected, `Failed for resolution: ${resolution}`);
+      });
+    });
+  });
 });

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -272,4 +272,63 @@ describe('SendSlotsManager', () => {
             expect(() => sendSlotsManager.getSlot(MediaType.VideoSlides)).to.throw();
         });
     });
+
+    describe('sourceStateOverride', () => {
+      let mediaConnection: MultistreamRoapMediaConnection;
+      beforeEach(() => {
+        mediaConnection = {
+          createSendSlot: sinon.stub().returns({
+            setSourceStateOverride: sinon.stub().resolves(),
+            clearSourceStateOverride: sinon.stub().resolves(),
+          }),
+        } as MultistreamRoapMediaConnection;
+      });
+
+      it(`can set source state override for ${MediaType.VideoMain}`, () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+
+        const set = () => sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(set).not.to.throw();
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+      });
+
+      [MediaType.VideoSlides, MediaType.AudioMain, MediaType.AudioSlides].forEach((mediaType) => {
+        it(`can't set source state override for ${mediaType}`, () => {
+          const slot: any = sendSlotsManager.createSlot(mediaConnection, mediaType);
+
+          const set = () => sendSlotsManager.setSourceStateOverride(mediaType, 'away');
+
+          expect(set).to.throw();
+          expect(slot.setSourceStateOverride.called).to.be.false;
+        });
+      });
+
+      it("can't set source state override for non-existing slot", () => {
+        const set = () => sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+        expect(set).to.throw(`Slot for ${MediaType.VideoMain} does not exist`);
+      });
+
+      it('can clear source state override', () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+        expect(slot.clearSourceStateOverride.called).to.be.false;
+
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, null);
+        expect(slot.clearSourceStateOverride.called).to.be.true;
+      });
+
+      it("won't set source state override if it didn't change", () => {
+        const slot: any = sendSlotsManager.createSlot(mediaConnection, MediaType.VideoMain);
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+
+        expect(slot.setSourceStateOverride.calledWith('away')).to.be.true;
+        slot.setSourceStateOverride.resetHistory();
+
+        sendSlotsManager.setSourceStateOverride(MediaType.VideoMain, 'away');
+        expect(slot.setSourceStateOverride.called).to.be.false;
+      });
+    });
 });

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

@@ -3,13 +3,14 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import sinon from 'sinon';
 import EventEmitter from 'events';
 import testUtils from '../../../utils/testUtils';
-import Reachability, {ReachabilityResultsForBackend} from '@webex/plugin-meetings/src/reachability/';
+import Reachability from '@webex/plugin-meetings/src/reachability/';
 import {ClusterNode} from '../../../../src/reachability/request';
 import MeetingUtil from '@webex/plugin-meetings/src/meeting/util';
 import * as ClusterReachabilityModule from '@webex/plugin-meetings/src/reachability/clusterReachability';
 import Metrics from '@webex/plugin-meetings/src/metrics';
 
 import {IP_VERSION} from '@webex/plugin-meetings/src/constants';
+import { ReachabilityResultsForBackend } from '@webex/plugin-meetings/src/reachability/reachability.types';
 
 describe('isAnyPublicClusterReachable', () => {
   let webex;
@@ -834,6 +835,162 @@ describe('gatherReachability', () => {
       },
     },
     // ========================================================================
+    {
+      title: '2 clusters: one with multiple urls, reachability should resolve after the first result for each protocol is ready',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1-1', 'udp-url1-2'],
+          tcp: ['tcp-url1-1', 'tcp-url1-2'],
+          xtls: ['xtls-url1-1', 'xtls-url1-2'],
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: ['udp-url2'],
+          tcp: ['tcp-url2'],
+          xtls: ['xtls-url2'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        // results are only for the first url for each protocol not the 2nd one
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 100,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 20,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'tcp',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 110,
+          },
+        },
+        {
+          clusterId: 'cluster2',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 220,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'reachable', latencyInMilliseconds: 100},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+        cluster2: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 20},
+          tcp: {result: 'reachable', latencyInMilliseconds: 110},
+          xtls: {result: 'reachable', latencyInMilliseconds: 220},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 20,
+        public_udp_average: 15,
+        public_tcp_min: 100,
+        public_tcp_max: 110,
+        public_tcp_average: 105,
+        public_xtls_min: 200,
+        public_xtls_max: 220,
+        public_xtls_average: 210,
+      },
+    },
+    // ========================================================================
+    {
+      title: '1 cluster with zero urls for TCP, reachability should resolve after the first result for each protocol is ready without waiting for TCP',
+      waitShortTimeout: false,
+      waitLongTimeout: false,
+      mockClusters: {
+        cluster1: {
+          udp: ['udp-url1'],
+          tcp: [],
+          xtls: ['xtls-url1'],
+          isVideoMesh: false,
+        },
+      },
+      mockResultReadyEvents: [
+        {
+          clusterId: 'cluster1',
+          protocol: 'udp',
+          result: {
+            result: 'reachable',
+            clientMediaIPs: ['1.2.3.4'],
+            latencyInMilliseconds: 10,
+          },
+        },
+        {
+          clusterId: 'cluster1',
+          protocol: 'xtls',
+          result: {
+            result: 'reachable',
+            latencyInMilliseconds: 200,
+          },
+        },
+      ],
+      expectedResults: {
+        cluster1: {
+          udp: {result: 'reachable', clientMediaIPs: ['1.2.3.4'], latencyInMilliseconds: 10},
+          tcp: {result: 'untested'},
+          xtls: {result: 'reachable', latencyInMilliseconds: 200},
+          isVideoMesh: false,
+        },
+      },
+      expectedMetrics: {
+        vmn_udp_min: -1,
+        vmn_udp_max: -1,
+        vmn_udp_average: -1,
+        public_udp_min: 10,
+        public_udp_max: 10,
+        public_udp_average: 10,
+        public_tcp_min: -1,
+        public_tcp_max: -1,
+        public_tcp_average: -1,
+        public_xtls_min: 200,
+        public_xtls_max: 200,
+        public_xtls_average: 200,
+      },
+    },
+    // ========================================================================
     {
       title: '2 clusters: both with no results at all',
       waitShortTimeout: 'public',