@office-ai/aioncli-core 0.2.3 → 0.18.4

package/dist/src/tools/write-file.test.js

@@ -4,27 +4,40 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, beforeEach, afterEach, vi, } from 'vitest';
-import { getCorrectedFileContent, WriteFileTool, } from './write-file.js';
+import { getCorrectedFileContent, WriteFileTool } from './write-file.js';
 import { ToolErrorType } from './tool-error.js';
-import { ToolConfirmationOutcome, } from './tools.js';
-import { ApprovalMode } from '../config/config.js';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
+import { ToolConfirmationOutcome } from './tools.js';
+import {} from './edit.js';
+import { ApprovalMode } from '../policy/types.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
 import { GeminiClient } from '../core/client.js';
 import { ensureCorrectEdit, ensureCorrectFileContent, } from '../utils/editCorrector.js';
-import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
 import { StandardFileSystemService } from '../services/fileSystemService.js';
+import { IdeClient } from '../ide/ide-client.js';
+import { WorkspaceContext } from '../utils/workspaceContext.js';
 const rootDir = path.resolve(os.tmpdir(), 'gemini-cli-test-root');
 // --- MOCKS ---
 vi.mock('../core/client.js');
 vi.mock('../utils/editCorrector.js');
+vi.mock('../ide/ide-client.js', () => ({
+    IdeClient: {
+        getInstance: vi.fn(),
+    },
+}));
 let mockGeminiClientInstance;
+let mockBaseLlmClientInstance;
 const mockEnsureCorrectEdit = vi.fn();
 const mockEnsureCorrectFileContent = vi.fn();
+const mockIdeClient = {
+    openDiff: vi.fn(),
+    isDiffingEnabled: vi.fn(),
+};
 // Wire up the mocked functions to be used by the actual module imports
 vi.mocked(ensureCorrectEdit).mockImplementation(mockEnsureCorrectEdit);
 vi.mocked(ensureCorrectFileContent).mockImplementation(mockEnsureCorrectFileContent);
+vi.mocked(IdeClient.getInstance).mockResolvedValue(mockIdeClient);
 // Mock Config
 const fsService = new StandardFileSystemService();
 const mockConfigInternal = {
@@ -32,16 +45,15 @@ const mockConfigInternal = {
     getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
     setApprovalMode: vi.fn(),
     getGeminiClient: vi.fn(), // Initialize as a plain mock function
+    getBaseLlmClient: vi.fn(), // Initialize as a plain mock function
     getFileSystemService: () => fsService,
-    getIdeClient: vi.fn(),
     getIdeMode: vi.fn(() => false),
-    getWorkspaceContext: () => createMockWorkspaceContext(rootDir),
+    getWorkspaceContext: () => new WorkspaceContext(rootDir),
     getApiKey: () => 'test-key',
     getModel: () => 'test-model',
     getSandbox: () => false,
     getDebugMode: () => false,
     getQuestion: () => undefined,
-    getFullContext: () => false,
     getToolDiscoveryCommand: () => undefined,
     getToolCallCommand: () => undefined,
     getMcpServerCommand: () => undefined,
@@ -55,8 +67,12 @@ const mockConfigInternal = {
         registerTool: vi.fn(),
         discoverTools: vi.fn(),
     }),
+    isInteractive: () => false,
 };
 const mockConfig = mockConfigInternal;
+vi.mock('../telemetry/loggers.js', () => ({
+    logFileOperation: vi.fn(),
+}));
 // --- END MOCKS ---
 describe('WriteFileTool', () => {
     let tool;
@@ -72,18 +88,15 @@ describe('WriteFileTool', () => {
         // Setup GeminiClient mock
         mockGeminiClientInstance = new (vi.mocked(GeminiClient))(mockConfig);
         vi.mocked(GeminiClient).mockImplementation(() => mockGeminiClientInstance);
+        // Setup BaseLlmClient mock
+        mockBaseLlmClientInstance = {
+            generateJson: vi.fn(),
+        };
         vi.mocked(ensureCorrectEdit).mockImplementation(mockEnsureCorrectEdit);
         vi.mocked(ensureCorrectFileContent).mockImplementation(mockEnsureCorrectFileContent);
-        // Now that mockGeminiClientInstance is initialized, set the mock implementation for getGeminiClient
+        // Now that mock instances are initialized, set the mock implementations for config getters
         mockConfigInternal.getGeminiClient.mockReturnValue(mockGeminiClientInstance);
-        mockConfigInternal.getIdeClient.mockReturnValue({
-            openDiff: vi.fn(),
-            closeDiff: vi.fn(),
-            getIdeContext: vi.fn(),
-            subscribeToIdeContext: vi.fn(),
-            isCodeTrackerEnabled: vi.fn(),
-            getTrackedCode: vi.fn(),
-        });
+        mockConfigInternal.getBaseLlmClient.mockReturnValue(mockBaseLlmClientInstance);
         tool = new WriteFileTool(mockConfig);
         // Reset mocks before each test
         mockConfigInternal.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
@@ -91,7 +104,7 @@ describe('WriteFileTool', () => {
         mockEnsureCorrectEdit.mockReset();
         mockEnsureCorrectFileContent.mockReset();
         // Default mock implementations that return valid structures
-        mockEnsureCorrectEdit.mockImplementation(async (filePath, _currentContent, params, _client, signal) => {
+        mockEnsureCorrectEdit.mockImplementation(async (filePath, _currentContent, params, _client, _baseClient, signal) => {
             if (signal?.aborted) {
                 return Promise.reject(new Error('Aborted'));
             }
@@ -100,8 +113,7 @@ describe('WriteFileTool', () => {
                 occurrences: 1,
             });
         });
-        mockEnsureCorrectFileContent.mockImplementation(async (content, _client, signal) => {
-            // Make AbortSignal optional
+        mockEnsureCorrectFileContent.mockImplementation(async (content, _baseClient, signal) => {
             if (signal?.aborted) {
                 return Promise.reject(new Error('Aborted'));
             }
@@ -128,9 +140,14 @@ describe('WriteFileTool', () => {
             expect(invocation).toBeDefined();
             expect(invocation.params).toEqual(params);
         });
-        it('should throw an error for a relative path', () => {
-            const params = { file_path: 'test.txt', content: 'hello' };
-            expect(() => tool.build(params)).toThrow(/File path must be absolute/);
+        it('should return an invocation for a valid relative path within root', () => {
+            const params = {
+                file_path: 'test.txt',
+                content: 'hello',
+            };
+            const invocation = tool.build(params);
+            expect(invocation).toBeDefined();
+            expect(invocation.params).toEqual(params);
         });
         it('should throw an error for a path outside root', () => {
             const outsidePath = path.resolve(tempDir, 'outside-root.txt');
@@ -177,7 +194,7 @@ describe('WriteFileTool', () => {
             // Ensure the mock is set for this specific test case if needed, or rely on beforeEach
             mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
             const result = await getCorrectedFileContent(mockConfig, filePath, proposedContent, abortSignal);
-            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockGeminiClientInstance, abortSignal);
+            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockBaseLlmClientInstance, abortSignal);
             expect(mockEnsureCorrectEdit).not.toHaveBeenCalled();
             expect(result.correctedContent).toBe(correctedContent);
             expect(result.originalContent).toBe('');
@@ -205,7 +222,7 @@ describe('WriteFileTool', () => {
                 old_string: originalContent,
                 new_string: proposedContent,
                 file_path: filePath,
-            }, mockGeminiClientInstance, abortSignal);
+            }, mockGeminiClientInstance, mockBaseLlmClientInstance, abortSignal);
             expect(mockEnsureCorrectFileContent).not.toHaveBeenCalled();
             expect(result.correctedContent).toBe(correctedProposedContent);
             expect(result.originalContent).toBe(originalContent);
@@ -254,7 +271,7 @@ describe('WriteFileTool', () => {
             const params = { file_path: filePath, content: proposedContent };
             const invocation = tool.build(params);
             const confirmation = (await invocation.shouldConfirmExecute(abortSignal));
-            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockGeminiClientInstance, abortSignal);
+            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockBaseLlmClientInstance, abortSignal);
             expect(confirmation).toEqual(expect.objectContaining({
                 title: `Confirm Write: ${path.basename(filePath)}`,
                 fileName: 'confirm_new_file.txt',
@@ -284,7 +301,7 @@ describe('WriteFileTool', () => {
                 old_string: originalContent,
                 new_string: proposedContent,
                 file_path: filePath,
-            }, mockGeminiClientInstance, abortSignal);
+            }, mockGeminiClientInstance, mockBaseLlmClientInstance, abortSignal);
             expect(confirmation).toEqual(expect.objectContaining({
                 title: `Confirm Write: ${path.basename(filePath)}`,
                 fileName: 'confirm_existing_file.txt',
@@ -292,9 +309,103 @@ describe('WriteFileTool', () => {
             }));
             expect(confirmation.fileDiff).toMatch(originalContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'));
         });
+        describe('with IDE integration', () => {
+            beforeEach(() => {
+                // Enable IDE mode and set connection status for these tests
+                mockConfigInternal.getIdeMode.mockReturnValue(true);
+                mockIdeClient.isDiffingEnabled.mockReturnValue(true);
+                mockIdeClient.openDiff.mockResolvedValue({
+                    status: 'accepted',
+                    content: 'ide-modified-content',
+                });
+            });
+            it('should call openDiff and await it when in IDE mode and connected', async () => {
+                const filePath = path.join(rootDir, 'ide_confirm_file.txt');
+                const params = { file_path: filePath, content: 'test' };
+                const invocation = tool.build(params);
+                const confirmation = (await invocation.shouldConfirmExecute(abortSignal));
+                expect(mockIdeClient.openDiff).toHaveBeenCalledWith(filePath, 'test');
+                // Ensure the promise is awaited by checking the result
+                expect(confirmation.ideConfirmation).toBeDefined();
+                await confirmation.ideConfirmation; // Should resolve
+            });
+            it('should not call openDiff if not in IDE mode', async () => {
+                mockConfigInternal.getIdeMode.mockReturnValue(false);
+                const filePath = path.join(rootDir, 'ide_disabled_file.txt');
+                const params = { file_path: filePath, content: 'test' };
+                const invocation = tool.build(params);
+                await invocation.shouldConfirmExecute(abortSignal);
+                expect(mockIdeClient.openDiff).not.toHaveBeenCalled();
+            });
+            it('should not call openDiff if IDE is not connected', async () => {
+                mockIdeClient.isDiffingEnabled.mockReturnValue(false);
+                const filePath = path.join(rootDir, 'ide_disconnected_file.txt');
+                const params = { file_path: filePath, content: 'test' };
+                const invocation = tool.build(params);
+                await invocation.shouldConfirmExecute(abortSignal);
+                expect(mockIdeClient.openDiff).not.toHaveBeenCalled();
+            });
+            it('should update params.content with IDE content when onConfirm is called', async () => {
+                const filePath = path.join(rootDir, 'ide_onconfirm_file.txt');
+                const params = { file_path: filePath, content: 'original-content' };
+                const invocation = tool.build(params);
+                // This is the key part: get the confirmation details
+                const confirmation = (await invocation.shouldConfirmExecute(abortSignal));
+                // The `onConfirm` function should exist on the details object
+                expect(confirmation.onConfirm).toBeDefined();
+                // Call `onConfirm` to trigger the logic that updates the content
+                await confirmation.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+                // Now, check if the original `params` object (captured by the invocation) was modified
+                expect(invocation.params.content).toBe('ide-modified-content');
+            });
+            it('should not await ideConfirmation promise', async () => {
+                const IDE_DIFF_DELAY_MS = 50;
+                const filePath = path.join(rootDir, 'ide_no_await_file.txt');
+                const params = { file_path: filePath, content: 'test' };
+                const invocation = tool.build(params);
+                let diffPromiseResolved = false;
+                const diffPromise = new Promise((resolve) => {
+                    setTimeout(() => {
+                        diffPromiseResolved = true;
+                        resolve({ status: 'accepted', content: 'ide-modified-content' });
+                    }, IDE_DIFF_DELAY_MS);
+                });
+                mockIdeClient.openDiff.mockReturnValue(diffPromise);
+                const confirmation = (await invocation.shouldConfirmExecute(abortSignal));
+                // This is the key check: the confirmation details should be returned
+                // *before* the diffPromise is resolved.
+                expect(diffPromiseResolved).toBe(false);
+                expect(confirmation).toBeDefined();
+                expect(confirmation.ideConfirmation).toBe(diffPromise);
+                // Now, we can await the promise to let the test finish cleanly.
+                await diffPromise;
+                expect(diffPromiseResolved).toBe(true);
+            });
+        });
     });
     describe('execute', () => {
         const abortSignal = new AbortController().signal;
+        async function confirmExecution(invocation, signal = abortSignal) {
+            const confirmDetails = await invocation.shouldConfirmExecute(signal);
+            if (typeof confirmDetails === 'object' &&
+                'onConfirm' in confirmDetails &&
+                confirmDetails.onConfirm) {
+                await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
+            }
+        }
+        it('should write a new file with a relative path', async () => {
+            const relativePath = 'execute_relative_new_file.txt';
+            const filePath = path.join(rootDir, relativePath);
+            const content = 'Content for relative path file.';
+            mockEnsureCorrectFileContent.mockResolvedValue(content);
+            const params = { file_path: relativePath, content };
+            const invocation = tool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toMatch(/Successfully created and wrote to new file/);
+            expect(fs.existsSync(filePath)).toBe(true);
+            const writtenContent = await fsService.readTextFile(filePath);
+            expect(writtenContent).toBe(content);
+        });
         it('should return error if _getCorrectedFileContent returns an error during execute', async () => {
             const filePath = path.join(rootDir, 'execute_error_file.txt');
             const params = { file_path: filePath, content: 'test content' };
@@ -320,14 +431,9 @@ describe('WriteFileTool', () => {
             mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
             const params = { file_path: filePath, content: proposedContent };
             const invocation = tool.build(params);
-            const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
-            if (typeof confirmDetails === 'object' &&
-                'onConfirm' in confirmDetails &&
-                confirmDetails.onConfirm) {
-                await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-            }
+            await confirmExecution(invocation);
             const result = await invocation.execute(abortSignal);
-            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockGeminiClientInstance, abortSignal);
+            expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(proposedContent, mockBaseLlmClientInstance, abortSignal);
             expect(result.llmContent).toMatch(/Successfully created and wrote to new file/);
             expect(fs.existsSync(filePath)).toBe(true);
             const writtenContent = await fsService.readTextFile(filePath);
@@ -354,18 +460,13 @@ describe('WriteFileTool', () => {
             });
             const params = { file_path: filePath, content: proposedContent };
             const invocation = tool.build(params);
-            const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
-            if (typeof confirmDetails === 'object' &&
-                'onConfirm' in confirmDetails &&
-                confirmDetails.onConfirm) {
-                await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-            }
+            await confirmExecution(invocation);
             const result = await invocation.execute(abortSignal);
             expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(filePath, initialContent, {
                 old_string: initialContent,
                 new_string: proposedContent,
                 file_path: filePath,
-            }, mockGeminiClientInstance, abortSignal);
+            }, mockGeminiClientInstance, mockBaseLlmClientInstance, abortSignal);
             expect(result.llmContent).toMatch(/Successfully overwrote file/);
             const writtenContent = await fsService.readTextFile(filePath);
             expect(writtenContent).toBe(correctedProposedContent);
@@ -381,56 +482,46 @@ describe('WriteFileTool', () => {
             mockEnsureCorrectFileContent.mockResolvedValue(content); // Ensure this mock is active
             const params = { file_path: filePath, content };
             const invocation = tool.build(params);
-            // Simulate confirmation if your logic requires it before execute, or remove if not needed for this path
-            const confirmDetails = await invocation.shouldConfirmExecute(abortSignal);
-            if (typeof confirmDetails === 'object' &&
-                'onConfirm' in confirmDetails &&
-                confirmDetails.onConfirm) {
-                await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-            }
+            await confirmExecution(invocation);
             await invocation.execute(abortSignal);
             expect(fs.existsSync(dirPath)).toBe(true);
             expect(fs.statSync(dirPath).isDirectory()).toBe(true);
             expect(fs.existsSync(filePath)).toBe(true);
             expect(fs.readFileSync(filePath, 'utf8')).toBe(content);
         });
-        it('should include modification message when proposed content is modified', async () => {
-            const filePath = path.join(rootDir, 'new_file_modified.txt');
-            const content = 'New file content modified by user';
-            mockEnsureCorrectFileContent.mockResolvedValue(content);
-            const params = {
-                file_path: filePath,
-                content,
+        it.each([
+            {
                 modified_by_user: true,
-            };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).toMatch(/User modified the `content`/);
-        });
-        it('should not include modification message when proposed content is not modified', async () => {
-            const filePath = path.join(rootDir, 'new_file_unmodified.txt');
-            const content = 'New file content not modified';
-            mockEnsureCorrectFileContent.mockResolvedValue(content);
-            const params = {
-                file_path: filePath,
-                content,
+                shouldIncludeMessage: true,
+                testCase: 'when modified_by_user is true',
+            },
+            {
                 modified_by_user: false,
-            };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).not.toMatch(/User modified the `content`/);
-        });
-        it('should not include modification message when modified_by_user is not provided', async () => {
-            const filePath = path.join(rootDir, 'new_file_unmodified.txt');
-            const content = 'New file content not modified';
+                shouldIncludeMessage: false,
+                testCase: 'when modified_by_user is false',
+            },
+            {
+                modified_by_user: undefined,
+                shouldIncludeMessage: false,
+                testCase: 'when modified_by_user is not provided',
+            },
+        ])('should $testCase include modification message', async ({ modified_by_user, shouldIncludeMessage }) => {
+            const filePath = path.join(rootDir, `new_file_${modified_by_user}.txt`);
+            const content = 'New file content';
             mockEnsureCorrectFileContent.mockResolvedValue(content);
             const params = {
                 file_path: filePath,
                 content,
+                ...(modified_by_user !== undefined && { modified_by_user }),
             };
             const invocation = tool.build(params);
             const result = await invocation.execute(abortSignal);
-            expect(result.llmContent).not.toMatch(/User modified the `content`/);
+            if (shouldIncludeMessage) {
+                expect(result.llmContent).toMatch(/User modified the `content`/);
+            }
+            else {
+                expect(result.llmContent).not.toMatch(/User modified the `content`/);
+            }
         });
     });
     describe('workspace boundary validation', () => {
@@ -451,76 +542,76 @@ describe('WriteFileTool', () => {
     });
     describe('specific error types for write failures', () => {
         const abortSignal = new AbortController().signal;
-        it('should return PERMISSION_DENIED error when write fails with EACCES', async () => {
-            const filePath = path.join(rootDir, 'permission_denied_file.txt');
+        it.each([
+            {
+                errorCode: 'EACCES',
+                errorType: ToolErrorType.PERMISSION_DENIED,
+                errorMessage: 'Permission denied',
+                expectedMessagePrefix: 'Permission denied writing to file',
+                mockFsExistsSync: false,
+                restoreAllMocks: false,
+            },
+            {
+                errorCode: 'ENOSPC',
+                errorType: ToolErrorType.NO_SPACE_LEFT,
+                errorMessage: 'No space left on device',
+                expectedMessagePrefix: 'No space left on device',
+                mockFsExistsSync: false,
+                restoreAllMocks: false,
+            },
+            {
+                errorCode: 'EISDIR',
+                errorType: ToolErrorType.TARGET_IS_DIRECTORY,
+                errorMessage: 'Is a directory',
+                expectedMessagePrefix: 'Target is a directory, not a file',
+                mockFsExistsSync: true,
+                restoreAllMocks: false,
+            },
+            {
+                errorCode: undefined,
+                errorType: ToolErrorType.FILE_WRITE_FAILURE,
+                errorMessage: 'Generic write error',
+                expectedMessagePrefix: 'Error writing to file',
+                mockFsExistsSync: false,
+                restoreAllMocks: true,
+            },
+        ])('should return $errorType error when write fails with $errorCode', async ({ errorCode, errorType, errorMessage, expectedMessagePrefix, mockFsExistsSync, restoreAllMocks, }) => {
+            const filePath = path.join(rootDir, `${errorType}_file.txt`);
             const content = 'test content';
-            // Mock FileSystemService writeTextFile to throw EACCES error
-            vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
-                const error = new Error('Permission denied');
-                error.code = 'EACCES';
-                return Promise.reject(error);
-            });
-            const params = { file_path: filePath, content };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.error?.type).toBe(ToolErrorType.PERMISSION_DENIED);
-            expect(result.llmContent).toContain(`Permission denied writing to file: ${filePath} (EACCES)`);
-            expect(result.returnDisplay).toContain(`Permission denied writing to file: ${filePath} (EACCES)`);
-        });
-        it('should return NO_SPACE_LEFT error when write fails with ENOSPC', async () => {
-            const filePath = path.join(rootDir, 'no_space_file.txt');
-            const content = 'test content';
-            // Mock FileSystemService writeTextFile to throw ENOSPC error
-            vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
-                const error = new Error('No space left on device');
-                error.code = 'ENOSPC';
-                return Promise.reject(error);
-            });
-            const params = { file_path: filePath, content };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.error?.type).toBe(ToolErrorType.NO_SPACE_LEFT);
-            expect(result.llmContent).toContain(`No space left on device: ${filePath} (ENOSPC)`);
-            expect(result.returnDisplay).toContain(`No space left on device: ${filePath} (ENOSPC)`);
-        });
-        it('should return TARGET_IS_DIRECTORY error when write fails with EISDIR', async () => {
-            const dirPath = path.join(rootDir, 'test_directory');
-            const content = 'test content';
-            // Mock fs.existsSync to return false to bypass validation
-            const originalExistsSync = fs.existsSync;
-            vi.spyOn(fs, 'existsSync').mockImplementation((path) => {
-                if (path === dirPath) {
-                    return false; // Pretend directory doesn't exist to bypass validation
+            if (restoreAllMocks) {
+                vi.restoreAllMocks();
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let existsSyncSpy;
+            try {
+                if (mockFsExistsSync) {
+                    const originalExistsSync = fs.existsSync;
+                    existsSyncSpy = vi
+                        .spyOn(fs, 'existsSync')
+                        .mockImplementation((path) => path === filePath ? false : originalExistsSync(path));
                 }
-                return originalExistsSync(path);
-            });
-            // Mock FileSystemService writeTextFile to throw EISDIR error
-            vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
-                const error = new Error('Is a directory');
-                error.code = 'EISDIR';
-                return Promise.reject(error);
-            });
-            const params = { file_path: dirPath, content };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.error?.type).toBe(ToolErrorType.TARGET_IS_DIRECTORY);
-            expect(result.llmContent).toContain(`Target is a directory, not a file: ${dirPath} (EISDIR)`);
-            expect(result.returnDisplay).toContain(`Target is a directory, not a file: ${dirPath} (EISDIR)`);
-            vi.spyOn(fs, 'existsSync').mockImplementation(originalExistsSync);
-        });
-        it('should return FILE_WRITE_FAILURE for generic write errors', async () => {
-            const filePath = path.join(rootDir, 'generic_error_file.txt');
-            const content = 'test content';
-            // Ensure fs.existsSync is not mocked for this test
-            vi.restoreAllMocks();
-            // Mock FileSystemService writeTextFile to throw generic error
-            vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => Promise.reject(new Error('Generic write error')));
-            const params = { file_path: filePath, content };
-            const invocation = tool.build(params);
-            const result = await invocation.execute(abortSignal);
-            expect(result.error?.type).toBe(ToolErrorType.FILE_WRITE_FAILURE);
-            expect(result.llmContent).toContain('Error writing to file: Generic write error');
-            expect(result.returnDisplay).toContain('Error writing to file: Generic write error');
+                vi.spyOn(fsService, 'writeTextFile').mockImplementationOnce(() => {
+                    const error = new Error(errorMessage);
+                    if (errorCode)
+                        error.code = errorCode;
+                    return Promise.reject(error);
+                });
+                const params = { file_path: filePath, content };
+                const invocation = tool.build(params);
+                const result = await invocation.execute(abortSignal);
+                expect(result.error?.type).toBe(errorType);
+                const errorSuffix = errorCode ? ` (${errorCode})` : '';
+                const expectedMessage = errorCode
+                    ? `${expectedMessagePrefix}: ${filePath}${errorSuffix}`
+                    : `${expectedMessagePrefix}: ${errorMessage}`;
+                expect(result.llmContent).toContain(expectedMessage);
+                expect(result.returnDisplay).toContain(expectedMessage);
+            }
+            finally {
+                if (existsSyncSpy) {
+                    existsSyncSpy.mockRestore();
+                }
+            }
         });
     });
 });