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

package/test/unit/spec/member/util.js

@@ -417,6 +417,30 @@ describe('plugin-meetings', () => {
     });
   });
 
+describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
+  it('throws an error when there is no participant', () => {
+    assert.throws(() => {
+      MemberUtil.isSupportsSingleUserAutoEndMeeting();
+    }, 'Single user auto end meeting support could not be processed, participant is undefined.');
+  });
+
+  it('returns true when single user auto end meeting is supported', () => {
+    const participant = {
+      supportsSingleUserAutoEndMeeting: {},
+    };
+    assert.isTrue(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+  });
+
+  it('returns false when single user auto end meeting is not supported', () => {
+    const participant = {
+      doesNotSupportSingleUserAutoEndMeeting: {},
+    };
+
+    assert.isFalse(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+  });
+});
+
+
   describe('MemberUtil.isLiveAnnotationSupported', () => {
     it('throws an error when there is no participant', () => {
       assert.throws(() => {

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

@@ -0,0 +1,120 @@
+const { default: MembersCollection } = require("../../../../src/members/collection");
+const { default: Member } = require("../../../../src/member");
+const { assert } = require('@webex/test-helper-chai');
+
+
+describe('plugin-meetings', () => {
+  describe('MembersCollection', () => {
+    let collection;
+    let member1;
+    let member2;
+    const participant1 = { controls: {}, status: {} };
+    const participant2 = { controls: {}, status: {} };
+
+    beforeEach(() => {
+      collection = new MembersCollection();
+      member1 = new Member(participant1);
+      member2 = new Member(participant2);
+    });
+
+    it('starts with no members', () => {
+      assert.equal(Object.keys(collection.getAll()).length, 0);
+    });
+
+    it('can add members', () => {      
+      collection.set('member1', member1);
+      assert.equal(Object.keys(collection.getAll()).length, 1);
+      assert.equal(collection.get('member1'), member1);
+
+      collection.set('member2', member2);
+      assert.equal(Object.keys(collection.getAll()).length, 2);
+      assert.equal(collection.get('member2'), member2);
+    });
+
+    it('can remove members', () => {
+      // Add some members first
+      collection.set('member1', member1);
+      collection.set('member2', member2);
+      assert.equal(Object.keys(collection.getAll()).length, 2);
+
+      // Remove one member
+      collection.remove('member1');
+      assert.equal(Object.keys(collection.getAll()).length, 1);
+      assert.equal(collection.get('member1'), undefined);
+      assert.equal(collection.get('member2'), member2);
+
+      // Remove another member
+      collection.remove('member2');
+      assert.equal(Object.keys(collection.getAll()).length, 0);
+      assert.equal(collection.get('member2'), undefined);
+
+      // Removing non-existent member should not cause errors
+      collection.remove('nonExistent');
+      assert.equal(Object.keys(collection.getAll()).length, 0);
+    });
+
+    describe('reset', () => {
+      it('removes all members', () => {
+        // Add some members first
+        collection.set('member1', member1);
+        collection.set('member2', member2);
+        assert.equal(Object.keys(collection.getAll()).length, 2);
+
+        // Reset should clear all members
+        collection.reset();
+        assert.equal(Object.keys(collection.getAll()).length, 0);
+        assert.equal(collection.get('member1'), undefined);
+        assert.equal(collection.get('member2'), undefined);
+      });
+    });
+
+    describe('setAll', () => {
+      it('replaces all members with new collection', () => {
+        // Add initial member
+        collection.set('member1', member1);
+        assert.equal(Object.keys(collection.getAll()).length, 1);
+
+        // Set all with new collection
+        const newMembers = {
+          'member2': member2,
+          'member3': new Member(participant1)
+        };
+        collection.setAll(newMembers);
+
+        assert.equal(Object.keys(collection.getAll()).length, 2);
+        assert.equal(collection.get('member1'), undefined);
+        assert.equal(collection.get('member2'), member2);
+        assert.exists(collection.get('member3'));
+      });
+    });
+
+    describe('get', () => {
+      it('returns undefined for non-existent members', () => {
+        assert.equal(collection.get('nonExistent'), undefined);
+      });
+
+      it('returns correct member for existing id', () => {
+        collection.set('member1', member1);
+        assert.equal(collection.get('member1'), member1);
+      });
+    });
+
+    describe('getAll', () => {
+      it('returns empty object when no members', () => {
+        const allMembers = collection.getAll();
+        assert.isObject(allMembers);
+        assert.equal(Object.keys(allMembers).length, 0);
+      });
+
+      it('returns all members', () => {
+        collection.set('member1', member1);
+        collection.set('member2', member2);
+        
+        const allMembers = collection.getAll();
+        assert.equal(Object.keys(allMembers).length, 2);
+        assert.equal(allMembers.member1, member1);
+        assert.equal(allMembers.member2, member2);
+      });
+    });
+  });
+});

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

@@ -177,6 +177,26 @@ describe('plugin-meetings', () => {
         assert.isFalse(MembersUtil.isInvalidInvitee({email: 'sip:test@cisco.com'}), 'SIP email should be valid');
       });
 
+      it('should skip email validation if skipEmailValidation is true', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+
+        const members = createMembers({url: true});
+        
+        await members.addMember({email: '8618578675309', skipEmailValidation: true});
+        
+        assert.notCalled(MembersUtil.isInvalidInvitee);
+      });
+
+      it('should not skip email validation if skipEmailValidation is not equal true', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+
+        const members = createMembers({url: true});
+        
+        await members.addMember({email: '86185786@ds.com'});
+        
+        assert.called(MembersUtil.isInvalidInvitee);
+      });
+
       it('should accept valid phone with isInternalNumber', async () => {
         sandbox.spy(MembersUtil, 'isInvalidInvitee');
 
@@ -190,6 +210,22 @@ describe('plugin-meetings', () => {
         assert.isFalse(MembersUtil.isInvalidInvitee({phoneNumber: '18578675309', isInternalNumber: true}));
         assert.isTrue(MembersUtil.isInvalidInvitee({phoneNumber: '+8618578675309', isInternalNumber: true}));
       });
+
+      it('should not crash if params is undefined', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+
+        const members = createMembers({url: true});
+        
+        try {
+          await members.addMember(undefined);
+        } catch (err) {
+          assert.instanceOf(err, ParameterError);
+
+          assert.equal(err.message, 'The invitee must be defined with either a valid email, emailAddress or phoneNumber property.');
+        }
+              
+        assert.called(MembersUtil.isInvalidInvitee);
+      });
     });
 
     describe('#admitMembers', () => {
@@ -284,9 +320,18 @@ describe('plugin-meetings', () => {
           EVENT_TRIGGERS.MEMBERS_CLEAR,
           {}
         );
+        sinon.restore();
       });
     });
     describe('#locusParticipantsUpdate', () => {
+      beforeEach(() => {
+        sinon.stub(Trigger, 'trigger');
+      });
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
       it('should send member update event with session info', () => {
         const members = createMembers({url: url1});
         const fakePayload = {
@@ -314,6 +359,38 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should handle participants being removed', () => {
+        const members = createMembers({url: url1});
+
+        // setup the collection with a fake member
+        members.membersCollection.setAll(fakeMembersCollection);
+        assert.equal(Object.keys(members.membersCollection.getAll()).length, 1);
+
+        // remove the member
+        members.locusParticipantsUpdate({
+          participants: [],
+          removedParticipantIds: ['test1'],
+        });
+
+        assert.equal(Object.keys(members.membersCollection.getAll()).length, 0);
+
+        // check that the event was emitted
+        assert.calledWith(
+          Trigger.trigger,
+          members,
+          {
+            file: 'members',
+            function: 'locusParticipantsUpdate',
+          },
+          EVENT_TRIGGERS.MEMBERS_UPDATE,
+          {
+            delta: {added: [], updated: [], removedIds: ['test1']},
+            full: {},
+            isReplace: false,
+          }
+        );
+      });
+
       describe('handles members with paired devices correctly', () => {
         const runCheck = (propsForUpdate, expectedPropsOnPairedMember) => {
           const members = createMembers({url: url1});
@@ -937,7 +1014,8 @@ describe('plugin-meetings', () => {
         expectedMemberId,
         expectedRequestingParticipantId,
         expectedAlias,
-        expectedLocusUrl
+        expectedLocusUrl,
+        expectedSuffix
       ) => {
         await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
@@ -945,13 +1023,15 @@ describe('plugin-meetings', () => {
           expectedMemberId,
           expectedRequestingParticipantId,
           expectedAlias,
-          expectedLocusUrl
+          expectedLocusUrl,
+          expectedSuffix
         );
         assert.calledOnceWithExactly(spies.editDisplayNameMember, {
           memberId: expectedMemberId,
           requestingParticipantId: expectedRequestingParticipantId,
           alias: expectedAlias,
           locusUrl: expectedLocusUrl,
+          suffix: expectedSuffix,
         });
         assert.strictEqual(resultPromise, spies.editDisplayNameMember.getCall(0).returnValue);
       };
@@ -981,6 +1061,31 @@ describe('plugin-meetings', () => {
       });
 
       it('should make the correct request when called with respective parameters', async () => {
+        const requestingParticipantId = uuid.v4();
+        const memberId = uuid.v4();
+        const alias = 'aliasName';
+        const suffix = 'suffixName';
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.editDisplayName(
+          memberId,
+          requestingParticipantId,
+          alias,
+          suffix
+        );
+
+        await checkValid(
+          resultPromise,
+          spies,
+          memberId,
+          requestingParticipantId,
+          alias,
+          url1,
+          suffix
+        );
+      });
+
+      it('should make the correct request when called with respective parameters - no suffix', async () => {
         const requestingParticipantId = uuid.v4();
         const memberId = uuid.v4();
         const alias = 'aliasName';

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

@@ -429,6 +429,61 @@ describe('plugin-meetings', () => {
           },
         });
       });
+
+      it('sends a POST request to the locus endpoint with suffix empty string', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const aliasValue = 'alias';
+
+        const options = {
+          memberId,
+          requestingParticipantId,
+          alias: aliasValue,
+          locusUrl,
+          suffix: '',
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/alias`,
+          body: {
+            aliasValue,
+            requestingParticipantId,
+            suffixValue: '',
+          },
+        });
+      });
+
+      it('sends a POST request to the locus endpoint with suffixValue', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const aliasValue = 'alias';
+        const suffixValue = 'suffix';
+
+        const options = {
+          memberId,
+          requestingParticipantId,
+          alias: aliasValue,
+          locusUrl,
+          suffix: suffixValue,
+        };
+
+        await membersRequest.editDisplayNameMember(options);
+
+        checkRequest({
+          method: 'POST',
+          uri: `${locusUrl}/participant/${memberId}/alias`,
+          body: {
+            aliasValue,
+            requestingParticipantId,
+            suffixValue,
+          },
+        });
+      });
     });
 
     describe('#moveToLobby', () => {

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

@@ -129,7 +129,32 @@ describe('plugin-meetings', () => {
       });
     });
     describe('#generateEditDisplayNameMemberOptions', () => {
-      it('returns the correct options', () => {
+      it('returns the correct options with suffix when suffix is there', () => {
+        const locusUrl = 'urlTest1';
+        const memberId = 'test1';
+        const requestingParticipantId = 'test2';
+        const alias = 'alias';
+        const suffix = 'suffix';
+
+        assert.deepEqual(
+          MembersUtil.generateEditDisplayNameMemberOptions(
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl,
+            suffix
+          ),
+          {
+            memberId,
+            requestingParticipantId,
+            alias,
+            locusUrl,
+            suffix,
+          }
+        );
+      });
+
+      it('returns the correct options without suffix when suffix is not there', () => {
         const locusUrl = 'urlTest1';
         const memberId = 'test1';
         const requestingParticipantId = 'test2';
@@ -147,6 +172,7 @@ describe('plugin-meetings', () => {
             requestingParticipantId,
             alias,
             locusUrl,
+            suffix: undefined,
           }
         );
       });
@@ -306,7 +332,7 @@ describe('plugin-meetings', () => {
         const options = {
           invitee: {
             phoneNumber: '1234567890',
-            isInternalNumber: false
+            isInternalNumber: false,
           },
           alertIfActive: false,
         };
@@ -315,7 +341,7 @@ describe('plugin-meetings', () => {
           invitees: [
             {
               address: '1234567890',
-              isInternalNumber: false
+              isInternalNumber: false,
             },
           ],
           alertIfActive: false,
@@ -417,16 +443,10 @@ describe('plugin-meetings', () => {
         const memberId = 'test';
         const invitee = {memberId, isInternalNumber: false};
 
-        assert.deepEqual(
-          MembersUtil.cancelInviteByMemberIdOptions(
-            invitee,
-            locusUrl
-          ),
-          {
-            invitee,
-            locusUrl,
-          }
-        );
+        assert.deepEqual(MembersUtil.cancelInviteByMemberIdOptions(invitee, locusUrl), {
+          invitee,
+          locusUrl,
+        });
       });
     });
 
@@ -436,7 +456,7 @@ describe('plugin-meetings', () => {
         const memberId = 'test';
         const options = {
           locusUrl,
-          invitee: {memberId, isInternalNumber: false}
+          invitee: {memberId, isInternalNumber: false},
         };
         const body = {
           actionType: 'REMOVE',
@@ -452,5 +472,87 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+    describe('#editDisplayNameMemberRequestParams', () => {
+      it('returns the correct params when suffix is available', () => {
+        const locusUrl = 'TestLocusUrl1';
+        const memberId = 'test1';
+        const alias = 'alias1';
+        const requestingParticipantId = '23131';
+        const suffix = 'suffix1';
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          requestingParticipantId,
+          suffix,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+            suffixValue: suffix,
+          },
+        });
+      });
+
+      it('returns the correct params when suffix is not available', () => {
+        const locusUrl = 'TestLocusUrl2';
+        const memberId = 'test2';
+        const alias = 'alias2';
+        const requestingParticipantId = '12345';
+
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          requestingParticipantId,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+          },
+        });
+      });
+
+      it('returns the correct params when suffix is empty string', () => {
+        const locusUrl = 'TestLocusUrl3';
+        const memberId = 'test3';
+        const alias = 'alias3';
+        const requestingParticipantId = '322424';
+        const suffix = '';
+
+        const options = {
+          locusUrl: locusUrl,
+          memberId,
+          alias,
+          suffix,
+          requestingParticipantId,
+        };
+
+        const uri = `${locusUrl}/participant/${memberId}/alias`;
+
+        assert.deepEqual(MembersUtil.editDisplayNameMemberRequestParams(options), {
+          method: HTTP_VERBS.POST,
+          uri,
+          body: {
+            aliasValue: alias,
+            requestingParticipantId,
+            suffixValue: suffix,
+          },
+        });
+      });
+    });
   });
 });

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,
       },
     ]);
   });