@lobehub/chat 0.107.16 → 0.109.0

package/src/services/__tests__/chat.test.ts

@@ -0,0 +1,221 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
+import { act } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { VISION_MODEL_WHITE_LIST } from '@/const/llm';
+import { DEFAULT_AGENT_CONFIG } from '@/const/settings';
+import { useFileStore } from '@/store/file';
+import { useToolStore } from '@/store/tool';
+import { ChatMessage } from '@/types/chatMessage';
+import { OpenAIChatStreamPayload } from '@/types/openai/chat';
+import { fetchAIFactory } from '@/utils/fetch';
+
+import { chatService } from '../chat';
+
+// Mocking external dependencies
+vi.stubGlobal(
+  'fetch',
+  vi.fn(() => Promise.resolve(new Response(JSON.stringify({ some: 'data' })))),
+); // 用你的模拟响应替换这里的内容
+
+vi.mock('@/utils/fetch', () => ({
+  fetchAIFactory: vi.fn(),
+  getMessageError: vi.fn(),
+}));
+
+describe('ChatService', () => {
+  describe('createAssistantMessage', () => {
+    it('should process messages and call getChatCompletion with the right parameters', async () => {
+      const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+      const messages = [{ content: 'Hello', role: 'user' }] as ChatMessage[];
+      const enabledPlugins = ['plugin1'];
+      await act(async () => {
+        useToolStore.setState({
+          pluginManifestMap: {
+            plugin1: {
+              identifier: 'plugin1',
+              api: [{ name: 'api1' }],
+              type: 'default',
+            } as LobeChatPluginManifest,
+            plugin2: {
+              identifier: 'plugin2',
+              api: [{ name: 'api2' }],
+              type: 'standalone',
+            } as LobeChatPluginManifest,
+          },
+        });
+      });
+      await chatService.createAssistantMessage({ messages, plugins: enabledPlugins });
+
+      expect(getChatCompletionSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          functions: expect.arrayContaining([{ name: 'plugin1____api1____default' }]),
+          messages: expect.anything(),
+        }),
+        undefined,
+      );
+    });
+
+    it('should not use tools for models in the vision model whitelist', async () => {
+      const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+      const messages = [{ content: 'Hello', role: 'user' }] as ChatMessage[];
+      const modelInWhitelist = VISION_MODEL_WHITE_LIST[0];
+
+      await chatService.createAssistantMessage({
+        messages,
+        model: modelInWhitelist,
+        plugins: ['plugin1'],
+      });
+
+      expect(getChatCompletionSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          functions: undefined,
+          model: modelInWhitelist,
+        }),
+        undefined,
+      );
+    });
+
+    // New test case for processMessages
+    it('should correctly process messages and handle content for vision models', async () => {
+      const messages = [
+        { content: 'Hello', role: 'user', files: ['file1'] }, // Message with files
+        { content: 'Hi', role: 'function', plugin: { identifier: 'plugin1' } }, // Message with function role
+        { content: 'Hey', role: 'assistant' }, // Regular user message
+      ] as ChatMessage[];
+
+      // Mock file store state to return a specific image URL or Base64 for the given files
+      act(() => {
+        useFileStore.setState({
+          imagesMap: {
+            file1: {
+              name: 'abc.png',
+              saveMode: 'url',
+              fileType: 'image/png',
+              url: 'http://example.com/image.jpg',
+            },
+          },
+        });
+      });
+
+      const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+      await chatService.createAssistantMessage({ messages, plugins: [] });
+
+      expect(getChatCompletionSpy).toHaveBeenCalledWith(
+        {
+          messages: [
+            {
+              content: [
+                { text: 'Hello', type: 'text' },
+                {
+                  image_url: { detail: 'auto', url: 'http://example.com/image.jpg' },
+                  type: 'image_url',
+                },
+              ],
+              role: 'user',
+            },
+            {
+              content: 'Hi',
+              name: 'plugin1',
+              role: 'function',
+            },
+            {
+              content: 'Hey',
+              role: 'assistant',
+            },
+          ],
+        },
+        undefined,
+      );
+    });
+
+    it('should correctly process messages and handle content for vision models', async () => {
+      const messages = [
+        { content: 'Hello', role: 'user', files: ['file2'] }, // Message with files
+        { content: 'Hi', role: 'function', plugin: { identifier: 'plugin1' } }, // Message with function role
+        { content: 'Hey', role: 'assistant' }, // Regular user message
+      ] as ChatMessage[];
+
+      // Mock file store state to return a specific image URL or Base64 for the given files
+      act(() => {
+        useFileStore.setState({
+          imagesMap: {
+            file1: {
+              name: 'abc.png',
+              saveMode: 'url',
+              fileType: 'image/png',
+              url: 'http://example.com/image.jpg',
+            },
+          },
+        });
+      });
+
+      const getChatCompletionSpy = vi.spyOn(chatService, 'getChatCompletion');
+      await chatService.createAssistantMessage({ messages, plugins: [] });
+
+      expect(getChatCompletionSpy).toHaveBeenCalledWith(
+        {
+          messages: [
+            {
+              content: 'Hello',
+              role: 'user',
+            },
+            {
+              content: 'Hi',
+              name: 'plugin1',
+              role: 'function',
+            },
+            {
+              content: 'Hey',
+              role: 'assistant',
+            },
+          ],
+        },
+        undefined,
+      );
+    });
+  });
+  describe('getChatCompletion', () => {
+    it('should make a POST request with the correct payload', async () => {
+      const params: Partial<OpenAIChatStreamPayload> = {
+        model: 'test-model',
+        messages: [],
+      };
+      const options = {};
+      const expectedPayload = {
+        model: DEFAULT_AGENT_CONFIG.model,
+        stream: true,
+        ...DEFAULT_AGENT_CONFIG.params,
+        ...params,
+      };
+
+      await chatService.getChatCompletion(params, options);
+
+      expect(global.fetch).toHaveBeenCalledWith(expect.any(String), {
+        body: JSON.stringify(expectedPayload),
+        headers: expect.any(Object),
+        method: 'POST',
+        signal: undefined,
+      });
+    });
+
+    // Add more test cases to cover different scenarios and edge cases
+  });
+
+  describe('runPluginApi', () => {
+    it('should make a POST request and return the result text', async () => {
+      const params = { identifier: 'test-plugin', apiName: '1' }; // Add more properties if needed
+      const options = {};
+      const mockResponse = new Response('Plugin Result', { status: 200 });
+
+      global.fetch = vi.fn(() => Promise.resolve(mockResponse));
+
+      const result = await chatService.runPluginApi(params, options);
+
+      expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.any(Object));
+      expect(result).toBe('Plugin Result');
+    });
+
+    // Add more test cases to cover different scenarios and edge cases
+  });
+});

package/src/services/__tests__/message.test.ts

@@ -0,0 +1,333 @@
+import { Mock, describe, expect, it, vi } from 'vitest';
+
+import { CreateMessageParams, MessageModel } from '@/database/models/message';
+import {
+  ChatMessage,
+  ChatMessageError,
+  ChatPluginPayload,
+  ChatTTS,
+  ChatTranslate,
+} from '@/types/chatMessage';
+
+import { messageService } from '../message';
+
+// Mock the MessageModel
+vi.mock('@/database/models/message', () => {
+  return {
+    MessageModel: {
+      create: vi.fn(),
+      batchCreate: vi.fn(),
+      isEmpty: vi.fn(),
+      query: vi.fn(),
+      delete: vi.fn(),
+      queryBySessionId: vi.fn(),
+      update: vi.fn(),
+      batchDelete: vi.fn(),
+      clearTable: vi.fn(),
+      batchUpdate: vi.fn(),
+      queryAll: vi.fn(),
+    },
+  };
+});
+
+describe('MessageService', () => {
+  // Mock data
+  const mockMessageId = 'mock-message-id';
+  const mockMessage = {
+    id: mockMessageId,
+    content: 'Mock message content',
+    sessionId: 'mock-session-id',
+    createdAt: 100,
+    updatedAt: 100,
+    role: 'user',
+    // ... other properties
+  } as ChatMessage;
+  const mockMessages = [mockMessage];
+
+  beforeEach(() => {
+    // Reset all mocks before running each test case
+    vi.resetAllMocks();
+  });
+
+  describe('create', () => {
+    it('should create a message and return its id', async () => {
+      // Setup
+      const createParams = {
+        content: 'New message content',
+        sessionId: '1',
+        // ... other properties
+      } as CreateMessageParams;
+      (MessageModel.create as Mock).mockResolvedValue({ id: mockMessageId });
+
+      // Execute
+      const messageId = await messageService.create(createParams);
+
+      // Assert
+      expect(MessageModel.create).toHaveBeenCalledWith(createParams);
+      expect(messageId).toBe(mockMessageId);
+    });
+  });
+
+  describe('batchCreate', () => {
+    it('should batch create messages', async () => {
+      // Setup
+      (MessageModel.batchCreate as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const result = await messageService.batchCreate(mockMessages);
+
+      // Assert
+      expect(MessageModel.batchCreate).toHaveBeenCalledWith(mockMessages);
+      expect(result).toBe(mockMessages);
+    });
+  });
+
+  describe('hasMessages', () => {
+    it('should return true if there are messages', async () => {
+      // Setup
+      (MessageModel.isEmpty as Mock).mockResolvedValue(false);
+
+      // Execute
+      const hasMessages = await messageService.hasMessages();
+
+      // Assert
+      expect(MessageModel.isEmpty).toHaveBeenCalled();
+      expect(hasMessages).toBe(true);
+    });
+
+    it('should return false if there are no messages', async () => {
+      // Setup
+      (MessageModel.isEmpty as Mock).mockResolvedValue(true);
+
+      // Execute
+      const hasMessages = await messageService.hasMessages();
+
+      // Assert
+      expect(MessageModel.isEmpty).toHaveBeenCalled();
+      expect(hasMessages).toBe(false);
+    });
+  });
+
+  describe('removeMessage', () => {
+    it('should remove a message by id', async () => {
+      // Setup
+      (MessageModel.delete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeMessage(mockMessageId);
+
+      // Assert
+      expect(MessageModel.delete).toHaveBeenCalledWith(mockMessageId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getMessages', () => {
+    it('should retrieve messages by sessionId and topicId', async () => {
+      // Setup
+      const sessionId = 'session-id';
+      const topicId = 'topic-id';
+      (MessageModel.query as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getMessages(sessionId, topicId);
+
+      // Assert
+      expect(MessageModel.query).toHaveBeenCalledWith({ sessionId, topicId });
+      expect(messages).toBe(mockMessages);
+    });
+  });
+
+  describe('getAllMessagesInSession', () => {
+    it('should retrieve all messages in a session', async () => {
+      // Setup
+      const sessionId = 'session-id';
+      (MessageModel.queryBySessionId as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getAllMessagesInSession(sessionId);
+
+      // Assert
+      expect(MessageModel.queryBySessionId).toHaveBeenCalledWith(sessionId);
+      expect(messages).toBe(mockMessages);
+    });
+  });
+
+  describe('updateMessageContent', () => {
+    it('should update the content of a message', async () => {
+      // Setup
+      const newContent = 'Updated message content';
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, content: newContent });
+
+      // Execute
+      const result = await messageService.updateMessageContent(mockMessageId, newContent);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { content: newContent });
+      expect(result).toEqual({ ...mockMessage, content: newContent });
+    });
+  });
+
+  describe('removeMessages', () => {
+    it('should batch remove messages by assistantId and topicId', async () => {
+      // Setup
+      const assistantId = 'assistant-id';
+      const topicId = 'topic-id';
+      (MessageModel.batchDelete as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.removeMessages(assistantId, topicId);
+
+      // Assert
+      expect(MessageModel.batchDelete).toHaveBeenCalledWith(assistantId, topicId);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('clearAllMessage', () => {
+    it('should clear all messages from the table', async () => {
+      // Setup
+      (MessageModel.clearTable as Mock).mockResolvedValue(true);
+
+      // Execute
+      const result = await messageService.clearAllMessage();
+
+      // Assert
+      expect(MessageModel.clearTable).toHaveBeenCalled();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('bindMessagesToTopic', () => {
+    it('should batch update messages to bind them to a topic', async () => {
+      // Setup
+      const topicId = 'topic-id';
+      const messageIds = [mockMessageId];
+      (MessageModel.batchUpdate as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const result = await messageService.bindMessagesToTopic(topicId, messageIds);
+
+      // Assert
+      expect(MessageModel.batchUpdate).toHaveBeenCalledWith(messageIds, { topicId });
+      expect(result).toBe(mockMessages);
+    });
+  });
+
+  describe('getAllMessages', () => {
+    it('should retrieve all messages', async () => {
+      // Setup
+      (MessageModel.queryAll as Mock).mockResolvedValue(mockMessages);
+
+      // Execute
+      const messages = await messageService.getAllMessages();
+
+      // Assert
+      expect(MessageModel.queryAll).toHaveBeenCalled();
+      expect(messages).toBe(mockMessages);
+    });
+  });
+
+  describe('updateMessageError', () => {
+    it('should update the error field of a message', async () => {
+      // Setup
+      const newError = { type: 'NoAPIKey', message: 'Error occurred' } as ChatMessageError;
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, error: newError });
+
+      // Execute
+      const result = await messageService.updateMessageError(mockMessageId, newError);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { error: newError });
+      expect(result).toEqual({ ...mockMessage, error: newError });
+    });
+  });
+
+  describe('updateMessageTranslate', () => {
+    it('should update the translate field of a message', async () => {
+      // Setup
+      const newTranslate = { content: 'Translated text', to: 'es' } as ChatTranslate;
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, translate: newTranslate });
+
+      // Execute
+      const result = await messageService.updateMessageTranslate(mockMessageId, newTranslate);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { translate: newTranslate });
+      expect(result).toEqual({ ...mockMessage, translate: newTranslate });
+    });
+  });
+
+  describe('updateMessageTTS', () => {
+    it('should update the tts field of a message', async () => {
+      // Setup
+      const newTTS = { init: false } as ChatTTS;
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, tts: newTTS });
+
+      // Execute
+      const result = await messageService.updateMessageTTS(mockMessageId, newTTS);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { tts: newTTS });
+      expect(result).toEqual({ ...mockMessage, tts: newTTS });
+    });
+  });
+
+  describe('updateMessageRole', () => {
+    it('should update the role of a message', async () => {
+      // Setup
+      const newRole = 'user';
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, role: newRole });
+
+      // Execute
+      const result = await messageService.updateMessageRole(mockMessageId, newRole);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { role: newRole });
+      expect(result).toEqual({ ...mockMessage, role: newRole });
+    });
+  });
+
+  describe('updateMessagePlugin', () => {
+    it('should update the plugin payload of a message', async () => {
+      // Setup
+      const newPlugin = {
+        type: 'default',
+        apiName: 'abc',
+        arguments: '',
+        identifier: 'plugin1',
+      } as ChatPluginPayload;
+
+      (MessageModel.update as Mock).mockResolvedValue({ ...mockMessage, plugin: newPlugin });
+
+      // Execute
+      const result = await messageService.updateMessagePlugin(mockMessageId, newPlugin);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, { plugin: newPlugin });
+      expect(result).toEqual({ ...mockMessage, plugin: newPlugin });
+    });
+  });
+
+  describe('updateMessagePluginState', () => {
+    it('should update the plugin state of a message', async () => {
+      // Setup
+      const key = 'stateKey';
+      const value = 'stateValue';
+      const newPluginState = { [key]: value };
+      (MessageModel.update as Mock).mockResolvedValue({
+        ...mockMessage,
+        pluginState: newPluginState,
+      });
+
+      // Execute
+      const result = await messageService.updateMessagePluginState(mockMessageId, key, value);
+
+      // Assert
+      expect(MessageModel.update).toHaveBeenCalledWith(mockMessageId, {
+        pluginState: newPluginState,
+      });
+      expect(result).toEqual({ ...mockMessage, pluginState: newPluginState });
+    });
+  });
+});

package/src/services/__tests__/plugin.test.ts

@@ -0,0 +1,88 @@
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { getPluginIndexJSON } from '@/const/url';
+import { getCurrentLanguage } from '@/store/global/helpers';
+
+import { pluginService } from '../plugin';
+
+// Mocking modules and functions
+vi.mock('@/const/url', () => ({
+  getPluginIndexJSON: vi.fn(),
+}));
+vi.mock('@/store/global/helpers', () => ({
+  getCurrentLanguage: vi.fn(),
+}));
+
+describe('PluginService', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('getPluginList', () => {
+    it('should fetch and return the plugin list', async () => {
+      // Arrange
+      const fakeResponse = { plugins: [{ name: 'TestPlugin' }] };
+      const fakeUrl = 'http://fake-url.com/plugins.json';
+      (getCurrentLanguage as Mock).mockReturnValue('en');
+      (getPluginIndexJSON as Mock).mockReturnValue(fakeUrl);
+      global.fetch = vi.fn(() =>
+        Promise.resolve({
+          json: () => Promise.resolve(fakeResponse),
+        }),
+      ) as any;
+
+      // Act
+      const pluginList = await pluginService.getPluginList();
+
+      // Assert
+      expect(getCurrentLanguage).toHaveBeenCalled();
+      expect(getPluginIndexJSON).toHaveBeenCalledWith('en');
+      expect(fetch).toHaveBeenCalledWith(fakeUrl);
+      expect(pluginList).toEqual(fakeResponse);
+    });
+
+    it('should handle fetch error', async () => {
+      // Arrange
+      const fakeUrl = 'http://fake-url.com/plugins.json';
+      (getCurrentLanguage as Mock).mockReturnValue('en');
+      (getPluginIndexJSON as Mock).mockReturnValue(fakeUrl);
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      // Act & Assert
+      await expect(pluginService.getPluginList()).rejects.toThrow('Network error');
+    });
+  });
+
+  describe('fetchManifest', () => {
+    it('should fetch and return the plugin manifest', async () => {
+      // Arrange
+      const fakeManifest = { name: 'TestPlugin', version: '1.0.0' };
+      const manifestUrl = 'http://fake-url.com/manifest.json';
+      global.fetch = vi.fn(() =>
+        Promise.resolve({
+          json: () => Promise.resolve(fakeManifest),
+        }),
+      ) as any;
+
+      // Act
+      const manifest = await pluginService.fetchManifest(manifestUrl);
+
+      // Assert
+      expect(fetch).toHaveBeenCalledWith(manifestUrl);
+      expect(manifest).toEqual(fakeManifest);
+    });
+
+    it('should return null on fetch error', async () => {
+      // Arrange
+      const manifestUrl = 'http://fake-url.com/manifest.json';
+      global.fetch = vi.fn(() => Promise.reject(new Error('Network error')));
+
+      // Act
+      const manifest = await pluginService.fetchManifest(manifestUrl);
+
+      // Assert
+      expect(fetch).toHaveBeenCalledWith(manifestUrl);
+      expect(manifest).toBeNull();
+    });
+  });
+});