Refactor chat to chat service and chat plugin

Signed-off-by: Anan Zhuang <[email protected]>

Author: ananzh

src/core/public/chat/chat_service.mock.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BehaviorSubject } from 'rxjs';
+import { ChatServiceSetup, ChatServiceStart } from './types';
+
+const createSetupContractMock = (): jest.Mocked<ChatServiceSetup> => ({
+  setImplementation: jest.fn(),
+  setSuggestedActionsService: jest.fn(),
+  suggestedActionsService: undefined,
+});
+
+const createStartContractMock = (): jest.Mocked<ChatServiceStart> => ({
+  isAvailable: jest.fn().mockReturnValue(false),
+  isWindowOpen: jest.fn().mockReturnValue(false),
+  getThreadId$: jest.fn().mockReturnValue(new BehaviorSubject<string>('')),
+  getThreadId: jest.fn().mockReturnValue(''),
+  openWindow: jest.fn(),
+  closeWindow: jest.fn(),
+  sendMessage: jest.fn().mockResolvedValue({
+    observable: null,
+    userMessage: { id: 'mock-id', role: 'user', content: 'mock-content' },
+  }),
+  sendMessageWithWindow: jest.fn().mockResolvedValue({
+    observable: null,
+    userMessage: { id: 'mock-id', role: 'user', content: 'mock-content' },
+  }),
+  getWindowState$: jest.fn().mockReturnValue(
+    new BehaviorSubject({
+      isWindowOpen: false,
+      windowMode: 'sidecar',
+      paddingSize: 400,
+    })
+  ),
+  onWindowOpen: jest.fn().mockReturnValue(() => {}),
+  onWindowClose: jest.fn().mockReturnValue(() => {}),
+  suggestedActionsService: undefined,
+});
+
+export const coreChatServiceMock = {
+  createSetupContract: createSetupContractMock,
+  createStartContract: createStartContractMock,
+};

src/core/public/chat/chat_service.test.ts

@@ -0,0 +1,264 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ChatService } from './chat_service';
+import { ChatImplementationFunctions, ChatWindowState } from './types';
+
+describe('ChatService', () => {
+  let service: ChatService;
+  let mockImplementation: ChatImplementationFunctions;
+  let mockThreadId$: BehaviorSubject<string>;
+  let mockWindowState$: BehaviorSubject<ChatWindowState>;
+
+  beforeEach(() => {
+    service = new ChatService();
+    mockThreadId$ = new BehaviorSubject<string>('test-thread-id');
+    mockWindowState$ = new BehaviorSubject<ChatWindowState>({
+      isWindowOpen: false,
+      windowMode: 'sidecar',
+      paddingSize: 400,
+    });
+
+    // Create complete mock implementation
+    mockImplementation = {
+      sendMessage: jest.fn().mockResolvedValue({
+        observable: null,
+        userMessage: { id: '1', role: 'user', content: 'test' },
+      }),
+      sendMessageWithWindow: jest.fn().mockResolvedValue({
+        observable: null,
+        userMessage: { id: '1', role: 'user', content: 'test' },
+      }),
+      getThreadId: jest.fn().mockReturnValue('test-thread-id'),
+      getThreadId$: jest.fn().mockReturnValue(mockThreadId$.asObservable()),
+      isWindowOpen: jest.fn().mockReturnValue(false),
+      openWindow: jest.fn().mockResolvedValue(undefined),
+      closeWindow: jest.fn().mockResolvedValue(undefined),
+      getWindowState: jest.fn().mockReturnValue({
+        isWindowOpen: false,
+        windowMode: 'sidecar',
+        paddingSize: 400,
+      }),
+      getWindowState$: jest.fn().mockReturnValue(mockWindowState$.asObservable()),
+      onWindowOpen: jest.fn().mockReturnValue(() => {}),
+      onWindowClose: jest.fn().mockReturnValue(() => {}),
+    };
+  });
+
+  describe('setup', () => {
+    it('returns valid setup contract', () => {
+      const setupContract = service.setup();
+
+      expect(setupContract).toEqual({
+        setImplementation: expect.any(Function),
+        setSuggestedActionsService: expect.any(Function),
+        suggestedActionsService: undefined,
+      });
+    });
+
+    it('setImplementation stores the implementation functions', () => {
+      const setupContract = service.setup();
+
+      expect(() => setupContract.setImplementation(mockImplementation)).not.toThrow();
+    });
+  });
+
+  describe('start', () => {
+    describe('availability logic', () => {
+      it('should be unavailable when no implementation is registered', () => {
+        const startContract = service.start();
+        expect(startContract.isAvailable()).toBe(false);
+      });
+
+      it('should be available after implementation is registered', () => {
+        const setupContract = service.setup();
+        setupContract.setImplementation(mockImplementation);
+        const startContract = service.start();
+        expect(startContract.isAvailable()).toBe(true);
+      });
+    });
+
+    describe('service interface', () => {
+      let startContract: any;
+
+      beforeEach(() => {
+        startContract = service.start();
+      });
+
+      it('provides all required interface methods', () => {
+        expect(startContract).toEqual({
+          isAvailable: expect.any(Function),
+          isWindowOpen: expect.any(Function),
+          getThreadId$: expect.any(Function),
+          getThreadId: expect.any(Function),
+          openWindow: expect.any(Function),
+          closeWindow: expect.any(Function),
+          sendMessage: expect.any(Function),
+          sendMessageWithWindow: expect.any(Function),
+          getWindowState: expect.any(Function),
+          getWindowState$: expect.any(Function),
+          onWindowOpen: expect.any(Function),
+          onWindowClose: expect.any(Function),
+          suggestedActionsService: undefined,
+        });
+      });
+
+      describe('window state management', () => {
+        beforeEach(() => {
+          // Set up implementation for these tests
+          const setupContract = service.setup();
+          setupContract.setImplementation(mockImplementation);
+          startContract = service.start();
+        });
+
+        it('should delegate to implementation for window state', () => {
+          expect(startContract.isWindowOpen()).toBe(false);
+          expect(mockImplementation.isWindowOpen).toHaveBeenCalled();
+        });
+
+        it('should delegate window open/close to implementation', async () => {
+          await startContract.openWindow();
+          expect(mockImplementation.openWindow).toHaveBeenCalled();
+
+          await startContract.closeWindow();
+          expect(mockImplementation.closeWindow).toHaveBeenCalled();
+        });
+
+        it('should provide window state via implementation', () => {
+          const state = startContract.getWindowState();
+          expect(mockImplementation.getWindowState).toHaveBeenCalled();
+          expect(state).toEqual({
+            isWindowOpen: false,
+            windowMode: 'sidecar',
+            paddingSize: 400,
+          });
+        });
+
+        it('should provide window state observable via implementation', (done) => {
+          const state$ = startContract.getWindowState$();
+          expect(mockImplementation.getWindowState$).toHaveBeenCalled();
+
+          state$
+            .subscribe((state: any) => {
+              expect(state).toEqual({
+                isWindowOpen: false,
+                windowMode: 'sidecar',
+                paddingSize: 400,
+              });
+              done();
+            })
+            .unsubscribe();
+        });
+
+        it('should delegate window callbacks to implementation', () => {
+          const openCallback = jest.fn();
+          const closeCallback = jest.fn();
+
+          startContract.onWindowOpen(openCallback);
+          startContract.onWindowClose(closeCallback);
+
+          expect(mockImplementation.onWindowOpen).toHaveBeenCalledWith(openCallback);
+          expect(mockImplementation.onWindowClose).toHaveBeenCalledWith(closeCallback);
+        });
+      });
+
+      describe('thread ID management', () => {
+        beforeEach(() => {
+          // Set up implementation for these tests
+          const setupContract = service.setup();
+          setupContract.setImplementation(mockImplementation);
+          startContract = service.start();
+        });
+
+        it('should delegate thread ID to implementation', () => {
+          const threadId = startContract.getThreadId();
+          expect(mockImplementation.getThreadId).toHaveBeenCalled();
+          expect(threadId).toBe('test-thread-id');
+        });
+
+        it('should provide thread ID observable via implementation', (done) => {
+          const threadId$ = startContract.getThreadId$();
+          expect(mockImplementation.getThreadId$).toHaveBeenCalled();
+
+          threadId$
+            .subscribe((threadId: string) => {
+              expect(threadId).toBe('test-thread-id');
+              done();
+            })
+            .unsubscribe();
+        });
+      });
+
+      describe('message handling', () => {
+        it('should throw error when no implementation is set', async () => {
+          // Use fresh service without implementation
+          const freshService = new ChatService();
+          const freshStartContract = freshService.start();
+
+          await expect(freshStartContract.sendMessage('test message', [])).rejects.toThrow(
+            'Chat service is not available'
+          );
+
+          await expect(
+            freshStartContract.sendMessageWithWindow('test message', [])
+          ).rejects.toThrow('Chat service is not available');
+        });
+
+        it('should delegate to implementation when set', async () => {
+          const setupContract = service.setup();
+          setupContract.setImplementation(mockImplementation);
+          const serviceWithImpl = service.start();
+
+          const testMessages = [{ id: '1', role: 'user', content: 'previous message' }];
+
+          await serviceWithImpl.sendMessage('test message', testMessages);
+          expect(mockImplementation.sendMessage).toHaveBeenCalledWith('test message', testMessages);
+
+          await serviceWithImpl.sendMessageWithWindow('test message with window', testMessages, {
+            clearConversation: true,
+          });
+          expect(mockImplementation.sendMessageWithWindow).toHaveBeenCalledWith(
+            'test message with window',
+            testMessages,
+            {
+              clearConversation: true,
+            }
+          );
+        });
+      });
+    });
+
+    describe('delegation without implementation', () => {
+      it('should return empty thread ID when no implementation', () => {
+        const startContract = service.start();
+        const threadId = startContract.getThreadId();
+        expect(threadId).toBe('');
+      });
+
+      it('should throw for observables when no implementation', () => {
+        const startContract = service.start();
+        expect(() => startContract.getThreadId$()).toThrow('Chat service is not available');
+        expect(() => startContract.getWindowState$()).toThrow('Chat service is not available');
+      });
+
+      it('should return default window state when no implementation', () => {
+        const startContract = service.start();
+        const state = startContract.getWindowState();
+        expect(state).toEqual({
+          isWindowOpen: false,
+          windowMode: 'sidecar',
+          paddingSize: 400,
+        });
+      });
+    });
+  });
+
+  describe('stop', () => {
+    it('should not throw when called', () => {
+      expect(() => service.stop()).not.toThrow();
+    });
+  });
+});