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
|
/**
* @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 non-existent 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' }); // Non-existent 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([]);
});
});
|
