@lobehub/chat 0.107.14 → 0.107.16

package/src/store/chat/actions/topic.test.ts

@@ -0,0 +1,391 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { mutate } from 'swr';
+import { Mock, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { LOADING_FLAT } from '@/const/message';
+import { chatService } from '@/services/chat';
+import { messageService } from '@/services/message';
+import { topicService } from '@/services/topic';
+import { ChatMessage } from '@/types/chatMessage';
+import { ChatTopic } from '@/types/topic';
+
+import { useChatStore } from '../store';
+
+// Mock topicService 和 messageService
+vi.mock('@/services/topic', () => ({
+  topicService: {
+    removeTopics: vi.fn(),
+    removeAllTopic: vi.fn(),
+    removeTopic: vi.fn(),
+    createTopic: vi.fn(),
+    updateTitle: vi.fn(),
+    updateFavorite: vi.fn(),
+    batchRemoveTopics: vi.fn(),
+    getTopics: vi.fn(),
+    searchTopics: vi.fn(),
+  },
+}));
+
+vi.mock('@/services/message', () => ({
+  messageService: {
+    removeMessages: vi.fn(),
+  },
+}));
+
+beforeEach(() => {
+  // Setup initial state and mocks before each test
+  vi.clearAllMocks();
+  useChatStore.setState(
+    {
+      activeId: undefined,
+      activeTopicId: undefined,
+      // ... initial state
+    },
+    false,
+  );
+});
+
+afterEach(() => {
+  // Cleanup mocks after each test
+  vi.restoreAllMocks();
+});
+
+describe('topic action', () => {
+  describe('openNewTopicOrSaveTopic', () => {
+    it('should call switchTopic if activeTopicId exists', async () => {
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ activeTopicId: 'existing-topic-id' });
+      });
+
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        result.current.openNewTopicOrSaveTopic();
+      });
+
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+
+    it('should call saveToTopic if activeTopicId does not exist', async () => {
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ activeTopicId: '' });
+      });
+
+      const saveToTopicSpy = vi.spyOn(result.current, 'saveToTopic');
+
+      await act(async () => {
+        await result.current.openNewTopicOrSaveTopic();
+      });
+
+      expect(saveToTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('saveToTopic', () => {
+    it('should not create a topic if there are no messages', async () => {
+      const { result } = renderHook(() => useChatStore());
+      useChatStore.setState({ messages: [] });
+
+      const createTopicSpy = vi.spyOn(topicService, 'createTopic');
+
+      const topicId = await result.current.saveToTopic();
+
+      expect(createTopicSpy).not.toHaveBeenCalled();
+      expect(topicId).toBeUndefined();
+    });
+
+    it('should create a topic and bind messages to it', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const messages = [{ id: 'message1' }, { id: 'message2' }] as ChatMessage[];
+      useChatStore.setState({ messages, activeId: 'session-id' });
+
+      const createTopicSpy = vi
+        .spyOn(topicService, 'createTopic')
+        .mockResolvedValue('new-topic-id');
+
+      const topicId = await result.current.saveToTopic();
+
+      expect(createTopicSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          sessionId: 'session-id',
+          messages: messages.map((m) => m.id),
+        }),
+      );
+      expect(topicId).toEqual('new-topic-id');
+    });
+  });
+  describe('refreshTopic', () => {
+    beforeEach(() => {
+      vi.mock('swr', async () => {
+        const actual = await vi.importActual('swr');
+        return {
+          ...(actual as any),
+          mutate: vi.fn(),
+        };
+      });
+    });
+    afterEach(() => {
+      // 在每个测试用例开始前恢复到实际的 SWR 实现
+      vi.resetAllMocks();
+    });
+
+    it('should call mutate to refresh topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      useChatStore.setState({ activeId });
+
+      // Mock the mutate function to resolve immediately
+
+      await act(async () => {
+        await result.current.refreshTopic();
+      });
+
+      // Check if mutate has been called with the active session ID
+      expect(mutate).toHaveBeenCalledWith(activeId);
+    });
+
+    it('should handle errors during refreshing topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      useChatStore.setState({ activeId });
+
+      // Mock the mutate function to throw an error
+      // 设置模拟错误
+      (mutate as Mock).mockImplementation(() => {
+        throw new Error('Mutate error');
+      });
+
+      await act(async () => {
+        await expect(result.current.refreshTopic()).rejects.toThrow('Mutate error');
+      });
+
+      // 确保恢复 mutate 的模拟，以免影响其他测试
+      (mutate as Mock).mockReset();
+    });
+
+    // Additional tests for refreshTopic can be added here...
+  });
+  describe('favoriteTopic', () => {
+    it('should update the favorite state of a topic and refresh topics', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const topicId = 'topic-id';
+      const favState = true;
+
+      const updateFavoriteSpy = vi.spyOn(topicService, 'updateFavorite').mockResolvedValue(true);
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      await act(async () => {
+        await result.current.favoriteTopic(topicId, favState);
+      });
+
+      expect(updateFavoriteSpy).toHaveBeenCalledWith(topicId, favState);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('useFetchTopics', () => {
+    it('should fetch topics for a given session id', async () => {
+      const sessionId = 'test-session-id';
+      const topics = [{ id: 'topic-id', title: 'Test Topic' }];
+
+      // Mock the topicService.getTopics to resolve with topics array
+      (topicService.getTopics as Mock).mockResolvedValue(topics);
+
+      // Use the hook with the session id
+      const { result } = renderHook(() => useChatStore().useFetchTopics(sessionId));
+
+      // Wait for the hook to resolve and update the state
+      await waitFor(() => {
+        expect(result.current.data).toEqual(topics);
+      });
+      expect(useChatStore.getState().topicsInit).toBeTruthy();
+      expect(useChatStore.getState().topics).toEqual(topics);
+    });
+  });
+  describe('useSearchTopics', () => {
+    it('should search topics with the given keywords', async () => {
+      const keywords = 'search-term';
+      const searchResults = [{ id: 'searched-topic-id', title: 'Searched Topic' }];
+
+      // Mock the topicService.searchTopics to resolve with search results
+      (topicService.searchTopics as Mock).mockResolvedValue(searchResults);
+
+      // Use the hook with the keywords
+      const { result } = renderHook(() => useChatStore().useSearchTopics(keywords));
+
+      // Wait for the hook to resolve and update the state
+      await waitFor(() => {
+        expect(result.current.data).toEqual(searchResults);
+      });
+    });
+  });
+  describe('updateTopicTitle', () => {
+    it('should call topicService.updateTitle with correct parameters and refresh the topic', async () => {
+      const topicId = 'topic-id';
+      const newTitle = 'Updated Topic Title';
+      // Mock the topicService.updateTitle to resolve immediately
+      (topicService.updateTitle as Mock).mockResolvedValue(undefined);
+
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      // Call the action with the topicId and newTitle
+      await act(async () => {
+        await result.current.updateTopicTitle(topicId, newTitle);
+      });
+
+      // Verify that the topicService.updateTitle was called with correct parameters
+      expect(topicService.updateTitle).toHaveBeenCalledWith(topicId, newTitle);
+
+      // Verify that the refreshTopic was called to update the state
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('switchTopic', () => {
+    it('should update activeTopicId and call refreshMessages', async () => {
+      const topicId = 'topic-id';
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshMessagesSpy = vi.spyOn(result.current, 'refreshMessages');
+      // Call the switchTopic action with the topicId
+      await act(async () => {
+        await result.current.switchTopic(topicId);
+      });
+
+      // Verify that the activeTopicId has been updated
+      expect(useChatStore.getState().activeTopicId).toBe(topicId);
+
+      // Verify that the refreshMessages was called to update the messages
+      expect(refreshMessagesSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeSessionTopics', () => {
+    it('should remove all topics from the current session and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+      await act(async () => {
+        useChatStore.setState({ activeId });
+      });
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeSessionTopics();
+      });
+
+      expect(topicService.removeTopics).toHaveBeenCalledWith(activeId);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeAllTopics', () => {
+    it('should remove all topics and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      await act(async () => {
+        await result.current.removeAllTopics();
+      });
+
+      expect(topicService.removeAllTopic).toHaveBeenCalled();
+      expect(refreshTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeTopic', () => {
+    it('should remove a specific topic and its messages, then refresh the topic list', async () => {
+      const topicId = 'topic-1';
+      const { result } = renderHook(() => useChatStore());
+      const activeId = 'test-session-id';
+
+      await act(async () => {
+        useChatStore.setState({ activeId });
+      });
+
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeTopic(topicId);
+      });
+
+      expect(messageService.removeMessages).toHaveBeenCalledWith(activeId, topicId);
+      expect(topicService.removeTopic).toHaveBeenCalledWith(topicId);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('removeUnstarredTopic', () => {
+    it('should remove unstarred topics and refresh the topic list', async () => {
+      const { result } = renderHook(() => useChatStore());
+      // Set up mock state with unstarred topics
+      await act(async () => {
+        useChatStore.setState({
+          topics: [
+            { id: 'topic-1', favorite: false },
+            { id: 'topic-2', favorite: true },
+            { id: 'topic-3', favorite: false },
+          ] as ChatTopic[],
+        });
+      });
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+      const switchTopicSpy = vi.spyOn(result.current, 'switchTopic');
+
+      await act(async () => {
+        await result.current.removeUnstarredTopic();
+      });
+
+      expect(topicService.batchRemoveTopics).toHaveBeenCalledWith(['topic-1', 'topic-3']);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+      expect(switchTopicSpy).toHaveBeenCalled();
+    });
+  });
+  describe('updateTopicLoading', () => {
+    it('should call update topicLoadingId', async () => {
+      const { result } = renderHook(() => useChatStore());
+      expect(result.current.topicLoadingId).toBeUndefined();
+
+      // Call the action with the topicId and newTitle
+      await act(async () => {
+        await result.current.updateTopicLoading('loading-id');
+      });
+
+      expect(result.current.topicLoadingId).toEqual('loading-id');
+    });
+  });
+  describe('summaryTopicTitle', () => {
+    it('should auto-summarize the topic title and update it', async () => {
+      const topicId = 'topic-1';
+      const messages = [{ id: 'message-1', content: 'Hello' }] as ChatMessage[];
+      const topics = [{ id: 'topic-1', title: 'Test Topic' }] as ChatTopic[];
+      const { result } = renderHook(() => useChatStore());
+      await act(async () => {
+        useChatStore.setState({ topics });
+      });
+
+      // Mock the `updateTopicTitleInSummary` and `refreshTopic` for spying
+      const updateTopicTitleInSummarySpy = vi.spyOn(result.current, 'updateTopicTitleInSummary');
+      const refreshTopicSpy = vi.spyOn(result.current, 'refreshTopic');
+
+      // Mock the `chatService.fetchPresetTaskResult` to simulate the AI response
+      vi.spyOn(chatService, 'fetchPresetTaskResult').mockImplementation((params) => {
+        if (params) {
+          params.onFinish?.('Summarized Title');
+        }
+        return Promise.resolve(undefined);
+      });
+
+      await act(async () => {
+        await result.current.summaryTopicTitle(topicId, messages);
+      });
+
+      // Verify that the title was updated and the topic was refreshed
+      expect(updateTopicTitleInSummarySpy).toHaveBeenCalledWith(topicId, LOADING_FLAT);
+      expect(refreshTopicSpy).toHaveBeenCalled();
+
+      // TODO: need to test with fetchPresetTaskResult
+    });
+  });
+});

package/src/store/chat/actions/topic.ts

@@ -22,7 +22,7 @@ const n = setNamespace('topic');
 
 export interface ChatTopicAction {
   favoriteTopic: (id: string, favState: boolean) => Promise<void>;
-  openNewTopicOrSaveTopic: () => void;
+  openNewTopicOrSaveTopic: () => Promise<void>;
   refreshTopic: () => Promise<void>;
   removeAllTopics: () => Promise<void>;
   removeSessionTopics: () => Promise<void>;
@@ -45,7 +45,7 @@ export const chatTopic: StateCreator<
   ChatTopicAction
 > = (set, get) => ({
   // create
-  openNewTopicOrSaveTopic: () => {
+  openNewTopicOrSaveTopic: async () => {
     const { switchTopic, saveToTopic, activeTopicId } = get();
     const hasTopic = !!activeTopicId;
 
@@ -60,23 +60,17 @@ export const chatTopic: StateCreator<
     const messages = chatSelectors.currentChats(get());
     if (messages.length === 0) return;
 
-    const { activeId, summaryTopicTitle, refreshTopic, refreshMessages } = get();
+    const { activeId, summaryTopicTitle, refreshTopic } = get();
 
-    // 1. create topic
+    // 1. create topic and bind these messages
     const topicId = await topicService.createTopic({
       sessionId: activeId,
       title: t('topic.defaultTitle', { ns: 'chat' }),
+      messages: messages.map((m) => m.id),
     });
     await refreshTopic();
 
-    // 2.add topicId to these message
-    await messageService.bindMessagesToTopic(
-      topicId,
-      messages.map((m) => m.id),
-    );
-    await refreshMessages();
-
-    // 3. auto summary topic Title
+    // 2. auto summary topic Title
     // we don't need to wait for summary, just let it run async
     summaryTopicTitle(topicId, messages);
 

package/src/store/chat/helpers.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { LobeAgentConfig } from '@/types/agent';
+import { ChatMessage } from '@/types/chatMessage';
+import { OpenAIChatMessage } from '@/types/openai/chat';
+import { encodeAsync } from '@/utils/tokenizer';
+import * as tokenizerObj from '@/utils/tokenizer';
+
+import { chatHelpers } from './helpers';
+
+// Mock encodeAsync function
+vi.mock('@/utils/tokenizer', () => ({
+  encodeAsync: vi.fn((text) => Promise.resolve(text.length)),
+}));
+
+describe('chatHelpers', () => {
+  describe('getMessagesTokenCount', () => {
+    it('returns token count for a list of messages', async () => {
+      const messages = [{ content: 'Hello' }, { content: 'World' }] as OpenAIChatMessage[];
+      const tokenCount = await chatHelpers.getMessagesTokenCount(messages);
+      expect(tokenCount).toBe('HelloWorld'.length);
+    });
+
+    it('returns 0 for an empty array', async () => {
+      const tokenCount = await chatHelpers.getMessagesTokenCount([]);
+      expect(tokenCount).toBe(0);
+    });
+
+    it('handles messages with empty content', async () => {
+      const messages = [
+        { content: 'Hello' },
+        { content: '' },
+        { content: 'World' },
+      ] as OpenAIChatMessage[];
+      const tokenCount = await chatHelpers.getMessagesTokenCount(messages);
+      expect(tokenCount).toBe('HelloWorld'.length);
+    });
+
+    it('throws an error when encodeAsync fails', async () => {
+      vi.spyOn(tokenizerObj, 'encodeAsync').mockRejectedValue(new Error('Test error'));
+      await expect(
+        chatHelpers.getMessagesTokenCount([{ content: 'Hello' }] as OpenAIChatMessage[]),
+      ).rejects.toThrow('Test error');
+    });
+  });
+
+  describe('getMessageById', () => {
+    const messages = [
+      { id: '1', content: 'Hello' },
+      { id: '2', content: 'World' },
+    ] as ChatMessage[];
+
+    it('finds a message by id', () => {
+      const message = chatHelpers.getMessageById(messages, '1');
+      expect(message).toEqual({ id: '1', content: 'Hello' });
+    });
+
+    it('returns undefined for an invalid id', () => {
+      const message = chatHelpers.getMessageById(messages, '3');
+      expect(message).toBeUndefined();
+    });
+
+    it('returns undefined for an empty array', () => {
+      const message = chatHelpers.getMessageById([], '1');
+      expect(message).toBeUndefined();
+    });
+  });
+
+  describe('getSlicedMessagesWithConfig', () => {
+    const messages = [
+      { id: '1', content: 'First' },
+      { id: '2', content: 'Second' },
+      { id: '3', content: 'Third' },
+    ] as ChatMessage[];
+
+    it('returns all messages if history is disabled', () => {
+      const config = { enableHistoryCount: false, historyCount: 0 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual(messages);
+    });
+
+    it('returns last N messages based on historyCount', () => {
+      const config = { enableHistoryCount: true, historyCount: 2 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual([
+        { id: '2', content: 'Second' },
+        { id: '3', content: 'Third' },
+      ]);
+    });
+
+    it('returns empty array when historyCount is negative', () => {
+      const config = { enableHistoryCount: true, historyCount: -1 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual([]);
+    });
+
+    it('returns all messages if historyCount exceeds the array length', () => {
+      const config = { enableHistoryCount: true, historyCount: 5 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig(messages, config);
+      expect(slicedMessages).toEqual(messages);
+    });
+
+    it('returns an empty array for an empty message array', () => {
+      const config = { enableHistoryCount: true, historyCount: 2 } as LobeAgentConfig;
+      const slicedMessages = chatHelpers.getSlicedMessagesWithConfig([], config);
+      expect(slicedMessages).toEqual([]);
+    });
+  });
+});

package/src/store/chat/helpers.ts

@@ -6,18 +6,25 @@ import { encodeAsync } from '@/utils/tokenizer';
 export const getMessagesTokenCount = async (messages: OpenAIChatMessage[]) =>
   encodeAsync(messages.map((m) => m.content).join(''));
 
+export const getMessageById = (messages: ChatMessage[], id: string) =>
+  messages.find((m) => m.id === id);
+
 const getSlicedMessagesWithConfig = (
   messages: ChatMessage[],
   config: LobeAgentConfig,
 ): ChatMessage[] => {
-  // 如果没有开启历史消息数限制，或者限制为 0，则直接返回
+  // if historyCount is not enabled or set to 0, return all messages
   if (!config.enableHistoryCount || !config.historyCount) return messages;
 
-  // 如果开启了，则返回尾部的N条消息
-  return messages.reverse().slice(0, config.historyCount).reverse();
+  // if historyCount is negative, return empty array
+  if (config.historyCount <= 0) return [];
+
+  // if historyCount is positive, return last N messages
+  return messages.slice(-config.historyCount);
 };
 
 export const chatHelpers = {
+  getMessageById,
   getMessagesTokenCount,
   getSlicedMessagesWithConfig,
 };