@webex/internal-plugin-llm 3.12.0-next.4 → 3.12.0-next.41

package/test/unit/spec/llm.js

@@ -3,6 +3,7 @@ import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import Mercury from '@webex/internal-plugin-mercury';
 import LLMService from '@webex/internal-plugin-llm';
+import LLMChannel from '@webex/internal-plugin-llm/src/llm';
 
 describe('plugin-llm', () => {
   const locusUrl = 'locusUrl';
@@ -172,6 +173,72 @@ describe('plugin-llm', () => {
 
         buildSpy.restore();
       });
+
+      it('rejects when the registration response has no websocket URL', async () => {
+        llmService.connections.set('llm-default-session', {});
+        llmService.register = sinon.stub().resolves();
+
+        await assert.isRejected(
+          llmService.registerAndConnect(locusUrl, datachannelUrl),
+          /returned no websocket URL/
+        );
+
+        sinon.assert.notCalled(llmService.connect);
+        assert.equal(llmService.isConnected(), false);
+      });
+
+      it('attaches the measured datachannel timing to the error when the websocket connect fails', async () => {
+        const clock = sinon.useFakeTimers();
+
+        llmService.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+        llmService.register = sinon.stub().callsFake(async () => {
+          clock.tick(37);
+          const sessionData = llmService.connections.get('llm-default-session') || {};
+          sessionData.webSocketUrl = 'wss://example.com/socket';
+          sessionData.binding = 'binding';
+          llmService.connections.set('llm-default-session', sessionData);
+        });
+
+        const connectError = new Error('websocket connect failed');
+        llmService.connect = sinon.stub().rejects(connectError);
+
+        let caughtError;
+        try {
+          await llmService.registerAndConnect(locusUrl, datachannelUrl);
+        } catch (error) {
+          caughtError = error;
+        }
+
+        assert.equal(caughtError, connectError);
+        assert.deepEqual(caughtError.timing, {clientLLMDatachannelResponseTime: 37});
+      });
+
+      it('attaches the measured datachannel timing to the error when the response has no websocket URL', async () => {
+        const clock = sinon.useFakeTimers();
+
+        llmService.register = sinon.stub().callsFake(async () => {
+          clock.tick(29);
+          // register() resolves but the response leaves the session without a websocket URL.
+          llmService.connections.set('llm-default-session', {
+            locusUrl,
+            datachannelUrl,
+          });
+        });
+
+        llmService.connect = sinon.stub();
+
+        let caughtError;
+        try {
+          await llmService.registerAndConnect(locusUrl, datachannelUrl);
+        } catch (error) {
+          caughtError = error;
+        }
+
+        sinon.assert.notCalled(llmService.connect);
+        assert.instanceOf(caughtError, Error);
+        assert.match(caughtError.message, /returned no websocket URL/);
+        assert.deepEqual(caughtError.timing, {clientLLMDatachannelResponseTime: 29});
+      });
     });
 
     describe('#register', () => {
@@ -277,23 +344,27 @@ describe('plugin-llm', () => {
         instance = {
           disconnect: jest.fn(() => Promise.resolve()),
           connections: new Map([
-            ['llm-default-session', { foo: 'bar' }],
+            ['llm-default-session', { foo: 'bar', datachannelToken: 'session-token' }],
           ]),
-          datachannelTokens: {
-            'llm-default-session': 'session-token',
-          },
 
-          disconnectLLM: function (options, sessionId = 'llm-default-session') {
+          disconnectLLM: function (
+            options,
+            sessionId = 'llm-default-session',
+            ownerMeetingId = 'meeting-1'
+          ) {
+            if (!ownerMeetingId) {
+              return Promise.reject(new Error('ownerMeetingId is required'));
+            }
+
             return this.disconnect(options, sessionId).then(() => {
               this.connections.delete(sessionId);
-              this.datachannelTokens[sessionId] = undefined;
             });
           },
         };
       });
 
-      it('calls disconnect and clears session connection + token', async () => {
-        await instance.disconnectLLM({ code: 3000, reason: 'bye' });
+      it('calls disconnect and clears session connection (including token stored in session)', async () => {
+        await instance.disconnectLLM({ code: 3000, reason: 'bye' }, 'llm-default-session', 'meeting-1');
 
         expect(instance.disconnect).toHaveBeenCalledWith(
           { code: 3000, reason: 'bye' },
@@ -301,26 +372,102 @@ describe('plugin-llm', () => {
         );
 
         expect(instance.connections.has('llm-default-session')).toBe(false);
+      });
+
+      it('disconnectLLM supports legacy call with options only', async () => {
+        llmService.disconnect = sinon.stub().resolves(true);
+
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 'llm-default-session');
+
+        const options = {code: 1000, reason: 'legacy'};
+        const disconnected = await llmService.disconnectLLM(options);
+
+        assert.equal(disconnected, true);
+        sinon.assert.calledOnceWithExactly(llmService.disconnect, options, 'llm-default-session');
+        assert.equal(llmService.getAllConnections().has('llm-default-session'), false);
+      });
+
+      it('disconnectLLM supports legacy call with options and sessionId', async () => {
+        llmService.disconnect = sinon.stub().resolves(true);
+
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+
+        const options = {code: 1000, reason: 'legacy'};
+        const disconnected = await llmService.disconnectLLM(options, 's1');
+
+        assert.equal(disconnected, true);
+        sinon.assert.calledOnceWithExactly(llmService.disconnect, options, 's1');
+        assert.equal(llmService.getAllConnections().has('s1'), false);
+      });
+
+      it('disconnectLLM treats null sessionId as default session', async () => {
+        llmService.disconnect = sinon.stub().resolves(true);
+
+        await llmService.registerAndConnect(
+          locusUrl,
+          datachannelUrl,
+          undefined,
+          'llm-default-session'
+        );
+
+        const options = {code: 1000, reason: 'legacy-null-session'};
+        const disconnected = await llmService.disconnectLLM(options, null);
 
-        expect(instance.datachannelTokens['llm-default-session']).toBeUndefined();
+        assert.equal(disconnected, true);
+        sinon.assert.calledOnceWithExactly(llmService.disconnect, options, 'llm-default-session');
+        assert.equal(llmService.getAllConnections().has('llm-default-session'), false);
       });
 
       it('propagates disconnect errors', async () => {
         instance.disconnect.mockRejectedValue(new Error('disconnect failed'));
 
         await expect(
-          instance.disconnectLLM({ code: 3000, reason: 'bye' })
+          instance.disconnectLLM({ code: 3000, reason: 'bye' }, 'llm-default-session', 'meeting-1')
         ).rejects.toThrow('disconnect failed');
       });
     });
 
     describe('#setRefreshHandler', () => {
+      beforeEach(() => {
+        llmService.setRefreshHandler = LLMChannel.prototype.setRefreshHandler.bind(llmService);
+        llmService.refreshDataChannelToken = LLMChannel.prototype.refreshDataChannelToken.bind(llmService);
+      });
+
+      it('defaults to llm-default-session when sessionId is omitted', () => {
+        const handler = sinon.stub().resolves({ body: { datachannelToken: 'legacyToken' } });
+
+        llmService.setRefreshHandler(handler);
+
+        return llmService.refreshDataChannelToken().then((result) => {
+          assert.equal(result.body.datachannelToken, 'legacyToken');
+          sinon.assert.calledOnce(handler);
+        });
+      });
+
       it('stores the provided handler', () => {
         const handler = sinon.stub().resolves({ body: { datachannelToken: 'newToken' } });
-        llmService.setRefreshHandler(handler);
+        llmService.setRefreshHandler(handler, 'llm-default-session');
 
-        // @ts-ignore
-        assert.equal(llmService.refreshHandler, handler);
+        return llmService.refreshDataChannelToken().then((result) => {
+          assert.equal(result.body.datachannelToken, 'newToken');
+          sinon.assert.calledOnce(handler);
+        });
+      });
+
+      it('stores handlers per session id', () => {
+        const handlerS1 = sinon.stub().resolves({ body: { datachannelToken: 'token-s1' } });
+        const handlerS2 = sinon.stub().resolves({ body: { datachannelToken: 'token-s2' } });
+
+        llmService.setRefreshHandler(handlerS1, 's1');
+        llmService.setRefreshHandler(handlerS2, 's2');
+
+        return Promise.all([
+          llmService.refreshDataChannelToken('s1'),
+          llmService.refreshDataChannelToken('s2'),
+        ]).then(([resultS1, resultS2]) => {
+          assert.equal(resultS1.body.datachannelToken, 'token-s1');
+          assert.equal(resultS2.body.datachannelToken, 'token-s2');
+        });
       });
     });
 
@@ -341,6 +488,11 @@ describe('plugin-llm', () => {
     });
 
     describe('#refreshDataChannelToken', () => {
+      beforeEach(() => {
+        llmService.setRefreshHandler = LLMChannel.prototype.setRefreshHandler.bind(llmService);
+        llmService.refreshDataChannelToken = LLMChannel.prototype.refreshDataChannelToken.bind(llmService);
+      });
+
       it('returns null and logs warn if no handler is set', async () => {
         const warnSpy = llmService.logger.warn
 
@@ -351,7 +503,7 @@ describe('plugin-llm', () => {
         sinon.assert.calledOnce(warnSpy);
         sinon.assert.calledWithMatch(
           warnSpy,
-          sinon.match('LLM refreshHandler is not set')
+          sinon.match('LLM refreshHandler is not set for session')
         );
       });
 
@@ -359,7 +511,7 @@ describe('plugin-llm', () => {
         const mockToken = { body: { datachannelToken: 'newToken', isPracticeSession: false } };
         const handler = sinon.stub().resolves(mockToken);
 
-        llmService.setRefreshHandler(handler);
+        llmService.setRefreshHandler(handler, 'llm-default-session');
 
         const token = await llmService.refreshDataChannelToken();
 
@@ -367,9 +519,21 @@ describe('plugin-llm', () => {
         sinon.assert.calledOnce(handler);
       });
 
+      it('uses the handler for the provided session id', async () => {
+        const mockToken = { body: { datachannelToken: 'session-token', isPracticeSession: true } };
+        const handler = sinon.stub().resolves(mockToken);
+
+        llmService.setRefreshHandler(handler, 's2');
+
+        const token = await llmService.refreshDataChannelToken('s2');
+
+        assert.equal(token, mockToken);
+        sinon.assert.calledOnce(handler);
+      });
+
       it('logs warn and returns null when handler rejects', async () => {
         const handler = sinon.stub().rejects(new Error('throw error'));
-        llmService.setRefreshHandler(handler);
+        llmService.setRefreshHandler(handler, 'llm-default-session');
 
         const warnSpy = llmService.logger.warn
 
@@ -392,6 +556,73 @@ describe('plugin-llm', () => {
         llmService.setDatachannelToken('123abc','llm-practice-session');
         assert.equal(llmService.getDatachannelToken('llm-practice-session'), '123abc');
       });
+
+      it('supports arbitrary session id token keys', () => {
+        llmService.setDatachannelToken('token-s1', 'session-custom-1');
+
+        assert.equal(llmService.getDatachannelToken('session-custom-1'), 'token-s1');
+      });
+
+    });
+
+    describe('#setOwnerMeetingId / #getOwnerMeetingId', () => {
+      it('stores and returns the owner meeting id for the default session', () => {
+        // beforeEach seeds connections with the default session entry
+        llmService.setOwnerMeetingId('meeting-1');
+
+        assert.equal(llmService.getOwnerMeetingId(), 'meeting-1');
+      });
+
+      it('returns undefined when no owner has been set yet', () => {
+        assert.equal(llmService.getOwnerMeetingId(), undefined);
+      });
+
+      it('is a no-op when there is no session data for the given sessionId', () => {
+        // Default session exists (seeded in beforeEach), but an arbitrary
+        // session id does not — setOwnerMeetingId must not create entries.
+        llmService.setOwnerMeetingId('meeting-1', 'unknown-session');
+
+        assert.equal(llmService.getOwnerMeetingId('unknown-session'), undefined);
+      });
+
+      it('allows clearing ownership by passing undefined', () => {
+        llmService.setOwnerMeetingId('meeting-1');
+        assert.equal(llmService.getOwnerMeetingId(), 'meeting-1');
+
+        llmService.setOwnerMeetingId(undefined);
+
+        assert.equal(llmService.getOwnerMeetingId(), undefined);
+      });
+
+      it('tracks ownership per session id', () => {
+        llmService.connections.set('session-A', {webSocketUrl: 'wss://a'});
+        llmService.connections.set('session-B', {webSocketUrl: 'wss://b'});
+
+        llmService.setOwnerMeetingId('meeting-A', 'session-A');
+        llmService.setOwnerMeetingId('meeting-B', 'session-B');
+
+        assert.equal(llmService.getOwnerMeetingId('session-A'), 'meeting-A');
+        assert.equal(llmService.getOwnerMeetingId('session-B'), 'meeting-B');
+      });
+
+      it('clears ownerMeetingId naturally when disconnectLLM deletes the session entry', async () => {
+        llmService.register = sinon.stub().callsFake(async () => ({
+          body: {binding: 'binding', webSocketUrl: 'wss://example.com/socket'},
+        }));
+
+        await llmService.registerAndConnect(locusUrl, datachannelUrl);
+        llmService.setOwnerMeetingId('meeting-1');
+        assert.equal(llmService.getOwnerMeetingId(), 'meeting-1');
+
+        await llmService.disconnectLLM(
+          {code: 3050, reason: 'done (permanent)'},
+          'llm-default-session',
+          'meeting-1'
+        );
+
+        // Session entry was deleted, so ownerMeetingId is gone.
+        assert.equal(llmService.getOwnerMeetingId(), undefined);
+      });
     });
 
     describe('multi-connection logic', () => {
@@ -421,20 +652,33 @@ describe('plugin-llm', () => {
         await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
 
         const options = {code: 1000, reason: 'test'};
-        await llmService.disconnectLLM(options, 's1');
+        const disconnected = await llmService.disconnectLLM(options, 's1', 'meeting-1');
 
+        assert.equal(disconnected, true);
         sinon.assert.calledOnceWithExactly(llmService.disconnect, options, 's1');
 
         const all = llmService.getAllConnections();
         assert.equal(all.has('s1'), false);
         assert.equal(all.has('s2'), true);
+        assert.equal(llmService.getDatachannelToken('s1'), undefined);
+      });
+
+      it('disconnectLLM skips disconnect when ownerMeetingId does not match', async () => {
+        llmService.disconnect = sinon.stub().resolves(true);
 
-        assert.equal(llmService.datachannelTokens['s1'], undefined);
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+        llmService.setOwnerMeetingId('meeting-1', 's1');
+
+        const options = {code: 1000, reason: 'test'};
+        const disconnected = await llmService.disconnectLLM(options, 's1', 'meeting-2');
+
+        assert.equal(disconnected, false);
+        sinon.assert.notCalled(llmService.disconnect);
+        assert.equal(llmService.getAllConnections().has('s1'), true);
       });
 
       it('disconnectAllLLM clears all sessions', async () => {
         llmService.disconnectAll = sinon.stub().resolves(true);
-        sinon.spy(llmService, 'resetDatachannelTokens');
 
         await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
         await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
@@ -446,5 +690,149 @@ describe('plugin-llm', () => {
       });
     });
 
+    describe('#getLocusUrlByDatachannelUrl', () => {
+      const locusUrl2 = 'https://locus-b.wbx2.com/locus/api/v1/loci/456';
+      const datachannelUrl2 = 'https://board-b.wbx2.com/datachannel/api/v1/locus/ps-encoded/registrations';
+
+      // Ampersand State.extend() does not always propagate prototype methods
+      // added to child classes, so we bind the method from the class prototype
+      // directly onto the test instance.
+      beforeEach(() => {
+        llmService.getLocusUrlByDatachannelUrl = LLMChannel.prototype.getLocusUrlByDatachannelUrl.bind(llmService);
+      });
+
+      it('returns locusUrl when request URL matches a session datachannelUrl', async () => {
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+        await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
+
+        const result = llmService.getLocusUrlByDatachannelUrl(datachannelUrl2 + '/some-path');
+
+        assert.equal(result, locusUrl2);
+      });
+
+      it('returns undefined when no session matches the request URL', async () => {
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+
+        const result = llmService.getLocusUrlByDatachannelUrl('https://unknown.example.com/path');
+
+        assert.equal(result, undefined);
+      });
+
+      it('matches locusUrl when request host is rewritten but pathname matches', async () => {
+        await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
+
+        const rewrittenHostRequestUrl =
+          'https://hostmap-rewritten.example.com/datachannel/api/v1/locus/ps-encoded/registrations/events';
+        const result = llmService.getLocusUrlByDatachannelUrl(rewrittenHostRequestUrl);
+
+        assert.equal(result, locusUrl2);
+      });
+
+      it('returns undefined when no connections exist', () => {
+        const result = llmService.getLocusUrlByDatachannelUrl(datachannelUrl);
+
+        assert.equal(result, undefined);
+      });
+    });
+
+    describe('#getSessionIdByDatachannelUrl', () => {
+      const datachannelUrl2 = 'https://board-b.wbx2.com/datachannel/api/v1/locus/ps-encoded/registrations';
+
+      beforeEach(() => {
+        llmService.getSessionIdByDatachannelUrl = LLMChannel.prototype.getSessionIdByDatachannelUrl.bind(llmService);
+      });
+
+      it('returns sessionId when request URL matches a session datachannelUrl', async () => {
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+        await llmService.registerAndConnect('https://locus-b.wbx2.com/locus/api/v1/loci/456', datachannelUrl2, undefined, 's2');
+
+        const result = llmService.getSessionIdByDatachannelUrl(datachannelUrl2 + '/some-path');
+
+        assert.equal(result, 's2');
+      });
+
+      it('returns undefined when no session matches the request URL', async () => {
+        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
+
+        const result = llmService.getSessionIdByDatachannelUrl('https://unknown.example.com/path');
+
+        assert.equal(result, undefined);
+      });
+
+      it('matches sessionId when request host is rewritten but pathname matches', async () => {
+        await llmService.registerAndConnect(
+          'https://locus-b.wbx2.com/locus/api/v1/loci/456',
+          datachannelUrl2,
+          undefined,
+          's2'
+        );
+
+        const rewrittenHostRequestUrl =
+          'https://hostmap-rewritten.example.com/datachannel/api/v1/locus/ps-encoded/registrations/messages';
+        const result = llmService.getSessionIdByDatachannelUrl(rewrittenHostRequestUrl);
+
+        assert.equal(result, 's2');
+      });
+    });
+
+    describe('#registerAndConnect timing', () => {
+      it('returns timing data on successful connection', async () => {
+        const clock = sinon.useFakeTimers();
+
+        llmService.isDataChannelTokenEnabled = sinon.stub().resolves(false);
+        llmService.register = sinon.stub().callsFake(async () => {
+          clock.tick(37);
+
+          const sessionData = llmService.connections.get('llm-default-session') || {};
+
+          sessionData.webSocketUrl = 'wss://example.com/socket';
+          sessionData.binding = 'binding';
+          llmService.connections.set('llm-default-session', sessionData);
+        });
+        llmService.connect = sinon.stub().callsFake(async () => {
+          clock.tick(23);
+        });
+
+        const result = await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined);
+
+        assert.deepEqual(result, {
+          clientLLMDatachannelResponseTime: 37,
+          clientLLMWebSocketConnectTime: 23,
+        });
+      });
+
+      it('returns undefined when locusUrl is empty', async () => {
+        llmService.register = sinon.stub().resolves();
+
+        const result = await llmService.registerAndConnect('', datachannelUrl, undefined);
+
+        assert.isUndefined(result);
+      });
+    });
+
+    describe('#getWebSocketUrl', () => {
+      it('returns the websocket URL for default session', () => {
+        llmService.connections.set('llm-default-session', {
+          webSocketUrl: 'wss://test.example.com/ws',
+        });
+
+        assert.equal(llmService.getWebSocketUrl(), 'wss://test.example.com/ws');
+      });
+
+      it('returns undefined when no connection exists', () => {
+        llmService.connections.clear();
+
+        assert.isUndefined(llmService.getWebSocketUrl());
+      });
+
+      it('returns the websocket URL for custom session', () => {
+        llmService.connections.set('custom-session', {
+          webSocketUrl: 'wss://custom.example.com/ws',
+        });
+
+        assert.equal(llmService.getWebSocketUrl('custom-session'), 'wss://custom.example.com/ws');
+      });
+    });
+
   });
 });