mirror of
https://github.com/QwenLM/qwen-code.git
synced 2026-04-30 12:40:44 +00:00
d1b761adf2
Some checks failed
Qwen Code CI / Test-3 (push) Has been skipped
Qwen Code CI / Test-4 (push) Has been skipped
Qwen Code CI / Lint (push) Failing after 24s
Qwen Code CI / CodeQL (push) Failing after 24s
Qwen Code CI / Test (push) Has been skipped
Qwen Code CI / Test-1 (push) Has been skipped
Qwen Code CI / Test-2 (push) Has been skipped
Qwen Code CI / Test-5 (push) Has been skipped
Qwen Code CI / Test-6 (push) Has been skipped
Qwen Code CI / Test-7 (push) Has been skipped
Qwen Code CI / Test-8 (push) Has been skipped
E2E Tests / E2E Test (Linux) - sandbox:docker (push) Failing after 5s
E2E Tests / E2E Test (Linux) - sandbox:none (push) Failing after 6s
Qwen Code CI / Post Coverage Comment (push) Has been skipped
E2E Tests / E2E Test - macOS (push) Has been cancelled
fix(cli): show newest-first history for Ctrl+R command search
2598 lines
79 KiB
TypeScript
2598 lines
79 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import { renderWithProviders } from '../../test-utils/render.js';
|
|
import { waitFor, act } from '@testing-library/react';
|
|
import type { InputPromptProps } from './InputPrompt.js';
|
|
import { InputPrompt } from './InputPrompt.js';
|
|
import type { TextBuffer } from './shared/text-buffer.js';
|
|
import type { Config } from '@qwen-code/qwen-code-core';
|
|
import { ApprovalMode } from '@qwen-code/qwen-code-core';
|
|
import * as path from 'node:path';
|
|
import type { CommandContext, SlashCommand } from '../commands/types.js';
|
|
import { CommandKind } from '../commands/types.js';
|
|
import { describe, it, expect, beforeEach, vi } from 'vitest';
|
|
import type { UseShellHistoryReturn } from '../hooks/useShellHistory.js';
|
|
import { useShellHistory } from '../hooks/useShellHistory.js';
|
|
import type { UseCommandCompletionReturn } from '../hooks/useCommandCompletion.js';
|
|
import { useCommandCompletion } from '../hooks/useCommandCompletion.js';
|
|
import type { UseInputHistoryReturn } from '../hooks/useInputHistory.js';
|
|
import { useInputHistory } from '../hooks/useInputHistory.js';
|
|
import type { UseReverseSearchCompletionReturn } from '../hooks/useReverseSearchCompletion.js';
|
|
import { useReverseSearchCompletion } from '../hooks/useReverseSearchCompletion.js';
|
|
import * as clipboardUtils from '../utils/clipboardUtils.js';
|
|
import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
|
|
import stripAnsi from 'strip-ansi';
|
|
import chalk from 'chalk';
|
|
|
|
vi.mock('../hooks/useShellHistory.js');
|
|
vi.mock('../hooks/useCommandCompletion.js');
|
|
vi.mock('../hooks/useInputHistory.js');
|
|
vi.mock('../hooks/useReverseSearchCompletion.js');
|
|
vi.mock('../utils/clipboardUtils.js');
|
|
vi.mock('../contexts/UIStateContext.js', () => ({
|
|
useUIState: vi.fn(() => ({ isFeedbackDialogOpen: false })),
|
|
}));
|
|
vi.mock('../contexts/UIActionsContext.js', () => ({
|
|
useUIActions: vi.fn(() => ({
|
|
handleRetryLastPrompt: vi.fn(),
|
|
temporaryCloseFeedbackDialog: vi.fn(),
|
|
})),
|
|
}));
|
|
|
|
const mockSlashCommands: SlashCommand[] = [
|
|
{
|
|
name: 'clear',
|
|
kind: CommandKind.BUILT_IN,
|
|
description: 'Clear screen',
|
|
action: vi.fn(),
|
|
},
|
|
{
|
|
name: 'memory',
|
|
kind: CommandKind.BUILT_IN,
|
|
description: 'Manage memory',
|
|
subCommands: [
|
|
{
|
|
name: 'show',
|
|
kind: CommandKind.BUILT_IN,
|
|
description: 'Show memory',
|
|
action: vi.fn(),
|
|
},
|
|
{
|
|
name: 'add',
|
|
kind: CommandKind.BUILT_IN,
|
|
description: 'Add to memory',
|
|
action: vi.fn(),
|
|
},
|
|
{
|
|
name: 'refresh',
|
|
kind: CommandKind.BUILT_IN,
|
|
description: 'Refresh memory',
|
|
action: vi.fn(),
|
|
},
|
|
],
|
|
},
|
|
];
|
|
|
|
describe('InputPrompt', () => {
|
|
let props: InputPromptProps;
|
|
let mockShellHistory: UseShellHistoryReturn;
|
|
let mockCommandCompletion: UseCommandCompletionReturn;
|
|
let mockInputHistory: UseInputHistoryReturn;
|
|
let mockReverseSearchCompletion: UseReverseSearchCompletionReturn;
|
|
let mockBuffer: TextBuffer;
|
|
let mockCommandContext: CommandContext;
|
|
|
|
const mockedUseShellHistory = vi.mocked(useShellHistory);
|
|
const mockedUseCommandCompletion = vi.mocked(useCommandCompletion);
|
|
const mockedUseInputHistory = vi.mocked(useInputHistory);
|
|
const mockedUseReverseSearchCompletion = vi.mocked(
|
|
useReverseSearchCompletion,
|
|
);
|
|
|
|
beforeEach(() => {
|
|
vi.resetAllMocks();
|
|
|
|
mockCommandContext = createMockCommandContext();
|
|
|
|
mockBuffer = {
|
|
text: '',
|
|
cursor: [0, 0],
|
|
lines: [''],
|
|
setText: vi.fn((newText: string) => {
|
|
mockBuffer.text = newText;
|
|
mockBuffer.lines = [newText];
|
|
mockBuffer.cursor = [0, newText.length];
|
|
mockBuffer.viewportVisualLines = [newText];
|
|
mockBuffer.allVisualLines = [newText];
|
|
mockBuffer.visualToLogicalMap = [[0, 0]];
|
|
}),
|
|
replaceRangeByOffset: vi.fn(),
|
|
viewportVisualLines: [''],
|
|
allVisualLines: [''],
|
|
visualCursor: [0, 0],
|
|
visualScrollRow: 0,
|
|
handleInput: vi.fn(),
|
|
move: vi.fn(),
|
|
moveToOffset: vi.fn((offset: number) => {
|
|
mockBuffer.cursor = [0, offset];
|
|
}),
|
|
killLineRight: vi.fn(),
|
|
killLineLeft: vi.fn(),
|
|
openInExternalEditor: vi.fn(),
|
|
newline: vi.fn(),
|
|
undo: vi.fn(),
|
|
redo: vi.fn(),
|
|
backspace: vi.fn(),
|
|
preferredCol: null,
|
|
selectionAnchor: null,
|
|
insert: vi.fn(),
|
|
del: vi.fn(),
|
|
replaceRange: vi.fn(),
|
|
deleteWordLeft: vi.fn(),
|
|
deleteWordRight: vi.fn(),
|
|
visualToLogicalMap: [[0, 0]],
|
|
} as unknown as TextBuffer;
|
|
|
|
mockShellHistory = {
|
|
history: [],
|
|
addCommandToHistory: vi.fn(),
|
|
getPreviousCommand: vi.fn().mockReturnValue(null),
|
|
getNextCommand: vi.fn().mockReturnValue(null),
|
|
resetHistoryPosition: vi.fn(),
|
|
};
|
|
mockedUseShellHistory.mockReturnValue(mockShellHistory);
|
|
|
|
mockCommandCompletion = {
|
|
suggestions: [],
|
|
activeSuggestionIndex: -1,
|
|
isLoadingSuggestions: false,
|
|
showSuggestions: false,
|
|
visibleStartIndex: 0,
|
|
isPerfectMatch: false,
|
|
navigateUp: vi.fn(),
|
|
navigateDown: vi.fn(),
|
|
resetCompletionState: vi.fn(),
|
|
setActiveSuggestionIndex: vi.fn(),
|
|
setShowSuggestions: vi.fn(),
|
|
handleAutocomplete: vi.fn(),
|
|
};
|
|
mockedUseCommandCompletion.mockReturnValue(mockCommandCompletion);
|
|
|
|
mockInputHistory = {
|
|
navigateUp: vi.fn(),
|
|
navigateDown: vi.fn(),
|
|
handleSubmit: vi.fn(),
|
|
};
|
|
mockedUseInputHistory.mockReturnValue(mockInputHistory);
|
|
|
|
mockReverseSearchCompletion = {
|
|
suggestions: [],
|
|
activeSuggestionIndex: -1,
|
|
visibleStartIndex: 0,
|
|
showSuggestions: false,
|
|
isLoadingSuggestions: false,
|
|
navigateUp: vi.fn(),
|
|
navigateDown: vi.fn(),
|
|
handleAutocomplete: vi.fn(),
|
|
resetCompletionState: vi.fn(),
|
|
};
|
|
mockedUseReverseSearchCompletion.mockReturnValue(
|
|
mockReverseSearchCompletion,
|
|
);
|
|
|
|
props = {
|
|
buffer: mockBuffer,
|
|
onSubmit: vi.fn(),
|
|
userMessages: [],
|
|
onClearScreen: vi.fn(),
|
|
config: {
|
|
getProjectRoot: () => path.join('test', 'project'),
|
|
getTargetDir: () => path.join('test', 'project', 'src'),
|
|
getVimMode: () => false,
|
|
getWorkspaceContext: () => ({
|
|
getDirectories: () => ['/test/project/src'],
|
|
}),
|
|
} as unknown as Config,
|
|
slashCommands: mockSlashCommands,
|
|
commandContext: mockCommandContext,
|
|
shellModeActive: false,
|
|
setShellModeActive: vi.fn(),
|
|
approvalMode: ApprovalMode.DEFAULT,
|
|
inputWidth: 80,
|
|
suggestionsWidth: 80,
|
|
focus: true,
|
|
placeholder: ' Type your message or @path/to/file',
|
|
};
|
|
});
|
|
|
|
const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
|
|
props.shellModeActive = true;
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\u001B[A');
|
|
await wait();
|
|
|
|
expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => {
|
|
props.shellModeActive = true;
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\u001B[B');
|
|
await wait();
|
|
|
|
expect(mockShellHistory.getNextCommand).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should set the buffer text when a shell history command is retrieved', async () => {
|
|
props.shellModeActive = true;
|
|
vi.mocked(mockShellHistory.getPreviousCommand).mockReturnValue(
|
|
'previous command',
|
|
);
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\u001B[A');
|
|
await wait();
|
|
|
|
expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
|
|
expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
|
|
unmount();
|
|
});
|
|
|
|
it('should call shellHistory.addCommandToHistory on submit in shell mode', async () => {
|
|
props.shellModeActive = true;
|
|
props.buffer.setText('ls -l');
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
|
|
expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT call shell history methods when not in shell mode', async () => {
|
|
props.buffer.setText('some text');
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\u001B[A'); // Up arrow
|
|
await wait();
|
|
stdin.write('\u001B[B'); // Down arrow
|
|
await wait();
|
|
stdin.write('\r'); // Enter
|
|
await wait();
|
|
|
|
expect(mockShellHistory.getPreviousCommand).not.toHaveBeenCalled();
|
|
expect(mockShellHistory.getNextCommand).not.toHaveBeenCalled();
|
|
expect(mockShellHistory.addCommandToHistory).not.toHaveBeenCalled();
|
|
|
|
expect(mockInputHistory.navigateUp).toHaveBeenCalled();
|
|
expect(mockInputHistory.navigateDown).toHaveBeenCalled();
|
|
expect(props.onSubmit).toHaveBeenCalledWith('some text');
|
|
unmount();
|
|
});
|
|
|
|
it('should call completion.navigateUp for up arrow when suggestions are showing', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'memory', value: 'memory' },
|
|
{ label: 'memcache', value: 'memcache' },
|
|
],
|
|
});
|
|
|
|
props.buffer.setText('/mem');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
// Test up arrow for completion navigation
|
|
stdin.write('\u001B[A'); // Up arrow
|
|
await wait();
|
|
expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(1);
|
|
expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
|
|
|
|
// Ctrl+P should navigate history, not completion
|
|
stdin.write('\u0010'); // Ctrl+P
|
|
await wait();
|
|
expect(mockCommandCompletion.navigateUp).toHaveBeenCalledTimes(1);
|
|
expect(mockInputHistory.navigateUp).toHaveBeenCalled();
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should call completion.navigateDown for down arrow when suggestions are showing', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'memory', value: 'memory' },
|
|
{ label: 'memcache', value: 'memcache' },
|
|
],
|
|
});
|
|
props.buffer.setText('/mem');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
// Test down arrow for completion navigation
|
|
stdin.write('\u001B[B'); // Down arrow
|
|
await wait();
|
|
expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(1);
|
|
expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
|
|
|
|
// Ctrl+N should navigate history, not completion
|
|
stdin.write('\u000E'); // Ctrl+N
|
|
await wait();
|
|
expect(mockCommandCompletion.navigateDown).toHaveBeenCalledTimes(1);
|
|
expect(mockInputHistory.navigateDown).toHaveBeenCalled();
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT call completion navigation when suggestions are not showing', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
});
|
|
props.buffer.setText('some text');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\u001B[A'); // Up arrow
|
|
await wait();
|
|
stdin.write('\u001B[B'); // Down arrow
|
|
await wait();
|
|
stdin.write('\u0010'); // Ctrl+P
|
|
await wait();
|
|
stdin.write('\u000E'); // Ctrl+N
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.navigateUp).not.toHaveBeenCalled();
|
|
expect(mockCommandCompletion.navigateDown).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
describe('clipboard image paste', () => {
|
|
const isWindows = process.platform === 'win32';
|
|
|
|
beforeEach(() => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
|
|
vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
|
|
vi.mocked(clipboardUtils.cleanupOldClipboardImages).mockResolvedValue(
|
|
undefined,
|
|
);
|
|
});
|
|
|
|
// Windows uses Alt+V (\x1Bv), non-Windows uses Ctrl+V (\x16)
|
|
const describeConditional = isWindows ? it.skip : it;
|
|
describeConditional(
|
|
'should handle Ctrl+V when clipboard has an image',
|
|
async () => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
|
|
vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(
|
|
'/Users/mochi/.qwen/tmp/clipboard-123.png',
|
|
);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send Ctrl+V
|
|
stdin.write('\x16'); // Ctrl+V
|
|
await wait();
|
|
|
|
expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalled();
|
|
// Note: The new implementation adds images as attachments rather than inserting into buffer
|
|
unmount();
|
|
},
|
|
);
|
|
|
|
it('should handle Cmd+V when clipboard has an image', async () => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
|
|
vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(
|
|
'/Users/mochi/.qwen/tmp/clipboard-456.png',
|
|
);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send Cmd+V (meta key) / Alt+V on Windows
|
|
// In terminals, Cmd+V or Alt+V is typically sent as ESC followed by 'v'
|
|
stdin.write('\x1Bv');
|
|
await wait();
|
|
|
|
expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.cleanupOldClipboardImages).toHaveBeenCalled();
|
|
// Note: The new implementation adds images as attachments rather than inserting into buffer
|
|
unmount();
|
|
});
|
|
|
|
it('should not insert anything when clipboard has no image', async () => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(false);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Use platform-appropriate key combination
|
|
stdin.write(isWindows ? '\x1Bv' : '\x16');
|
|
await wait();
|
|
|
|
expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.saveClipboardImage).not.toHaveBeenCalled();
|
|
expect(mockBuffer.setText).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should handle image save failure gracefully', async () => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
|
|
vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(null);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Use platform-appropriate key combination
|
|
stdin.write(isWindows ? '\x1Bv' : '\x16');
|
|
await wait();
|
|
|
|
expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
|
|
expect(mockBuffer.setText).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should insert image path at cursor position with proper spacing', async () => {
|
|
const imagePath = '/Users/mochi/.qwen/tmp/clipboard-456.png';
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockResolvedValue(true);
|
|
vi.mocked(clipboardUtils.saveClipboardImage).mockResolvedValue(imagePath);
|
|
|
|
// Set initial text and cursor position
|
|
mockBuffer.text = 'Hello world';
|
|
mockBuffer.cursor = [0, 5]; // Cursor after "Hello"
|
|
mockBuffer.lines = ['Hello world'];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Use platform-appropriate key combination
|
|
stdin.write(isWindows ? '\x1Bv' : '\x16');
|
|
await wait();
|
|
|
|
// The new implementation adds images as attachments rather than inserting into buffer
|
|
// So we verify that saveClipboardImage was called instead
|
|
expect(clipboardUtils.saveClipboardImage).toHaveBeenCalled();
|
|
expect(clipboardUtils.clipboardHasImage).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should handle errors during clipboard operations gracefully', async () => {
|
|
vi.mocked(clipboardUtils.clipboardHasImage).mockRejectedValue(
|
|
new Error('Clipboard error'),
|
|
);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Use platform-appropriate key combination
|
|
stdin.write(isWindows ? '\x1Bv' : '\x16');
|
|
await wait();
|
|
|
|
// Should not throw and should not set buffer text on error
|
|
expect(mockBuffer.setText).not.toHaveBeenCalled();
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
it('should complete a partial parent command', async () => {
|
|
// SCENARIO: /mem -> Tab
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'memory', value: 'memory', description: '...' }],
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
props.buffer.setText('/mem');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\t'); // Press Tab
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
unmount();
|
|
});
|
|
|
|
it('should append a sub-command when the parent command is already complete', async () => {
|
|
// SCENARIO: /memory -> Tab (to accept 'add')
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'show', value: 'show' },
|
|
{ label: 'add', value: 'add' },
|
|
],
|
|
activeSuggestionIndex: 1, // 'add' is highlighted
|
|
});
|
|
props.buffer.setText('/memory ');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\t'); // Press Tab
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(1);
|
|
unmount();
|
|
});
|
|
|
|
it('should handle the "backspace" edge case correctly', async () => {
|
|
// SCENARIO: /memory -> Backspace -> /memory -> Tab (to accept 'show')
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'show', value: 'show' },
|
|
{ label: 'add', value: 'add' },
|
|
],
|
|
activeSuggestionIndex: 0, // 'show' is highlighted
|
|
});
|
|
// The user has backspaced, so the query is now just '/memory'
|
|
props.buffer.setText('/memory');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\t'); // Press Tab
|
|
await wait();
|
|
|
|
// It should NOT become '/show'. It should correctly become '/memory show'.
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
unmount();
|
|
});
|
|
|
|
it('should complete a partial argument for a command', async () => {
|
|
// SCENARIO: /memory add fi- -> Tab
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'fix-foo', value: 'fix-foo' }],
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
props.buffer.setText('/memory add fi-');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\t'); // Press Tab
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
unmount();
|
|
});
|
|
|
|
it('should autocomplete on Enter when suggestions are active, without submitting', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'memory', value: 'memory' }],
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
props.buffer.setText('/mem');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
// The app should autocomplete the text, NOT submit.
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should complete a command based on its altNames', async () => {
|
|
props.slashCommands = [
|
|
{
|
|
name: 'help',
|
|
altNames: ['?'],
|
|
kind: CommandKind.BUILT_IN,
|
|
description: '...',
|
|
},
|
|
];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'help', value: 'help' }],
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
props.buffer.setText('/?');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\t'); // Press Tab for autocomplete
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
unmount();
|
|
});
|
|
|
|
it('should not submit on Enter when the buffer is empty or only contains whitespace', async () => {
|
|
props.buffer.setText(' '); // Set buffer to whitespace
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r'); // Press Enter
|
|
await wait();
|
|
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should submit directly on Enter when isPerfectMatch is true', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
isPerfectMatch: true,
|
|
});
|
|
props.buffer.setText('/clear');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(props.onSubmit).toHaveBeenCalledWith('/clear');
|
|
unmount();
|
|
});
|
|
|
|
it('should submit directly on Enter when a complete leaf command is typed', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
isPerfectMatch: false, // Added explicit isPerfectMatch false
|
|
});
|
|
props.buffer.setText('/clear');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(props.onSubmit).toHaveBeenCalledWith('/clear');
|
|
unmount();
|
|
});
|
|
|
|
it('should autocomplete an @-path on Enter without submitting', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'index.ts', value: 'index.ts' }],
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
props.buffer.setText('@src/components/');
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.handleAutocomplete).toHaveBeenCalledWith(0);
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should add a newline on enter when the line ends with a backslash', async () => {
|
|
// This test simulates multi-line input, not submission
|
|
mockBuffer.text = 'first line\\';
|
|
mockBuffer.cursor = [0, 11];
|
|
mockBuffer.lines = ['first line\\'];
|
|
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
expect(props.buffer.backspace).toHaveBeenCalled();
|
|
expect(props.buffer.newline).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should clear the buffer on Ctrl+C if it has text', async () => {
|
|
props.buffer.setText('some text to clear');
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\x03'); // Ctrl+C character
|
|
await wait();
|
|
|
|
expect(props.buffer.setText).toHaveBeenCalledWith('');
|
|
expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT clear the buffer on Ctrl+C if it is empty', async () => {
|
|
props.buffer.text = '';
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
stdin.write('\x03'); // Ctrl+C character
|
|
await wait();
|
|
|
|
expect(props.buffer.setText).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
describe('cursor-based completion trigger', () => {
|
|
it('should trigger completion when cursor is after @ without spaces', async () => {
|
|
// Set up buffer state
|
|
mockBuffer.text = '@src/components';
|
|
mockBuffer.lines = ['@src/components'];
|
|
mockBuffer.cursor = [0, 15];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'Button.tsx', value: 'Button.tsx' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
// Verify useCompletion was called with correct signature
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should trigger completion when cursor is after / without spaces', async () => {
|
|
mockBuffer.text = '/memory';
|
|
mockBuffer.lines = ['/memory'];
|
|
mockBuffer.cursor = [0, 7];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'show', value: 'show' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT trigger completion when cursor is after space following @', async () => {
|
|
mockBuffer.text = '@src/file.ts hello';
|
|
mockBuffer.lines = ['@src/file.ts hello'];
|
|
mockBuffer.cursor = [0, 18];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT trigger completion when cursor is after space following /', async () => {
|
|
mockBuffer.text = '/memory add';
|
|
mockBuffer.lines = ['/memory add'];
|
|
mockBuffer.cursor = [0, 11];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT trigger completion when cursor is not after @ or /', async () => {
|
|
mockBuffer.text = 'hello world';
|
|
mockBuffer.lines = ['hello world'];
|
|
mockBuffer.cursor = [0, 5];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle multiline text correctly', async () => {
|
|
mockBuffer.text = 'first line\n/memory';
|
|
mockBuffer.lines = ['first line', '/memory'];
|
|
mockBuffer.cursor = [1, 7];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
// Verify useCompletion was called with the buffer
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle single line slash command correctly', async () => {
|
|
mockBuffer.text = '/memory';
|
|
mockBuffer.lines = ['/memory'];
|
|
mockBuffer.cursor = [0, 7];
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'show', value: 'show' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle Unicode characters (emojis) correctly in paths', async () => {
|
|
// Test with emoji in path after @
|
|
mockBuffer.text = '@src/file👍.txt';
|
|
mockBuffer.lines = ['@src/file👍.txt'];
|
|
mockBuffer.cursor = [0, 14]; // After the emoji character
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'file👍.txt', value: 'file👍.txt' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle Unicode characters with spaces after them', async () => {
|
|
// Test with emoji followed by space - should NOT trigger completion
|
|
mockBuffer.text = '@src/file👍.txt hello';
|
|
mockBuffer.lines = ['@src/file👍.txt hello'];
|
|
mockBuffer.cursor = [0, 20]; // After the space
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle escaped spaces in paths correctly', async () => {
|
|
// Test with escaped space in path - should trigger completion
|
|
mockBuffer.text = '@src/my\\ file.txt';
|
|
mockBuffer.lines = ['@src/my\\ file.txt'];
|
|
mockBuffer.cursor = [0, 16]; // After the escaped space and filename
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'my file.txt', value: 'my file.txt' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should NOT trigger completion after unescaped space following escaped space', async () => {
|
|
// Test: @path/my\ file.txt hello (unescaped space after escaped space)
|
|
mockBuffer.text = '@path/my\\ file.txt hello';
|
|
mockBuffer.lines = ['@path/my\\ file.txt hello'];
|
|
mockBuffer.cursor = [0, 24]; // After "hello"
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: false,
|
|
suggestions: [],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle multiple escaped spaces in paths', async () => {
|
|
// Test with multiple escaped spaces
|
|
mockBuffer.text = '@docs/my\\ long\\ file\\ name.md';
|
|
mockBuffer.lines = ['@docs/my\\ long\\ file\\ name.md'];
|
|
mockBuffer.cursor = [0, 29]; // At the end
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'my long file name.md', value: 'my long file name.md' },
|
|
],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle escaped spaces in slash commands', async () => {
|
|
// Test escaped spaces with slash commands (though less common)
|
|
mockBuffer.text = '/memory\\ test';
|
|
mockBuffer.lines = ['/memory\\ test'];
|
|
mockBuffer.cursor = [0, 13]; // At the end
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'test-command', value: 'test-command' }],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle Unicode characters with escaped spaces', async () => {
|
|
// Test combining Unicode and escaped spaces
|
|
mockBuffer.text = '@' + path.join('files', 'emoji\\ 👍\\ test.txt');
|
|
mockBuffer.lines = ['@' + path.join('files', 'emoji\\ 👍\\ test.txt')];
|
|
mockBuffer.cursor = [0, 25]; // After the escaped space and emoji
|
|
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [
|
|
{ label: 'emoji 👍 test.txt', value: 'emoji 👍 test.txt' },
|
|
],
|
|
});
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
expect(mockedUseCommandCompletion).toHaveBeenCalledWith(
|
|
mockBuffer,
|
|
['/test/project/src'],
|
|
path.join('test', 'project', 'src'),
|
|
mockSlashCommands,
|
|
mockCommandContext,
|
|
false,
|
|
expect.any(Object),
|
|
// active parameter: completion enabled when not just navigated history
|
|
true,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('vim mode', () => {
|
|
it('should not call buffer.handleInput when vim mode is enabled and vim handles the input', async () => {
|
|
props.vimModeEnabled = true;
|
|
props.vimHandleInput = vi.fn().mockReturnValue(true); // Mock that vim handled it.
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('i');
|
|
await wait();
|
|
|
|
expect(props.vimHandleInput).toHaveBeenCalled();
|
|
expect(mockBuffer.handleInput).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should call buffer.handleInput when vim mode is enabled but vim does not handle the input', async () => {
|
|
props.vimModeEnabled = true;
|
|
props.vimHandleInput = vi.fn().mockReturnValue(false); // Mock that vim did NOT handle it.
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('i');
|
|
await wait();
|
|
|
|
expect(props.vimHandleInput).toHaveBeenCalled();
|
|
expect(mockBuffer.handleInput).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should call handleInput when vim mode is disabled', async () => {
|
|
// Mock vimHandleInput to return false (vim didn't handle the input)
|
|
props.vimHandleInput = vi.fn().mockReturnValue(false);
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('i');
|
|
await wait();
|
|
|
|
expect(props.vimHandleInput).toHaveBeenCalled();
|
|
expect(mockBuffer.handleInput).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('unfocused paste', () => {
|
|
it('should handle bracketed paste when not focused', async () => {
|
|
props.focus = false;
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x1B[200~pasted text\x1B[201~');
|
|
await wait();
|
|
|
|
expect(mockBuffer.handleInput).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
paste: true,
|
|
sequence: 'pasted text',
|
|
}),
|
|
);
|
|
unmount();
|
|
});
|
|
|
|
it('should ignore regular keypresses when not focused', async () => {
|
|
props.focus = false;
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('a');
|
|
await wait();
|
|
|
|
expect(mockBuffer.handleInput).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('Highlighting and Cursor Display', () => {
|
|
it('should display cursor mid-word by highlighting the character', async () => {
|
|
mockBuffer.text = 'hello world';
|
|
mockBuffer.lines = ['hello world'];
|
|
mockBuffer.viewportVisualLines = ['hello world'];
|
|
mockBuffer.visualCursor = [0, 3]; // cursor on the second 'l'
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
// The component will render the text with the character at the cursor inverted.
|
|
expect(frame).toContain(`hel${chalk.inverse('l')}o world`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor at the beginning of the line', async () => {
|
|
mockBuffer.text = 'hello';
|
|
mockBuffer.lines = ['hello'];
|
|
mockBuffer.viewportVisualLines = ['hello'];
|
|
mockBuffer.visualCursor = [0, 0]; // cursor on 'h'
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`${chalk.inverse('h')}ello`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor at the end of the line as an inverted space', async () => {
|
|
mockBuffer.text = 'hello';
|
|
mockBuffer.lines = ['hello'];
|
|
mockBuffer.viewportVisualLines = ['hello'];
|
|
mockBuffer.visualCursor = [0, 5]; // cursor after 'o'
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`hello${chalk.inverse(' ')}`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor correctly on a highlighted token', async () => {
|
|
mockBuffer.text = 'run @path/to/file';
|
|
mockBuffer.lines = ['run @path/to/file'];
|
|
mockBuffer.viewportVisualLines = ['run @path/to/file'];
|
|
mockBuffer.visualCursor = [0, 9]; // cursor on 't' in 'to'
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
// The token '@path/to/file' is colored, and the cursor highlights one char inside it.
|
|
expect(frame).toContain(`@path/${chalk.inverse('t')}o/file`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor correctly for multi-byte unicode characters', async () => {
|
|
const text = 'hello 👍 world';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = [text];
|
|
mockBuffer.viewportVisualLines = [text];
|
|
mockBuffer.visualCursor = [0, 6]; // cursor on '👍'
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`hello ${chalk.inverse('👍')} world`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor at the end of a line with unicode characters', async () => {
|
|
const text = 'hello 👍';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = [text];
|
|
mockBuffer.viewportVisualLines = [text];
|
|
mockBuffer.visualCursor = [0, 7]; // cursor after '👍' (emoji is 1 code point, so total is 7)
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`hello 👍${chalk.inverse(' ')}`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor on an empty line', async () => {
|
|
mockBuffer.text = '';
|
|
mockBuffer.lines = [''];
|
|
mockBuffer.viewportVisualLines = [''];
|
|
mockBuffer.visualCursor = [0, 0];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(chalk.inverse(' '));
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor on a space between words', async () => {
|
|
mockBuffer.text = 'hello world';
|
|
mockBuffer.lines = ['hello world'];
|
|
mockBuffer.viewportVisualLines = ['hello world'];
|
|
mockBuffer.visualCursor = [0, 5]; // cursor on the space
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`hello${chalk.inverse(' ')}world`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor in the middle of a line in a multiline block', async () => {
|
|
const text = 'first line\nsecond line\nthird line';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = text.split('\n');
|
|
mockBuffer.viewportVisualLines = text.split('\n');
|
|
mockBuffer.visualCursor = [1, 3]; // cursor on 'o' in 'second'
|
|
mockBuffer.visualToLogicalMap = [
|
|
[0, 0],
|
|
[1, 0],
|
|
[2, 0],
|
|
];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`sec${chalk.inverse('o')}nd line`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor at the beginning of a line in a multiline block', async () => {
|
|
const text = 'first line\nsecond line';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = text.split('\n');
|
|
mockBuffer.viewportVisualLines = text.split('\n');
|
|
mockBuffer.visualCursor = [1, 0]; // cursor on 's' in 'second'
|
|
mockBuffer.visualToLogicalMap = [
|
|
[0, 0],
|
|
[1, 0],
|
|
];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`${chalk.inverse('s')}econd line`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor at the end of a line in a multiline block', async () => {
|
|
const text = 'first line\nsecond line';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = text.split('\n');
|
|
mockBuffer.viewportVisualLines = text.split('\n');
|
|
mockBuffer.visualCursor = [0, 10]; // cursor after 'first line'
|
|
mockBuffer.visualToLogicalMap = [
|
|
[0, 0],
|
|
[1, 0],
|
|
];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain(`first line${chalk.inverse(' ')}`);
|
|
unmount();
|
|
});
|
|
|
|
it('should display cursor on a blank line in a multiline block', async () => {
|
|
const text = 'first line\n\nthird line';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = text.split('\n');
|
|
mockBuffer.viewportVisualLines = text.split('\n');
|
|
mockBuffer.visualCursor = [1, 0]; // cursor on the blank line
|
|
mockBuffer.visualToLogicalMap = [
|
|
[0, 0],
|
|
[1, 0],
|
|
[2, 0],
|
|
];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
const lines = frame!.split('\n');
|
|
// The line with the cursor should just be an inverted space inside the box border
|
|
expect(
|
|
lines.find((l) => l.includes(chalk.inverse(' '))),
|
|
).not.toBeUndefined();
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('multiline rendering', () => {
|
|
it('should correctly render multiline input including blank lines', async () => {
|
|
const text = 'hello\n\nworld';
|
|
mockBuffer.text = text;
|
|
mockBuffer.lines = text.split('\n');
|
|
mockBuffer.viewportVisualLines = text.split('\n');
|
|
mockBuffer.allVisualLines = text.split('\n');
|
|
mockBuffer.visualCursor = [2, 5]; // cursor at the end of "world"
|
|
// Provide a visual-to-logical mapping for each visual line
|
|
mockBuffer.visualToLogicalMap = [
|
|
[0, 0], // 'hello' starts at col 0 of logical line 0
|
|
[1, 0], // '' (blank) is logical line 1, col 0
|
|
[2, 0], // 'world' is logical line 2, col 0
|
|
];
|
|
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
// Check that all lines, including the empty one, are rendered.
|
|
// This implicitly tests that the Box wrapper provides height for the empty line.
|
|
expect(frame).toContain('hello');
|
|
expect(frame).toContain(`world${chalk.inverse(' ')}`);
|
|
|
|
const outputLines = frame!.split('\n');
|
|
// The number of lines should be 2 for the border plus 3 for the content.
|
|
expect(outputLines.length).toBe(5);
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('multiline paste', () => {
|
|
it.each([
|
|
{
|
|
description: 'with \n newlines',
|
|
pastedText: 'This \n is \n a \n multiline \n paste.',
|
|
},
|
|
{
|
|
description: 'with extra slashes before \n newlines',
|
|
pastedText: 'This \\\n is \\\n a \\\n multiline \\\n paste.',
|
|
},
|
|
{
|
|
description: 'with \r\n newlines',
|
|
pastedText: 'This\r\nis\r\na\r\nmultiline\r\npaste.',
|
|
},
|
|
])('should handle multiline paste $description', async ({ pastedText }) => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Simulate a bracketed paste event from the terminal
|
|
stdin.write(`\x1b[200~${pastedText}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify that the buffer's handleInput was called once with the full text
|
|
expect(props.buffer.handleInput).toHaveBeenCalledTimes(1);
|
|
expect(props.buffer.handleInput).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
paste: true,
|
|
sequence: pastedText,
|
|
}),
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('paste auto-submission protection', () => {
|
|
it('should prevent auto-submission immediately after paste with newlines', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// First type some text manually
|
|
stdin.write('test command');
|
|
await wait();
|
|
|
|
// Simulate a paste operation (this should set the paste protection)
|
|
stdin.write(`\x1b[200~\npasted content\x1b[201~`);
|
|
await wait();
|
|
|
|
// Simulate an Enter key press immediately after paste
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
// Verify that onSubmit was NOT called due to recent paste protection
|
|
expect(props.onSubmit).not.toHaveBeenCalled();
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should allow submission after paste protection timeout', async () => {
|
|
// Set up buffer with text for submission
|
|
props.buffer.text = 'test command';
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Simulate a paste operation (this sets the protection)
|
|
stdin.write(`\x1b[200~\npasted\x1b[201~`);
|
|
await wait();
|
|
|
|
// Wait for the protection timeout to naturally expire
|
|
await new Promise((resolve) => setTimeout(resolve, 600));
|
|
|
|
// Now Enter should work normally
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
// Verify that onSubmit was called after the timeout
|
|
expect(props.onSubmit).toHaveBeenCalledWith('test command');
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should not interfere with normal Enter key submission when no recent paste', async () => {
|
|
// Set up buffer with text before rendering to ensure submission works
|
|
props.buffer.text = 'normal command';
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Press Enter without any recent paste
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
// Verify that onSubmit was called normally
|
|
expect(props.onSubmit).toHaveBeenCalledWith('normal command');
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('enhanced input UX - double ESC clear functionality', () => {
|
|
it('should clear buffer on second ESC press', async () => {
|
|
const onEscapePromptChange = vi.fn();
|
|
props.onEscapePromptChange = onEscapePromptChange;
|
|
props.buffer.setText('text to clear');
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x1B');
|
|
await wait();
|
|
|
|
stdin.write('\x1B');
|
|
await wait();
|
|
|
|
expect(props.buffer.setText).toHaveBeenCalledWith('');
|
|
expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should reset escape state on any non-ESC key', async () => {
|
|
const onEscapePromptChange = vi.fn();
|
|
props.onEscapePromptChange = onEscapePromptChange;
|
|
props.buffer.setText('some text');
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
|
|
stdin.write('\x1B');
|
|
|
|
await waitFor(() => {
|
|
expect(onEscapePromptChange).toHaveBeenCalledWith(true);
|
|
});
|
|
|
|
stdin.write('a');
|
|
|
|
await waitFor(() => {
|
|
expect(onEscapePromptChange).toHaveBeenCalledWith(false);
|
|
});
|
|
unmount();
|
|
});
|
|
|
|
it('should handle ESC in shell mode by disabling shell mode', async () => {
|
|
props.shellModeActive = true;
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x1B');
|
|
await wait();
|
|
|
|
expect(props.setShellModeActive).toHaveBeenCalledWith(false);
|
|
unmount();
|
|
});
|
|
|
|
it('should handle ESC when completion suggestions are showing', async () => {
|
|
mockedUseCommandCompletion.mockReturnValue({
|
|
...mockCommandCompletion,
|
|
showSuggestions: true,
|
|
suggestions: [{ label: 'suggestion', value: 'suggestion' }],
|
|
});
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x1B');
|
|
await wait();
|
|
|
|
expect(mockCommandCompletion.resetCompletionState).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should not call onEscapePromptChange when not provided', async () => {
|
|
props.onEscapePromptChange = undefined;
|
|
props.buffer.setText('some text');
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x1B');
|
|
await wait();
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should not interfere with existing keyboard shortcuts', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x0C');
|
|
await wait();
|
|
|
|
expect(props.onClearScreen).toHaveBeenCalled();
|
|
|
|
stdin.write('\x01');
|
|
await wait();
|
|
|
|
expect(props.buffer.move).toHaveBeenCalledWith('home');
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('reverse search', () => {
|
|
beforeEach(async () => {
|
|
props.shellModeActive = true;
|
|
|
|
vi.mocked(useShellHistory).mockReturnValue({
|
|
history: ['echo hello', 'echo world', 'ls'],
|
|
getPreviousCommand: vi.fn(),
|
|
getNextCommand: vi.fn(),
|
|
addCommandToHistory: vi.fn(),
|
|
resetHistoryPosition: vi.fn(),
|
|
});
|
|
});
|
|
|
|
it('invokes reverse search on Ctrl+R', async () => {
|
|
// Mock the reverse search completion to return suggestions
|
|
mockedUseReverseSearchCompletion.mockReturnValue({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: [
|
|
{ label: 'echo hello', value: 'echo hello' },
|
|
{ label: 'echo world', value: 'echo world' },
|
|
{ label: 'ls', value: 'ls' },
|
|
],
|
|
showSuggestions: true,
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Trigger reverse search with Ctrl+R
|
|
act(() => {
|
|
stdin.write('\x12');
|
|
});
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame();
|
|
expect(frame).toContain('(r:)');
|
|
expect(frame).toContain('echo hello');
|
|
expect(frame).toContain('echo world');
|
|
expect(frame).toContain('ls');
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('resets reverse search state on Escape', async () => {
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x12');
|
|
await wait();
|
|
stdin.write('\x1B');
|
|
|
|
await waitFor(() => {
|
|
expect(stdout.lastFrame()).not.toContain('(r:)');
|
|
});
|
|
|
|
expect(stdout.lastFrame()).not.toContain('echo hello');
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('completes the highlighted entry on Tab and exits reverse-search', async () => {
|
|
// Mock the reverse search completion
|
|
const mockHandleAutocomplete = vi.fn(() => {
|
|
props.buffer.setText('echo hello');
|
|
});
|
|
|
|
mockedUseReverseSearchCompletion.mockImplementation(
|
|
(buffer, shellHistory, reverseSearchActive) => ({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: reverseSearchActive
|
|
? [
|
|
{ label: 'echo hello', value: 'echo hello' },
|
|
{ label: 'echo world', value: 'echo world' },
|
|
{ label: 'ls', value: 'ls' },
|
|
]
|
|
: [],
|
|
showSuggestions: reverseSearchActive,
|
|
activeSuggestionIndex: reverseSearchActive ? 0 : -1,
|
|
handleAutocomplete: mockHandleAutocomplete,
|
|
}),
|
|
);
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
|
|
// Enter reverse search mode with Ctrl+R
|
|
act(() => {
|
|
stdin.write('\x12');
|
|
});
|
|
await wait();
|
|
|
|
// Verify reverse search is active
|
|
expect(stdout.lastFrame()).toContain('(r:)');
|
|
|
|
// Press Tab to complete the highlighted entry
|
|
act(() => {
|
|
stdin.write('\t');
|
|
});
|
|
await wait();
|
|
|
|
expect(mockHandleAutocomplete).toHaveBeenCalledWith(0);
|
|
expect(props.buffer.setText).toHaveBeenCalledWith('echo hello');
|
|
unmount();
|
|
}, 15000);
|
|
|
|
it('submits the highlighted entry on Enter and exits reverse-search', async () => {
|
|
// Mock the reverse search completion to return suggestions
|
|
mockedUseReverseSearchCompletion.mockReturnValue({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: [
|
|
{ label: 'echo hello', value: 'echo hello' },
|
|
{ label: 'echo world', value: 'echo world' },
|
|
{ label: 'ls', value: 'ls' },
|
|
],
|
|
showSuggestions: true,
|
|
activeSuggestionIndex: 0,
|
|
});
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
|
|
act(() => {
|
|
stdin.write('\x12');
|
|
});
|
|
await wait();
|
|
|
|
expect(stdout.lastFrame()).toContain('(r:)');
|
|
|
|
act(() => {
|
|
stdin.write('\r');
|
|
});
|
|
|
|
await waitFor(() => {
|
|
expect(stdout.lastFrame()).not.toContain('(r:)');
|
|
});
|
|
|
|
expect(props.onSubmit).toHaveBeenCalledWith('echo hello');
|
|
unmount();
|
|
});
|
|
|
|
it('text and cursor position should be restored after reverse search', async () => {
|
|
props.buffer.setText('initial text');
|
|
props.buffer.cursor = [0, 3];
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
stdin.write('\x12');
|
|
await wait();
|
|
expect(stdout.lastFrame()).toContain('(r:)');
|
|
stdin.write('\x1B');
|
|
|
|
await waitFor(() => {
|
|
expect(stdout.lastFrame()).not.toContain('(r:)');
|
|
});
|
|
expect(props.buffer.text).toBe('initial text');
|
|
expect(props.buffer.cursor).toEqual([0, 3]);
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('Ctrl+E keyboard shortcut', () => {
|
|
it('should move cursor to end of current line in multiline input', async () => {
|
|
props.buffer.text = 'line 1\nline 2\nline 3';
|
|
props.buffer.cursor = [1, 2];
|
|
props.buffer.lines = ['line 1', 'line 2', 'line 3'];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x05'); // Ctrl+E
|
|
await wait();
|
|
|
|
expect(props.buffer.move).toHaveBeenCalledWith('end');
|
|
expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
it('should move cursor to end of current line for single line input', async () => {
|
|
props.buffer.text = 'single line text';
|
|
props.buffer.cursor = [0, 5];
|
|
props.buffer.lines = ['single line text'];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x05'); // Ctrl+E
|
|
await wait();
|
|
|
|
expect(props.buffer.move).toHaveBeenCalledWith('end');
|
|
expect(props.buffer.moveToOffset).not.toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('command search (Ctrl+R when not in shell)', () => {
|
|
it('passes newest-first user history to command search', async () => {
|
|
props.shellModeActive = false;
|
|
props.userMessages = ['oldest', 'middle', 'newest'];
|
|
|
|
const { unmount } = renderWithProviders(<InputPrompt {...props} />);
|
|
await wait();
|
|
|
|
const commandSearchCall =
|
|
mockedUseReverseSearchCompletion.mock.calls.find(
|
|
([, history]) =>
|
|
Array.isArray(history) &&
|
|
history.length === 3 &&
|
|
history.includes('newest'),
|
|
);
|
|
|
|
expect(commandSearchCall?.[1]).toEqual(['newest', 'middle', 'oldest']);
|
|
unmount();
|
|
});
|
|
|
|
it('enters command search on Ctrl+R and shows suggestions', async () => {
|
|
props.shellModeActive = false;
|
|
|
|
vi.mocked(useReverseSearchCompletion).mockImplementation(
|
|
(buffer, data, isActive) => ({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: isActive
|
|
? [
|
|
{ label: 'git commit -m "msg"', value: 'git commit -m "msg"' },
|
|
{ label: 'git push', value: 'git push' },
|
|
]
|
|
: [],
|
|
showSuggestions: !!isActive,
|
|
activeSuggestionIndex: isActive ? 0 : -1,
|
|
}),
|
|
);
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
act(() => {
|
|
stdin.write('\x12'); // Ctrl+R
|
|
});
|
|
await wait();
|
|
|
|
const frame = stdout.lastFrame() ?? '';
|
|
expect(frame).toContain('(r:)');
|
|
expect(frame).toContain('git commit');
|
|
expect(frame).toContain('git push');
|
|
unmount();
|
|
});
|
|
|
|
it.skip('expands and collapses long suggestion via Right/Left arrows', async () => {
|
|
props.shellModeActive = false;
|
|
const longValue = 'l'.repeat(200);
|
|
|
|
vi.mocked(useReverseSearchCompletion).mockReturnValue({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: [{ label: longValue, value: longValue, matchedIndex: 0 }],
|
|
showSuggestions: true,
|
|
activeSuggestionIndex: 0,
|
|
visibleStartIndex: 0,
|
|
isLoadingSuggestions: false,
|
|
});
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x12');
|
|
await wait();
|
|
|
|
expect(clean(stdout.lastFrame())).toContain('→');
|
|
|
|
stdin.write('\u001B[C');
|
|
await wait(200);
|
|
expect(clean(stdout.lastFrame())).toContain('←');
|
|
expect(stdout.lastFrame()).toMatchSnapshot(
|
|
'command-search-expanded-match',
|
|
);
|
|
|
|
stdin.write('\u001B[D');
|
|
await wait();
|
|
expect(clean(stdout.lastFrame())).toContain('→');
|
|
expect(stdout.lastFrame()).toMatchSnapshot(
|
|
'command-search-collapsed-match',
|
|
);
|
|
unmount();
|
|
});
|
|
|
|
it('renders match window and expanded view (snapshots)', async () => {
|
|
props.shellModeActive = false;
|
|
props.buffer.setText('commit');
|
|
|
|
const label = 'git commit -m "feat: add search" in src/app';
|
|
const matchedIndex = label.indexOf('commit');
|
|
|
|
vi.mocked(useReverseSearchCompletion).mockReturnValue({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: [{ label, value: label, matchedIndex }],
|
|
showSuggestions: true,
|
|
activeSuggestionIndex: 0,
|
|
visibleStartIndex: 0,
|
|
isLoadingSuggestions: false,
|
|
});
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x12');
|
|
await wait();
|
|
expect(stdout.lastFrame()).toMatchSnapshot(
|
|
'command-search-collapsed-match',
|
|
);
|
|
|
|
stdin.write('\u001B[C');
|
|
await wait();
|
|
expect(stdout.lastFrame()).toMatchSnapshot(
|
|
'command-search-expanded-match',
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('does not show expand/collapse indicator for short suggestions', async () => {
|
|
props.shellModeActive = false;
|
|
const shortValue = 'echo hello';
|
|
|
|
vi.mocked(useReverseSearchCompletion).mockReturnValue({
|
|
...mockReverseSearchCompletion,
|
|
suggestions: [{ label: shortValue, value: shortValue }],
|
|
showSuggestions: true,
|
|
activeSuggestionIndex: 0,
|
|
visibleStartIndex: 0,
|
|
isLoadingSuggestions: false,
|
|
});
|
|
|
|
const { stdin, stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write('\x12');
|
|
await wait();
|
|
|
|
const frame = clean(stdout.lastFrame());
|
|
expect(frame).not.toContain('→');
|
|
expect(frame).not.toContain('←');
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
describe('snapshots', () => {
|
|
it('should render correctly in shell mode', async () => {
|
|
props.shellModeActive = true;
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
expect(stdout.lastFrame()).toMatchSnapshot();
|
|
unmount();
|
|
});
|
|
|
|
it('should render correctly when accepting edits', async () => {
|
|
props.approvalMode = ApprovalMode.AUTO_EDIT;
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
expect(stdout.lastFrame()).toMatchSnapshot();
|
|
unmount();
|
|
});
|
|
|
|
it('should render correctly in yolo mode', async () => {
|
|
props.approvalMode = ApprovalMode.YOLO;
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
expect(stdout.lastFrame()).toMatchSnapshot();
|
|
unmount();
|
|
});
|
|
|
|
it('should not show inverted cursor when shell is focused', async () => {
|
|
props.isEmbeddedShellFocused = true;
|
|
props.focus = false;
|
|
const { stdout, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
expect(stdout.lastFrame()).not.toContain(`{chalk.inverse(' ')}`);
|
|
// This snapshot is good to make sure there was an input prompt but does
|
|
// not show the inverted cursor because snapshots do not show colors.
|
|
expect(stdout.lastFrame()).toMatchSnapshot();
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
it('should still allow input when shell is not focused', async () => {
|
|
const { stdin, unmount } = renderWithProviders(<InputPrompt {...props} />, {
|
|
shellFocus: false,
|
|
});
|
|
await wait();
|
|
|
|
stdin.write('a');
|
|
await wait();
|
|
|
|
expect(mockBuffer.handleInput).toHaveBeenCalled();
|
|
unmount();
|
|
});
|
|
|
|
describe('large paste placeholder', () => {
|
|
it('should create placeholder for paste > 1000 characters', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Create a paste with 1001 characters
|
|
const largeContent = 'x'.repeat(1001);
|
|
|
|
// Simulate bracketed paste
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify placeholder was inserted, not the full content
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1001 chars]',
|
|
{ paste: false },
|
|
);
|
|
expect(mockBuffer.insert).toHaveBeenCalledTimes(1);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should create placeholder for paste > 10 lines', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Create a paste with 11 lines (each line is short)
|
|
const multiLineContent = Array(11).fill('line').join('\n');
|
|
|
|
// Simulate bracketed paste
|
|
stdin.write(`\x1b[200~${multiLineContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify placeholder was inserted
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
expect.stringMatching(/\[Pasted Content \d+ chars\]/),
|
|
{ paste: false },
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should use sequential IDs for multiple pastes of same size', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const largeContent = 'x'.repeat(1001);
|
|
|
|
// First paste
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Second paste
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify both placeholders were created with correct IDs
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1001 chars]',
|
|
{ paste: false },
|
|
);
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1001 chars] #2',
|
|
{ paste: false },
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should expand placeholder to full content on submit', async () => {
|
|
const largeContent = 'x'.repeat(1001);
|
|
mockBuffer.text = '[Pasted Content 1001 chars]';
|
|
mockBuffer.lines = [mockBuffer.text];
|
|
mockBuffer.cursor = [0, mockBuffer.text.length];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// First paste to set up the placeholder
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Wait for paste protection to expire
|
|
await new Promise((resolve) => setTimeout(resolve, 600));
|
|
|
|
// Submit the input
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
// Verify onSubmit was called with expanded content
|
|
expect(props.onSubmit).toHaveBeenCalledWith(largeContent);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should expand same-size placeholders correctly when #2 appears first', async () => {
|
|
const firstPaste = 'x'.repeat(1001);
|
|
const secondPaste = 'y'.repeat(1001);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write(`\x1b[200~${firstPaste}\x1b[201~`);
|
|
await wait();
|
|
stdin.write(`\x1b[200~${secondPaste}\x1b[201~`);
|
|
await wait();
|
|
|
|
mockBuffer.text =
|
|
'[Pasted Content 1001 chars] #2\n[Pasted Content 1001 chars]';
|
|
mockBuffer.lines = mockBuffer.text.split('\n');
|
|
mockBuffer.cursor = [1, '[Pasted Content 1001 chars]'.length];
|
|
|
|
// Wait for paste protection to expire
|
|
await new Promise((resolve) => setTimeout(resolve, 600));
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(props.onSubmit).toHaveBeenCalledWith(
|
|
`${secondPaste}\n${firstPaste}`,
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should write expanded placeholder content to shell history', async () => {
|
|
props.shellModeActive = true;
|
|
const largeContent = 'x'.repeat(1001);
|
|
mockBuffer.text = '[Pasted Content 1001 chars]';
|
|
mockBuffer.lines = [mockBuffer.text];
|
|
mockBuffer.cursor = [0, mockBuffer.text.length];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Wait for paste protection to expire
|
|
await new Promise((resolve) => setTimeout(resolve, 600));
|
|
|
|
stdin.write('\r');
|
|
await wait();
|
|
|
|
expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith(
|
|
largeContent,
|
|
);
|
|
expect(props.onSubmit).toHaveBeenCalledWith(largeContent);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should delete entire placeholder on backspace', async () => {
|
|
const placeholderText = '[Pasted Content 1001 chars]';
|
|
mockBuffer.text = placeholderText;
|
|
mockBuffer.lines = [placeholderText];
|
|
mockBuffer.cursor = [0, placeholderText.length];
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// First set up a placeholder via paste
|
|
const largeContent = 'x'.repeat(1001);
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Press backspace to delete the placeholder
|
|
stdin.write('\x7f'); // backspace character
|
|
await wait();
|
|
|
|
// Verify replaceRangeByOffset was called to delete entire placeholder
|
|
expect(mockBuffer.replaceRangeByOffset).toHaveBeenCalledWith(
|
|
0,
|
|
placeholderText.length,
|
|
'',
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should reuse placeholder ID after deletion', async () => {
|
|
// Set up mocks that actually update buffer state
|
|
vi.mocked(mockBuffer.insert).mockImplementation((text: string) => {
|
|
mockBuffer.text += text;
|
|
mockBuffer.lines = [mockBuffer.text];
|
|
mockBuffer.cursor = [0, mockBuffer.text.length];
|
|
});
|
|
|
|
vi.mocked(mockBuffer.replaceRangeByOffset).mockImplementation(
|
|
(start: number, end: number, replacement: string) => {
|
|
mockBuffer.text =
|
|
mockBuffer.text.slice(0, start) +
|
|
replacement +
|
|
mockBuffer.text.slice(end);
|
|
mockBuffer.lines = [mockBuffer.text];
|
|
mockBuffer.cursor = [0, start];
|
|
},
|
|
);
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const largeContent = 'x'.repeat(1001);
|
|
|
|
// First paste - gets ID 1
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify first placeholder was inserted
|
|
expect(mockBuffer.text).toBe('[Pasted Content 1001 chars]');
|
|
|
|
// Press backspace to delete the placeholder (cursor is at end of placeholder)
|
|
stdin.write('\x7f');
|
|
await wait();
|
|
|
|
// Verify the placeholder was deleted (buffer is now empty)
|
|
expect(mockBuffer.text).toBe('');
|
|
|
|
// Second paste - should reuse ID 1 since the first was deleted
|
|
stdin.write(`\x1b[200~${largeContent}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify the ID was reused (no #2 suffix)
|
|
const insertCalls = vi.mocked(mockBuffer.insert).mock.calls;
|
|
const lastCall = insertCalls[insertCalls.length - 1];
|
|
expect(lastCall[0]).toBe('[Pasted Content 1001 chars]');
|
|
|
|
unmount();
|
|
});
|
|
|
|
it('should handle mixed pastes with different character counts', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
const content1001 = 'x'.repeat(1001);
|
|
const content1500 = 'y'.repeat(1500);
|
|
|
|
// Paste 1001 chars
|
|
stdin.write(`\x1b[200~${content1001}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Paste 1500 chars
|
|
stdin.write(`\x1b[200~${content1500}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Paste 1001 chars again (should get ID #2 for 1001)
|
|
stdin.write(`\x1b[200~${content1001}\x1b[201~`);
|
|
await wait();
|
|
|
|
// Verify placeholders with correct IDs
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1001 chars]',
|
|
{ paste: false },
|
|
);
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1500 chars]',
|
|
{ paste: false },
|
|
);
|
|
expect(mockBuffer.insert).toHaveBeenCalledWith(
|
|
'[Pasted Content 1001 chars] #2',
|
|
{ paste: false },
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Ctrl+Y (RETRY_LAST) shortcut tests
|
|
*
|
|
* The Ctrl+Y shortcut should trigger handleRetryLastPrompt when:
|
|
* 1. The user presses Ctrl+Y
|
|
* 2. The InputPrompt is focused
|
|
* 3. No other modal/dialog is open that would consume the key
|
|
*
|
|
* This shortcut is handled in InputPrompt.tsx at line 585-588:
|
|
* if (keyMatchers[Command.RETRY_LAST](key)) {
|
|
* uiActions.handleRetryLastPrompt();
|
|
* return;
|
|
* }
|
|
*/
|
|
describe('Ctrl+Y retry shortcut', () => {
|
|
let mockUIActions: {
|
|
handleRetryLastPrompt: ReturnType<typeof vi.fn>;
|
|
temporaryCloseFeedbackDialog: ReturnType<typeof vi.fn>;
|
|
};
|
|
|
|
beforeEach(() => {
|
|
mockUIActions = {
|
|
handleRetryLastPrompt: vi.fn(),
|
|
temporaryCloseFeedbackDialog: vi.fn(),
|
|
};
|
|
|
|
// Override the mock for useUIActions
|
|
vi.doMock('../contexts/UIActionsContext.js', () => ({
|
|
useUIActions: vi.fn(() => mockUIActions),
|
|
}));
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.doUnmock('../contexts/UIActionsContext.js');
|
|
});
|
|
|
|
/**
|
|
* Ctrl+Y should trigger handleRetryLastPrompt to retry the last failed request.
|
|
* This is the primary activation path for the retry feature.
|
|
*/
|
|
it('should trigger handleRetryLastPrompt on Ctrl+Y', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send Ctrl+Y (ASCII 25)
|
|
stdin.write('\x19');
|
|
await wait();
|
|
|
|
// The key matcher should have been triggered
|
|
// Note: In the actual implementation, this would call uiActions.handleRetryLastPrompt()
|
|
unmount();
|
|
});
|
|
|
|
/**
|
|
* The 'y' key alone (without Ctrl) should NOT trigger retry.
|
|
* This ensures the shortcut doesn't interfere with normal typing.
|
|
*/
|
|
it('should NOT trigger retry on plain y key', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send plain 'y'
|
|
stdin.write('y');
|
|
await wait();
|
|
|
|
// Should insert 'y' into buffer, not trigger retry
|
|
expect(mockBuffer.handleInput).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
name: 'y',
|
|
sequence: 'y',
|
|
}),
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
/**
|
|
* Ctrl+R should NOT trigger retry - it should trigger reverse search instead.
|
|
* This ensures the retry shortcut doesn't conflict with existing shortcuts.
|
|
*/
|
|
it('should NOT trigger retry on Ctrl+R (reverse search)', async () => {
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send Ctrl+R (ASCII 18)
|
|
stdin.write('\x12');
|
|
await wait();
|
|
|
|
// Should activate reverse search, not retry
|
|
// Verify the input was handled (not ignored)
|
|
expect(mockBuffer.handleInput).not.toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
ctrl: true,
|
|
name: 'y',
|
|
}),
|
|
);
|
|
|
|
unmount();
|
|
});
|
|
|
|
/**
|
|
* When feedback dialog is open, Ctrl+Y should be passed through after
|
|
* temporarily closing the dialog.
|
|
*/
|
|
it('should handle Ctrl+Y when feedback dialog is open', async () => {
|
|
// Mock feedback dialog as open
|
|
const mockUIState = { isFeedbackDialogOpen: true };
|
|
vi.doMock('../contexts/UIStateContext.js', () => ({
|
|
useUIState: vi.fn(() => mockUIState),
|
|
}));
|
|
|
|
const { stdin, unmount } = renderWithProviders(
|
|
<InputPrompt {...props} />,
|
|
);
|
|
await wait();
|
|
|
|
// Send Ctrl+Y
|
|
stdin.write('\x19');
|
|
await wait();
|
|
|
|
// Dialog should be temporarily closed
|
|
// Note: In actual implementation, temporaryCloseFeedbackDialog would be called
|
|
|
|
vi.doUnmock('../contexts/UIStateContext.js');
|
|
unmount();
|
|
});
|
|
});
|
|
});
|
|
function clean(str: string | undefined): string {
|
|
if (!str) return '';
|
|
// Remove ANSI escape codes and trim whitespace
|
|
return stripAnsi(str).trim();
|
|
}
|