✅ test: Add unit tests for ServerService methods in server.test.ts (#6260)

Co-authored-by: gru-agent[bot] <185149714+gru-agent[bot]@users.noreply.github.com>

Author: gru-agent[bot]

src/services/session/server.test.ts

@@ -0,0 +1,255 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { lambdaClient } from '@/libs/trpc/client';
+import { LobeSessionType } from '@/types/session';
+
+import { ServerService } from './server';
+
+vi.mock('@/libs/trpc/client', () => ({
+  lambdaClient: {
+    session: {
+      createSession: { mutate: vi.fn() },
+      batchCreateSessions: { mutate: vi.fn() },
+      cloneSession: { mutate: vi.fn() },
+      getGroupedSessions: { query: vi.fn() },
+      countSessions: { query: vi.fn() },
+      rankSessions: { query: vi.fn() },
+      updateSession: { mutate: vi.fn() },
+      updateSessionConfig: { mutate: vi.fn() },
+      updateSessionChatConfig: { mutate: vi.fn() },
+      getSessions: { query: vi.fn() },
+      searchSessions: { query: vi.fn() },
+      removeSession: { mutate: vi.fn() },
+      removeAllSessions: { mutate: vi.fn() },
+    },
+    agent: {
+      getAgentConfig: { query: vi.fn() },
+    },
+    sessionGroup: {
+      createSessionGroup: { mutate: vi.fn() },
+      getSessionGroup: { query: vi.fn() },
+      removeSessionGroup: { mutate: vi.fn() },
+      removeAllSessionGroups: { mutate: vi.fn() },
+      updateSessionGroup: { mutate: vi.fn() },
+      updateSessionGroupOrder: { mutate: vi.fn() },
+    },
+  },
+}));
+
+describe('ServerService', () => {
+  let service: ServerService;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    service = new ServerService();
+  });
+
+  it('hasSessions should return true if count is 0', async () => {
+    vi.mocked(lambdaClient.session.countSessions.query).mockResolvedValue(0);
+    const result = await service.hasSessions();
+    expect(result).toBe(true);
+  });
+
+  it('createSession should call lambdaClient with correct params', async () => {
+    const mockData = {
+      config: {
+        model: 'gpt-3.5',
+        params: {},
+        systemRole: '',
+        chatConfig: {
+          autoCreateTopicThreshold: 2,
+          compressThreshold: 10,
+          enableAutoCreateTopic: true,
+          enableCompressThreshold: true,
+          maxTokens: 2000,
+          model: 'gpt-3.5-turbo',
+          params: {},
+          temperature: 0.7,
+          title: 'test',
+        },
+        tts: {
+          showAllLocaleVoice: false,
+          sttLocale: 'auto',
+          ttsService: 'openai' as const,
+          voice: {
+            model: 'tts-1',
+            name: 'alloy',
+            type: 'tts',
+            openai: 'voice-id',
+          },
+        },
+      },
+      group: 'testGroup',
+      meta: { description: 'test' },
+      title: 'Test Session',
+    };
+
+    await service.createSession(LobeSessionType.Agent, mockData);
+
+    expect(lambdaClient.session.createSession.mutate).toBeCalledWith({
+      config: { ...mockData.config, description: 'test' },
+      session: { title: 'Test Session', groupId: 'testGroup' },
+      type: LobeSessionType.Agent,
+    });
+  });
+
+  it('batchCreateSessions should call lambdaClient', async () => {
+    const mockSessions = [
+      {
+        id: '1',
+        title: 'Test',
+        config: {
+          model: 'gpt-3.5',
+          params: {},
+          systemRole: '',
+          chatConfig: {
+            autoCreateTopicThreshold: 2,
+            compressThreshold: 10,
+            enableAutoCreateTopic: true,
+            enableCompressThreshold: true,
+            maxTokens: 2000,
+            model: 'gpt-3.5-turbo',
+            params: {},
+            temperature: 0.7,
+            title: 'test',
+          },
+          tts: {
+            showAllLocaleVoice: false,
+            sttLocale: 'auto',
+            ttsService: 'openai' as const,
+            voice: {
+              model: 'tts-1',
+              name: 'alloy',
+              type: 'tts',
+              openai: 'voice-id',
+            },
+          },
+        },
+        createdAt: new Date(),
+        meta: { description: 'test' },
+        model: 'gpt-3.5',
+        type: LobeSessionType.Agent,
+        updatedAt: new Date(),
+      },
+    ];
+
+    await service.batchCreateSessions(mockSessions as any);
+    expect(lambdaClient.session.batchCreateSessions.mutate).toBeCalledWith(mockSessions);
+  });
+
+  it('cloneSession should call lambdaClient', async () => {
+    await service.cloneSession('123', 'New Title');
+    expect(lambdaClient.session.cloneSession.mutate).toBeCalledWith({
+      id: '123',
+      newTitle: 'New Title',
+    });
+  });
+
+  it('getGroupedSessions should call lambdaClient', async () => {
+    await service.getGroupedSessions();
+    expect(lambdaClient.session.getGroupedSessions.query).toBeCalled();
+  });
+
+  it('countSessions should call lambdaClient with params', async () => {
+    const params = { startDate: '2023-01-01' };
+    await service.countSessions(params);
+    expect(lambdaClient.session.countSessions.query).toBeCalledWith(params);
+  });
+
+  it('rankSessions should call lambdaClient with limit', async () => {
+    await service.rankSessions(10);
+    expect(lambdaClient.session.rankSessions.query).toBeCalledWith(10);
+  });
+
+  it('updateSession should call lambdaClient with correct params', async () => {
+    const mockData = {
+      group: 'default',
+      pinned: true,
+      meta: { description: 'bar' },
+      updatedAt: new Date(),
+    };
+
+    await service.updateSession('123', mockData);
+
+    expect(lambdaClient.session.updateSession.mutate).toBeCalledWith({
+      id: '123',
+      value: {
+        groupId: null,
+        pinned: true,
+        description: 'bar',
+        updatedAt: mockData.updatedAt,
+      },
+    });
+  });
+
+  it('getSessionConfig should call lambdaClient', async () => {
+    await service.getSessionConfig('123');
+    expect(lambdaClient.agent.getAgentConfig.query).toBeCalledWith({ sessionId: '123' });
+  });
+
+  it('updateSessionConfig should call lambdaClient', async () => {
+    const config = { model: 'gpt-4' };
+    const signal = new AbortController().signal;
+    await service.updateSessionConfig('123', config, signal);
+    expect(lambdaClient.session.updateSessionConfig.mutate).toBeCalledWith(
+      { id: '123', value: config },
+      { signal },
+    );
+  });
+
+  it('getSessionsByType should call lambdaClient', async () => {
+    await service.getSessionsByType('all');
+    expect(lambdaClient.session.getSessions.query).toBeCalledWith({});
+  });
+
+  it('searchSessions should call lambdaClient with keywords', async () => {
+    await service.searchSessions('test');
+    expect(lambdaClient.session.searchSessions.query).toBeCalledWith({ keywords: 'test' });
+  });
+
+  it('removeSession should call lambdaClient', async () => {
+    await service.removeSession('123');
+    expect(lambdaClient.session.removeSession.mutate).toBeCalledWith({ id: '123' });
+  });
+
+  it('removeAllSessions should call lambdaClient', async () => {
+    await service.removeAllSessions();
+    expect(lambdaClient.session.removeAllSessions.mutate).toBeCalled();
+  });
+
+  it('createSessionGroup should call lambdaClient', async () => {
+    await service.createSessionGroup('Test Group', 1);
+    expect(lambdaClient.sessionGroup.createSessionGroup.mutate).toBeCalledWith({
+      name: 'Test Group',
+      sort: 1,
+    });
+  });
+
+  it('getSessionGroups should call lambdaClient', async () => {
+    await service.getSessionGroups();
+    expect(lambdaClient.sessionGroup.getSessionGroup.query).toBeCalled();
+  });
+
+  it('removeSessionGroup should call lambdaClient', async () => {
+    await service.removeSessionGroup('123', true);
+    expect(lambdaClient.sessionGroup.removeSessionGroup.mutate).toBeCalledWith({
+      id: '123',
+      removeChildren: true,
+    });
+  });
+
+  it('updateSessionGroup should call lambdaClient', async () => {
+    const value = { name: 'Updated Group' };
+    await service.updateSessionGroup('123', value);
+    expect(lambdaClient.sessionGroup.updateSessionGroup.mutate).toBeCalledWith({
+      id: '123',
+      value,
+    });
+  });
+
+  it('updateSessionGroupOrder should call lambdaClient', async () => {
+    const sortMap = [{ id: '123', sort: 1 }];
+    await service.updateSessionGroupOrder(sortMap);
+    expect(lambdaClient.sessionGroup.updateSessionGroupOrder.mutate).toBeCalledWith({ sortMap });
+  });
+});