@webex/plugin-meetings 3.12.0-next.7 → 3.12.0-next.70

package/test/unit/spec/recording-controller/index.js

@@ -35,6 +35,7 @@ describe('plugin-meetings', () => {
         beforeEach(() => {
           request = {
             request: sinon.stub().returns(Promise.resolve()),
+            locusDeltaRequest: sinon.stub().returns(Promise.resolve()),
           };
 
           controller = new RecordingController(request);
@@ -69,13 +70,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.startRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -103,13 +104,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.stopRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: false, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -139,13 +140,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.pauseRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: true}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
 
@@ -176,13 +177,13 @@ describe('plugin-meetings', () => {
 
             const result = controller.resumeRecording();
 
-            assert.calledWith(request.request, {
+            assert.calledWith(request.locusDeltaRequest, {
               uri: `${locusUrl}/controls`,
               body: {record: {recording: true, paused: false}},
               method: HTTP_VERBS.PATCH,
             });
 
-            assert.deepEqual(result, request.request.firstCall.returnValue);
+            assert.deepEqual(result, request.locusDeltaRequest.firstCall.returnValue);
           });
         });
       });

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

@@ -5,7 +5,9 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import uuid from 'uuid';
 import sinon from 'sinon';
 import {DataChannelTokenType} from '@webex/internal-plugin-llm';
-import {LLM_PRACTICE_SESSION, SHARE_STATUS} from '@webex/plugin-meetings/src/constants';
+import {LLM_PRACTICE_SESSION, LOCUS_LLM_EVENT, SHARE_STATUS} from '@webex/plugin-meetings/src/constants';
+
+const PRACTICE_SESSION_KEY = LLM_PRACTICE_SESSION || DataChannelTokenType.PracticeSession;
 
 describe('plugin-meetings', () => {
     describe('Webinar', () => {
@@ -33,6 +35,17 @@ describe('plugin-meetings', () => {
       webex.internal.llm = {
         getDatachannelToken: sinon.stub().returns(undefined),
         setDatachannelToken: sinon.stub(),
+        setRefreshHandler: sinon.stub(),
+        getOwnerMeetingId: sinon.stub().returns(undefined),
+        resolveSessionOwnership: sinon.stub().callsFake((ownerMeetingId, sessionId) => {
+          const currentOwner = webex.internal.llm.getOwnerMeetingId(sessionId);
+
+          return {
+            currentOwner,
+            isOwner: !currentOwner || !ownerMeetingId || currentOwner === ownerMeetingId,
+          };
+        }),
+        setOwnerMeetingId: sinon.stub(),
         isDataChannelTokenEnabled: sinon.stub().resolves(false),
         isConnected: sinon.stub().returns(false),
         disconnectLLM: sinon.stub().resolves(),
@@ -176,6 +189,42 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#getValidatedWebinarMeeting', () => {
+      it('returns the meeting when its locusUrl matches the webinar locusUrl', () => {
+        const meeting = {locusUrl: 'locusUrl'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.equal(webinar.getValidatedWebinarMeeting(), meeting);
+      });
+
+      it('returns undefined and warns when the resolved meeting locusUrl does not match', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'other-locus-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = 'locusUrl';
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+
+      it('returns undefined when no meeting is resolved', () => {
+        webex.meetings.getMeetingByType = sinon.stub().returns(undefined);
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+      });
+
+      it('returns undefined and warns when webinar locusUrl is not yet initialized', () => {
+        const warnStub = sinon.stub(LoggerProxy.logger, 'warn');
+        const meeting = {locusUrl: 'some-url'};
+        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        webinar.locusUrl = undefined;
+
+        assert.isUndefined(webinar.getValidatedWebinarMeeting());
+        assert.calledOnce(warnStub);
+      });
+    });
+
     describe('#cleanUp', () => {
       it('delegates to cleanupPSDataChannel', () => {
         const cleanupPSDataChannelStub = sinon.stub(webinar, 'cleanupPSDataChannel').resolves();
@@ -187,29 +236,119 @@ describe('plugin-meetings', () => {
     });
 
     describe('#cleanupPSDataChannel', () => {
-      let meeting;
+      let relayListener;
 
       beforeEach(() => {
-        meeting = {
-          processRelayEvent: sinon.stub(),
-        };
+        webinar.meetingId = 'meeting-id';
+        relayListener = sinon.stub();
+        webinar.llmListeners = {relay: relayListener, locusLLM: null};
+      });
 
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+      it('disconnects the practice session channel and removes the tracked relay listener', async () => {
+        await webinar.cleanupPSDataChannel();
+
+        assert.calledOnceWithExactly(
+          webex.internal.llm.disconnectLLM,
+          {code: 3050, reason: 'done (permanent)'},
+          PRACTICE_SESSION_KEY,
+          webinar.meetingId
+        );
+        assert.calledWithExactly(
+          webex.internal.llm.off,
+          `event:relay.event:${PRACTICE_SESSION_KEY}`,
+          relayListener
+        );
+        assert.isNull(webinar.llmListeners.relay);
       });
 
-      it('disconnects the practice session channel and removes the relay listener', async () => {
+      it('skips disconnect when practice-session owner is another meeting', async () => {
+        webex.internal.llm.getOwnerMeetingId.returns('other-meeting-id');
+        webex.internal.llm.disconnectLLM.resolves(false);
+
         await webinar.cleanupPSDataChannel();
 
         assert.calledOnceWithExactly(
           webex.internal.llm.disconnectLLM,
           {code: 3050, reason: 'done (permanent)'},
-          LLM_PRACTICE_SESSION
+          PRACTICE_SESSION_KEY,
+          webinar.meetingId
         );
+        assert.notCalled(webex.internal.llm.setOwnerMeetingId);
         assert.calledOnceWithExactly(
           webex.internal.llm.off,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting.processRelayEvent
+          `event:relay.event:${PRACTICE_SESSION_KEY}`,
+          relayListener
+        );
+      });
+
+      it('skips relay listener removal when no listener has been tracked', async () => {
+        webinar.llmListeners.relay = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        const relayOffCalls = webex.internal.llm.off.args.filter(
+          ([event]) => event === `event:relay.event:${PRACTICE_SESSION_KEY}`
         );
+        assert.equal(relayOffCalls.length, 0);
+      });
+
+      it('removes tracked relay listener even when disconnect throws', async () => {
+        const disconnectError = new Error('disconnect failed');
+        webex.internal.llm.disconnectLLM.rejects(disconnectError);
+
+        let caughtError;
+
+        try {
+          await webinar.cleanupPSDataChannel();
+        } catch (error) {
+          caughtError = error;
+        }
+
+        assert.equal(caughtError, disconnectError);
+        assert.calledOnceWithExactly(
+          webex.internal.llm.setOwnerMeetingId,
+          undefined,
+          PRACTICE_SESSION_KEY
+        );
+        assert.calledOnceWithExactly(
+          webex.internal.llm.off,
+          `event:relay.event:${PRACTICE_SESSION_KEY}`,
+          relayListener
+        );
+        assert.notOk(webinar._practiceSessionRelayListener);
+       });
+
+      it('disconnects and removes the tracked locusLLM listener', async () => {
+        const locusLLMListener = sinon.stub();
+        webinar.llmListeners.locusLLM = locusLLMListener;
+
+        await webinar.cleanupPSDataChannel();
+
+        assert.calledWithExactly(
+          webex.internal.llm.off,
+          `${LOCUS_LLM_EVENT}:${LLM_PRACTICE_SESSION}`,
+          locusLLMListener
+        );
+        assert.isNull(webinar.llmListeners.locusLLM);
+      });
+
+      it('skips locusLLM listener removal when no listener has been tracked', async () => {
+        webinar.llmListeners.locusLLM = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        const locusLLMOffCalls = webex.internal.llm.off.args.filter(
+          ([event]) => event === `${LOCUS_LLM_EVENT}:${LLM_PRACTICE_SESSION}`
+        );
+        assert.equal(locusLLMOffCalls.length, 0);
+      });
+
+      it('does not consult the meeting collection during cleanup', async () => {
+        webex.meetings.getMeetingByType = sinon.stub();
+
+        await webinar.cleanupPSDataChannel();
+
+        assert.notCalled(webex.meetings.getMeetingByType);
       });
 
       it('removes a pending online listener if one exists', async () => {
@@ -236,12 +375,18 @@ describe('plugin-meetings', () => {
     describe('#updatePSDataChannel', () => {
       let meeting;
       let processRelayEvent;
+      let processLocusLLMEvent;
 
       beforeEach(() => {
+        webinar.meetingId = 'meeting-id';
         processRelayEvent = sinon.stub();
+        processLocusLLMEvent = sinon.stub();
         meeting = {
+          id: 'meeting-id',
+          locusUrl: 'locusUrl',
           isJoined: sinon.stub().returns(true),
           processRelayEvent,
+          processLocusLLMEvent,
           locusInfo: {
             url: 'locus-url',
             info: {practiceSessionDatachannelUrl: 'dc-url'},
@@ -252,7 +397,7 @@ describe('plugin-meetings', () => {
 
         // Default session is connected by default; practice session is not
         webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
+          return sessionId !== PRACTICE_SESSION_KEY;
         });
 
         // Token is pre-saved into LLM by saveDataChannelToken
@@ -288,14 +433,15 @@ describe('plugin-meetings', () => {
         assert.calledWithExactly(
           webex.internal.llm.setDatachannelToken,
           'ps-token-from-refresh',
-          DataChannelTokenType.PracticeSession
+          DataChannelTokenType.PracticeSession,
+          'meeting-id'
         );
         assert.calledWith(
           webex.internal.llm.registerAndConnect,
           'locus-url',
           'dc-url',
           'ps-token-from-refresh',
-          LLM_PRACTICE_SESSION
+          PRACTICE_SESSION_KEY
         );
       });
 
@@ -355,6 +501,8 @@ describe('plugin-meetings', () => {
         const result = await webinar.updatePSDataChannel();
 
         assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.setRefreshHandler);
+        assert.notCalled(webex.internal.llm.setOwnerMeetingId);
         assert.notCalled(webex.internal.llm.registerAndConnect);
       });
 
@@ -375,12 +523,17 @@ describe('plugin-meetings', () => {
         const result = await webinar.updatePSDataChannel();
 
         assert.calledOnce(webex.internal.llm.registerAndConnect);
+        assert.calledWithExactly(
+          webex.internal.llm.setOwnerMeetingId,
+          'meeting-id',
+          PRACTICE_SESSION_KEY
+        );
         assert.calledWith(
           webex.internal.llm.registerAndConnect,
           'locus-url',
           'dc-url',
           'ps-token',
-          LLM_PRACTICE_SESSION
+          PRACTICE_SESSION_KEY
         );
         assert.calledOnceWithExactly(webex.internal.voicea.announce);
         assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
@@ -396,7 +549,8 @@ describe('plugin-meetings', () => {
 
         assert.calledWithExactly(
           webex.internal.llm.getDatachannelToken,
-          DataChannelTokenType.PracticeSession
+          DataChannelTokenType.PracticeSession,
+          webinar.meetingId
         );
         assert.notCalled(webex.internal.llm.setDatachannelToken);
         assert.calledWith(
@@ -404,7 +558,7 @@ describe('plugin-meetings', () => {
           'locus-url',
           'dc-url',
           'cached-token',
-          LLM_PRACTICE_SESSION
+          PRACTICE_SESSION_KEY
         );
       });
 
@@ -418,19 +572,55 @@ describe('plugin-meetings', () => {
         assert.calledOnce(webex.internal.llm.registerAndConnect);
       });
 
-      it('rebinds relay listener after successful connect', async () => {
+      it('tracks and binds the relay listener after successful connect', async () => {
         await webinar.updatePSDataChannel();
 
+        // Stores the exact listener reference for deterministic cleanup
+        assert.equal(webinar.llmListeners.relay, processRelayEvent);
         assert.calledWith(
-          webex.internal.llm.off,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
+          webex.internal.llm.on,
+          `event:relay.event:${PRACTICE_SESSION_KEY}`,
           processRelayEvent
         );
+      });
+
+      it('removes a previously tracked relay listener before re-binding on reconnect', async () => {
+        const previousListener = sinon.stub();
+        webinar.llmListeners = {relay: previousListener, locusLLM: null};
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledWith(
+          webex.internal.llm.off,
+          `event:relay.event:${PRACTICE_SESSION_KEY}`,
+          previousListener
+        );
+        assert.equal(webinar.llmListeners.relay, processRelayEvent);
+      });
+
+      it('tracks and binds the locusLLM listener after successful connect', async () => {
+        await webinar.updatePSDataChannel();
+
+        assert.equal(webinar.llmListeners.locusLLM, processLocusLLMEvent);
         assert.calledWith(
           webex.internal.llm.on,
-          `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
+          `${LOCUS_LLM_EVENT}:${LLM_PRACTICE_SESSION}`,
+          processLocusLLMEvent
+        );
+      });
+
+      it('removes a previously tracked locusLLM listener before re-binding on reconnect', async () => {
+        const previousListener = sinon.stub();
+        webinar.llmListeners = {relay: null, locusLLM: previousListener};
+
+        await webinar.updatePSDataChannel();
+
+        assert.calledWith(
+          webex.internal.llm.off,
+          `${LOCUS_LLM_EVENT}:${LLM_PRACTICE_SESSION}`,
+          previousListener
         );
+        assert.equal(webinar.llmListeners.locusLLM, processLocusLLMEvent);
       });
 
       it('subscribes to transcription when caption intent is enabled', async () => {
@@ -460,6 +650,8 @@ describe('plugin-meetings', () => {
         // Should register an 'online' listener but NOT call registerAndConnect yet
         assert.calledWith(webex.internal.llm.on, 'online', sinon.match.func);
         assert.notCalled(webex.internal.llm.registerAndConnect);
+        assert.notCalled(webex.internal.llm.setRefreshHandler);
+        assert.notCalled(webex.internal.llm.setOwnerMeetingId);
         // Should store the pending listener
         assert.isNotNull(webinar._pendingOnlineListener);
       });
@@ -491,7 +683,7 @@ describe('plugin-meetings', () => {
 
         // Now simulate default session coming online
         webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
+          return sessionId !== PRACTICE_SESSION_KEY;
         });
 
         // Fire the captured listener
@@ -518,7 +710,7 @@ describe('plugin-meetings', () => {
 
         // Now default session comes online
         webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
+          return sessionId !== PRACTICE_SESSION_KEY;
         });
 
         // Fire the listener — re-invokes updatePSDataChannel which will see isPracticeSession = false
@@ -531,7 +723,7 @@ describe('plugin-meetings', () => {
       it('proceeds immediately when default session is already connected', async () => {
         // Default session already connected, practice session not
         webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
-          return sessionId !== LLM_PRACTICE_SESSION;
+          return sessionId !== PRACTICE_SESSION_KEY;
         });
 
         const result = await webinar.updatePSDataChannel();
@@ -543,6 +735,115 @@ describe('plugin-meetings', () => {
         assert.calledOnce(webex.internal.llm.registerAndConnect);
         assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
       });
+
+      it('does not override practice refresh handler or reconnect when owned by another meeting', async () => {
+        webex.internal.llm.getOwnerMeetingId.returns('other-meeting-id');
+        webex.internal.llm.isConnected = sinon.stub().callsFake((sessionId) => {
+          return sessionId !== undefined;
+        });
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.setRefreshHandler);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('does not reconnect when practice session is disconnected but owned by another meeting', async () => {
+        webex.internal.llm.getOwnerMeetingId.returns('other-meeting-id');
+        webex.internal.llm.isConnected = sinon.stub().returns(false);
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.setRefreshHandler);
+        assert.notCalled(webex.internal.llm.setOwnerMeetingId);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('does not write owner or connect if ownership changes before pre-connect owner write', async () => {
+        let ownerMeetingId = 'meeting-id';
+
+        webex.internal.llm.getOwnerMeetingId.callsFake(() => ownerMeetingId);
+        webex.internal.llm.isDataChannelTokenEnabled.resolves(true);
+        webex.internal.llm.getDatachannelToken = sinon.stub().returns(undefined);
+
+        let resolveRefresh;
+        meeting.refreshDataChannelToken = sinon.stub().returns(
+          new Promise((resolve) => {
+            resolveRefresh = resolve;
+          })
+        );
+
+        const updatePromise = webinar.updatePSDataChannel();
+
+        ownerMeetingId = 'other-meeting-id';
+        resolveRefresh({
+          body: {
+            datachannelToken: 'ps-token-from-refresh',
+            dataChannelTokenType: DataChannelTokenType.PracticeSession,
+          },
+        });
+
+        const result = await updatePromise;
+
+        assert.isUndefined(result);
+        assert.notCalled(webex.internal.llm.setRefreshHandler);
+        assert.notCalled(webex.internal.llm.setOwnerMeetingId);
+        assert.notCalled(webex.internal.llm.registerAndConnect);
+      });
+
+      it('does not overwrite owner after connect when ownership changed during registerAndConnect', async () => {
+        let ownerMeetingId = 'meeting-id';
+
+        webex.internal.llm.getOwnerMeetingId.callsFake(() => ownerMeetingId);
+        webex.internal.llm.registerAndConnect = sinon.stub().callsFake(async () => {
+          ownerMeetingId = 'other-meeting-id';
+
+          return 'REGISTER_AND_CONNECT_RESULT';
+        });
+
+        const result = await webinar.updatePSDataChannel();
+
+        assert.equal(result, 'REGISTER_AND_CONNECT_RESULT');
+        assert.calledOnce(webex.internal.llm.setOwnerMeetingId);
+        assert.calledWithExactly(
+          webex.internal.llm.setOwnerMeetingId,
+          'meeting-id',
+          PRACTICE_SESSION_KEY
+        );
+      });
+
+      it('clears pre-claimed owner when registerAndConnect rejects', async () => {
+        const registerError = new Error('register failed');
+        let ownerMeetingId = 'meeting-id';
+
+        webex.internal.llm.getOwnerMeetingId.callsFake(() => ownerMeetingId);
+        webex.internal.llm.setOwnerMeetingId.callsFake((id) => {
+          ownerMeetingId = id;
+        });
+        webex.internal.llm.registerAndConnect = sinon.stub().rejects(registerError);
+
+        try {
+          await webinar.updatePSDataChannel();
+          assert.fail('Expected updatePSDataChannel to reject when registerAndConnect fails');
+        } catch (error) {
+          assert.equal(error, registerError);
+        }
+
+        assert.calledTwice(webex.internal.llm.setOwnerMeetingId);
+        assert.calledWithExactly(
+          webex.internal.llm.setOwnerMeetingId.firstCall,
+          'meeting-id',
+          PRACTICE_SESSION_KEY
+        );
+        assert.calledWithExactly(
+          webex.internal.llm.setOwnerMeetingId.secondCall,
+          undefined,
+          PRACTICE_SESSION_KEY
+        );
+        assert.isUndefined(ownerMeetingId);
+      });
       });
 
       describe('#updateStatusByRole', () => {
@@ -551,7 +852,7 @@ describe('plugin-meetings', () => {
           updateMediaShares = sinon.stub()
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE,
@@ -606,7 +907,7 @@ describe('plugin-meetings', () => {
 
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               isJoined: sinon.stub().returns(false),
               updateLLMConnection: sinon.stub(),
               shareStatus: SHARE_STATUS.REMOTE_SHARE_ACTIVE,
@@ -1034,7 +1335,7 @@ describe('plugin-meetings', () => {
           // @ts-ignore
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {
@@ -1051,7 +1352,7 @@ describe('plugin-meetings', () => {
         it('throws an error if attendeeSearchUrl is not available', async () => {
           webinar.webex.meetings = {
             getMeetingByType: sinon.stub().returns({
-              id: 'meeting-id',
+              id: 'meeting-id', locusUrl: 'locusUrl',
               locusInfo: {
                 links:{
                   resources: {