lobe-chat

1
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
2

3
import { SessionModel } from '@/database/client/models/session';
4
import { SessionGroups } from '@/types/session';
5

6
import { DB_SessionGroup } from '../../schemas/sessionGroup';
7
import { SessionGroupModel } from '../sessionGroup';
8

9
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
10

11
describe('SessionGroupModel', () => {
12
  let sessionGroupData: DB_SessionGroup;
13

14
  beforeEach(() => {
15
    // 设置正确结构的会话组数据
16
    sessionGroupData = {
17
      name: 'test-group',
18
      sort: 1,
19
    };
20
  });
21

22
  afterEach(async () => {
23
    // 每次测试后清理数据库
24
    await SessionGroupModel.clear();
25
  });
26

27
  describe('create', () => {
28
    it('should create a session group record', async () => {
29
      const createdGroup = await SessionGroupModel.create(
30
        sessionGroupData.name,
31
        sessionGroupData.sort,
32
      );
33
      const item = await SessionGroupModel.findById(createdGroup.id);
34
      expect(item.name).toEqual(sessionGroupData.name);
35
      expect(item.sort).toEqual(sessionGroupData.sort);
36
    });
37
  });
38

39
  describe('batchCreate', () => {
40
    it('should batch create session group records', async () => {
41
      const groups = [
42
        sessionGroupData,
43
        { ...sessionGroupData, name: 'another-group' },
44
      ] as SessionGroups;
45
      await SessionGroupModel.batchCreate(groups);
46
      const fetchedGroups = await SessionGroupModel.query();
47
      expect(fetchedGroups).toHaveLength(2);
48
    });
49
  });
50

51
  describe('update', () => {
52
    it('should update a session group', async () => {
53
      const createdGroup = await SessionGroupModel.create(
54
        sessionGroupData.name,
55
        sessionGroupData.sort,
56
      );
57
      const updatedGroupData: DB_SessionGroup = { ...sessionGroupData, name: 'updated-group' };
58
      await SessionGroupModel.update(createdGroup.id, updatedGroupData);
59
      const fetchedGroups = await SessionGroupModel.query();
60
      expect(fetchedGroups[0].name).toEqual(updatedGroupData.name);
61
    });
62
  });
63

64
  describe('delete', () => {
65
    it('should delete a session group', async () => {
66
      const createdGroup = await SessionGroupModel.create(
67
        sessionGroupData.name,
68
        sessionGroupData.sort,
69
      );
70
      await SessionGroupModel.delete(createdGroup.id);
71
      const fetchedGroups = await SessionGroupModel.query();
72
      expect(fetchedGroups).toHaveLength(0);
73
    });
74
    it('should delete a session group and update associated sessions', async () => {
75
      // Create a new session group
76
      const createdGroup = await SessionGroupModel.create(
77
        sessionGroupData.name,
78
        sessionGroupData.sort,
79
      );
80

81
      // Delete the created session group
82
      await SessionGroupModel.delete(createdGroup.id);
83

84
      // Fetch all session groups to confirm deletion
85
      const fetchedGroups = await SessionGroupModel.query();
86
      expect(fetchedGroups).toHaveLength(0);
87

88
      // Fetch all sessions to confirm update
89
      const fetchedSessions = await SessionModel.query();
90
      fetchedSessions.forEach((session) => {
91
        expect(session.group).not.toEqual(createdGroup.id);
92
      });
93
    });
94
    it('should update associated sessions to default group when a session group is deleted', async () => {
95
      const createdGroup = await SessionGroupModel.create(
96
        sessionGroupData.name,
97
        sessionGroupData.sort,
98
      );
99
      const sessionId = await SessionModel.create('agent', {}, createdGroup.id);
100
      await SessionGroupModel.delete(createdGroup.id);
101
      const updatedSession = await SessionModel.findById(sessionId.id);
102
      expect(updatedSession.group).toEqual('default');
103
    });
104
  });
105

106
  describe('query', () => {
107
    it('should fetch and return the session group list', async () => {
108
      await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
109
      const fetchedGroups = await SessionGroupModel.query();
110
      expect(fetchedGroups).toHaveLength(1);
111
      expect(fetchedGroups[0].name).toEqual(sessionGroupData.name);
112
    });
113

114
    it('should return an empty array when there are no session groups', async () => {
115
      const fetchedGroups = await SessionGroupModel.query();
116
      expect(fetchedGroups).toEqual([]);
117
    });
118

119
    it('should return session groups sorted by sort field when it exists', async () => {
120
      const group1 = await SessionGroupModel.create('group1', 2);
121
      const group2 = await SessionGroupModel.create('group2', 1);
122
      const fetchedGroups = await SessionGroupModel.query();
123
      expect(fetchedGroups[0].id).toEqual(group2.id);
124
      expect(fetchedGroups[1].id).toEqual(group1.id);
125
    });
126

127
    it('should return session groups sorted by createdAt when sort field does not exist', async () => {
128
      const group1 = await SessionGroupModel.create('group1');
129
      await new Promise((resolve) => setTimeout(() => resolve(undefined), 300));
130
      const group2 = await SessionGroupModel.create('group2');
131

132
      const fetchedGroups = await SessionGroupModel.query();
133

134
      expect(fetchedGroups[0].id).toEqual(group2.id);
135
      expect(fetchedGroups[1].id).toEqual(group1.id);
136
    });
137

138
    it('should return session groups sorted by sort field first and then by createdAt', async () => {
139
      const group0 = await SessionGroupModel.create('group0');
140
      await sleep(10);
141
      const group1 = await SessionGroupModel.create('group1', 1);
142
      await sleep(10);
143
      const group2 = await SessionGroupModel.create('group2');
144
      await sleep(10);
145
      const group3 = await SessionGroupModel.create('group3', 2);
146
      await sleep(10);
147

148
      const fetchedGroups = await SessionGroupModel.query();
149
      expect(fetchedGroups[0].id).toEqual(group1.id);
150
      expect(fetchedGroups[1].id).toEqual(group3.id);
151
      expect(fetchedGroups[2].id).toEqual(group2.id);
152
      expect(fetchedGroups[3].id).toEqual(group0.id);
153
    });
154

155
    it('should return session groups sorted by sort ', async () => {
156
      const group1 = await SessionGroupModel.create('group1', 1);
157
      const group2 = await SessionGroupModel.create('group2');
158
      const group3 = await SessionGroupModel.create('group3', 2);
159
      const fetchedGroups = await SessionGroupModel.query();
160
      expect(fetchedGroups[0].id).toEqual(group1.id);
161
      expect(fetchedGroups[1].id).toEqual(group3.id);
162
      expect(fetchedGroups[2].id).toEqual(group2.id);
163
    });
164

165
    it('should return session groups sorted by createdAt when sort fields are equal', async () => {
166
      const group1 = await SessionGroupModel.create('group1', 1);
167
      await new Promise((resolve) => setTimeout(() => resolve(undefined), 300));
168
      const group2 = await SessionGroupModel.create('group2', 1);
169
      const fetchedGroups = await SessionGroupModel.query();
170
      expect(fetchedGroups[0].id).toEqual(group2.id);
171
      expect(fetchedGroups[1].id).toEqual(group1.id);
172
    });
173

174
    it('should sort session groups correctly when only b has a sort value', async () => {
175
      const groupA = await SessionGroupModel.create('groupA'); // sort undefined
176
      const groupB = await SessionGroupModel.create('groupB', 1); // sort defined
177
      const fetchedGroups = await SessionGroupModel.query();
178
      expect(fetchedGroups[0].id).toEqual(groupB.id);
179
      expect(fetchedGroups[1].id).toEqual(groupA.id);
180
    });
181
  });
182

183
  describe('updateOrder', () => {
184
    it('should update the order of session groups', async () => {
185
      const group1 = await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
186
      const group2 = await SessionGroupModel.create('another-group', 2);
187
      await SessionGroupModel.updateOrder([
188
        { id: group1.id, sort: 2 },
189
        { id: group2.id, sort: 1 },
190
      ]);
191
      const fetchedGroups = await SessionGroupModel.query();
192
      expect(fetchedGroups[0].id).toEqual(group2.id);
193
      expect(fetchedGroups[1].id).toEqual(group1.id);
194
    });
195
  });
196

197
  describe('findById', () => {
198
    it('should find a session group by id', async () => {
199
      const createdGroup = await SessionGroupModel.create(
200
        sessionGroupData.name,
201
        sessionGroupData.sort,
202
      );
203
      const fetchedGroup = await SessionGroupModel.findById(createdGroup.id);
204
      expect(fetchedGroup).toMatchObject({ ...createdGroup, ...sessionGroupData });
205
    });
206
  });
207

208
  describe('clear', () => {
209
    it('should clear all session groups', async () => {
210
      await SessionGroupModel.create(sessionGroupData.name, sessionGroupData.sort);
211
      const first = await SessionGroupModel.query();
212
      expect(first).toHaveLength(1);
213

214
      await SessionGroupModel.clear();
215

216
      const fetchedGroups = await SessionGroupModel.query();
217
      expect(fetchedGroups).toHaveLength(0);
218
    });
219
  });
220
});
221