@webex/plugin-meetings 3.12.0-next.65 → 3.12.0-next.67

package/test/unit/spec/interceptors/dataChannelAuthToken.ts

@@ -7,6 +7,7 @@ import DataChannelAuthTokenInterceptor from '@webex/plugin-meetings/src/intercep
 import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
 import * as utils from '@webex/plugin-meetings/src/interceptors/utils';
 import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY} from '@webex/plugin-meetings/src/interceptors/constant';
+import {LOCUS_URL} from '@webex/plugin-meetings/src/constants';
 
 describe('plugin-meetings', () => {
   describe('Interceptors', () => {
@@ -178,6 +179,28 @@ describe('plugin-meetings', () => {
           expect(result).to.equal('mock-response');
         });
 
+        it('passes request URL to _refreshDataChannelToken', async () => {
+          const psOptions = {
+            headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'},
+            method: 'POST',
+            uri: 'https://locus.example.com/practiceSession/datachannel',
+          };
+
+          interceptor._refreshDataChannelToken.resolves('new-token');
+          webex.request.resolves('mock-response');
+
+          const promise = interceptor.refreshTokenAndRetryWithDelay(psOptions);
+
+          clock.tick(2000);
+
+          await promise;
+
+          sinon.assert.calledOnceWithExactly(
+            interceptor._refreshDataChannelToken,
+            psOptions.uri
+          );
+        });
+
         it('rejects when refreshDataChannelToken fails', async () => {
           interceptor._refreshDataChannelToken.rejects(new Error('refresh failed'));
 
@@ -205,6 +228,179 @@ describe('plugin-meetings', () => {
           );
         });
       });
+
+      describe('refreshDataChannelToken routing (factory dispatcher)', () => {
+        let llmMock;
+        let meetingA;
+        let meetingsMock;
+        let dispatcherInterceptor;
+
+        const PS_DATACHANNEL_URL = 'https://board-a.wbx2.com/datachannel/api/v1/locus/cHJhY3RpY2Vfc2Vzc2lvbl9sb2N1cw==/registrations';
+        const DEFAULT_DATACHANNEL_URL = 'https://board-a.wbx2.com/datachannel/api/v1/locus/aHR0cHM6Ly9sb2N1cy1hLndieDIuY29t/registrations';
+
+        beforeEach(() => {
+          meetingA = {
+            id: 'meeting-a',
+            refreshDataChannelToken: sinon.stub().resolves({
+              body: {
+                datachannelToken: 'token-from-meeting-a',
+                dataChannelTokenType: 'llm-practice-session',
+              },
+            }),
+          };
+
+          llmMock = {
+            isDataChannelTokenEnabled: sinon.stub().resolves(true),
+            getSessionIdByDatachannelUrl: sinon.stub(),
+            getLocusUrlByDatachannelUrl: sinon.stub(),
+            getOwnerMeetingId: sinon.stub().returns(undefined),
+            refreshDataChannelToken: sinon.stub().resolves({
+              body: {
+                datachannelToken: 'token-from-llm-fallback',
+                dataChannelTokenType: 'llm-default-session',
+              },
+            }),
+            setDatachannelToken: sinon.stub(),
+          };
+
+          meetingsMock = {
+            getMeetingByType: sinon.stub(),
+          };
+
+          const context = {
+            internal: {llm: llmMock},
+            meetings: meetingsMock,
+          };
+
+          dispatcherInterceptor = Reflect.apply(DataChannelAuthTokenInterceptor.create, context, []);
+        });
+
+        it('routes PS request URL to PS session handler', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns('llm-practice-session');
+          llmMock.refreshDataChannelToken
+            .withArgs('llm-practice-session')
+            .resolves({
+              body: {
+                datachannelToken: 'token-from-ps-session',
+                dataChannelTokenType: 'llm-practice-session',
+              },
+            });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-ps-session');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, 'llm-practice-session');
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-ps-session',
+            'llm-practice-session',
+            undefined
+          );
+        });
+
+        it('routes non-PS URL to default session handler', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(DEFAULT_DATACHANNEL_URL).returns('llm-default-session');
+          llmMock.refreshDataChannelToken
+            .withArgs('llm-default-session')
+            .resolves({
+              body: {
+                datachannelToken: 'token-from-default-session',
+                dataChannelTokenType: 'llm-default-session',
+              },
+            });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(DEFAULT_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-default-session');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, 'llm-default-session');
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-default-session',
+            'llm-default-session',
+            undefined
+          );
+        });
+
+        it('falls back to default refresh when URL does not match any session or meeting route', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.refreshDataChannelToken.withArgs(undefined).resolves({
+            body: {
+              datachannelToken: 'token-from-default-fallback',
+              dataChannelTokenType: 'llm-default-session',
+            },
+          });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-default-fallback');
+          sinon.assert.calledOnceWithExactly(llmMock.refreshDataChannelToken, undefined);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-default-fallback',
+            'llm-default-session',
+            undefined
+          );
+        });
+
+        it('falls back to meeting lookup by locusUrl when session cannot be resolved', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns('https://locus-a.example.com');
+          meetingsMock.getMeetingByType.withArgs(LOCUS_URL, 'https://locus-a.example.com').returns(meetingA);
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-meeting-a');
+          sinon.assert.calledOnceWithExactly(meetingA.refreshDataChannelToken);
+          sinon.assert.notCalled(llmMock.refreshDataChannelToken);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-meeting-a',
+            'llm-practice-session',
+            'meeting-a'
+          );
+        });
+
+        it('falls back to active meeting datachannel URL lookup when session/locus routing is unavailable', async () => {
+          llmMock.getSessionIdByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          llmMock.getLocusUrlByDatachannelUrl.withArgs(PS_DATACHANNEL_URL).returns(undefined);
+          meetingsMock.getAllMeetings = sinon.stub().returns({
+            'meeting-a': {
+              ...meetingA,
+              locusInfo: {
+                info: {
+                  practiceSessionDatachannelUrl: PS_DATACHANNEL_URL,
+                  datachannelUrl: DEFAULT_DATACHANNEL_URL,
+                },
+              },
+            },
+          });
+
+          const token = await dispatcherInterceptor._refreshDataChannelToken(PS_DATACHANNEL_URL);
+
+          expect(token).to.equal('token-from-meeting-a');
+          sinon.assert.calledOnceWithExactly(meetingA.refreshDataChannelToken);
+          sinon.assert.notCalled(llmMock.refreshDataChannelToken);
+          sinon.assert.calledOnceWithExactly(
+            llmMock.setDatachannelToken,
+            'token-from-meeting-a',
+            'llm-practice-session',
+            'meeting-a'
+          );
+        });
+
+        it('throws when refresh returns no payload', async () => {
+          llmMock.getSessionIdByDatachannelUrl.returns('llm-default-session');
+          llmMock.refreshDataChannelToken.withArgs('llm-default-session').resolves(null);
+
+          await assert.isRejected(
+            dispatcherInterceptor._refreshDataChannelToken(
+              'https://unknown-datachannel.example.com/registrations'
+            ),
+            /DataChannel token refresh returned no payload/
+          );
+        });
+      });
     });
   });
 });

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

@@ -269,6 +269,20 @@ describe('plugin-meetings', () => {
       stopReachability: sinon.stub(),
       isSubnetReachable: sinon.stub().returns(true),
     };
+    webex.internal.llm.resolveSessionOwnership = sinon
+      .stub()
+      .callsFake((ownerMeetingId, sessionId) => {
+        const currentOwner = webex.internal.llm.getOwnerMeetingId
+          ? webex.internal.llm.getOwnerMeetingId(sessionId)
+          : undefined;
+        const canAssertOwnership = !!ownerMeetingId;
+
+        return {
+          currentOwner,
+          canAssertOwnership,
+          isOwner: !currentOwner || !canAssertOwnership || currentOwner === ownerMeetingId,
+        };
+      });
     webex.internal.llm.isDataChannelTokenEnabled = sinon.stub().resolves(false);
     webex.internal.llm.on = sinon.stub();
     webex.internal.voicea.announce = sinon.stub();
@@ -11107,7 +11121,7 @@ describe('plugin-meetings', () => {
           );
           done();
         });
-        it('listens to the self admitted guest event without blocking on token prefetch', async () => {
+        it('listens to the self admitted guest event and waits for token prefetch before reconnecting LLM', async () => {
           meeting.stopKeepAlive = sinon.stub();
           meeting.updateLLMConnection = sinon.stub();
           let resolvePrefetch;
@@ -11133,7 +11147,7 @@ describe('plugin-meetings', () => {
             'meeting:self:guestAdmitted',
             {payload: test1}
           );
-          assert.calledOnce(meeting.updateLLMConnection);
+          assert.notCalled(meeting.updateLLMConnection);
           assert.calledOnceWithExactly(meeting.rtcMetrics.sendNextMetrics);
 
           assert.calledOnceWithExactly(
@@ -11146,6 +11160,7 @@ describe('plugin-meetings', () => {
 
           resolvePrefetch(false);
           await Promise.resolve();
+          await Promise.resolve();
 
           assert.calledOnce(meeting.updateLLMConnection);
         });
@@ -13670,6 +13685,10 @@ describe('plugin-meetings', () => {
       describe('#saveDataChannelToken', () => {
         beforeEach(() => {
           webex.internal.llm.setDatachannelToken = sinon.stub();
+          webex.internal.llm.resolveSessionOwnership = sinon
+            .stub()
+            .returns({currentOwner: undefined, isOwner: true});
+          webex.internal.llm.isConnected = sinon.stub().returns(false);
         });
 
         it('saves datachannelToken into LLM as Default', () => {
@@ -13682,7 +13701,8 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(
             webex.internal.llm.setDatachannelToken,
             'default-token',
-            'llm-default-session'
+            'llm-default-session',
+            meeting.id
           );
         });
 
@@ -13696,7 +13716,8 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(
             webex.internal.llm.setDatachannelToken,
             'ps-token',
-            'llm-practice-session'
+            'llm-practice-session',
+            meeting.id
           );
         });
 
@@ -13714,12 +13735,14 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(
             webex.internal.llm.setDatachannelToken,
             'default-token',
-            'llm-default-session'
+            'llm-default-session',
+            meeting.id
           );
           assert.calledWithExactly(
             webex.internal.llm.setDatachannelToken,
             'ps-token',
-            'llm-practice-session'
+            'llm-practice-session',
+            meeting.id
           );
         });
 
@@ -13740,17 +13763,42 @@ describe('plugin-meetings', () => {
 
           assert.notCalled(webex.internal.llm.setDatachannelToken);
         });
+
+        it('writes token with meeting id as owner', () => {
+          meeting.saveDataChannelToken({
+            locus: {
+              self: {datachannelToken: 'default-token'},
+            },
+          });
+
+          assert.calledOnceWithExactly(
+            webex.internal.llm.setDatachannelToken,
+            'default-token',
+            'llm-default-session',
+            meeting.id
+          );
+        });
       });
 
       describe('#clearDataChannelToken', () => {
         beforeEach(() => {
-          webex.internal.llm.resetDatachannelTokens = sinon.stub();
+          webex.internal.llm.clearDatachannelToken = sinon.stub();
         });
 
-        it('calls resetDatachannelTokens on LLM', () => {
+        it('delegates default and practice token clears to llm with meeting ownership id', () => {
           meeting.clearDataChannelToken();
 
-          assert.calledOnce(webex.internal.llm.resetDatachannelTokens);
+          assert.calledWithExactly(
+            webex.internal.llm.clearDatachannelToken,
+            'llm-default-session',
+            meeting.id
+          );
+          assert.calledWithExactly(
+            webex.internal.llm.clearDatachannelToken,
+            'llm-practice-session',
+            meeting.id
+          );
+          assert.callCount(webex.internal.llm.clearDatachannelToken, 2);
         });
       });
 
@@ -13760,6 +13808,7 @@ describe('plugin-meetings', () => {
           webex.internal.llm.getLocusUrl = sinon.stub();
           webex.internal.llm.getDatachannelUrl = sinon.stub();
           webex.internal.llm.registerAndConnect = sinon.stub().resolves('something');
+          webex.internal.llm.setRefreshHandler = sinon.stub();
           webex.internal.llm.disconnectLLM = sinon.stub().resolves();
           webex.internal.llm.on = sinon.stub();
           webex.internal.llm.off = sinon.stub();
@@ -13837,6 +13886,12 @@ describe('plugin-meetings', () => {
             'a datachannel url',
             undefined
           );
+          assert.calledOnceWithExactly(
+            webex.internal.llm.setRefreshHandler,
+            sinon.match.func,
+            'llm-default-session',
+            meeting.id
+          );
           assert.equal(result, 'something');
           assert.calledOnceWithExactly(meeting.locusInfo.syncAllHashTreeDatasets, {onlyLLM: true});
         });
@@ -13858,7 +13913,7 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
-          });
+          }, 'llm-default-session', meeting.id);
 
           assert.calledWithExactly(
             webex.internal.llm.registerAndConnect,
@@ -13912,7 +13967,7 @@ describe('plugin-meetings', () => {
           assert.calledWithExactly(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
-          });
+          }, 'llm-default-session', meeting.id);
 
           assert.calledWithExactly(
             webex.internal.llm.registerAndConnect,
@@ -13960,7 +14015,7 @@ describe('plugin-meetings', () => {
           assert.calledWith(webex.internal.llm.disconnectLLM, {
             code: 3050,
             reason: 'done (permanent)',
-          });
+          }, 'llm-default-session', meeting.id);
           assert.notCalled(webex.internal.llm.registerAndConnect);
           assert.equal(result, undefined);
           assert.isFalse(
@@ -14035,7 +14090,7 @@ describe('plugin-meetings', () => {
           };
 
           webex.internal.llm.getDatachannelToken
-            .withArgs('llm-default-session')
+            .withArgs('llm-default-session', meeting.id)
             .returns('token-123');
 
           await meeting.updateLLMConnection();
@@ -14157,6 +14212,33 @@ describe('plugin-meetings', () => {
             assert.calledWith(webex.internal.llm.setOwnerMeetingId, undefined);
           });
 
+          it('does not clear owner tag when ownership changes during cleanup disconnect await', 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.callsFake(async () => {
+              webex.internal.llm.getOwnerMeetingId.returns('new-owner-id');
+              throw new Error('disconnect failed');
+            });
+            meeting.locusInfo = {
+              syncAllHashTreeDatasets: sinon.stub().resolves(),
+              url: 'a different url',
+              info: {datachannelUrl: 'a datachannel url'},
+              self: {},
+            };
+
+            try {
+              await meeting.updateLLMConnection();
+            } catch (e) {
+              /* updateLLMConnection may reject when cleanup throws */
+            }
+
+            assert.notCalled(webex.internal.llm.setOwnerMeetingId);
+            assert.equal(webex.internal.llm.getOwnerMeetingId(), 'new-owner-id');
+          });
+
           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);
@@ -14175,7 +14257,7 @@ describe('plugin-meetings', () => {
             assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
               code: 3050,
               reason: 'done (permanent)',
-            });
+            }, 'llm-default-session', meeting.id);
             assert.calledWithExactly(
               webex.internal.llm.registerAndConnect,
               'a different url',
@@ -14200,6 +14282,12 @@ describe('plugin-meetings', () => {
             await meeting.updateLLMConnection();
 
             assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledOnceWithExactly(
+              webex.internal.llm.setRefreshHandler,
+              sinon.match.func,
+              'llm-default-session',
+              meeting.id
+            );
             assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
           });
 
@@ -14211,11 +14299,41 @@ describe('plugin-meetings', () => {
             meeting.joinedWith = {state: 'JOINED'};
             webex.internal.llm.isConnected.returns(false);
             webex.internal.llm.getOwnerMeetingId.returns('stale-owner-id');
+            webex.internal.llm.getDatachannelToken.onFirstCall().returns(undefined);
+            webex.internal.llm.getDatachannelToken.onSecondCall().returns('recovered-token');
             meeting.locusInfo = {syncAllHashTreeDatasets: sinon.stub().resolves(), url: 'a url', info: {datachannelUrl: 'a datachannel url'}};
 
             await meeting.updateLLMConnection();
 
-            assert.calledOnce(webex.internal.llm.registerAndConnect);
+            assert.calledTwice(webex.internal.llm.getDatachannelToken);
+            assert.calledWithExactly(
+              webex.internal.llm.getDatachannelToken.firstCall,
+              'llm-default-session',
+              meeting.id
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.getDatachannelToken.secondCall,
+              'llm-default-session'
+            );
+            assert.calledOnceWithExactly(
+              webex.internal.llm.registerAndConnect,
+              'a url',
+              'a datachannel url',
+              'recovered-token'
+            );
+            assert.calledWithExactly(
+              webex.internal.llm.setRefreshHandler.firstCall,
+              sinon.match.func,
+              'llm-default-session',
+              undefined
+            );
+            assert.calledTwice(webex.internal.llm.setRefreshHandler);
+            assert.calledWithExactly(
+              webex.internal.llm.setRefreshHandler.secondCall,
+              sinon.match.func,
+              'llm-default-session',
+              meeting.id
+            );
             assert.calledOnceWithExactly(webex.internal.llm.setOwnerMeetingId, meeting.id);
           });
         });
@@ -14238,7 +14356,7 @@ describe('plugin-meetings', () => {
             assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
               code: 3050,
               reason: 'done (permanent)',
-            });
+            }, 'llm-default-session', meeting.id);
             assert.calledWithExactly(webex.internal.llm.off, 'online', meeting.handleLLMOnline);
             assert.calledWithExactly(
               webex.internal.llm.off,
@@ -14292,11 +14410,9 @@ describe('plugin-meetings', () => {
               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);
+              // clearDataChannelToken is always delegated; llm enforces
+              // ownership and no-ops for non-owners internally.
+              assert.calledOnce(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.
@@ -14322,7 +14438,7 @@ describe('plugin-meetings', () => {
               assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
                 code: 3050,
                 reason: 'done (permanent)',
-              });
+              }, 'llm-default-session', meeting.id);
               assert.calledOnce(meeting.clearDataChannelToken);
             });
 
@@ -14334,7 +14450,7 @@ describe('plugin-meetings', () => {
               assert.calledOnceWithExactly(webex.internal.llm.disconnectLLM, {
                 code: 3050,
                 reason: 'done (permanent)',
-              });
+              }, 'llm-default-session', meeting.id);
               assert.calledOnce(meeting.clearDataChannelToken);
             });
           });

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

@@ -347,6 +347,18 @@ describe('plugin-meetings', () => {
           'ANNOTATION_ON_SHARE_SUPPORTED',
         ]);
       });
+      it('adds deviceCapabilities to request when simultaneous interpretation is enabled', async () => {
+        await meetingsRequest.joinMeeting({
+          enableSimultaneousInterpretation: true,
+        });
+        const requestParams = meetingsRequest.request.getCall(0).args[0];
+        assert.deepEqual(requestParams.body.deviceCapabilities, [
+          'HOST_CONTROL_SI_SUPPORTED',
+          'INTERPRETER_CONTROL_SI_SUPPORTED',
+          'SI_HANDOVER_SUPPORTED',
+          'SIGN_INTERPRETER_SUPPORTED',
+        ]);
+      });
       it('does not add deviceCapabilities to request when breakouts and live annotation are not supported', async () => {
         await meetingsRequest.joinMeeting({});