@google/gemini-cli 0.12.0-preview.4 → 0.13.0-nightly.20251031.c89bc30d

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

@@ -1,12 +1,12 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 /**
  * @license
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { act } from 'react';
-import { render } from 'ink-testing-library';
+import { renderHook } from '../../test-utils/render.js';
+import { waitFor } from '../../test-utils/async.js';
 import { useSlashCommandProcessor } from './slashCommandProcessor.js';
 import { CommandKind } from '../commands/types.js';
 import { MessageType } from '../types.js';
@@ -23,6 +23,12 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         ...original,
         logSlashCommand,
         getIdeInstaller: vi.fn().mockReturnValue(null),
+        IdeClient: {
+            getInstance: vi.fn().mockResolvedValue({
+                addStatusChangeListener: vi.fn(),
+                removeStatusChangeListener: vi.fn(),
+            }),
+        },
     };
 });
 const { mockProcessExit } = vi.hoisted(() => ({
@@ -84,6 +90,7 @@ describe('useSlashCommandProcessor', () => {
     const mockSetQuittingMessages = vi.fn();
     const mockConfig = makeFakeConfig({});
     const mockSettings = {};
+    let unmountHook;
     beforeEach(() => {
         vi.clearAllMocks();
         vi.mocked(BuiltinCommandLoader).mockClear();
@@ -91,13 +98,21 @@ describe('useSlashCommandProcessor', () => {
         mockFileLoadCommands.mockResolvedValue([]);
         mockMcpLoadCommands.mockResolvedValue([]);
     });
-    const setupProcessorHook = (builtinCommands = [], fileCommands = [], mcpCommands = [], setIsProcessing = vi.fn()) => {
+    afterEach(async () => {
+        if (unmountHook) {
+            await unmountHook();
+            unmountHook = undefined;
+        }
+    });
+    const setupProcessorHook = async (builtinCommands = [], fileCommands = [], mcpCommands = [], setIsProcessing = vi.fn()) => {
         mockBuiltinLoadCommands.mockResolvedValue(Object.freeze(builtinCommands));
         mockFileLoadCommands.mockResolvedValue(Object.freeze(fileCommands));
         mockMcpLoadCommands.mockResolvedValue(Object.freeze(mcpCommands));
-        let hookResult;
-        function TestComponent() {
-            hookResult = useSlashCommandProcessor(mockConfig, mockSettings, mockAddItem, mockClearItems, mockLoadHistory, vi.fn(), // refreshStatic
+        let result;
+        let unmount;
+        let rerender;
+        await act(async () => {
+            const hook = renderHook(() => useSlashCommandProcessor(mockConfig, mockSettings, mockAddItem, mockClearItems, mockLoadHistory, vi.fn(), // refreshStatic
             vi.fn(), // toggleVimEnabled
             setIsProcessing, vi.fn(), // setGeminiMdFileCount
             {
@@ -115,29 +130,36 @@ describe('useSlashCommandProcessor', () => {
                 dispatchExtensionStateUpdate: vi.fn(),
                 addConfirmUpdateExtensionRequest: vi.fn(),
             }, new Map(), // extensionsUpdateState
-            true);
-            return null;
-        }
-        const { unmount, rerender } = render(_jsx(TestComponent, {}));
+            true));
+            result = hook.result;
+            unmount = hook.unmount;
+            rerender = hook.rerender;
+        });
+        unmountHook = async () => unmount();
+        await waitFor(() => {
+            expect(result.current.slashCommands).toBeDefined();
+        });
         return {
             get current() {
-                return hookResult;
+                return result.current;
             },
             unmount,
-            rerender: () => rerender(_jsx(TestComponent, {})),
+            rerender: async () => {
+                rerender();
+            },
         };
     };
     describe('Initialization and Command Loading', () => {
-        it('should initialize CommandService with all required loaders', () => {
-            setupProcessorHook();
+        it('should initialize CommandService with all required loaders', async () => {
+            await setupProcessorHook();
             expect(BuiltinCommandLoader).toHaveBeenCalledWith(mockConfig);
             expect(FileCommandLoader).toHaveBeenCalledWith(mockConfig);
             expect(McpPromptLoader).toHaveBeenCalledWith(mockConfig);
         });
         it('should call loadCommands and populate state after mounting', async () => {
             const testCommand = createTestCommand({ name: 'test' });
-            const result = setupProcessorHook([testCommand]);
-            await vi.waitFor(() => {
+            const result = await setupProcessorHook([testCommand]);
+            await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(1);
             });
             expect(result.current.slashCommands?.[0]?.name).toBe('test');
@@ -147,8 +169,8 @@ describe('useSlashCommandProcessor', () => {
         });
         it('should provide an immutable array of commands to consumers', async () => {
             const testCommand = createTestCommand({ name: 'test' });
-            const result = setupProcessorHook([testCommand]);
-            await vi.waitFor(() => {
+            const result = await setupProcessorHook([testCommand]);
+            await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(1);
             });
             const commands = result.current.slashCommands;
@@ -166,8 +188,8 @@ describe('useSlashCommandProcessor', () => {
                 action: builtinAction,
             });
             const fileCommand = createTestCommand({ name: 'override', description: 'file', action: fileAction }, CommandKind.FILE);
-            const result = setupProcessorHook([builtinCommand], [fileCommand]);
-            await vi.waitFor(() => {
+            const result = await setupProcessorHook([builtinCommand], [fileCommand]);
+            await waitFor(() => {
                 // The service should only return one command with the name 'override'
                 expect(result.current.slashCommands).toHaveLength(1);
             });
@@ -181,8 +203,8 @@ describe('useSlashCommandProcessor', () => {
     });
     describe('Command Execution Logic', () => {
         it('should display an error for an unknown command', async () => {
-            const result = setupProcessorHook();
-            await vi.waitFor(() => expect(result.current.slashCommands).toBeDefined());
+            const result = await setupProcessorHook();
+            await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
                 await result.current.handleSlashCommand('/nonexistent');
             });
@@ -206,8 +228,8 @@ describe('useSlashCommandProcessor', () => {
                     },
                 ],
             };
-            const result = setupProcessorHook([parentCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([parentCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/parent');
             });
@@ -232,8 +254,8 @@ describe('useSlashCommandProcessor', () => {
                     },
                 ],
             };
-            const result = setupProcessorHook([parentCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([parentCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/parent child with args');
             });
@@ -249,7 +271,7 @@ describe('useSlashCommandProcessor', () => {
         });
         it('sets isProcessing to false if the the input is not a command', async () => {
             const setMockIsProcessing = vi.fn();
-            const result = setupProcessorHook([], [], [], setMockIsProcessing);
+            const result = await setupProcessorHook([], [], [], setMockIsProcessing);
             await act(async () => {
                 await result.current.handleSlashCommand('imnotacommand');
             });
@@ -261,8 +283,8 @@ describe('useSlashCommandProcessor', () => {
                 name: 'fail',
                 action: vi.fn().mockRejectedValue(new Error('oh no!')),
             });
-            const result = setupProcessorHook([failCommand], [], [], setMockIsProcessing);
-            await vi.waitFor(() => expect(result.current.slashCommands).toBeDefined());
+            const result = await setupProcessorHook([failCommand], [], [], setMockIsProcessing);
+            await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
                 await result.current.handleSlashCommand('/fail');
             });
@@ -275,8 +297,8 @@ describe('useSlashCommandProcessor', () => {
                 name: 'long-running',
                 action: () => new Promise((resolve) => setTimeout(resolve, 50)),
             });
-            const result = setupProcessorHook([command], [], [], mockSetIsProcessing);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command], [], [], mockSetIsProcessing);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             const executionPromise = act(async () => {
                 await result.current.handleSlashCommand('/long-running');
             });
@@ -296,8 +318,8 @@ describe('useSlashCommandProcessor', () => {
                 name: 'themecmd',
                 action: vi.fn().mockResolvedValue({ type: 'dialog', dialog: 'theme' }),
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/themecmd');
             });
@@ -308,8 +330,8 @@ describe('useSlashCommandProcessor', () => {
                 name: 'modelcmd',
                 action: vi.fn().mockResolvedValue({ type: 'dialog', dialog: 'model' }),
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/modelcmd');
             });
@@ -329,8 +351,8 @@ describe('useSlashCommandProcessor', () => {
                     clientHistory: [{ role: 'user', parts: [{ text: 'old prompt' }] }],
                 }),
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/load');
             });
@@ -357,8 +379,8 @@ describe('useSlashCommandProcessor', () => {
                     clientHistory: historyWithThoughts,
                 }),
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/loadwiththoughts');
             });
@@ -373,8 +395,8 @@ describe('useSlashCommandProcessor', () => {
                 name: 'exit',
                 action: quitAction,
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/exit');
             });
@@ -389,8 +411,8 @@ describe('useSlashCommandProcessor', () => {
                     content: [{ text: 'The actual prompt from the TOML file.' }],
                 }),
             }, CommandKind.FILE);
-            const result = setupProcessorHook([], [fileCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([], [fileCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             let actionResult;
             await act(async () => {
                 actionResult = await result.current.handleSlashCommand('/filecmd');
@@ -410,8 +432,8 @@ describe('useSlashCommandProcessor', () => {
                     content: [{ text: 'The actual prompt from the mcp command.' }],
                 }),
             }, CommandKind.MCP_PROMPT);
-            const result = setupProcessorHook([], [], [mcpCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([], [], [mcpCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             let actionResult;
             await act(async () => {
                 actionResult = await result.current.handleSlashCommand('/mcpcmd');
@@ -441,30 +463,33 @@ describe('useSlashCommandProcessor', () => {
             });
         });
         it('should set confirmation request when action returns confirm_shell_commands', async () => {
-            const result = setupProcessorHook([shellCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            // This is intentionally not awaited, because the promise it returns
-            // will not resolve until the user responds to the confirmation.
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            const result = await setupProcessorHook([shellCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            // Trigger command, don't await it yet as it suspends for confirmation
+            await act(async () => {
+                void result.current.handleSlashCommand('/shellcmd');
             });
             // We now wait for the state to be updated with the request.
-            await vi.waitFor(() => {
-                expect(result.current.shellConfirmationRequest).not.toBeNull();
+            await act(async () => {
+                await waitFor(() => {
+                    expect(result.current.shellConfirmationRequest).not.toBeNull();
+                });
             });
             expect(result.current.shellConfirmationRequest?.commands).toEqual([
                 'rm -rf /',
             ]);
         });
         it('should do nothing if user cancels confirmation', async () => {
-            const result = setupProcessorHook([shellCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            const result = await setupProcessorHook([shellCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            await act(async () => {
+                void result.current.handleSlashCommand('/shellcmd');
             });
             // Wait for the confirmation dialog to be set
-            await vi.waitFor(() => {
-                expect(result.current.shellConfirmationRequest).not.toBeNull();
+            await act(async () => {
+                await waitFor(() => {
+                    expect(result.current.shellConfirmationRequest).not.toBeNull();
+                });
             });
             const onConfirm = result.current.shellConfirmationRequest?.onConfirm;
             expect(onConfirm).toBeDefined();
@@ -483,13 +508,16 @@ describe('useSlashCommandProcessor', () => {
             expect(mockCommandAction).toHaveBeenCalledTimes(1);
         });
         it('should re-run command with one-time allowlist on "Proceed Once"', async () => {
-            const result = setupProcessorHook([shellCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            const result = await setupProcessorHook([shellCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            let commandPromise;
+            await act(async () => {
+                commandPromise = result.current.handleSlashCommand('/shellcmd');
             });
-            await vi.waitFor(() => {
-                expect(result.current.shellConfirmationRequest).not.toBeNull();
+            await act(async () => {
+                await waitFor(() => {
+                    expect(result.current.shellConfirmationRequest).not.toBeNull();
+                });
             });
             const onConfirm = result.current.shellConfirmationRequest?.onConfirm;
             // **Change the mock's behavior for the SECOND run.**
@@ -502,9 +530,12 @@ describe('useSlashCommandProcessor', () => {
             await act(async () => {
                 onConfirm(ToolConfirmationOutcome.ProceedOnce, ['rm -rf /']);
             });
+            await act(async () => {
+                await commandPromise;
+            });
             expect(result.current.shellConfirmationRequest).toBeNull();
             // The action should have been called twice (initial + re-run).
-            await vi.waitFor(() => {
+            await waitFor(() => {
                 expect(mockCommandAction).toHaveBeenCalledTimes(2);
             });
             // We can inspect the context of the second call to ensure the one-time list was used.
@@ -516,19 +547,22 @@ describe('useSlashCommandProcessor', () => {
             // Verify the session-wide allowlist was NOT permanently updated.
             // Re-render the hook by calling a no-op command to get the latest context.
             await act(async () => {
-                result.current.handleSlashCommand('/no-op');
+                await result.current.handleSlashCommand('/no-op');
             });
             const finalContext = result.current.commandContext;
             expect(finalContext.session.sessionShellAllowlist.size).toBe(0);
         });
         it('should re-run command and update session allowlist on "Proceed Always"', async () => {
-            const result = setupProcessorHook([shellCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            const result = await setupProcessorHook([shellCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            let commandPromise;
+            await act(async () => {
+                commandPromise = result.current.handleSlashCommand('/shellcmd');
             });
-            await vi.waitFor(() => {
-                expect(result.current.shellConfirmationRequest).not.toBeNull();
+            await act(async () => {
+                await waitFor(() => {
+                    expect(result.current.shellConfirmationRequest).not.toBeNull();
+                });
             });
             const onConfirm = result.current.shellConfirmationRequest?.onConfirm;
             mockCommandAction.mockResolvedValue({
@@ -539,13 +573,16 @@ describe('useSlashCommandProcessor', () => {
             await act(async () => {
                 onConfirm(ToolConfirmationOutcome.ProceedAlways, ['rm -rf /']);
             });
+            await act(async () => {
+                await commandPromise;
+            });
             expect(result.current.shellConfirmationRequest).toBeNull();
-            await vi.waitFor(() => {
+            await waitFor(() => {
                 expect(mockCommandAction).toHaveBeenCalledTimes(2);
             });
             expect(mockAddItem).toHaveBeenCalledWith({ type: MessageType.INFO, text: 'Success!' }, expect.any(Number));
             // Check that the session-wide allowlist WAS updated.
-            await vi.waitFor(() => {
+            await waitFor(() => {
                 const finalContext = result.current.commandContext;
                 expect(finalContext.session.sessionShellAllowlist.has('rm -rf /')).toBe(true);
             });
@@ -554,8 +591,8 @@ describe('useSlashCommandProcessor', () => {
     describe('Command Parsing and Matching', () => {
         it('should be case-sensitive', async () => {
             const command = createTestCommand({ name: 'test' });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 // Use uppercase when command is lowercase
                 await result.current.handleSlashCommand('/Test');
@@ -574,8 +611,8 @@ describe('useSlashCommandProcessor', () => {
                 description: 'a command with an alias',
                 action,
             });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/alias');
             });
@@ -585,8 +622,8 @@ describe('useSlashCommandProcessor', () => {
         it('should handle extra whitespace around the command', async () => {
             const action = vi.fn();
             const command = createTestCommand({ name: 'test', action });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('  /test  with-args  ');
             });
@@ -595,8 +632,8 @@ describe('useSlashCommandProcessor', () => {
         it('should handle `?` as a command prefix', async () => {
             const action = vi.fn();
             const command = createTestCommand({ name: 'help', action });
-            const result = setupProcessorHook([command]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+            const result = await setupProcessorHook([command]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('?help');
             });
@@ -613,8 +650,8 @@ describe('useSlashCommandProcessor', () => {
                 action: mcpAction,
             }, CommandKind.MCP_PROMPT);
             const fileCommand = createTestCommand({ name: 'override', description: 'file', action: fileAction }, CommandKind.FILE);
-            const result = setupProcessorHook([], [fileCommand], [mcpCommand]);
-            await vi.waitFor(() => {
+            const result = await setupProcessorHook([], [fileCommand], [mcpCommand]);
+            await waitFor(() => {
                 // The service should only return one command with the name 'override'
                 expect(result.current.slashCommands).toHaveLength(1);
             });
@@ -639,8 +676,8 @@ describe('useSlashCommandProcessor', () => {
             }, CommandKind.FILE);
             // The order of commands in the final loaded array is not guaranteed,
             // so the test must work regardless of which comes first.
-            const result = setupProcessorHook([quitCommand], [exitCommand]);
-            await vi.waitFor(() => {
+            const result = await setupProcessorHook([quitCommand], [exitCommand]);
+            await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(2);
             });
             await act(async () => {
@@ -658,8 +695,8 @@ describe('useSlashCommandProcessor', () => {
                 action: vi.fn(),
             });
             const exitCommand = createTestCommand({ name: 'exit', action: vi.fn() }, CommandKind.FILE);
-            const result = setupProcessorHook([quitCommand], [exitCommand]);
-            await vi.waitFor(() => expect(result.current.slashCommands).toHaveLength(2));
+            const result = await setupProcessorHook([quitCommand], [exitCommand]);
+            await waitFor(() => expect(result.current.slashCommands).toHaveLength(2));
             await act(async () => {
                 await result.current.handleSlashCommand('/exit');
             });
@@ -668,9 +705,9 @@ describe('useSlashCommandProcessor', () => {
         });
     });
     describe('Lifecycle', () => {
-        it('should abort command loading when the hook unmounts', () => {
+        it('should abort command loading when the hook unmounts', async () => {
             const abortSpy = vi.spyOn(AbortController.prototype, 'abort');
-            const { unmount } = setupProcessorHook();
+            const { unmount } = await setupProcessorHook();
             unmount();
             expect(abortSpy).toHaveBeenCalledTimes(1);
         });
@@ -708,8 +745,8 @@ describe('useSlashCommandProcessor', () => {
             vi.mocked(logSlashCommand).mockClear();
         });
         it('should log a simple slash command', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/logtest');
             });
@@ -720,16 +757,16 @@ describe('useSlashCommandProcessor', () => {
             }));
         });
         it('logs nothing for a bogus command', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/bogusbogusbogus');
             });
             expect(logSlashCommand).not.toHaveBeenCalled();
         });
         it('logs a failure event for a failed command', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/fail');
             });
@@ -740,8 +777,8 @@ describe('useSlashCommandProcessor', () => {
             }));
         });
         it('should log a slash command with a subcommand', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/logwithsub sub');
             });
@@ -751,8 +788,8 @@ describe('useSlashCommandProcessor', () => {
             }));
         });
         it('should log the command path when an alias is used', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/la');
             });
@@ -761,8 +798,8 @@ describe('useSlashCommandProcessor', () => {
             }));
         });
         it('should not log for unknown commands', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await vi.waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
             await act(async () => {
                 await result.current.handleSlashCommand('/unknown');
             });