1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
import { describe, it, expect } from 'vitest';
import { renderHook, act } from '@testing-library/react';
import { useHistory } from './useHistoryManager.js';
import { HistoryItem } from '../types.js';
describe('useHistoryManager', () => {
it('should initialize with an empty history', () => {
const { result } = renderHook(() => useHistory());
expect(result.current.history).toEqual([]);
});
it('should add an item to history with a unique ID', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Hello',
};
act(() => {
result.current.addItem(itemData, timestamp);
});
expect(result.current.history).toHaveLength(1);
expect(result.current.history[0]).toEqual(
expect.objectContaining({
...itemData,
id: expect.any(Number),
}),
);
// Basic check that ID incorporates timestamp
expect(result.current.history[0].id).toBeGreaterThanOrEqual(timestamp);
});
it('should generate unique IDs for items added with the same base timestamp', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData1: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'First',
};
const itemData2: Omit<HistoryItem, 'id'> = {
type: 'gemini', // Replaced HistoryItemType.Gemini
text: 'Second',
};
let id1!: number;
let id2!: number;
act(() => {
id1 = result.current.addItem(itemData1, timestamp);
id2 = result.current.addItem(itemData2, timestamp);
});
expect(result.current.history).toHaveLength(2);
expect(id1).not.toEqual(id2);
expect(result.current.history[0].id).toEqual(id1);
expect(result.current.history[1].id).toEqual(id2);
// IDs should be sequential based on the counter
expect(id2).toBeGreaterThan(id1);
});
it('should update an existing history item', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const initialItem: Omit<HistoryItem, 'id'> = {
type: 'gemini', // Replaced HistoryItemType.Gemini
text: 'Initial content',
};
let itemId!: number;
act(() => {
itemId = result.current.addItem(initialItem, timestamp);
});
const updatedText = 'Updated content';
act(() => {
result.current.updateItem(itemId, { text: updatedText });
});
expect(result.current.history).toHaveLength(1);
expect(result.current.history[0]).toEqual({
...initialItem,
id: itemId,
text: updatedText,
});
});
it('should not change history if updateHistoryItem is called with a nonexistent ID', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Hello',
};
act(() => {
result.current.addItem(itemData, timestamp);
});
const originalHistory = [...result.current.history]; // Clone before update attempt
act(() => {
result.current.updateItem(99999, { text: 'Should not apply' }); // Nonexistent ID
});
expect(result.current.history).toEqual(originalHistory);
});
it('should clear the history', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData1: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'First',
};
const itemData2: Omit<HistoryItem, 'id'> = {
type: 'gemini', // Replaced HistoryItemType.Gemini
text: 'Second',
};
act(() => {
result.current.addItem(itemData1, timestamp);
result.current.addItem(itemData2, timestamp);
});
expect(result.current.history).toHaveLength(2);
act(() => {
result.current.clearItems();
});
expect(result.current.history).toEqual([]);
});
it('should not add consecutive duplicate user messages', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData1: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Duplicate message',
};
const itemData2: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Duplicate message',
};
const itemData3: Omit<HistoryItem, 'id'> = {
type: 'gemini', // Replaced HistoryItemType.Gemini
text: 'Gemini response',
};
const itemData4: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Another user message',
};
act(() => {
result.current.addItem(itemData1, timestamp);
result.current.addItem(itemData2, timestamp + 1); // Same text, different timestamp
result.current.addItem(itemData3, timestamp + 2);
result.current.addItem(itemData4, timestamp + 3);
});
expect(result.current.history).toHaveLength(3);
expect(result.current.history[0].text).toBe('Duplicate message');
expect(result.current.history[1].text).toBe('Gemini response');
expect(result.current.history[2].text).toBe('Another user message');
});
it('should add duplicate user messages if they are not consecutive', () => {
const { result } = renderHook(() => useHistory());
const timestamp = Date.now();
const itemData1: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Message 1',
};
const itemData2: Omit<HistoryItem, 'id'> = {
type: 'gemini', // Replaced HistoryItemType.Gemini
text: 'Gemini response',
};
const itemData3: Omit<HistoryItem, 'id'> = {
type: 'user', // Replaced HistoryItemType.User
text: 'Message 1', // Duplicate text, but not consecutive
};
act(() => {
result.current.addItem(itemData1, timestamp);
result.current.addItem(itemData2, timestamp + 1);
result.current.addItem(itemData3, timestamp + 2);
});
expect(result.current.history).toHaveLength(3);
expect(result.current.history[0].text).toBe('Message 1');
expect(result.current.history[1].text).toBe('Gemini response');
expect(result.current.history[2].text).toBe('Message 1');
});
});
|
