@google/gemini-cli 0.30.1 → 0.31.0-preview.1

package/dist/src/ui/hooks/useSelectionList.test.js

@@ -59,7 +59,8 @@ describe('useSelectionList', () => {
             hookResult = useSelectionList(props);
             return null;
         }
-        const { rerender, unmount } = render(_jsx(TestComponent, { ...initialProps }));
+        const { rerender, unmount, waitUntilReady } = render(_jsx(TestComponent, { ...initialProps }));
+        await waitUntilReady();
         return {
             result: {
                 get current() {
@@ -67,11 +68,15 @@ describe('useSelectionList', () => {
                 },
             },
             rerender: async (newProps) => {
-                rerender(_jsx(TestComponent, { ...initialProps, ...newProps }));
+                await act(async () => {
+                    rerender(_jsx(TestComponent, { ...initialProps, ...newProps }));
+                });
+                await waitUntilReady();
             },
             unmount: async () => {
                 unmount();
             },
+            waitUntilReady,
         };
     };
     describe('Initialization', () => {
@@ -147,30 +152,34 @@ describe('useSelectionList', () => {
     });
     describe('Keyboard Navigation (Up/Down/J/K)', () => {
         it('should move down with "j" and "down" keys, skipping disabled items', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
             });
             expect(result.current.activeIndex).toBe(0);
             pressKey('j');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
         });
         it('should move up with "k" and "up" keys, skipping disabled items', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: 3,
                 onSelect: mockOnSelect,
             });
             expect(result.current.activeIndex).toBe(3);
             pressKey('k');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             pressKey('up');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
         });
         it('should ignore navigation keys when shift is pressed', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: 2, // Start at middle item 'C'
                 onSelect: mockOnSelect,
@@ -178,48 +187,57 @@ describe('useSelectionList', () => {
             expect(result.current.activeIndex).toBe(2);
             // Shift+Down / Shift+J should not move down
             pressKey('down', undefined, { shift: true });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             pressKey('j', undefined, { shift: true });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             // Shift+Up / Shift+K should not move up
             pressKey('up', undefined, { shift: true });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             pressKey('k', undefined, { shift: true });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             // Verify normal navigation still works
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
         });
         it('should wrap navigation correctly', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: items.length - 1,
                 onSelect: mockOnSelect,
             });
             expect(result.current.activeIndex).toBe(3);
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             pressKey('up');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
         });
         it('should call onHighlight when index changes', async () => {
-            await renderSelectionListHook({
+            const { waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
             });
             pressKey('down');
+            await waitUntilReady();
             expect(mockOnHighlight).toHaveBeenCalledTimes(1);
             expect(mockOnHighlight).toHaveBeenCalledWith('C');
         });
         it('should not move or call onHighlight if navigation results in the same index (e.g., single item)', async () => {
             const singleItem = [{ value: 'A', key: 'A' }];
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: singleItem,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
             });
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnHighlight).not.toHaveBeenCalled();
         });
@@ -228,32 +246,35 @@ describe('useSelectionList', () => {
                 { value: 'A', disabled: true, key: 'A' },
                 { value: 'B', disabled: true, key: 'B' },
             ];
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: allDisabled,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
             });
             const initialIndex = result.current.activeIndex;
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(initialIndex);
             expect(mockOnHighlight).not.toHaveBeenCalled();
         });
     });
     describe('Wrapping (wrapAround)', () => {
         it('should wrap by default (wrapAround=true)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: items.length - 1,
                 onSelect: mockOnSelect,
             });
             expect(result.current.activeIndex).toBe(3);
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             pressKey('up');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
         });
         it('should not wrap when wrapAround is false', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: items.length - 1,
                 onSelect: mockOnSelect,
@@ -261,37 +282,43 @@ describe('useSelectionList', () => {
             });
             expect(result.current.activeIndex).toBe(3);
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3); // Should stay at bottom
             act(() => result.current.setActiveIndex(0));
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             pressKey('up');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0); // Should stay at top
         });
     });
     describe('Selection (Enter)', () => {
         it('should call onSelect when "return" is pressed on enabled item', async () => {
-            await renderSelectionListHook({
+            const { waitUntilReady } = await renderSelectionListHook({
                 items,
                 initialIndex: 2,
                 onSelect: mockOnSelect,
             });
             pressKey('return');
+            await waitUntilReady();
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
             expect(mockOnSelect).toHaveBeenCalledWith('C');
         });
         it('should not call onSelect if the active item is disabled', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
             });
             act(() => result.current.setActiveIndex(1));
+            await waitUntilReady();
             pressKey('return');
+            await waitUntilReady();
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
     });
     describe('Keyboard Navigation Robustness (Rapid Input)', () => {
         it('should handle rapid navigation and selection robustly (avoiding stale state)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items, // A, B(disabled), C, D. Initial index 0 (A).
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
@@ -316,14 +343,17 @@ describe('useSelectionList', () => {
             act(() => {
                 press('down');
             });
+            await waitUntilReady();
             // 2. Press Down again. Should move 2 (C) -> 3 (D).
             act(() => {
                 press('down');
             });
+            await waitUntilReady();
             // 3. Press Enter. Should select D.
             act(() => {
                 press('return');
             });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
             expect(mockOnHighlight).toHaveBeenCalledTimes(2);
             expect(mockOnHighlight).toHaveBeenNthCalledWith(1, 'C');
@@ -333,7 +363,7 @@ describe('useSelectionList', () => {
             expect(mockOnSelect).not.toHaveBeenCalledWith('A');
         });
         it('should handle ultra-rapid input (multiple presses in single act) without stale state', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items, // A, B(disabled), C, D. Initial index 0 (A).
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
@@ -360,6 +390,7 @@ describe('useSelectionList', () => {
                 press('down'); // Should move 2 (C) -> 3 (D)
                 press('return'); // Should select D
             });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
             expect(mockOnHighlight).toHaveBeenCalledWith('D');
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
@@ -368,12 +399,13 @@ describe('useSelectionList', () => {
     });
     describe('Focus Management (isFocused)', () => {
         it('should activate the keypress handler when focused (default) and items exist', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
             });
             expect(activeKeypressHandler).not.toBeNull();
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
         });
         it('should not activate the keypress handler when isFocused is false', async () => {
@@ -395,7 +427,7 @@ describe('useSelectionList', () => {
             expect(() => pressKey('down')).toThrow(/keypress handler is not active/);
         });
         it('should activate/deactivate when isFocused prop changes', async () => {
-            const { result, rerender } = await renderSelectionListHook({
+            const { result, rerender, waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
                 isFocused: false,
@@ -404,6 +436,7 @@ describe('useSelectionList', () => {
             await rerender({ isFocused: true });
             expect(activeKeypressHandler).not.toBeNull();
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             await rerender({ isFocused: false });
             expect(activeKeypressHandler).toBeNull();
@@ -421,22 +454,24 @@ describe('useSelectionList', () => {
         const longList = Array.from({ length: 15 }, (_, i) => ({ value: `Item ${i + 1}`, key: `Item ${i + 1}` }));
         const pressNumber = (num) => pressKey(num, num);
         it('should not respond to numbers if showNumbers is false (default)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: shortList,
                 onSelect: mockOnSelect,
             });
             pressNumber('1');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
         it('should select item immediately if the number cannot be extended (unambiguous)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: shortList,
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 showNumbers: true,
             });
             pressNumber('3');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             expect(mockOnHighlight).toHaveBeenCalledWith('C');
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
@@ -444,7 +479,7 @@ describe('useSelectionList', () => {
             expect(vi.getTimerCount()).toBe(0);
         });
         it('should highlight and wait for timeout if the number can be extended (ambiguous)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 initialIndex: 1, // Start at index 1 so pressing "1" (index 0) causes a change
                 onSelect: mockOnSelect,
@@ -452,82 +487,94 @@ describe('useSelectionList', () => {
                 showNumbers: true,
             });
             pressNumber('1');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnHighlight).toHaveBeenCalledWith('Item 1');
             expect(mockOnSelect).not.toHaveBeenCalled();
             expect(vi.getTimerCount()).toBe(1);
-            act(() => {
+            await act(async () => {
                 vi.advanceTimersByTime(1000);
             });
+            await waitUntilReady();
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
             expect(mockOnSelect).toHaveBeenCalledWith('Item 1');
         });
         it('should handle multi-digit input correctly', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('1');
+            await waitUntilReady();
             expect(mockOnSelect).not.toHaveBeenCalled();
             pressNumber('2');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(11);
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
             expect(mockOnSelect).toHaveBeenCalledWith('Item 12');
         });
         it('should reset buffer if input becomes invalid (out of bounds)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: shortList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('5');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
             pressNumber('3');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             expect(mockOnSelect).toHaveBeenCalledWith('C');
         });
         it('should allow "0" as subsequent digit, but ignore as first digit', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('0');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(mockOnSelect).not.toHaveBeenCalled();
             // Timer should be running to clear the '0' input buffer
             expect(vi.getTimerCount()).toBe(1);
             // Press '1', then '0' (Item 10, index 9)
             pressNumber('1');
+            await waitUntilReady();
             pressNumber('0');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(9);
             expect(mockOnSelect).toHaveBeenCalledWith('Item 10');
         });
         it('should clear the initial "0" input after timeout', async () => {
-            await renderSelectionListHook({
+            const { waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('0');
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            act(() => vi.advanceTimersByTime(1000)); // Timeout the '0' input
+            await waitUntilReady();
+            await act(async () => vi.advanceTimersByTime(1000)); // Timeout the '0' input
+            await waitUntilReady();
             pressNumber('1');
+            await waitUntilReady();
             expect(mockOnSelect).not.toHaveBeenCalled(); // Should be waiting for second digit
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            act(() => vi.advanceTimersByTime(1000)); // Timeout '1'
+            await act(async () => vi.advanceTimersByTime(1000)); // Timeout '1'
+            await waitUntilReady();
             expect(mockOnSelect).toHaveBeenCalledWith('Item 1');
         });
         it('should highlight but not select a disabled item (immediate selection case)', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: shortList, // B (index 1, number 2) is disabled
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 showNumbers: true,
             });
             pressNumber('2');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(1);
             expect(mockOnHighlight).toHaveBeenCalledWith('B');
             // Should not select immediately, even though 20 > 4
@@ -539,48 +586,56 @@ describe('useSelectionList', () => {
                 { value: 'Item 1 Disabled', disabled: true, key: 'Item 1 Disabled' },
                 ...longList.slice(1),
             ];
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: disabledAmbiguousList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('1');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(0);
             expect(vi.getTimerCount()).toBe(1);
-            act(() => {
+            await act(async () => {
                 vi.advanceTimersByTime(1000);
             });
+            await waitUntilReady();
             // Should not select after timeout
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
         it('should clear the number buffer if a non-numeric key (e.g., navigation) is pressed', async () => {
-            const { result } = await renderSelectionListHook({
+            const { result, waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('1');
+            await waitUntilReady();
             expect(vi.getTimerCount()).toBe(1);
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(1);
             expect(vi.getTimerCount()).toBe(0);
             pressNumber('3');
+            await waitUntilReady();
             // Should select '3', not '13'
             expect(result.current.activeIndex).toBe(2);
         });
         it('should clear the number buffer if "return" is pressed', async () => {
-            await renderSelectionListHook({
+            const { waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressNumber('1');
+            await waitUntilReady();
             pressKey('return');
+            await waitUntilReady();
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
             expect(vi.getTimerCount()).toBe(0);
-            act(() => {
+            await act(async () => {
                 vi.advanceTimersByTime(1000);
             });
+            await waitUntilReady();
             expect(mockOnSelect).toHaveBeenCalledTimes(1);
         });
     });
@@ -597,13 +652,14 @@ describe('useSelectionList', () => {
             });
         });
         it('should respect a new initialIndex even after user interaction', async () => {
-            const { result, rerender } = await renderSelectionListHook({
+            const { result, rerender, waitUntilReady } = await renderSelectionListHook({
                 items,
                 onSelect: mockOnSelect,
                 initialIndex: 0,
             });
             // User navigates, changing the active index
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(2);
             // The component re-renders with a new initial index
             await rerender({ initialIndex: 3 });
@@ -680,16 +736,17 @@ describe('useSelectionList', () => {
                 { value: 'C', key: 'C' },
                 { value: 'D', key: 'D' },
             ];
-            const { result, rerender } = await renderSelectionListHook({
+            const { result, rerender, waitUntilReady } = await renderSelectionListHook({
                 onSelect: mockOnSelect,
                 onHighlight: mockOnHighlight,
                 initialIndex: 2,
                 items: initialItems,
             });
             expect(result.current.activeIndex).toBe(2);
-            act(() => {
+            await act(async () => {
                 result.current.setActiveIndex(3);
             });
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(3);
             mockOnHighlight.mockClear();
             // Create new array with same content (deeply equal but not identical)
@@ -764,11 +821,12 @@ describe('useSelectionList', () => {
                 { value: 'B', key: 'B' },
                 { value: 'C', key: 'C' },
             ];
-            const { result, rerender } = await renderSelectionListHook({
+            const { result, rerender, waitUntilReady } = await renderSelectionListHook({
                 onSelect: mockOnSelect,
                 items: initialItems,
             });
             pressKey('down');
+            await waitUntilReady();
             expect(result.current.activeIndex).toBe(1);
             const newItems = [
                 { value: 'D', key: 'D' },
@@ -797,10 +855,14 @@ describe('useSelectionList', () => {
                     });
                     return null;
                 }
-                const { rerender } = render(_jsx(TestComponent, { ...initialProps }));
+                const { rerender, waitUntilReady } = render(_jsx(TestComponent, { ...initialProps }));
+                await waitUntilReady();
                 return {
                     rerender: async (newProps) => {
-                        rerender(_jsx(TestComponent, { ...initialProps, ...newProps }));
+                        await act(async () => {
+                            rerender(_jsx(TestComponent, { ...initialProps, ...newProps }));
+                        });
+                        await waitUntilReady();
                     },
                 };
             };
@@ -825,22 +887,26 @@ describe('useSelectionList', () => {
         });
         it('should clear timeout on unmount when timer is active', async () => {
             const longList = Array.from({ length: 15 }, (_, i) => ({ value: `Item ${i + 1}`, key: `Item ${i + 1}` }));
-            const { unmount } = await renderSelectionListHook({
+            const { unmount, waitUntilReady } = await renderSelectionListHook({
                 items: longList,
                 onSelect: mockOnSelect,
                 showNumbers: true,
             });
             pressKey('1', '1');
+            await waitUntilReady();
             expect(vi.getTimerCount()).toBe(1);
-            act(() => {
+            await act(async () => {
                 vi.advanceTimersByTime(500);
             });
+            await waitUntilReady();
             expect(mockOnSelect).not.toHaveBeenCalled();
+            const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
             await unmount();
-            expect(vi.getTimerCount()).toBe(0);
-            act(() => {
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+            await act(async () => {
                 vi.advanceTimersByTime(1000);
             });
+            // No waitUntilReady here as component is unmounted
             expect(mockOnSelect).not.toHaveBeenCalled();
         });
     });