Download packages/core/src/utils/editor.test.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 34.2 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/utils/editor.test.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/core/src/utils/editor.test.ts
-
curl -L -o editor.test.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/utils/editor.test.ts
34.2 kB
| /** | |
| * @license | |
| * Copyright 2025 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { | |
| vi, | |
| describe, | |
| it, | |
| expect, | |
| beforeEach, | |
| afterEach, | |
| type Mock, | |
| } from 'vitest'; | |
| import { | |
| hasValidEditorCommand, | |
| hasValidEditorCommandAsync, | |
| getDiffCommand, | |
| openDiff, | |
| allowEditorTypeInSandbox, | |
| isEditorAvailable, | |
| isEditorAvailableAsync, | |
| isValidEditorType, | |
| getEditorWaitFlag, | |
| getEditorExtraArgs, | |
| resolveEditorAsync, | |
| resolveEditorTypeFromCommand, | |
| type EditorType, | |
| } from './editor.js'; | |
| import { coreEvents, CoreEvent } from './events.js'; | |
| import { exec, execSync, spawn, spawnSync } from 'node:child_process'; | |
| import { debugLogger } from './debugLogger.js'; | |
| vi.mock('child_process', () => ({ | |
| exec: vi.fn(), | |
| execSync: vi.fn(), | |
| spawn: vi.fn(), | |
| spawnSync: vi.fn(() => ({ error: null, status: 0 })), | |
| })); | |
| vi.mock('./headless.js', () => ({ | |
| isHeadlessMode: vi.fn(() => false), | |
| })); | |
| const originalPlatform = process.platform; | |
| describe('editor utils', () => { | |
| beforeEach(() => { | |
| vi.clearAllMocks(); | |
| vi.unstubAllEnvs(); | |
| Object.defineProperty(process, 'platform', { | |
| value: originalPlatform, | |
| writable: true, | |
| }); | |
| }); | |
| afterEach(() => { | |
| vi.restoreAllMocks(); | |
| vi.unstubAllEnvs(); | |
| Object.defineProperty(process, 'platform', { | |
| value: originalPlatform, | |
| writable: true, | |
| }); | |
| }); | |
| describe('hasValidEditorCommand', () => { | |
| const testCases: Array<{ | |
| editor: EditorType; | |
| commands: string[]; | |
| win32Commands: string[]; | |
| }> = [ | |
| { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] }, | |
| { | |
| editor: 'vscodium', | |
| commands: ['codium'], | |
| win32Commands: ['codium.cmd'], | |
| }, | |
| { | |
| editor: 'windsurf', | |
| commands: ['windsurf'], | |
| win32Commands: ['windsurf'], | |
| }, | |
| { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] }, | |
| { editor: 'vim', commands: ['vim'], win32Commands: ['vim'] }, | |
| { editor: 'neovim', commands: ['nvim'], win32Commands: ['nvim'] }, | |
| { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] }, | |
| { editor: 'emacs', commands: ['emacs'], win32Commands: ['emacs.exe'] }, | |
| { | |
| editor: 'antigravity', | |
| commands: ['agy', 'antigravity'], | |
| win32Commands: ['agy.cmd', 'antigravity.cmd', 'antigravity'], | |
| }, | |
| { editor: 'hx', commands: ['hx'], win32Commands: ['hx'] }, | |
| { | |
| editor: 'sublimetext', | |
| commands: ['subl'], | |
| win32Commands: ['subl'], | |
| }, | |
| { editor: 'lapce', commands: ['lapce'], win32Commands: ['lapce'] }, | |
| { editor: 'nova', commands: ['nova'], win32Commands: ['nova'] }, | |
| { editor: 'bbedit', commands: ['bbedit'], win32Commands: ['bbedit'] }, | |
| { | |
| editor: 'emacsclient', | |
| commands: ['emacsclient'], | |
| win32Commands: ['emacsclient'], | |
| }, | |
| { editor: 'micro', commands: ['micro'], win32Commands: ['micro'] }, | |
| ]; | |
| for (const { editor, commands, win32Commands } of testCases) { | |
| describe(`${editor}`, () => { | |
| // Non-windows tests | |
| it(`should return true if first command "${commands[0]}" exists on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock).mockReturnValue( | |
| Buffer.from(`/usr/bin/${commands[0]}`), | |
| ); | |
| expect(hasValidEditorCommand(editor)).toBe(true); | |
| expect(execSync).toHaveBeenCalledWith(`command -v ${commands[0]}`, { | |
| stdio: 'ignore', | |
| }); | |
| }); | |
| if (commands.length > 1) { | |
| it(`should return true if first command doesn't exist but second command "${commands[1]}" exists on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock) | |
| .mockImplementationOnce(() => { | |
| throw new Error(); // first command not found | |
| }) | |
| .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found | |
| expect(hasValidEditorCommand(editor)).toBe(true); | |
| expect(execSync).toHaveBeenCalledTimes(2); | |
| }); | |
| } | |
| it(`should return false if none of the commands exist on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock).mockImplementation(() => { | |
| throw new Error(); // all commands not found | |
| }); | |
| expect(hasValidEditorCommand(editor)).toBe(false); | |
| expect(execSync).toHaveBeenCalledTimes(commands.length); | |
| }); | |
| // Windows tests | |
| it(`should return true if first command "${win32Commands[0]}" exists on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock).mockReturnValue( | |
| Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`), | |
| ); | |
| expect(hasValidEditorCommand(editor)).toBe(true); | |
| expect(execSync).toHaveBeenCalledWith( | |
| `where.exe ${win32Commands[0]}`, | |
| { | |
| stdio: 'ignore', | |
| }, | |
| ); | |
| }); | |
| if (win32Commands.length > 1) { | |
| it(`should return true if first command doesn't exist but second command "${win32Commands[1]}" exists on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock) | |
| .mockImplementationOnce(() => { | |
| throw new Error(); // first command not found | |
| }) | |
| .mockReturnValueOnce( | |
| Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`), | |
| ); // second command found | |
| expect(hasValidEditorCommand(editor)).toBe(true); | |
| expect(execSync).toHaveBeenCalledTimes(2); | |
| }); | |
| } | |
| it(`should return false if none of the commands exist on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock).mockImplementation(() => { | |
| throw new Error(); // all commands not found | |
| }); | |
| expect(hasValidEditorCommand(editor)).toBe(false); | |
| expect(execSync).toHaveBeenCalledTimes(win32Commands.length); | |
| }); | |
| }); | |
| } | |
| }); | |
| describe('getDiffCommand', () => { | |
| const guiEditors: Array<{ | |
| editor: EditorType; | |
| commands: string[]; | |
| win32Commands: string[]; | |
| }> = [ | |
| { editor: 'vscode', commands: ['code'], win32Commands: ['code.cmd'] }, | |
| { | |
| editor: 'vscodium', | |
| commands: ['codium'], | |
| win32Commands: ['codium.cmd'], | |
| }, | |
| { | |
| editor: 'windsurf', | |
| commands: ['windsurf'], | |
| win32Commands: ['windsurf'], | |
| }, | |
| { editor: 'cursor', commands: ['cursor'], win32Commands: ['cursor'] }, | |
| { editor: 'zed', commands: ['zed', 'zeditor'], win32Commands: ['zed'] }, | |
| { | |
| editor: 'antigravity', | |
| commands: ['agy', 'antigravity'], | |
| win32Commands: ['agy.cmd', 'antigravity.cmd', 'antigravity'], | |
| }, | |
| { editor: 'bbedit', commands: ['bbedit'], win32Commands: ['bbedit'] }, | |
| ]; | |
| for (const { editor, commands, win32Commands } of guiEditors) { | |
| // Non-windows tests | |
| it(`should use first command "${commands[0]}" when it exists on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock).mockReturnValue( | |
| Buffer.from(`/usr/bin/${commands[0]}`), | |
| ); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: commands[0], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| if (commands.length > 1) { | |
| it(`should use second command "${commands[1]}" when first doesn't exist on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock) | |
| .mockImplementationOnce(() => { | |
| throw new Error(); // first command not found | |
| }) | |
| .mockReturnValueOnce(Buffer.from(`/usr/bin/${commands[1]}`)); // second command found | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: commands[1], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| } | |
| it(`should fall back to last command "${commands[commands.length - 1]}" when none exist on non-windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| (execSync as Mock).mockImplementation(() => { | |
| throw new Error(); // all commands not found | |
| }); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: commands[commands.length - 1], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| // Windows tests | |
| it(`should use first command "${win32Commands[0]}" when it exists on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock).mockReturnValue( | |
| Buffer.from(`C:\\Program Files\\...\\${win32Commands[0]}`), | |
| ); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: win32Commands[0], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| if (win32Commands.length > 1) { | |
| it(`should use second command "${win32Commands[1]}" when first doesn't exist on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock) | |
| .mockImplementationOnce(() => { | |
| throw new Error(); // first command not found | |
| }) | |
| .mockReturnValueOnce( | |
| Buffer.from(`C:\\Program Files\\...\\${win32Commands[1]}`), | |
| ); // second command found | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: win32Commands[1], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| } | |
| it(`should fall back to last command "${win32Commands[win32Commands.length - 1]}" when none exist on windows`, () => { | |
| Object.defineProperty(process, 'platform', { value: 'win32' }); | |
| (execSync as Mock).mockImplementation(() => { | |
| throw new Error(); // all commands not found | |
| }); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command: win32Commands[win32Commands.length - 1], | |
| args: ['--wait', '--diff', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| } | |
| const terminalEditors: Array<{ | |
| editor: EditorType; | |
| command: string; | |
| }> = [ | |
| { editor: 'vim', command: 'vim' }, | |
| { editor: 'neovim', command: 'nvim' }, | |
| ]; | |
| for (const { editor, command } of terminalEditors) { | |
| it(`should return the correct command for ${editor}`, () => { | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor); | |
| expect(diffCommand).toEqual({ | |
| command, | |
| args: [ | |
| '-d', | |
| '-i', | |
| 'NONE', | |
| '-c', | |
| 'wincmd h | set readonly | wincmd l', | |
| '-c', | |
| 'highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000', | |
| '-c', | |
| 'set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)', | |
| '-c', | |
| 'wincmd h | setlocal statusline=OLD\\ FILE', | |
| '-c', | |
| 'wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)', | |
| '-c', | |
| 'autocmd BufWritePost * wqa', | |
| 'old.txt', | |
| 'new.txt', | |
| ], | |
| }); | |
| }); | |
| } | |
| it('should return the correct command for emacs with escaped paths', () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| const command = getDiffCommand( | |
| 'old file "quote".txt', | |
| 'new file \\back\\slash.txt', | |
| 'emacs', | |
| ); | |
| expect(command).toEqual({ | |
| command: 'emacs', | |
| args: [ | |
| '--eval', | |
| '(ediff "old file \\"quote\\".txt" "new file \\\\back\\\\slash.txt")', | |
| ], | |
| }); | |
| }); | |
| it('should return the correct command for emacsclient', () => { | |
| const command = getDiffCommand('old.txt', 'new.txt', 'emacsclient'); | |
| expect(command).toEqual({ | |
| command: 'emacsclient', | |
| args: ['-nw', '--eval', '(ediff "old.txt" "new.txt")'], | |
| }); | |
| }); | |
| it('should return the correct command for emacsclient with escaped paths', () => { | |
| const command = getDiffCommand( | |
| 'old file "quote".txt', | |
| 'new file \\back\\slash.txt', | |
| 'emacsclient', | |
| ); | |
| expect(command).toEqual({ | |
| command: 'emacsclient', | |
| args: [ | |
| '-nw', | |
| '--eval', | |
| '(ediff "old file \\"quote\\".txt" "new file \\\\back\\\\slash.txt")', | |
| ], | |
| }); | |
| }); | |
| it('should return the correct command for helix', () => { | |
| const command = getDiffCommand('old.txt', 'new.txt', 'hx'); | |
| expect(command).toEqual({ | |
| command: 'hx', | |
| args: ['--vsplit', '--', 'old.txt', 'new.txt'], | |
| }); | |
| }); | |
| it('should return null for sublimetext (no CLI diff support)', () => { | |
| expect(getDiffCommand('old.txt', 'new.txt', 'sublimetext')).toBeNull(); | |
| }); | |
| it('should return null for lapce (no CLI diff support)', () => { | |
| expect(getDiffCommand('old.txt', 'new.txt', 'lapce')).toBeNull(); | |
| }); | |
| it('should return null for nova (no CLI diff support)', () => { | |
| expect(getDiffCommand('old.txt', 'new.txt', 'nova')).toBeNull(); | |
| }); | |
| it('should return null for micro (no CLI diff support)', () => { | |
| expect(getDiffCommand('old.txt', 'new.txt', 'micro')).toBeNull(); | |
| }); | |
| it('should return null for an unsupported editor', () => { | |
| // @ts-expect-error Testing unsupported editor | |
| const command = getDiffCommand('old.txt', 'new.txt', 'foobar'); | |
| expect(command).toBeNull(); | |
| }); | |
| }); | |
| describe('openDiff', () => { | |
| const guiEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'windsurf', | |
| 'cursor', | |
| 'zed', | |
| 'bbedit', | |
| ]; | |
| for (const editor of guiEditors) { | |
| it(`should call spawn for ${editor}`, async () => { | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'close') { | |
| cb(0); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await openDiff('old.txt', 'new.txt', editor); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor)!; | |
| expect(spawn).toHaveBeenCalledWith( | |
| diffCommand.command, | |
| diffCommand.args, | |
| { | |
| stdio: 'inherit', | |
| shell: process.platform === 'win32', | |
| }, | |
| ); | |
| expect(mockSpawnOn).toHaveBeenCalledWith('close', expect.any(Function)); | |
| expect(mockSpawnOn).toHaveBeenCalledWith('error', expect.any(Function)); | |
| }); | |
| it(`should reject if spawn for ${editor} fails`, async () => { | |
| const mockError = new Error('spawn error'); | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'error') { | |
| cb(mockError); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await expect(openDiff('old.txt', 'new.txt', editor)).rejects.toThrow( | |
| 'spawn error', | |
| ); | |
| }); | |
| it(`should resolve and log warning if ${editor} exits with non-zero code`, async () => { | |
| const warnSpy = vi | |
| .spyOn(debugLogger, 'warn') | |
| .mockImplementation(() => {}); | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'close') { | |
| cb(1); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await openDiff('old.txt', 'new.txt', editor); | |
| expect(warnSpy).toHaveBeenCalledWith(`${editor} exited with code 1`); | |
| }); | |
| it(`should emit ExternalEditorClosed when ${editor} exits successfully`, async () => { | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'close') { | |
| cb(0); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await openDiff('old.txt', 'new.txt', editor); | |
| expect(emitSpy).toHaveBeenCalledWith(CoreEvent.ExternalEditorClosed); | |
| }); | |
| it(`should emit ExternalEditorClosed when ${editor} exits with non-zero code`, async () => { | |
| vi.spyOn(debugLogger, 'warn').mockImplementation(() => {}); | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'close') { | |
| cb(1); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await openDiff('old.txt', 'new.txt', editor); | |
| expect(emitSpy).toHaveBeenCalledWith(CoreEvent.ExternalEditorClosed); | |
| }); | |
| it(`should emit ExternalEditorClosed when ${editor} spawn errors`, async () => { | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| const mockError = new Error('spawn error'); | |
| const mockSpawnOn = vi.fn((event, cb) => { | |
| if (event === 'error') { | |
| cb(mockError); | |
| } | |
| }); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| await expect(openDiff('old.txt', 'new.txt', editor)).rejects.toThrow( | |
| 'spawn error', | |
| ); | |
| expect(emitSpy).toHaveBeenCalledWith(CoreEvent.ExternalEditorClosed); | |
| }); | |
| it(`should only emit ExternalEditorClosed once when ${editor} fires both error and close`, async () => { | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| const callbacks: Record<string, (arg: unknown) => void> = {}; | |
| const mockSpawnOn = vi.fn( | |
| (event: string, cb: (arg: unknown) => void) => { | |
| callbacks[event] = cb; | |
| }, | |
| ); | |
| (spawn as Mock).mockReturnValue({ on: mockSpawnOn }); | |
| const promise = openDiff('old.txt', 'new.txt', editor); | |
| // Simulate Node.js behavior: error fires first, then close. | |
| callbacks['error'](new Error('spawn error')); | |
| callbacks['close'](1); | |
| await expect(promise).rejects.toThrow('spawn error'); | |
| const editorClosedEmissions = emitSpy.mock.calls.filter( | |
| (call) => call[0] === CoreEvent.ExternalEditorClosed, | |
| ); | |
| expect(editorClosedEmissions).toHaveLength(1); | |
| }); | |
| } | |
| // micro has no CLI diff support (getDiffCommand returns null) so is excluded here | |
| const terminalEditors: EditorType[] = [ | |
| 'vim', | |
| 'neovim', | |
| 'emacs', | |
| 'hx', | |
| 'emacsclient', | |
| ]; | |
| for (const editor of terminalEditors) { | |
| it(`should call spawnSync for ${editor}`, async () => { | |
| await openDiff('old.txt', 'new.txt', editor); | |
| const diffCommand = getDiffCommand('old.txt', 'new.txt', editor)!; | |
| expect(spawnSync).toHaveBeenCalledWith( | |
| diffCommand.command, | |
| diffCommand.args, | |
| { | |
| stdio: 'inherit', | |
| }, | |
| ); | |
| }); | |
| } | |
| it('should log an error if diff command is not available', async () => { | |
| const consoleErrorSpy = vi | |
| .spyOn(debugLogger, 'error') | |
| .mockImplementation(() => {}); | |
| // @ts-expect-error Testing unsupported editor | |
| await openDiff('old.txt', 'new.txt', 'foobar'); | |
| expect(consoleErrorSpy).toHaveBeenCalledWith( | |
| 'No diff tool available. Install a supported editor.', | |
| ); | |
| }); | |
| }); | |
| describe('allowEditorTypeInSandbox', () => { | |
| it('should allow vim in sandbox mode', () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox('vim')).toBe(true); | |
| }); | |
| it('should allow vim when not in sandbox mode', () => { | |
| expect(allowEditorTypeInSandbox('vim')).toBe(true); | |
| }); | |
| it('should allow emacs in sandbox mode', () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox('emacs')).toBe(true); | |
| }); | |
| it('should allow emacs when not in sandbox mode', () => { | |
| expect(allowEditorTypeInSandbox('emacs')).toBe(true); | |
| }); | |
| it('should allow emacsclient in sandbox mode', () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox('emacsclient')).toBe(true); | |
| }); | |
| it('should allow emacsclient when not in sandbox mode', () => { | |
| expect(allowEditorTypeInSandbox('emacsclient')).toBe(true); | |
| }); | |
| it('should allow neovim in sandbox mode', () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox('neovim')).toBe(true); | |
| }); | |
| it('should allow neovim when not in sandbox mode', () => { | |
| expect(allowEditorTypeInSandbox('neovim')).toBe(true); | |
| }); | |
| it('should allow hx in sandbox mode', () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox('hx')).toBe(true); | |
| }); | |
| it('should allow hx when not in sandbox mode', () => { | |
| expect(allowEditorTypeInSandbox('hx')).toBe(true); | |
| }); | |
| const guiEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'windsurf', | |
| 'cursor', | |
| 'zed', | |
| 'sublimetext', | |
| 'lapce', | |
| 'nova', | |
| 'bbedit', | |
| ]; | |
| for (const editor of guiEditors) { | |
| it(`should not allow ${editor} in sandbox mode`, () => { | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(allowEditorTypeInSandbox(editor)).toBe(false); | |
| }); | |
| it(`should allow ${editor} when not in sandbox mode`, () => { | |
| vi.stubEnv('SANDBOX', ''); | |
| expect(allowEditorTypeInSandbox(editor)).toBe(true); | |
| }); | |
| } | |
| }); | |
| describe('isEditorAvailable', () => { | |
| it('should return false for undefined editor', () => { | |
| expect(isEditorAvailable(undefined)).toBe(false); | |
| }); | |
| it('should return false for empty string editor', () => { | |
| expect(isEditorAvailable('')).toBe(false); | |
| }); | |
| it('should return false for invalid editor type', () => { | |
| expect(isEditorAvailable('invalid-editor')).toBe(false); | |
| }); | |
| it('should return true for vscode when installed and not in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code')); | |
| vi.stubEnv('SANDBOX', ''); | |
| expect(isEditorAvailable('vscode')).toBe(true); | |
| }); | |
| it('should return false for vscode when not installed and not in sandbox mode', () => { | |
| (execSync as Mock).mockImplementation(() => { | |
| throw new Error(); | |
| }); | |
| expect(isEditorAvailable('vscode')).toBe(false); | |
| }); | |
| it('should return false for vscode when installed and in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/code')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(isEditorAvailable('vscode')).toBe(false); | |
| }); | |
| it('should return true for vim when installed and in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/vim')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(isEditorAvailable('vim')).toBe(true); | |
| }); | |
| it('should return true for emacs when installed and in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/emacs')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(isEditorAvailable('emacs')).toBe(true); | |
| }); | |
| it('should return true for hx when installed and in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/hx')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(isEditorAvailable('hx')).toBe(true); | |
| }); | |
| it('should return true for neovim when installed and in sandbox mode', () => { | |
| (execSync as Mock).mockReturnValue(Buffer.from('/usr/bin/nvim')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(isEditorAvailable('neovim')).toBe(true); | |
| }); | |
| }); | |
| // Helper to create a mock exec that simulates async behavior | |
| const mockExecAsync = (implementation: (cmd: string) => boolean): void => { | |
| (exec as unknown as Mock).mockImplementation( | |
| ( | |
| cmd: string, | |
| callback: (error: Error | null, stdout: string, stderr: string) => void, | |
| ) => { | |
| if (implementation(cmd)) { | |
| callback(null, '/usr/bin/cmd', ''); | |
| } else { | |
| callback(new Error('Command not found'), '', ''); | |
| } | |
| }, | |
| ); | |
| }; | |
| describe('hasValidEditorCommandAsync', () => { | |
| it('should return true if vim command exists', async () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| mockExecAsync((cmd) => cmd.includes('vim')); | |
| expect(await hasValidEditorCommandAsync('vim')).toBe(true); | |
| }); | |
| it('should return false if vim command does not exist', async () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| mockExecAsync(() => false); | |
| expect(await hasValidEditorCommandAsync('vim')).toBe(false); | |
| }); | |
| it('should check zed and zeditor commands in order', async () => { | |
| Object.defineProperty(process, 'platform', { value: 'linux' }); | |
| mockExecAsync((cmd) => cmd.includes('zeditor')); | |
| expect(await hasValidEditorCommandAsync('zed')).toBe(true); | |
| }); | |
| }); | |
| describe('isEditorAvailableAsync', () => { | |
| it('should return false for undefined editor', async () => { | |
| expect(await isEditorAvailableAsync(undefined)).toBe(false); | |
| }); | |
| it('should return false for empty string editor', async () => { | |
| expect(await isEditorAvailableAsync('')).toBe(false); | |
| }); | |
| it('should return false for invalid editor type', async () => { | |
| expect(await isEditorAvailableAsync('invalid-editor')).toBe(false); | |
| }); | |
| it('should return true for vscode when installed and not in sandbox mode', async () => { | |
| mockExecAsync((cmd) => cmd.includes('code')); | |
| vi.stubEnv('SANDBOX', ''); | |
| expect(await isEditorAvailableAsync('vscode')).toBe(true); | |
| }); | |
| it('should return false for vscode when not installed', async () => { | |
| mockExecAsync(() => false); | |
| expect(await isEditorAvailableAsync('vscode')).toBe(false); | |
| }); | |
| it('should return false for vscode in sandbox mode', async () => { | |
| mockExecAsync((cmd) => cmd.includes('code')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(await isEditorAvailableAsync('vscode')).toBe(false); | |
| }); | |
| it('should return true for vim in sandbox mode', async () => { | |
| mockExecAsync((cmd) => cmd.includes('vim')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| expect(await isEditorAvailableAsync('vim')).toBe(true); | |
| }); | |
| }); | |
| describe('resolveEditorAsync', () => { | |
| it('should return the preferred editor when available', async () => { | |
| mockExecAsync((cmd) => cmd.includes('vim')); | |
| vi.stubEnv('SANDBOX', ''); | |
| const result = await resolveEditorAsync('vim'); | |
| expect(result).toBe('vim'); | |
| }); | |
| it('should request editor selection when preferred editor is not installed', async () => { | |
| mockExecAsync(() => false); | |
| vi.stubEnv('SANDBOX', ''); | |
| const resolvePromise = resolveEditorAsync('vim'); | |
| setTimeout( | |
| () => coreEvents.emit(CoreEvent.EditorSelected, { editor: 'neovim' }), | |
| 0, | |
| ); | |
| const result = await resolvePromise; | |
| expect(result).toBe('neovim'); | |
| }); | |
| it('should request editor selection when preferred GUI editor cannot be used in sandbox mode', async () => { | |
| mockExecAsync((cmd) => cmd.includes('code')); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| const resolvePromise = resolveEditorAsync('vscode'); | |
| setTimeout( | |
| () => coreEvents.emit(CoreEvent.EditorSelected, { editor: 'vim' }), | |
| 0, | |
| ); | |
| const result = await resolvePromise; | |
| expect(result).toBe('vim'); | |
| }); | |
| it('should request editor selection when no preference is set', async () => { | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| vi.stubEnv('SANDBOX', ''); | |
| const resolvePromise = resolveEditorAsync(undefined); | |
| // Simulate UI selection | |
| setTimeout( | |
| () => coreEvents.emit(CoreEvent.EditorSelected, { editor: 'vim' }), | |
| 0, | |
| ); | |
| const result = await resolvePromise; | |
| expect(result).toBe('vim'); | |
| expect(emitSpy).toHaveBeenCalledWith(CoreEvent.RequestEditorSelection); | |
| }); | |
| it('should return undefined when editor selection is cancelled', async () => { | |
| const resolvePromise = resolveEditorAsync(undefined); | |
| // Simulate UI cancellation (exit dialog) | |
| setTimeout( | |
| () => coreEvents.emit(CoreEvent.EditorSelected, { editor: undefined }), | |
| 0, | |
| ); | |
| const result = await resolvePromise; | |
| expect(result).toBeUndefined(); | |
| }); | |
| it('should return undefined when abort signal is triggered', async () => { | |
| const controller = new AbortController(); | |
| const resolvePromise = resolveEditorAsync(undefined, controller.signal); | |
| setTimeout(() => controller.abort(), 0); | |
| const result = await resolvePromise; | |
| expect(result).toBeUndefined(); | |
| }); | |
| it('should request editor selection in sandbox mode when no preference is set', async () => { | |
| const emitSpy = vi.spyOn(coreEvents, 'emit'); | |
| vi.stubEnv('SANDBOX', 'sandbox'); | |
| const resolvePromise = resolveEditorAsync(undefined); | |
| // Simulate UI selection | |
| setTimeout( | |
| () => coreEvents.emit(CoreEvent.EditorSelected, { editor: 'vim' }), | |
| 0, | |
| ); | |
| const result = await resolvePromise; | |
| expect(result).toBe('vim'); | |
| expect(emitSpy).toHaveBeenCalledWith(CoreEvent.RequestEditorSelection); | |
| }); | |
| }); | |
| describe('isValidEditorType', () => { | |
| it('should return true for known editor identifiers', () => { | |
| expect(isValidEditorType('vscode')).toBe(true); | |
| expect(isValidEditorType('vim')).toBe(true); | |
| expect(isValidEditorType('sublimetext')).toBe(true); | |
| expect(isValidEditorType('emacsclient')).toBe(true); | |
| expect(isValidEditorType('micro')).toBe(true); | |
| expect(isValidEditorType('lapce')).toBe(true); | |
| expect(isValidEditorType('nova')).toBe(true); | |
| expect(isValidEditorType('bbedit')).toBe(true); | |
| }); | |
| it('should return false for unrecognized strings', () => { | |
| expect(isValidEditorType('emacsclient -nw')).toBe(false); | |
| expect(isValidEditorType('subl')).toBe(false); | |
| expect(isValidEditorType('code')).toBe(false); | |
| expect(isValidEditorType('')).toBe(false); | |
| expect(isValidEditorType('notepad')).toBe(false); | |
| }); | |
| }); | |
| describe('getEditorWaitFlag', () => { | |
| it('should return -w for sublimetext', () => { | |
| expect(getEditorWaitFlag('sublimetext')).toBe('-w'); | |
| }); | |
| it('should return --wait for all other GUI editors', () => { | |
| const standardGuiEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'windsurf', | |
| 'cursor', | |
| 'zed', | |
| 'antigravity', | |
| 'lapce', | |
| 'nova', | |
| 'bbedit', | |
| ]; | |
| for (const editor of standardGuiEditors) { | |
| expect(getEditorWaitFlag(editor)).toBe('--wait'); | |
| } | |
| }); | |
| }); | |
| describe('resolveEditorTypeFromCommand', () => { | |
| it('should resolve known command names to their editor type', () => { | |
| expect(resolveEditorTypeFromCommand('cursor')).toBe('cursor'); | |
| expect(resolveEditorTypeFromCommand('code')).toBe('vscode'); | |
| expect(resolveEditorTypeFromCommand('codium')).toBe('vscodium'); | |
| expect(resolveEditorTypeFromCommand('vim')).toBe('vim'); | |
| }); | |
| it('should be case-insensitive', () => { | |
| expect(resolveEditorTypeFromCommand('Cursor')).toBe('cursor'); | |
| expect(resolveEditorTypeFromCommand('CODE')).toBe('vscode'); | |
| }); | |
| it('should return undefined for unknown commands', () => { | |
| expect(resolveEditorTypeFromCommand('unknowntool')).toBeUndefined(); | |
| expect(resolveEditorTypeFromCommand('')).toBeUndefined(); | |
| }); | |
| }); | |
| describe('getEditorExtraArgs', () => { | |
| it('should return [-nw] for emacsclient', () => { | |
| expect(getEditorExtraArgs('emacsclient')).toEqual(['-nw']); | |
| }); | |
| it('should return [] for VS Code-family editors by default', () => { | |
| const vscodeEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'cursor', | |
| 'windsurf', | |
| ]; | |
| for (const editor of vscodeEditors) { | |
| expect(getEditorExtraArgs(editor)).toEqual([]); | |
| } | |
| }); | |
| it('should return [--new-window] for VS Code-family editors when newWindow is true', () => { | |
| const vscodeEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'cursor', | |
| 'windsurf', | |
| ]; | |
| for (const editor of vscodeEditors) { | |
| expect(getEditorExtraArgs(editor, { newWindow: true })).toEqual([ | |
| '--new-window', | |
| ]); | |
| } | |
| }); | |
| it('should return [] for VS Code-family editors when newWindow is false', () => { | |
| const vscodeEditors: EditorType[] = [ | |
| 'vscode', | |
| 'vscodium', | |
| 'cursor', | |
| 'windsurf', | |
| ]; | |
| for (const editor of vscodeEditors) { | |
| expect(getEditorExtraArgs(editor, { newWindow: false })).toEqual([]); | |
| } | |
| }); | |
| it('should return [] for all other editors', () => { | |
| const otherEditors: EditorType[] = [ | |
| 'vim', | |
| 'neovim', | |
| 'emacs', | |
| 'hx', | |
| 'sublimetext', | |
| 'micro', | |
| ]; | |
| for (const editor of otherEditors) { | |
| expect(getEditorExtraArgs(editor)).toEqual([]); | |
| } | |
| }); | |
| }); | |
| }); | |