Download packages/core/src/services/sandboxedFileSystemService.test.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 6.68 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/services/sandboxedFileSystemService.test.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/core/src/services/sandboxedFileSystemService.test.ts
-
curl -L -o sandboxedFileSystemService.test.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/services/sandboxedFileSystemService.test.ts
6.68 kB
| /** | |
| * @license | |
| * Copyright 2026 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { | |
| describe, | |
| it, | |
| expect, | |
| vi, | |
| beforeEach, | |
| afterEach, | |
| type Mock, | |
| } from 'vitest'; | |
| import { SandboxedFileSystemService } from './sandboxedFileSystemService.js'; | |
| import type { | |
| SandboxManager, | |
| SandboxRequest, | |
| SandboxedCommand, | |
| GlobalSandboxOptions, | |
| } from './sandboxManager.js'; | |
| import { spawn, type ChildProcess } from 'node:child_process'; | |
| import { EventEmitter } from 'node:events'; | |
| import type { Writable } from 'node:stream'; | |
| import path from 'node:path'; | |
| vi.mock('node:child_process', () => ({ | |
| spawn: vi.fn(), | |
| })); | |
| class MockSandboxManager implements SandboxManager { | |
| prepareCommand = vi.fn( | |
| async (req: SandboxRequest): Promise<SandboxedCommand> => ({ | |
| program: 'sandbox.exe', | |
| args: ['0', req.cwd, req.command, ...req.args], | |
| env: req.env || {}, | |
| }), | |
| ); | |
| isKnownSafeCommand(): boolean { | |
| return false; | |
| } | |
| isDangerousCommand(): boolean { | |
| return false; | |
| } | |
| parseDenials(): undefined { | |
| return undefined; | |
| } | |
| getWorkspace(): string { | |
| return path.resolve('/workspace'); | |
| } | |
| getOptions(): GlobalSandboxOptions | undefined { | |
| return { | |
| workspace: path.resolve('/workspace'), | |
| includeDirectories: [path.resolve('/test/cwd')], | |
| }; | |
| } | |
| } | |
| describe('SandboxedFileSystemService', () => { | |
| let sandboxManager: MockSandboxManager; | |
| let service: SandboxedFileSystemService; | |
| const cwd = path.resolve('/test/cwd'); | |
| beforeEach(() => { | |
| sandboxManager = new MockSandboxManager(); | |
| service = new SandboxedFileSystemService(sandboxManager, cwd); | |
| vi.clearAllMocks(); | |
| }); | |
| afterEach(() => { | |
| vi.restoreAllMocks(); | |
| }); | |
| it('should read a file through the sandbox', async () => { | |
| const mockChild = new EventEmitter() as unknown as ChildProcess; | |
| Object.assign(mockChild, { | |
| stdout: new EventEmitter(), | |
| stderr: new EventEmitter(), | |
| }); | |
| vi.mocked(spawn).mockReturnValue(mockChild); | |
| const testFile = path.resolve('/test/cwd/file.txt'); | |
| const readPromise = service.readTextFile(testFile); | |
| // Use setImmediate to ensure events are emitted after the promise starts executing | |
| setImmediate(() => { | |
| mockChild.stdout!.emit('data', Buffer.from('file content')); | |
| mockChild.emit('close', 0); | |
| }); | |
| const content = await readPromise; | |
| expect(content).toBe('file content'); | |
| expect(vi.mocked(sandboxManager.prepareCommand)).toHaveBeenCalledWith( | |
| expect.objectContaining({ | |
| command: '__read', | |
| args: [testFile], | |
| policy: { | |
| allowedPaths: [testFile], | |
| }, | |
| }), | |
| ); | |
| expect(spawn).toHaveBeenCalledWith( | |
| 'sandbox.exe', | |
| ['0', cwd, '__read', testFile], | |
| expect.any(Object), | |
| ); | |
| }); | |
| it('should write a file through the sandbox', async () => { | |
| const mockChild = new EventEmitter() as unknown as ChildProcess; | |
| const mockStdin = new EventEmitter(); | |
| Object.assign(mockStdin, { | |
| write: vi.fn(), | |
| end: vi.fn(), | |
| }); | |
| Object.assign(mockChild, { | |
| stdin: mockStdin as unknown as Writable, | |
| stderr: new EventEmitter(), | |
| }); | |
| vi.mocked(spawn).mockReturnValue(mockChild); | |
| const testFile = path.resolve('/test/cwd/file.txt'); | |
| const writePromise = service.writeTextFile(testFile, 'new content'); | |
| setImmediate(() => { | |
| mockChild.emit('close', 0); | |
| }); | |
| await writePromise; | |
| expect( | |
| (mockStdin as unknown as { write: Mock }).write, | |
| ).toHaveBeenCalledWith('new content'); | |
| expect((mockStdin as unknown as { end: Mock }).end).toHaveBeenCalled(); | |
| expect(vi.mocked(sandboxManager.prepareCommand)).toHaveBeenCalledWith( | |
| expect.objectContaining({ | |
| command: '__write', | |
| args: [testFile], | |
| policy: { | |
| allowedPaths: [testFile], | |
| additionalPermissions: { | |
| fileSystem: { | |
| write: [testFile], | |
| }, | |
| }, | |
| }, | |
| }), | |
| ); | |
| expect(spawn).toHaveBeenCalledWith( | |
| 'sandbox.exe', | |
| ['0', cwd, '__write', testFile], | |
| expect.any(Object), | |
| ); | |
| }); | |
| it('should reject if sandbox command fails', async () => { | |
| const mockChild = new EventEmitter() as unknown as ChildProcess; | |
| Object.assign(mockChild, { | |
| stdout: new EventEmitter(), | |
| stderr: new EventEmitter(), | |
| }); | |
| vi.mocked(spawn).mockReturnValue(mockChild); | |
| const testFile = path.resolve('/test/cwd/file.txt'); | |
| const readPromise = service.readTextFile(testFile); | |
| setImmediate(() => { | |
| mockChild.stderr!.emit('data', Buffer.from('access denied')); | |
| mockChild.emit('close', 1); | |
| }); | |
| await expect(readPromise).rejects.toThrow( | |
| `Sandbox Error: read_file failed for '${testFile}'. Exit code 1. Details: access denied`, | |
| ); | |
| }); | |
| it('should set ENOENT code when file does not exist', async () => { | |
| const mockChild = new EventEmitter() as unknown as ChildProcess; | |
| Object.assign(mockChild, { | |
| stdout: new EventEmitter(), | |
| stderr: new EventEmitter(), | |
| }); | |
| vi.mocked(spawn).mockReturnValue(mockChild); | |
| const testFile = path.resolve('/test/cwd/missing.txt'); | |
| const readPromise = service.readTextFile(testFile); | |
| setImmediate(() => { | |
| mockChild.stderr!.emit('data', Buffer.from('No such file or directory')); | |
| mockChild.emit('close', 1); | |
| }); | |
| try { | |
| await readPromise; | |
| expect.fail('Should have rejected'); | |
| } catch (err: unknown) { | |
| // @ts-expect-error - Checking message and code on unknown error | |
| expect(err.message).toContain('No such file or directory'); | |
| // @ts-expect-error - Checking message and code on unknown error | |
| expect(err.code).toBe('ENOENT'); | |
| } | |
| }); | |
| it('should set ENOENT code when file does not exist on Windows', async () => { | |
| const mockChild = new EventEmitter() as unknown as ChildProcess; | |
| Object.assign(mockChild, { | |
| stdout: new EventEmitter(), | |
| stderr: new EventEmitter(), | |
| }); | |
| vi.mocked(spawn).mockReturnValue(mockChild); | |
| const testFile = path.resolve('/test/cwd/missing.txt'); | |
| const readPromise = service.readTextFile(testFile); | |
| setImmediate(() => { | |
| mockChild.stderr!.emit( | |
| 'data', | |
| Buffer.from('Could not find a part of the path'), | |
| ); | |
| mockChild.emit('close', 1); | |
| }); | |
| try { | |
| await readPromise; | |
| expect.fail('Should have rejected'); | |
| } catch (err: unknown) { | |
| const error = err as { message: string; code?: string }; | |
| expect(error.message).toContain('Could not find a part of the path'); | |
| expect(error.code).toBe('ENOENT'); | |
| } | |
| }); | |
| }); | |