@machina.ai/cell-cli 1.11.0-rc1 → 1.13.0-rc2

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

@@ -3,8 +3,10 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { act } from 'react';
+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';
@@ -21,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(() => ({
@@ -82,6 +90,7 @@ describe('useSlashCommandProcessor', () => {
     const mockSetQuittingMessages = vi.fn();
     const mockConfig = makeFakeConfig({});
     const mockSettings = {};
+    let unmountHook;
     beforeEach(() => {
         vi.clearAllMocks();
         vi.mocked(BuiltinCommandLoader).mockClear();
@@ -89,41 +98,67 @@ 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));
-        const { result } = renderHook(() => useSlashCommandProcessor(mockConfig, mockSettings, mockAddItem, mockClearItems, mockLoadHistory, vi.fn(), // refreshStatic
-        vi.fn(), // toggleVimEnabled
-        setIsProcessing, vi.fn(), // setGeminiMdFileCount
-        {
-            openAuthDialog: mockOpenAuthDialog,
-            openThemeDialog: mockOpenThemeDialog,
-            openEditorDialog: vi.fn(),
-            openPrivacyNotice: vi.fn(),
-            openSettingsDialog: vi.fn(),
-            openModelDialog: mockOpenModelDialog,
-            openPermissionsDialog: vi.fn(),
-            quit: mockSetQuittingMessages,
-            setDebugMessage: vi.fn(),
-            toggleCorgiMode: vi.fn(),
-            toggleDebugProfiler: vi.fn(),
-            dispatchExtensionStateUpdate: vi.fn(),
-            addConfirmUpdateExtensionRequest: vi.fn(),
-        }, new Map(), // extensionsUpdateState
-        true));
-        return result;
+        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
+            {
+                openAuthDialog: mockOpenAuthDialog,
+                openThemeDialog: mockOpenThemeDialog,
+                openEditorDialog: vi.fn(),
+                openPrivacyNotice: vi.fn(),
+                openSettingsDialog: vi.fn(),
+                openModelDialog: mockOpenModelDialog,
+                openPermissionsDialog: vi.fn(),
+                quit: mockSetQuittingMessages,
+                setDebugMessage: vi.fn(),
+                toggleCorgiMode: vi.fn(),
+                toggleDebugProfiler: vi.fn(),
+                dispatchExtensionStateUpdate: vi.fn(),
+                addConfirmUpdateExtensionRequest: vi.fn(),
+            }, new Map(), // extensionsUpdateState
+            true));
+            result = hook.result;
+            unmount = hook.unmount;
+            rerender = hook.rerender;
+        });
+        unmountHook = async () => unmount();
+        await waitFor(() => {
+            expect(result.current.slashCommands).toBeDefined();
+        });
+        return {
+            get current() {
+                return result.current;
+            },
+            unmount,
+            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]);
+            const result = await setupProcessorHook([testCommand]);
             await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(1);
             });
@@ -134,7 +169,7 @@ describe('useSlashCommandProcessor', () => {
         });
         it('should provide an immutable array of commands to consumers', async () => {
             const testCommand = createTestCommand({ name: 'test' });
-            const result = setupProcessorHook([testCommand]);
+            const result = await setupProcessorHook([testCommand]);
             await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(1);
             });
@@ -153,7 +188,7 @@ describe('useSlashCommandProcessor', () => {
                 action: builtinAction,
             });
             const fileCommand = createTestCommand({ name: 'override', description: 'file', action: fileAction }, CommandKind.FILE);
-            const result = setupProcessorHook([builtinCommand], [fileCommand]);
+            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);
@@ -168,7 +203,7 @@ describe('useSlashCommandProcessor', () => {
     });
     describe('Command Execution Logic', () => {
         it('should display an error for an unknown command', async () => {
-            const result = setupProcessorHook();
+            const result = await setupProcessorHook();
             await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
                 await result.current.handleSlashCommand('/nonexistent');
@@ -193,7 +228,7 @@ describe('useSlashCommandProcessor', () => {
                     },
                 ],
             };
-            const result = setupProcessorHook([parentCommand]);
+            const result = await setupProcessorHook([parentCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/parent');
@@ -219,7 +254,7 @@ describe('useSlashCommandProcessor', () => {
                     },
                 ],
             };
-            const result = setupProcessorHook([parentCommand]);
+            const result = await setupProcessorHook([parentCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/parent child with args');
@@ -236,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');
             });
@@ -248,7 +283,7 @@ describe('useSlashCommandProcessor', () => {
                 name: 'fail',
                 action: vi.fn().mockRejectedValue(new Error('oh no!')),
             });
-            const result = setupProcessorHook([failCommand], [], [], setMockIsProcessing);
+            const result = await setupProcessorHook([failCommand], [], [], setMockIsProcessing);
             await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
                 await result.current.handleSlashCommand('/fail');
@@ -262,7 +297,7 @@ describe('useSlashCommandProcessor', () => {
                 name: 'long-running',
                 action: () => new Promise((resolve) => setTimeout(resolve, 50)),
             });
-            const result = setupProcessorHook([command], [], [], mockSetIsProcessing);
+            const result = await setupProcessorHook([command], [], [], mockSetIsProcessing);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             const executionPromise = act(async () => {
                 await result.current.handleSlashCommand('/long-running');
@@ -278,29 +313,32 @@ describe('useSlashCommandProcessor', () => {
         });
     });
     describe('Action Result Handling', () => {
-        it('should handle "dialog: theme" action', async () => {
-            const command = createTestCommand({
-                name: 'themecmd',
-                action: vi.fn().mockResolvedValue({ type: 'dialog', dialog: 'theme' }),
-            });
-            const result = setupProcessorHook([command]);
-            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            await act(async () => {
-                await result.current.handleSlashCommand('/themecmd');
-            });
-            expect(mockOpenThemeDialog).toHaveBeenCalled();
-        });
-        it('should handle "dialog: model" action', async () => {
-            const command = createTestCommand({
-                name: 'modelcmd',
-                action: vi.fn().mockResolvedValue({ type: 'dialog', dialog: 'model' }),
-            });
-            const result = setupProcessorHook([command]);
-            await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            await act(async () => {
-                await result.current.handleSlashCommand('/modelcmd');
+        describe('Dialog actions', () => {
+            it.each([
+                {
+                    dialogType: 'theme',
+                    commandName: 'themecmd',
+                    mockFn: mockOpenThemeDialog,
+                },
+                {
+                    dialogType: 'model',
+                    commandName: 'modelcmd',
+                    mockFn: mockOpenModelDialog,
+                },
+            ])('should handle "dialog: $dialogType" action', async ({ dialogType, commandName, mockFn }) => {
+                const command = createTestCommand({
+                    name: commandName,
+                    action: vi
+                        .fn()
+                        .mockResolvedValue({ type: 'dialog', dialog: dialogType }),
+                });
+                const result = await setupProcessorHook([command]);
+                await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
+                await act(async () => {
+                    await result.current.handleSlashCommand(`/${commandName}`);
+                });
+                expect(mockFn).toHaveBeenCalled();
             });
-            expect(mockOpenModelDialog).toHaveBeenCalled();
         });
         it('should handle "load_history" action', async () => {
             const mockClient = {
@@ -316,7 +354,7 @@ describe('useSlashCommandProcessor', () => {
                     clientHistory: [{ role: 'user', parts: [{ text: 'old prompt' }] }],
                 }),
             });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/load');
@@ -344,7 +382,7 @@ describe('useSlashCommandProcessor', () => {
                     clientHistory: historyWithThoughts,
                 }),
             });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/loadwiththoughts');
@@ -360,7 +398,7 @@ describe('useSlashCommandProcessor', () => {
                 name: 'exit',
                 action: quitAction,
             });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/exit');
@@ -376,7 +414,7 @@ describe('useSlashCommandProcessor', () => {
                     content: [{ text: 'The actual prompt from the TOML file.' }],
                 }),
             }, CommandKind.FILE);
-            const result = setupProcessorHook([], [fileCommand]);
+            const result = await setupProcessorHook([], [fileCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             let actionResult;
             await act(async () => {
@@ -397,7 +435,7 @@ describe('useSlashCommandProcessor', () => {
                     content: [{ text: 'The actual prompt from the mcp command.' }],
                 }),
             }, CommandKind.MCP_PROMPT);
-            const result = setupProcessorHook([], [], [mcpCommand]);
+            const result = await setupProcessorHook([], [], [mcpCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             let actionResult;
             await act(async () => {
@@ -428,30 +466,33 @@ describe('useSlashCommandProcessor', () => {
             });
         });
         it('should set confirmation request when action returns confirm_shell_commands', async () => {
-            const result = setupProcessorHook([shellCommand]);
+            const result = await setupProcessorHook([shellCommand]);
             await 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');
+            // 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 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]);
+            const result = await setupProcessorHook([shellCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            await act(async () => {
+                void result.current.handleSlashCommand('/shellcmd');
             });
             // Wait for the confirmation dialog to be set
-            await 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();
@@ -470,13 +511,16 @@ describe('useSlashCommandProcessor', () => {
             expect(mockCommandAction).toHaveBeenCalledTimes(1);
         });
         it('should re-run command with one-time allowlist on "Proceed Once"', async () => {
-            const result = setupProcessorHook([shellCommand]);
+            const result = await setupProcessorHook([shellCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            let commandPromise;
+            await act(async () => {
+                commandPromise = result.current.handleSlashCommand('/shellcmd');
             });
-            await 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.**
@@ -489,6 +533,9 @@ 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 waitFor(() => {
@@ -503,19 +550,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]);
+            const result = await setupProcessorHook([shellCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
-            act(() => {
-                result.current.handleSlashCommand('/shellcmd');
+            let commandPromise;
+            await act(async () => {
+                commandPromise = result.current.handleSlashCommand('/shellcmd');
             });
-            await 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({
@@ -526,6 +576,9 @@ describe('useSlashCommandProcessor', () => {
             await act(async () => {
                 onConfirm(ToolConfirmationOutcome.ProceedAlways, ['rm -rf /']);
             });
+            await act(async () => {
+                await commandPromise;
+            });
             expect(result.current.shellConfirmationRequest).toBeNull();
             await waitFor(() => {
                 expect(mockCommandAction).toHaveBeenCalledTimes(2);
@@ -541,7 +594,7 @@ describe('useSlashCommandProcessor', () => {
     describe('Command Parsing and Matching', () => {
         it('should be case-sensitive', async () => {
             const command = createTestCommand({ name: 'test' });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 // Use uppercase when command is lowercase
@@ -561,7 +614,7 @@ describe('useSlashCommandProcessor', () => {
                 description: 'a command with an alias',
                 action,
             });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('/alias');
@@ -572,7 +625,7 @@ 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]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('  /test  with-args  ');
@@ -582,7 +635,7 @@ describe('useSlashCommandProcessor', () => {
         it('should handle `?` as a command prefix', async () => {
             const action = vi.fn();
             const command = createTestCommand({ name: 'help', action });
-            const result = setupProcessorHook([command]);
+            const result = await setupProcessorHook([command]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(1));
             await act(async () => {
                 await result.current.handleSlashCommand('?help');
@@ -600,7 +653,7 @@ describe('useSlashCommandProcessor', () => {
                 action: mcpAction,
             }, CommandKind.MCP_PROMPT);
             const fileCommand = createTestCommand({ name: 'override', description: 'file', action: fileAction }, CommandKind.FILE);
-            const result = setupProcessorHook([], [fileCommand], [mcpCommand]);
+            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);
@@ -626,7 +679,7 @@ 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]);
+            const result = await setupProcessorHook([quitCommand], [exitCommand]);
             await waitFor(() => {
                 expect(result.current.slashCommands).toHaveLength(2);
             });
@@ -645,7 +698,7 @@ describe('useSlashCommandProcessor', () => {
                 action: vi.fn(),
             });
             const exitCommand = createTestCommand({ name: 'exit', action: vi.fn() }, CommandKind.FILE);
-            const result = setupProcessorHook([quitCommand], [exitCommand]);
+            const result = await setupProcessorHook([quitCommand], [exitCommand]);
             await waitFor(() => expect(result.current.slashCommands).toHaveLength(2));
             await act(async () => {
                 await result.current.handleSlashCommand('/exit');
@@ -655,28 +708,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 } = renderHook(() => useSlashCommandProcessor(mockConfig, mockSettings, mockAddItem, mockClearItems, mockLoadHistory, vi.fn(), // refreshStatic
-            vi.fn().mockResolvedValue(false), // toggleVimEnabled
-            vi.fn(), // setIsProcessing
-            vi.fn(), // setGeminiMdFileCount
-            {
-                openAuthDialog: vi.fn(),
-                openThemeDialog: vi.fn(),
-                openEditorDialog: vi.fn(),
-                openPrivacyNotice: vi.fn(),
-                openSettingsDialog: vi.fn(),
-                openModelDialog: vi.fn(),
-                openPermissionsDialog: vi.fn(),
-                quit: vi.fn(),
-                setDebugMessage: vi.fn(),
-                toggleCorgiMode: vi.fn(),
-                toggleDebugProfiler: vi.fn(),
-                dispatchExtensionStateUpdate: vi.fn(),
-                addConfirmUpdateExtensionRequest: vi.fn(),
-            }, new Map(), // extensionsUpdateState
-            true));
+            const { unmount } = await setupProcessorHook();
             unmount();
             expect(abortSpy).toHaveBeenCalledTimes(1);
         });
@@ -713,64 +747,58 @@ describe('useSlashCommandProcessor', () => {
             mockCommandAction.mockClear();
             vi.mocked(logSlashCommand).mockClear();
         });
-        it('should log a simple slash command', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
-            await act(async () => {
-                await result.current.handleSlashCommand('/logtest');
-            });
-            expect(logSlashCommand).toHaveBeenCalledWith(mockConfig, expect.objectContaining({
-                command: 'logtest',
-                subcommand: undefined,
-                status: SlashCommandStatus.SUCCESS,
-            }));
-        });
-        it('logs nothing for a bogus command', async () => {
-            const result = 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 waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
-            await act(async () => {
-                await result.current.handleSlashCommand('/fail');
-            });
-            expect(logSlashCommand).toHaveBeenCalledWith(mockConfig, expect.objectContaining({
-                command: 'fail',
-                status: 'error',
-                subcommand: undefined,
-            }));
-        });
-        it('should log a slash command with a subcommand', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+        it.each([
+            {
+                command: '/logtest',
+                expectedLog: {
+                    command: 'logtest',
+                    subcommand: undefined,
+                    status: SlashCommandStatus.SUCCESS,
+                },
+                desc: 'simple slash command',
+            },
+            {
+                command: '/fail',
+                expectedLog: {
+                    command: 'fail',
+                    status: 'error',
+                    subcommand: undefined,
+                },
+                desc: 'failure event for failed command',
+            },
+            {
+                command: '/logwithsub sub',
+                expectedLog: {
+                    command: 'logwithsub',
+                    subcommand: 'sub',
+                },
+                desc: 'slash command with subcommand',
+            },
+            {
+                command: '/la',
+                expectedLog: {
+                    command: 'logalias',
+                },
+                desc: 'command path when alias is used',
+            },
+        ])('should log $desc', async ({ command, expectedLog }) => {
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
-                await result.current.handleSlashCommand('/logwithsub sub');
+                await result.current.handleSlashCommand(command);
             });
-            expect(logSlashCommand).toHaveBeenCalledWith(mockConfig, expect.objectContaining({
-                command: 'logwithsub',
-                subcommand: 'sub',
-            }));
-        });
-        it('should log the command path when an alias is used', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
-            await act(async () => {
-                await result.current.handleSlashCommand('/la');
+            await waitFor(() => {
+                expect(logSlashCommand).toHaveBeenCalledWith(mockConfig, expect.objectContaining(expectedLog));
             });
-            expect(logSlashCommand).toHaveBeenCalledWith(mockConfig, expect.objectContaining({
-                command: 'logalias',
-            }));
         });
-        it('should not log for unknown commands', async () => {
-            const result = setupProcessorHook(loggingTestCommands);
-            await waitFor(() => expect(result.current.slashCommands?.length).toBeGreaterThan(0));
+        it.each([
+            { command: '/bogusbogusbogus', desc: 'bogus command' },
+            { command: '/unknown', desc: 'unknown command' },
+        ])('should not log for $desc', async ({ command }) => {
+            const result = await setupProcessorHook(loggingTestCommands);
+            await waitFor(() => expect(result.current.slashCommands).toBeDefined());
             await act(async () => {
-                await result.current.handleSlashCommand('/unknown');
+                await result.current.handleSlashCommand(command);
             });
             expect(logSlashCommand).not.toHaveBeenCalled();
         });