@webex/internal-plugin-llm 3.12.0-next.9 → 3.12.0-task-refactor.1

package/test/unit/spec/llm.js

@@ -19,182 +19,47 @@ describe('plugin-llm', () => {
         },
       });
 
-      webex.internal.feature = {
-        setFeature: sinon.stub().resolves({value: true}),
-        getFeature: sinon.stub().resolves(true),
-      };
-
       llmService = webex.internal.llm;
-      llmService.webSocketUrl = 'wss://example.com/socket';
+      llmService.connect = sinon.stub().callsFake(() => {
+        llmService.connected = true;
+      });
       llmService.disconnect = sinon.stub().resolves(true);
       llmService.request = sinon.stub().resolves({
         headers: {},
         body: {
           binding: 'binding',
-          webSocketUrl: 'wss://example.com/socket',
+          webSocketUrl: 'url',
         },
       });
-      const sockets = new Map();
-
-      llmService.connect = sinon.stub().callsFake((url, sessionId) => {
-        sockets.set(sessionId, {connected: true});
-        llmService.getSocket = sinon.stub().callsFake((sid) => sockets.get(sid));
-      });
-            llmService.connections.set('llm-default-session',{
-            webSocketUrl: 'wss://example.com/socket',
-        })
     });
 
-    afterEach(() => sinon.restore());
-
     describe('#registerAndConnect', () => {
       it('registers connection', async () => {
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
-        });
-
-        assert.equal(llmService.isConnected('llm-default-session'), false);
-        await llmService.registerAndConnect(locusUrl, datachannelUrl,undefined);
-        assert.equal(llmService.isConnected('llm-default-session'), true);
-      });
-
-      it("doesn't register connection for invalid input", async () => {
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
-        });
-
-        await llmService.registerAndConnect();
-        assert.equal(llmService.isConnected(), false);
-      });
-
-      it('registers connection with token', async () => {
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url',
+          },
         });
-
         assert.equal(llmService.isConnected(), false);
-
-        await llmService.registerAndConnect(locusUrl, datachannelUrl,'abc123');
-
-        sinon.assert.calledOnceWithExactly(
-          llmService.register,
-          datachannelUrl,
-          'abc123',
-          'llm-default-session'
-        );
-
+        await llmService.registerAndConnect(locusUrl, datachannelUrl);
         assert.equal(llmService.isConnected(), true);
       });
 
-      it('connects with subscriptionAwareSubchannels when token enabled', async () => {
-        llmService.isDataChannelTokenEnabled = sinon.stub().returns(true);
-
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
-        });
-
-        const buildSpy = sinon.spy(LLMService, 'buildUrlWithAwareSubchannels');
-
-        await llmService.registerAndConnect(locusUrl, datachannelUrl,'abc123');
-
-        sinon.assert.calledOnce(buildSpy);
-        sinon.assert.calledOnce(llmService.connect);
-
-        const calledUrl = llmService.connect.getCall(0).args[0];
-        assert.include(calledUrl, 'subscriptionAwareSubchannels=');
-      });
-
-      it('connects without subscriptionAwareSubchannels when token disabled', async () => {
-        llmService.isDataChannelTokenEnabled = sinon.stub().returns(false);
-
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
+      it("doesn't registers connection for invalid input", async () => {
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url',
+          },
         });
-
-        const buildSpy = sinon.spy(LLMService, 'buildUrlWithAwareSubchannels');
-
-        await llmService.registerAndConnect(locusUrl, datachannelUrl);
-
-        sinon.assert.notCalled(buildSpy);
-        sinon.assert.calledOnce(llmService.connect);
-
-        const calledUrl = llmService.connect.getCall(0).args[0];
-        assert.equal(calledUrl, llmService.webSocketUrl);
-      });
-
-      it('connects without subscriptionAwareSubchannels when token enabled BUT token missing', async () => {
-        llmService.isDataChannelTokenEnabled = sinon.stub().resolves(true);
-
-        const buildSpy = sinon.spy(LLMService, 'buildUrlWithAwareSubchannels');
-
-        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined);
-
-        sinon.assert.calledOnce(buildSpy);
-        sinon.assert.calledOnce(llmService.connect);
-
-        const calledUrl = llmService.connect.getCall(0).args[0];
-        assert.include(calledUrl, 'subscriptionAwareSubchannels=');
-
-        buildSpy.restore();
+        await llmService.registerAndConnect();
+        assert.equal(llmService.isConnected(), false);
       });
     });
 
     describe('#register', () => {
-      beforeEach(() => {
-        llmService.isDataChannelTokenEnabled = sinon.stub();
-      });
-
-      it('registers connection with token header', async () => {
-        llmService.isDataChannelTokenEnabled.resolves(true);
-        await llmService.register(datachannelUrl, 'abc123');
-
-        sinon.assert.calledOnceWithExactly(
-          llmService.request,
-          sinon.match({
-            method: 'POST',
-            url: `${datachannelUrl}`,
-            body: {deviceUrl: webex.internal.device.url},
-            headers: {'Data-Channel-Auth-Token': 'abc123'},
-          })
-        );
-      });
-
-      it('registers connection without token header when none provided', async () => {
+      it('registers connection', async () => {
         await llmService.register(datachannelUrl);
 
         sinon.assert.calledOnceWithExactly(
@@ -203,40 +68,21 @@ describe('plugin-llm', () => {
             method: 'POST',
             url: `${datachannelUrl}`,
             body: {deviceUrl: webex.internal.device.url},
-            headers: {},
           })
         );
-      });
 
-      it('registers connection without token header when toggle disabled', async () => {
-        llmService.isDataChannelTokenEnabled.resolves(false);
-
-        await llmService.register(datachannelUrl,'abc123');
-        sinon.assert.calledOnceWithExactly(
-          llmService.request,
-          sinon.match({
-            method: 'POST',
-            url: `${datachannelUrl}`,
-            body: {deviceUrl: webex.internal.device.url},
-            headers: {},
-          })
-        );
+        assert.equal(llmService.getBinding(), 'binding');
       });
     });
 
     describe('#getLocusUrl', () => {
       it('gets LocusUrl', async () => {
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url',
+          },
         });
-
         await llmService.registerAndConnect(locusUrl, datachannelUrl);
         assert.equal(llmService.getLocusUrl(), locusUrl);
       });
@@ -244,15 +90,11 @@ describe('plugin-llm', () => {
 
     describe('#getDatachannelUrl', () => {
       it('gets dataChannel Url', async () => {
-        llmService.register = sinon.stub().callsFake(async () => {
-          llmService.binding = 'binding';
-          llmService.webSocketUrl = 'wss://example.com/socket';
-          return {
-            body: {
-              binding: 'binding',
-              webSocketUrl: 'wss://example.com/socket',
-            },
-          };
+        llmService.register = sinon.stub().resolves({
+          body: {
+            binding: 'binding',
+            webSocketUrl: 'url',
+          },
         });
         await llmService.registerAndConnect(locusUrl, datachannelUrl);
         assert.equal(llmService.getDatachannelUrl(), datachannelUrl);
@@ -270,181 +112,42 @@ describe('plugin-llm', () => {
       });
     });
 
-    describe('#disconnectLLM', () => {
+    describe('disconnectLLM', () => {
       let instance;
 
       beforeEach(() => {
         instance = {
           disconnect: jest.fn(() => Promise.resolve()),
-          connections: new Map([
-            ['llm-default-session', { foo: 'bar' }],
-          ]),
-          datachannelTokens: {
-            'llm-default-session': 'session-token',
-          },
-
-          disconnectLLM: function (options, sessionId = 'llm-default-session') {
-            return this.disconnect(options, sessionId).then(() => {
-              this.connections.delete(sessionId);
-              this.datachannelTokens[sessionId] = undefined;
+          locusUrl: 'someUrl',
+          datachannelUrl: 'someUrl',
+          binding: {},
+          webSocketUrl: 'someUrl',
+          disconnectLLM: function (options) {
+            return this.disconnect(options).then(() => {
+              this.locusUrl = undefined;
+              this.datachannelUrl = undefined;
+              this.binding = undefined;
+              this.webSocketUrl = undefined;
             });
-          },
+          }
         };
       });
 
-      it('calls disconnect and clears session connection + token', async () => {
-        await instance.disconnectLLM({ code: 3000, reason: 'bye' });
-
-        expect(instance.disconnect).toHaveBeenCalledWith(
-          { code: 3000, reason: 'bye' },
-          'llm-default-session'
-        );
-
-        expect(instance.connections.has('llm-default-session')).toBe(false);
-
-        expect(instance.datachannelTokens['llm-default-session']).toBeUndefined();
-      });
-
-      it('propagates disconnect errors', async () => {
-        instance.disconnect.mockRejectedValue(new Error('disconnect failed'));
+      it('should call disconnect and clear relevant properties', async () => {
+        await instance.disconnectLLM({});
 
-        await expect(
-          instance.disconnectLLM({ code: 3000, reason: 'bye' })
-        ).rejects.toThrow('disconnect failed');
+        expect(instance.disconnect).toHaveBeenCalledWith({});
+        expect(instance.locusUrl).toBeUndefined();
+        expect(instance.datachannelUrl).toBeUndefined();
+        expect(instance.binding).toBeUndefined();
+        expect(instance.webSocketUrl).toBeUndefined();
       });
-    });
-
-    describe('#setRefreshHandler', () => {
-      it('stores the provided handler', () => {
-        const handler = sinon.stub().resolves({ body: { datachannelToken: 'newToken' } });
-        llmService.setRefreshHandler(handler);
-
-        // @ts-ignore
-        assert.equal(llmService.refreshHandler, handler);
-      });
-    });
 
-    describe('#isDataChannelTokenEnabled', () => {
-      it('works correctly', async () => {
-        webex.internal.feature.getFeature.returns(true);
-
-        const result = await llmService.isDataChannelTokenEnabled();
-
-        sinon.assert.calledOnceWithExactly(
-          webex.internal.feature.getFeature,
-          'developer',
-          'data-channel-with-jwt-token'
-        );
+      it('should handle errors from disconnect gracefully', async () => {
+        instance.disconnect.mockRejectedValue(new Error('Disconnect failed'));
 
-        assert.equal(result, true);
+        await expect(instance.disconnectLLM({})).rejects.toThrow('Disconnect failed');
       });
     });
-
-    describe('#refreshDataChannelToken', () => {
-      it('returns null and logs warn if no handler is set', async () => {
-        const warnSpy = llmService.logger.warn
-
-        const result = await llmService.refreshDataChannelToken();
-
-        assert.equal(result, null);
-
-        sinon.assert.calledOnce(warnSpy);
-        sinon.assert.calledWithMatch(
-          warnSpy,
-          sinon.match('LLM refreshHandler is not set')
-        );
-      });
-
-      it('returns token when handler resolves', async () => {
-        const mockToken = { body: { datachannelToken: 'newToken', isPracticeSession: false } };
-        const handler = sinon.stub().resolves(mockToken);
-
-        llmService.setRefreshHandler(handler);
-
-        const token = await llmService.refreshDataChannelToken();
-
-        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);
-
-        const warnSpy = llmService.logger.warn
-
-        const result = await llmService.refreshDataChannelToken();
-
-        assert.equal(result, null);
-
-        sinon.assert.calledOnce(warnSpy);
-        sinon.assert.calledWithMatch(
-          warnSpy,
-          sinon.match('DataChannel token refresh failed'),
-        );
-      });
-    });
-
-    describe('#getDatachannelToken / #setDatachannelToken', () => {
-      it('sets and gets datachannel token', () => {
-        llmService.setDatachannelToken('abc123','llm-default-session');
-        assert.equal(llmService.getDatachannelToken('llm-default-session'), 'abc123');
-        llmService.setDatachannelToken('123abc','llm-practice-session');
-        assert.equal(llmService.getDatachannelToken('llm-practice-session'), '123abc');
-      });
-    });
-
-    describe('multi-connection logic', () => {
-      const locusUrl2 = 'locusUrl2';
-      const datachannelUrl2 = 'datachannelUrl2';
-
-      it('tracks multiple sessions independently', async () => {
-        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
-        await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
-
-        assert.equal(llmService.isConnected('s1'), true);
-        assert.equal(llmService.isConnected('s2'), true);
-        assert.equal(llmService.getLocusUrl('s1'), locusUrl);
-        assert.equal(llmService.getLocusUrl('s2'), locusUrl2);
-        assert.equal(llmService.getDatachannelUrl('s1'), datachannelUrl);
-        assert.equal(llmService.getDatachannelUrl('s2'), datachannelUrl2);
-
-        const all = llmService.getAllConnections();
-        assert.equal(all.has('s1'), true);
-        assert.equal(all.has('s2'), true);
-      });
-
-      it('disconnectLLM clears only the targeted session', async () => {
-        llmService.disconnect = sinon.stub().resolves(true);
-
-        await llmService.registerAndConnect(locusUrl, datachannelUrl, undefined, 's1');
-        await llmService.registerAndConnect(locusUrl2, datachannelUrl2, undefined, 's2');
-
-        const options = {code: 1000, reason: 'test'};
-        await llmService.disconnectLLM(options, 's1');
-
-        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.datachannelTokens['s1'], undefined);
-      });
-
-      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');
-
-        await llmService.disconnectAllLLM({code: 1000, reason: 'all'});
-
-        sinon.assert.calledOnce(llmService.disconnectAll);
-        assert.equal(llmService.getAllConnections().size, 0);
-      });
-    });
-
   });
 });