@webex/plugin-meetings 3.8.1-next.3 → 3.8.1-next.31

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

@@ -826,4 +826,75 @@ describe('plugin-meetings', () => {
       });
     });
   });
+
+  describe('#synchronizeStage', () => {
+    [
+      ['an unset stage', {overrideDefault: false}],
+      [
+        'a minimally set stage',
+        {
+          overrideDefault: true,
+          lockAttendeeViewOnStageOnly: false,
+          stageParameters: {
+            activeSpeakerProportion: 0.5,
+            showActiveSpeaker: {show: false, order: 0},
+            stageManagerType: 0,
+          },
+        },
+      ],
+      [
+        'a fully set stage',
+        {
+          overrideDefault: true,
+          lockAttendeeViewOnStageOnly: true,
+          stageParameters: {
+            activeSpeakerProportion: 0.6,
+            importantParticipants: [
+              {mainCsi: 11111111, participantId: uuidv4(), order: 1},
+              {mainCsi: 22222222, participantId: uuidv4(), order: 2},
+              {mainCsi: 33333333, participantId: uuidv4(), order: 3},
+              {mainCsi: 44444444, participantId: uuidv4(), order: 4},
+              {mainCsi: 55555555, participantId: uuidv4(), order: 5},
+              {mainCsi: 66666666, participantId: uuidv4(), order: 6},
+              {mainCsi: 77777777, participantId: uuidv4(), order: 7},
+              {mainCsi: 88888888, participantId: uuidv4(), order: 8},
+            ],
+            showActiveSpeaker: {show: true, order: 0},
+            stageManagerType: 7,
+          },
+          customLayouts: {
+            background: {url: `https://test.wbx2.com/background/${uuidv4()}.jpg`},
+            logo: {url: `https://test.wbx2.com/logo/${uuidv4()}.png`, position: 'UpperMiddle'},
+          },
+          nameLabelStyle: {
+            accentColor: '#00A3FF',
+            background: {color: 'rgba(0, 163, 255, 1)'},
+            border: {color: 'rgba(0, 163, 255, 1)'},
+            content: {
+              displayName: {color: 'rgba(255, 255, 255, 0.95)'},
+              subtitle: {color: 'rgba(255, 255, 255, 0.7)'},
+            },
+            decoration: {color: 'rgba(255, 255, 255, 0.95)'},
+            fadeOut: {delay: 15},
+            type: 'PrimaryInverted',
+          },
+        },
+      ],
+    ].forEach(([description, videoLayout]) => {
+      it(`sends request to synchronize the stage with ${description} video layout`, async () => {
+        const locusUrl = `https://locus-test.wbx2.com/locus/api/v1/loci/${uuidv4()}`;
+
+        const synchronizePromise = meetingsRequest.synchronizeStage(locusUrl, videoLayout);
+
+        assert.exists(synchronizePromise.then);
+        await synchronizePromise;
+
+        checkRequest({
+          method: 'PATCH',
+          uri: `${locusUrl}/controls`,
+          body: {videoLayout},
+        });
+      });
+    });
+  });
 });

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

@@ -1716,6 +1716,7 @@ describe('plugin-meetings', () => {
               {file: 'meetings', function: 'fetchMeetingInfo'},
               'meeting:meetingInfoAvailable'
             );
+            assert.equal(webex.meetings.meetingCollection.get(meeting.id), meeting);
           };
 
           it('creates the meeting from a successful meeting info fetch promise testing', async () => {

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

@@ -176,6 +176,20 @@ describe('plugin-meetings', () => {
         assert.calledOnce(MembersUtil.isInvalidInvitee);
         assert.isFalse(MembersUtil.isInvalidInvitee({email: 'sip:test@cisco.com'}), 'SIP email should be valid');
       });
+
+      it('should accept valid phone with isInternalNumber', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+
+        const members = createMembers({url: true});
+        
+        await members.addMember({phoneNumber: '+8618578675309', isInternalNumber: false});
+        
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.isFalse(MembersUtil.isInvalidInvitee({ phoneNumber: '+8618578675309', isInternalNumber: false }));
+        assert.isTrue(MembersUtil.isInvalidInvitee({ phoneNumber: '18578675309', isInternalNumber: false }));
+        assert.isFalse(MembersUtil.isInvalidInvitee({phoneNumber: '18578675309', isInternalNumber: true}));
+        assert.isTrue(MembersUtil.isInvalidInvitee({phoneNumber: '+8618578675309', isInternalNumber: true}));
+      });
     });
 
     describe('#admitMembers', () => {
@@ -465,29 +479,38 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#cancelSIPInvite', () => {
+    describe('#cancelInviteByMemberId', () => {
       const memberId = uuid.v4();
-      it('should invoke cancelSIPInviteOptions from MembersUtil when cancelSIPInvite is called with valid params', async () => {
-        sandbox.spy(MembersUtil, 'cancelSIPInviteOptions');
+      it('should invoke cancelInviteByMemberIdOptions from MembersUtil when cancelInviteByMemberId is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'cancelInviteByMemberIdOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.cancelInviteByMemberId({memberId});
+        assert.calledOnce(MembersUtil.cancelInviteByMemberIdOptions);
+      });
+
+      it('should invoke cancelInviteByMemberIdOptions from MembersUtil when cancelInviteByMemberId is called with isInternalNumber', async () => {
+        sandbox.spy(MembersUtil, 'cancelInviteByMemberIdOptions');
 
         const members = createMembers({url: url1});
 
-        await members.cancelSIPInvite({memberId});
-        assert.calledOnce(MembersUtil.cancelSIPInviteOptions);
+        await members.cancelInviteByMemberId({memberId, isInternalNumber: true});
+        assert.calledOnce(MembersUtil.cancelInviteByMemberIdOptions);
       });
 
       it('should throw a rejection if there is no locus url', async () => {
         const members = createMembers({url: false});
 
-        assert.isRejected(members.cancelSIPInvite({memberId}));
+        assert.isRejected(members.cancelInviteByMemberId({memberId}));
       });
       
       it('should throw a rejection if memberId is not provided', async () => {
         const members = createMembers({url: url1});
 
-        assert.isRejected(members.cancelSIPInvite({}));
-        assert.isRejected(members.cancelSIPInvite({memberId: null}));
-        assert.isRejected(members.cancelSIPInvite({memberId: undefined}));
+        assert.isRejected(members.cancelInviteByMemberId({}));
+        assert.isRejected(members.cancelInviteByMemberId({memberId: null}));
+        assert.isRejected(members.cancelInviteByMemberId({memberId: undefined}));
       });
     });
 

package/test/unit/spec/members/request.js

@@ -221,7 +221,7 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#cancelSIPInvite', () => {
+    describe('#cancelInviteByMemberId', () => {
       const memberId = uuid.v4();
       it('sends a PUT to the locus endpoint', async () => {
         const options = {
@@ -231,7 +231,7 @@ describe('plugin-meetings', () => {
           locusUrl: url1,
         };
 
-        await membersRequest.cancelSIPInvite(options);
+        await membersRequest.cancelInviteByMemberId(options);
 
         checkRequest({
           method: 'PUT',

package/test/unit/spec/members/utils.js

@@ -302,6 +302,26 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('returns the correct body with phone number and isInternalNumber', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+            isInternalNumber: false
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+              isInternalNumber: false
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
       it('returns the correct body with fallback to email', () => {
         const options = {
           invitee: {
@@ -391,14 +411,14 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#cancelSIPInviteOptions', () => {
+    describe('#cancelInviteByMemberIdOptions', () => {
       it('returns the correct options', () => {
         const locusUrl = 'TestLocusUrl';
         const memberId = 'test';
-        const invitee = {memberId};
+        const invitee = {memberId, isInternalNumber: false};
 
         assert.deepEqual(
-          MembersUtil.cancelSIPInviteOptions(
+          MembersUtil.cancelInviteByMemberIdOptions(
             invitee,
             locusUrl
           ),
@@ -410,22 +430,22 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#generateCancelSIPInviteRequestParams', () => {
+    describe('#generateCancelInviteByMemberIdRequestParams', () => {
       it('returns the correct params', () => {
         const locusUrl = 'TestLocusUrl';
         const memberId = 'test';
         const options = {
           locusUrl,
-          invitee: {memberId}
+          invitee: {memberId, isInternalNumber: false}
         };
         const body = {
           actionType: 'REMOVE',
-          invitees: [{address: options.invitee.memberId}],
+          invitees: [{address: options.invitee.memberId, isInternalNumber: false}],
         };
 
         const uri = options.locusUrl;
 
-        assert.deepEqual(MembersUtil.generateCancelSIPInviteRequestParams(options), {
+        assert.deepEqual(MembersUtil.generateCancelInviteByMemberIdRequestParams(options), {
           method: HTTP_VERBS.PUT,
           uri,
           body,

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

@@ -2764,14 +2764,10 @@ describe('isSubnetReachable', () => {
   });
 
   it('returns true if the subnet is reachable', () => {
-    assert(reachability.isSubnetReachable('1.2.3.4'));
+    assert(reachability.isSubnetReachable('1'));
   });
 
   it(`returns false if the subnet is unreachable`, () => {
-    assert(!reachability.isSubnetReachable('11.2.3.4'));
-  });
-
-  it('returns null if the subnet is not provided', () => {
-    assert.isNull(reachability.isSubnetReachable(undefined));
+    assert(!reachability.isSubnetReachable('11'));
   });
 });