@webex/plugin-meetings 3.11.0 → 3.12.0-next.2

package/test/unit/spec/aiEnableRequest/utils.ts

@@ -0,0 +1,130 @@
+import {assert} from '@webex/test-helper-chai';
+import {getAIEnablementApprover} from '../../../../src/aiEnableRequest/utils';
+import {Meeting} from '../../../../src';
+
+describe('AI Enable Request Utils', () => {
+  describe('#getAIEnablementApprover', () => {
+    const createMember = (id, roles, canApproveAIEnablement) => ({
+      id,
+      roles,
+      canApproveAIEnablement,
+    });
+
+    const createMeeting = (members) =>
+      ({
+        members: {
+          membersCollection: {
+            members: members.reduce((acc, member) => {
+              acc[member.id] = member;
+              return acc;
+            }, {}),
+          },
+        },
+      } as Meeting);
+
+    it('should return host id when host has moderator role and canApproveAIEnablement', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, true);
+      const member1 = createMember('member-456', {moderator: false, cohost: false}, false);
+      const meeting = createMeeting([host, member1]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.equal(result, 'host-123');
+    });
+
+    it('should return null when host exists but does not have canApproveAIEnablement', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, false);
+      const member1 = createMember('member-456', {moderator: false, cohost: false}, false);
+      const meeting = createMeeting([host, member1]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.isNull(result);
+    });
+
+    it('should return first cohost id (alphabetically) when host does not have capability but cohosts do', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, false);
+      const cohost1 = createMember('cohost-zzz', {moderator: false, cohost: true}, true);
+      const cohost2 = createMember('cohost-aaa', {moderator: false, cohost: true}, true);
+      const cohost3 = createMember('cohost-mmm', {moderator: false, cohost: true}, true);
+      const meeting = createMeeting([host, cohost1, cohost2, cohost3]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.equal(result, 'cohost-aaa');
+    });
+
+    it('should return null when no host exists and no cohosts have capability', () => {
+      const member1 = createMember('member-123', {moderator: false, cohost: false}, false);
+      const member2 = createMember('member-456', {moderator: false, cohost: false}, false);
+      const meeting = createMeeting([member1, member2]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.isNull(result);
+    });
+
+    it('should return null when cohosts exist but none have canApproveAIEnablement', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, false);
+      const cohost1 = createMember('cohost-111', {moderator: false, cohost: true}, false);
+      const cohost2 = createMember('cohost-222', {moderator: false, cohost: true}, false);
+      const meeting = createMeeting([host, cohost1, cohost2]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.isNull(result);
+    });
+
+    it('should prioritize host over cohosts even if cohosts have capability', () => {
+      const host = createMember('host-zzz', {moderator: true, cohost: false}, true);
+      const cohost1 = createMember('cohost-aaa', {moderator: false, cohost: true}, true);
+      const meeting = createMeeting([cohost1, host]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.equal(result, 'host-zzz');
+    });
+
+    it('should handle a single cohost with capability when no host has capability', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, false);
+      const cohost = createMember('cohost-999', {moderator: false, cohost: true}, true);
+      const meeting = createMeeting([host, cohost]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.equal(result, 'cohost-999');
+    });
+
+    it('should handle empty members collection', () => {
+      const meeting = createMeeting([]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.isNull(result);
+    });
+
+    it('should correctly sort cohosts by id string (not numeric)', () => {
+      const host = createMember('host-123', {moderator: true, cohost: false}, false);
+      const cohost1 = createMember('cohost-20', {moderator: false, cohost: true}, true);
+      const cohost2 = createMember('cohost-100', {moderator: false, cohost: true}, true);
+      const cohost3 = createMember('cohost-3', {moderator: false, cohost: true}, true);
+      const meeting = createMeeting([host, cohost1, cohost2, cohost3]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      // Alphabetically: "cohost-100" < "cohost-20" < "cohost-3"
+      assert.equal(result, 'cohost-100');
+    });
+
+    it('should handle members with both moderator and cohost roles', () => {
+      // If someone is both moderator and cohost with capability, they should be found as host
+      const hostCohost = createMember('host-cohost-123', {moderator: true, cohost: true}, true);
+      const member = createMember('member-456', {moderator: false, cohost: false}, false);
+      const meeting = createMeeting([hostCohost, member]);
+
+      const result = getAIEnablementApprover(meeting);
+
+      assert.equal(result, 'host-cohost-123');
+    });
+  });
+});

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

@@ -7,6 +7,7 @@ import LLMChannel from '@webex/internal-plugin-llm';
 
 import AnnotationService from '../../../../src/annotation/index';
 import {ANNOTATION_RELAY_TYPES, ANNOTATION_REQUEST_TYPE, EVENT_TRIGGERS} from '../../../../src/annotation/constants';
+import {LLM_PRACTICE_SESSION} from '../../../../src/constants';
 
 
 describe('live-annotation', () => {
@@ -28,6 +29,7 @@ describe('live-annotation', () => {
       annotationService = webex.internal.annotation;
       annotationService.connect = sinon.stub().resolves(true);
       annotationService.webex.internal.llm.isConnected = sinon.stub().returns(true);
+      annotationService.webex.internal.llm.getSocket = sinon.stub().returns(undefined);
       annotationService.webex.internal.llm.getBinding = sinon.stub().returns(undefined);
       annotationService.webex.internal.llm.getLocusUrl = sinon.stub().returns(locusUrl);
       annotationService.approvalUrl = 'url/approval';
@@ -183,7 +185,13 @@ describe('live-annotation', () => {
 
         annotationService.listenToEvents();
 
-        assert.calledOnceWithExactly(spy, 'event:relay.event', sinon.match.func,sinon.match.object);
+        assert.calledWithExactly(spy.firstCall, 'event:relay.event', sinon.match.func, sinon.match.object);
+        assert.calledWithExactly(
+          spy.secondCall,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          sinon.match.func,
+          sinon.match.object
+        );
       });
 
     });
@@ -226,14 +234,11 @@ describe('live-annotation', () => {
     });
 
     describe('sendStrokeData', () => {
+      let strokeData;
 
       beforeEach(async () => {
         annotationService.webex.internal.llm.socket = new MockWebSocket();
-      });
-
-
-      it('works on publish Stroke Data', async () => {
-        const strokeData = {
+        strokeData = {
           content: {
             "contentsBuffer": [{
               "contentArray": [{
@@ -249,8 +254,11 @@ describe('live-annotation', () => {
           shareInstanceId: '7fa6fe07-dcb1-41ad-973d-7bcf65fab55d',
           encryptionKeyUrl: "encryptionKeyUrl",
           version: '1',
-        } ;
+        };
+      });
+
 
+      it('works on publish Stroke Data', async () => {
         annotationService.publishEncrypted(strokeData.content, strokeData);
 
         const sendObject = {
@@ -283,6 +291,49 @@ describe('live-annotation', () => {
         assert.calledOnceWithExactly(annotationService.webex.internal.llm.socket.send, sendObject);
       });
 
+      it('uses the practice-session socket and binding only when the practice-session session is connected', () => {
+        const practiceSocket = new MockWebSocket();
+
+        annotationService.webex.internal.llm.isConnected.callsFake((sessionId) =>
+          sessionId === LLM_PRACTICE_SESSION
+        );
+        annotationService.webex.internal.llm.getSocket
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns(practiceSocket);
+        annotationService.webex.internal.llm.getBinding
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns('practice-binding');
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        assert.calledOnce(practiceSocket.send);
+        assert.notCalled(annotationService.webex.internal.llm.socket.send);
+
+        const sent = practiceSocket.send.getCall(0).args[0];
+        assert.equal(sent.recipients.route, 'practice-binding');
+      });
+
+      it('falls back to the default socket and binding when the practice-session socket exists but is not connected', () => {
+        const practiceSocket = new MockWebSocket();
+
+        annotationService.webex.internal.llm.isConnected.callsFake((sessionId) => !sessionId);
+        annotationService.webex.internal.llm.getSocket
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns(practiceSocket);
+        annotationService.webex.internal.llm.getBinding
+          .withArgs(LLM_PRACTICE_SESSION)
+          .returns('practice-binding');
+        annotationService.webex.internal.llm.getBinding.returns('default-binding');
+
+        annotationService.publishEncrypted(strokeData.content, strokeData);
+
+        assert.notCalled(practiceSocket.send);
+        assert.calledOnce(annotationService.webex.internal.llm.socket.send);
+
+        const sent = annotationService.webex.internal.llm.socket.send.getCall(0).args[0];
+        assert.equal(sent.recipients.route, 'default-binding');
+      });
+
     });
 
 
@@ -441,10 +492,21 @@ describe('live-annotation', () => {
           annotationService.eventDataProcessor,
           annotationService
         );
+        assert.calledWith(
+          llmOn,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          annotationService.eventDataProcessor,
+          annotationService
+        );
         assert.match(annotationService.hasSubscribedToEvents, true);
 
         annotationService.deregisterEvents();
         assert.calledWith(llmOff, 'event:relay.event', annotationService.eventDataProcessor);
+        assert.calledWith(
+          llmOff,
+          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          annotationService.eventDataProcessor
+        );
         assert.calledWith(
           mercuryOff,
           'event:locus.approval_request',

package/test/unit/spec/hashTree/hashTree.ts

@@ -652,4 +652,70 @@ describe('HashTree', () => {
       expect(() => hashTree.computeLeafHash(2)).to.not.throw();
     });
   });
+
+  describe('getItemVersion', () => {
+    it('should return version when item exists', () => {
+      const items: LeafDataItem[] = [
+        {type: 'participant', id: 1, version: 5},
+        {type: 'self', id: 2, version: 10},
+      ];
+      const hashTree = new HashTree(items, 4);
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.equal(5);
+      expect(hashTree.getItemVersion(2, 'self')).to.equal(10);
+    });
+
+    it('should return undefined when item does not exist', () => {
+      const items: LeafDataItem[] = [{type: 'participant', id: 1, version: 5}];
+      const hashTree = new HashTree(items, 4);
+
+      expect(hashTree.getItemVersion(999, 'participant')).to.be.undefined;
+    });
+
+    it('should return undefined when type does not match', () => {
+      const items: LeafDataItem[] = [{type: 'participant', id: 1, version: 5}];
+      const hashTree = new HashTree(items, 4);
+
+      expect(hashTree.getItemVersion(1, 'self')).to.be.undefined;
+    });
+
+    it('should return undefined for tree with 0 leaves', () => {
+      const hashTree = new HashTree([], 0);
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.be.undefined;
+    });
+
+    it('should return correct version when multiple items exist in same leaf', () => {
+      const items: LeafDataItem[] = [
+        {type: 'participant', id: 1, version: 3}, // leaf 1 (1 % 2 = 1)
+        {type: 'self', id: 3, version: 7}, // leaf 1 (3 % 2 = 1)
+        {type: 'locus', id: 5, version: 12}, // leaf 1 (5 % 2 = 1)
+      ];
+      const hashTree = new HashTree(items, 2);
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.equal(3);
+      expect(hashTree.getItemVersion(3, 'self')).to.equal(7);
+      expect(hashTree.getItemVersion(5, 'locus')).to.equal(12);
+    });
+
+    it('should return updated version after item is updated', () => {
+      const hashTree = new HashTree([{type: 'participant', id: 1, version: 5}], 4);
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.equal(5);
+
+      hashTree.putItem({type: 'participant', id: 1, version: 10});
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.equal(10);
+    });
+
+    it('should return undefined after item is removed', () => {
+      const hashTree = new HashTree([{type: 'participant', id: 1, version: 5}], 4);
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.equal(5);
+
+      hashTree.removeItem({type: 'participant', id: 1, version: 5});
+
+      expect(hashTree.getItemVersion(1, 'participant')).to.be.undefined;
+    });
+  });
 });