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

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

@@ -189,6 +189,7 @@ describe('plugin-meetings', () => {
           },
           callDiagnosticMetrics: {
             clearErrorCache: sinon.stub(),
+            clearEventLimits: sinon.stub(),
           },
         },
       });
@@ -1098,6 +1099,7 @@ describe('plugin-meetings', () => {
         const FAKE_USE_RANDOM_DELAY = true;
         const correlationId = 'my-correlationId';
         const sessionCorrelationId = 'my-session-correlationId';
+        const classificationId = 'my-classificationId';
         const callStateForMetrics = {
           sessionCorrelationId: 'my-session-correlationId2',
           correlationId: 'my-correlationId2',
@@ -1118,7 +1120,8 @@ describe('plugin-meetings', () => {
             callStateForMetrics,
             undefined,
             undefined,
-            sessionCorrelationId
+            sessionCorrelationId,
+            classificationId
           );
           assert.calledOnceWithExactly(fakeMeeting.updateCallStateForMetrics, {
             ...callStateForMetrics,
@@ -1200,6 +1203,13 @@ describe('plugin-meetings', () => {
           );
         });
 
+        it('calls createMeeting with classificationId and returns its promise', async () => {
+          await checkCallCreateMeeting(
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, undefined, true, callStateForMetrics, undefined, undefined, undefined, classificationId],
+            [test1, test2, FAKE_USE_RANDOM_DELAY, {}, callStateForMetrics, true, undefined, undefined, classificationId],
+          );
+        });
+
         it('calls createMeeting with callStateForMetrics overwritten with correlationId and returns its promise', async () => {
           await checkCallCreateMeeting(
             [test1, test2, FAKE_USE_RANDOM_DELAY, {}, correlationId, true, callStateForMetrics],
@@ -1716,6 +1726,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/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

@@ -176,6 +176,56 @@ describe('plugin-meetings', () => {
         assert.calledOnce(MembersUtil.isInvalidInvitee);
         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');
+
+        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}));
+      });
+
+      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', () => {
@@ -270,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 = {
@@ -293,13 +352,45 @@ describe('plugin-meetings', () => {
           },
           EVENT_TRIGGERS.MEMBERS_UPDATE,
           {
-            delta: {added: [], updated: []},
+            delta: {added: [], updated: [], removedIds: []},
             full: {},
             isReplace: true,
           }
         );
       });
 
+      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});
@@ -465,29 +556,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}));
       });
     });
 
@@ -914,7 +1014,8 @@ describe('plugin-meetings', () => {
         expectedMemberId,
         expectedRequestingParticipantId,
         expectedAlias,
-        expectedLocusUrl
+        expectedLocusUrl,
+        expectedSuffix
       ) => {
         await assert.isFulfilled(resultPromise);
         assert.calledOnceWithExactly(
@@ -922,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);
       };
@@ -958,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

@@ -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',
@@ -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,
           }
         );
       });
@@ -302,6 +328,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,46 +437,122 @@ 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(
-            invitee,
-            locusUrl
-          ),
-          {
-            invitee,
-            locusUrl,
-          }
-        );
+        assert.deepEqual(MembersUtil.cancelInviteByMemberIdOptions(invitee, locusUrl), {
+          invitee,
+          locusUrl,
+        });
       });
     });
 
-    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,
         });
       });
     });
+
+    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,
+          },
+        });
+      });
+    });
   });
 });