@webex/plugin-meetings 3.12.0-next.44 → 3.12.0-next.46

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

@@ -9,6 +9,7 @@ describe('plugin-meetings', () => {
   describe('SimultaneousInterpretation', () => {
     let webex;
     let interpretation;
+    let mockMeeting;
 
     beforeEach(() => {
       // @ts-ignore
@@ -17,8 +18,17 @@ describe('plugin-meetings', () => {
       interpretation = new SimultaneousInterpretation({}, {parent: webex});
       interpretation.locusUrl = 'locusUrl';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
-      webex.meetings = {};
-      webex.meetings.getMeetingByType = sinon.stub();
+      mockMeeting = {
+        locusInfo: {
+          handleLocusAPIResponse: sinon.stub(),
+        },
+      };
+      webex.meetings = {
+        getMeetingByType: sinon.stub(),
+        meetingCollection: {
+          getByKey: sinon.stub().returns(mockMeeting),
+        },
+      };
     });
 
     describe('#initialize', () => {
@@ -316,7 +326,8 @@ describe('plugin-meetings', () => {
             order : 0,
             isActive : true
           },];
-        webex.request.returns(Promise.resolve({}));
+        const mockResponse = {body: {locus: {url: 'locusUrl'}}};
+        webex.request.returns(Promise.resolve(mockResponse));
 
         await interpretation.updateInterpreters(sampleData);
         assert.calledOnceWithExactly(webex.request, {
@@ -328,6 +339,11 @@ describe('plugin-meetings', () => {
             },
           },
         });
+        assert.calledOnceWithExactly(
+          mockMeeting.locusInfo.handleLocusAPIResponse,
+          mockMeeting,
+          mockResponse.body
+        );
       });
 
       it('rejects with error', async () => {
@@ -354,7 +370,8 @@ describe('plugin-meetings', () => {
           order: 0,
           selfParticipantId: '123',
         });
-        webex.request.returns(Promise.resolve({}));
+        const mockResponse = {body: {locus: {url: 'locusUrl'}}};
+        webex.request.returns(Promise.resolve(mockResponse));
 
         await interpretation.changeDirection();
         assert.calledOnceWithExactly(webex.request, {
@@ -369,6 +386,11 @@ describe('plugin-meetings', () => {
             },
           },
         });
+        assert.calledOnceWithExactly(
+          mockMeeting.locusInfo.handleLocusAPIResponse,
+          mockMeeting,
+          mockResponse.body
+        );
       });
 
       it('request rejects with error', async () => {

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

@@ -13703,6 +13703,131 @@ describe('plugin-meetings', () => {
           assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
 
+        describe('ownership tag', () => {
+          beforeEach(() => {
+            // Make the owner stub dynamic so setOwnerMeetingId() writes
+            // propagate back to getOwnerMeetingId() reads. This mirrors the
+            // real LLM singleton behavior so the finally-block release in
+            // cleanupLLMConneciton is reflected in subsequent reads.
+            webex.internal.llm.getOwnerMeetingId = sinon.stub().returns(undefined);
+            webex.internal.llm.setOwnerMeetingId = sinon.stub().callsFake((id) => {
+              webex.internal.llm.getOwnerMeetingId.returns(id);
+            });
+          });
+
+          it('skips disconnect and reconnect when LLM is connected and owned by another meeting (regardless of URL)', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns('some-other-meeting-id');
+            // Locus/datachannel URL mismatch is the *normal* case when
+            // another meeting owns the live socket -- each meeting has its
+            // own locus URL. URL mismatch must NOT trigger a reclaim,
+            // because doing so would tear down the owning meeting's healthy
+            // LLM socket and break its data channel.
+            webex.internal.llm.getLocusUrl.returns('owner-locus-url');
+            webex.internal.llm.getDatachannelUrl.returns('owner-dc-url');
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a different datachannel url'},
+              self: {},
+            };
+
+            const result = await meeting.updateLLMConnection();
+
+            assert.equal(result, undefined);
+            assert.notCalled(webex.internal.llm.disconnectLLM);
+            assert.notCalled(webex.internal.llm.registerAndConnect);
+            assert.notCalled(webex.internal.llm.setOwnerMeetingId);
+            assert.notCalled(meeting.startLLMHealthCheckTimer);
+          });
+
+
+          it('clears stale owner tag in cleanup finally block even when disconnectLLM rejects', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+            webex.internal.llm.getLocusUrl.returns('a url');
+            webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
+            webex.internal.llm.disconnectLLM.rejects(new Error('disconnect failed'));
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a datachannel url'},
+              self: {},
+            };
+
+            try {
+              await meeting.updateLLMConnection();
+            } catch (e) {
+              /* updateLLMConnection may reject when cleanup throws */
+            }
+
+            // The owner-eligible finally branch must release the tag so a
+            // subsequent reconnect attempt from any meeting is not blocked.
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId, undefined);
+          });
+
+          it('proceeds normally when LLM is connected and owned by this meeting with URL change', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(true);
+            webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+            webex.internal.llm.getLocusUrl.returns('a url');
+            webex.internal.llm.getDatachannelUrl.returns('a datachannel url');
+            meeting.locusInfo = {
+              url: 'a different url',
+              info: {datachannelUrl: 'a datachannel url'},
+              self: {},
+            };
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+              code: 3050,
+              reason: 'done (permanent)',
+            });
+            assert.calledWithExactly(
+              webex.internal.llm.registerAndConnect,
+              'a different url',
+              'a datachannel url',
+              undefined
+            );
+            // setOwnerMeetingId is called twice: first with undefined in
+            // cleanupLLMConneciton's finally block (so a failed disconnect
+            // cannot leave a stale owner), then with this meeting's id
+            // after registerAndConnect resolves.
+            assert.calledTwice(webex.internal.llm.setOwnerMeetingId);
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId.firstCall, undefined);
+            assert.calledWith(webex.internal.llm.setOwnerMeetingId.lastCall, meeting.id);
+          });
+
+          it('claims ownership after successful registerAndConnect on initial connect', async () => {
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(false);
+            webex.internal.llm.getOwnerMeetingId.returns(undefined);
+            meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
+          });
+
+          it('proceeds to connect when LLM is not connected even if another ownerId lingers', async () => {
+            // Defensive path: if the LLM reports not-connected but an old
+            // ownerId is still present (e.g. race before a successful
+            // connections.delete), this meeting can still claim a fresh
+            // connection.
+            meeting.joinedWith = {state: 'JOINED'};
+            webex.internal.llm.isConnected.returns(false);
+            webex.internal.llm.getOwnerMeetingId.returns('stale-owner-id');
+            meeting.locusInfo = {url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
+
+            await meeting.updateLLMConnection();
+
+            assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
+          });
+        });
+
         describe('#clearMeetingData', () => {
           beforeEach(() => {
             webex.internal.llm.isConnected = sinon.stub().returns(true);
@@ -13763,6 +13888,64 @@ describe('plugin-meetings', () => {
             assert.notCalled(meeting.stopTranscription);
             assert.notCalled(meeting.annotation.deregisterEvents);
           });
+
+          describe('ownership tag', () => {
+            beforeEach(() => {
+              webex.internal.llm.getOwnerMeetingId = sinon.stub();
+            });
+
+            it('skips disconnectLLM but still removes this meeting listeners when another meeting owns the LLM', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns('some-other-meeting-id');
+
+              await meeting.clearMeetingData();
+
+              assert.notCalled(webex.internal.llm.disconnectLLM);
+              // Shared data-channel auth tokens belong to the owner meeting's
+              // live LLM session and must not be wiped by a non-owner
+              // teardown, otherwise the owner's next reconnect would lose
+              // its Data-Channel-Auth-Token.
+              assert.notCalled(meeting.clearDataChannelToken);
+              // Listeners owned by *this* Meeting instance must still be
+              // removed so a leaving subordinate meeting stops receiving
+              // relay/locus events from the shared singleton.
+              assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
+              assert.calledWithExactly(
+                webex.internal.llm.off,
+                'event:relay.event',
+                meeting.processRelayEvent
+              );
+              assert.calledWithExactly(
+                webex.internal.llm.off,
+                'event:locus.state_message',
+                meeting.processLocusLLMEvent
+              );
+              assert.calledOnce(meeting.clearLLMHealthCheckTimer);
+            });
+
+            it('calls disconnectLLM and clears data channel token when this meeting is the owner', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns(meeting.id);
+
+              await meeting.clearMeetingData();
+
+              assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+                code: 3050,
+                reason: 'done (permanent)',
+              });
+              assert.calledOnce(meeting.clearDataChannelToken);
+            });
+
+            it('calls disconnectLLM and clears data channel token when no owner is recorded (first-claim / legacy)', async () => {
+              webex.internal.llm.getOwnerMeetingId.returns(undefined);
+
+              await meeting.clearMeetingData();
+
+              assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
+                code: 3050,
+                reason: 'done (permanent)',
+              });
+              assert.calledOnce(meeting.clearDataChannelToken);
+            });
+          });
         });
       });
 

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

@@ -11,6 +11,7 @@ describe('plugin-meetings', () => {
   let audio;
   let video;
   let originalRemoteUpdateAudioVideo;
+  let originalUpdateLocusFromApiResponse;
 
   const fakeLocusResponse = {body: {locus: {info: 'this is a fake locus'}}};
 
@@ -45,6 +46,7 @@ describe('plugin-meetings', () => {
     };
 
     originalRemoteUpdateAudioVideo = MeetingUtil.remoteUpdateAudioVideo;
+    originalUpdateLocusFromApiResponse = MeetingUtil.updateLocusFromApiResponse;
 
     MeetingUtil.remoteUpdateAudioVideo = sinon.stub().resolves(fakeLocusResponse);
     MeetingUtil.updateLocusFromApiResponse = sinon.stub();
@@ -57,6 +59,7 @@ describe('plugin-meetings', () => {
 
   afterEach(() => {
     MeetingUtil.remoteUpdateAudioVideo = originalRemoteUpdateAudioVideo;
+    MeetingUtil.updateLocusFromApiResponse = originalUpdateLocusFromApiResponse;
   });
 
   describe('mute state library', () => {

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

@@ -276,6 +276,31 @@ describe('plugin-meetings', () => {
         assert.notCalled(meeting.locusInfo.handleLocusAPIResponse);
       });
 
+      it('should call handleLocusAPIResponse when response body is an unwrapped LocusDTO', () => {
+        const meeting = {
+          locusInfo: {
+            handleLocusAPIResponse: sinon.stub(),
+          },
+        };
+
+        const originalResponse = {
+          body: {
+            url: 'https://locus-a.wbx2.com/locus/api/v1/loci/some-id',
+            participants: [],
+            self: {},
+          },
+        };
+
+        const response = MeetingUtil.updateLocusFromApiResponse(meeting, originalResponse);
+
+        assert.deepEqual(response, originalResponse);
+        assert.calledOnceWithExactly(
+          meeting.locusInfo.handleLocusAPIResponse,
+          meeting,
+          originalResponse.body
+        );
+      });
+
       it('should work with an undefined meeting', () => {
         const originalResponse = {
           body: {

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

@@ -176,6 +176,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,17 +223,14 @@ describe('plugin-meetings', () => {
     });
 
     describe('#cleanupPSDataChannel', () => {
-      let meeting;
+      let relayListener;
 
       beforeEach(() => {
-        meeting = {
-          processRelayEvent: sinon.stub(),
-        };
-
-        webex.meetings.getMeetingByType = sinon.stub().returns(meeting);
+        relayListener = sinon.stub();
+        webinar._practiceSessionRelayListener = relayListener;
       });
 
-      it('disconnects the practice session channel and removes the relay listener', async () => {
+      it('disconnects the practice session channel and removes the tracked relay listener', async () => {
         await webinar.cleanupPSDataChannel();
 
         assert.calledOnceWithExactly(
@@ -208,8 +241,28 @@ describe('plugin-meetings', () => {
         assert.calledOnceWithExactly(
           webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          meeting.processRelayEvent
+          relayListener
         );
+        assert.isNull(webinar._practiceSessionRelayListener);
+      });
+
+      it('skips relay listener removal when no listener has been tracked', async () => {
+        webinar._practiceSessionRelayListener = null;
+
+        await webinar.cleanupPSDataChannel();
+
+        const relayOffCalls = webex.internal.llm.off.args.filter(
+          ([event]) => event === `event:relay.event:${LLM_PRACTICE_SESSION}`
+        );
+        assert.equal(relayOffCalls.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 () => {
@@ -240,6 +293,7 @@ describe('plugin-meetings', () => {
       beforeEach(() => {
         processRelayEvent = sinon.stub();
         meeting = {
+          locusUrl: 'locusUrl',
           isJoined: sinon.stub().returns(true),
           processRelayEvent,
           locusInfo: {
@@ -418,19 +472,30 @@ 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._practiceSessionRelayListener, processRelayEvent);
         assert.calledWith(
-          webex.internal.llm.off,
+          webex.internal.llm.on,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
           processRelayEvent
         );
+      });
+
+      it('removes a previously tracked relay listener before re-binding on reconnect', async () => {
+        const previousListener = sinon.stub();
+        webinar._practiceSessionRelayListener = previousListener;
+
+        await webinar.updatePSDataChannel();
+
         assert.calledWith(
-          webex.internal.llm.on,
+          webex.internal.llm.off,
           `event:relay.event:${LLM_PRACTICE_SESSION}`,
-          processRelayEvent
+          previousListener
         );
+        assert.equal(webinar._practiceSessionRelayListener, processRelayEvent);
       });
 
       it('subscribes to transcription when caption intent is enabled', async () => {
@@ -551,7 +616,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 +671,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 +1099,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 +1116,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: {