@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/npm/tests/unit/edit-create-tools.test.js

@@ -0,0 +1,609 @@
+/**
+ * Tests for Edit and Create tools
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { editTool, createTool } from '../../src/tools/edit.js';
+import { promises as fs } from 'fs';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+
+describe('Edit and Create Tools', () => {
+  let testDir;
+  let testFile;
+
+  beforeEach(async () => {
+    // Create a temporary directory for testing
+    testDir = join(tmpdir(), `probe-test-${randomUUID()}`);
+    await fs.mkdir(testDir, { recursive: true });
+    testFile = join(testDir, 'test.txt');
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    if (existsSync(testDir)) {
+      await fs.rm(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('editTool', () => {
+    test('should edit a file with exact string replacement', async () => {
+      // Create a test file
+      const originalContent = 'Hello, world!\nThis is a test file.\nGoodbye!';
+      await fs.writeFile(testFile, originalContent);
+
+      // Create the edit tool
+      const edit = editTool({
+        debug: false,
+        allowedFolders: [testDir]
+      });
+
+      // Edit the file
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: 'This is a test file.',
+        new_string: 'This is an edited file.'
+      });
+
+      expect(result).toBe('Successfully edited ' + testFile + ' (1 replacement)');
+
+      // Verify the file was edited
+      const newContent = await fs.readFile(testFile, 'utf-8');
+      expect(newContent).toBe('Hello, world!\nThis is an edited file.\nGoodbye!');
+    });
+
+    test('should handle replace_all option', async () => {
+      // Create a test file with repeated content
+      const originalContent = 'foo bar foo baz foo';
+      await fs.writeFile(testFile, originalContent);
+
+      // Create the edit tool
+      const edit = editTool({
+        allowedFolders: [testDir]
+      });
+
+      // Edit with replace_all
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: 'foo',
+        new_string: 'FOO',
+        replace_all: true
+      });
+
+      expect(result).toBe('Successfully edited ' + testFile + ' (3 replacements)');
+
+      // Verify all occurrences were replaced
+      const newContent = await fs.readFile(testFile, 'utf-8');
+      expect(newContent).toBe('FOO bar FOO baz FOO');
+    });
+
+    test('should fail when old_string is not unique without replace_all', async () => {
+      // Create a test file with repeated content
+      const originalContent = 'foo bar foo baz';
+      await fs.writeFile(testFile, originalContent);
+
+      // Create the edit tool
+      const edit = editTool({
+        allowedFolders: [testDir]
+      });
+
+      // Try to edit without replace_all
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: 'foo',
+        new_string: 'FOO',
+        replace_all: false
+      });
+
+      expect(result).toContain('Error editing file: Multiple occurrences found');
+      expect(result).toContain('2 times');
+    });
+
+    test('should fail when old_string is not found', async () => {
+      // Create a test file
+      const originalContent = 'Hello, world!';
+      await fs.writeFile(testFile, originalContent);
+
+      // Create the edit tool
+      const edit = editTool({
+        allowedFolders: [testDir]
+      });
+
+      // Try to edit with non-existent string
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: 'does not exist',
+        new_string: 'replacement'
+      });
+
+      expect(result).toContain('Error editing file: String not found');
+    });
+
+    test('should fail when file does not exist', async () => {
+      // Create the edit tool
+      const edit = editTool({
+        allowedFolders: [testDir]
+      });
+
+      // Try to edit non-existent file
+      const result = await edit.execute({
+        file_path: join(testDir, 'nonexistent.txt'),
+        old_string: 'foo',
+        new_string: 'bar'
+      });
+
+      expect(result).toContain('Error editing file: File not found');
+    });
+
+    test('should respect allowed folders restriction', async () => {
+      // Create a test file
+      await fs.writeFile(testFile, 'content');
+
+      // Create the edit tool with different allowed folder
+      const edit = editTool({
+        allowedFolders: ['/some/other/path']
+      });
+
+      // Try to edit file outside allowed folders
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: 'content',
+        new_string: 'new content'
+      });
+
+      expect(result).toContain('Error editing file: Permission denied');
+    });
+
+    test('should handle whitespace in strings correctly', async () => {
+      // Create a test file with indented code
+      const originalContent = `function test() {
+  const message = "Hello";
+  console.log(message);
+}`;
+      await fs.writeFile(testFile, originalContent);
+
+      // Create the edit tool
+      const edit = editTool({
+        allowedFolders: [testDir]
+      });
+
+      // Edit with exact whitespace matching
+      const result = await edit.execute({
+        file_path: testFile,
+        old_string: '  const message = "Hello";',
+        new_string: '  const message = "Goodbye";'
+      });
+
+      expect(result).toBe('Successfully edited ' + testFile + ' (1 replacement)');
+
+      // Verify the edit
+      const newContent = await fs.readFile(testFile, 'utf-8');
+      expect(newContent).toContain('const message = "Goodbye"');
+      expect(newContent).not.toContain('const message = "Hello"');
+    });
+  });
+
+  describe('createTool', () => {
+    test('should create a new file', async () => {
+      const newFile = join(testDir, 'new.txt');
+      const content = 'This is new file content';
+
+      // Create the create tool
+      const create = createTool({
+        allowedFolders: [testDir]
+      });
+
+      // Create the file
+      const result = await create.execute({
+        file_path: newFile,
+        content: content
+      });
+
+      expect(result).toContain('Successfully created');
+      expect(result).toContain(`(${Buffer.byteLength(content)} bytes)`);
+
+      // Verify the file was created
+      expect(existsSync(newFile)).toBe(true);
+      const fileContent = await fs.readFile(newFile, 'utf-8');
+      expect(fileContent).toBe(content);
+    });
+
+    test('should create parent directories if they do not exist', async () => {
+      const newFile = join(testDir, 'nested', 'deep', 'file.txt');
+      const content = 'Nested file content';
+
+      // Create the create tool
+      const create = createTool({
+        allowedFolders: [testDir]
+      });
+
+      // Create the file
+      const result = await create.execute({
+        file_path: newFile,
+        content: content
+      });
+
+      expect(result).toContain('Successfully created');
+
+      // Verify the file and directories were created
+      expect(existsSync(newFile)).toBe(true);
+      const fileContent = await fs.readFile(newFile, 'utf-8');
+      expect(fileContent).toBe(content);
+    });
+
+    test('should fail when file exists without overwrite', async () => {
+      // Create an existing file
+      await fs.writeFile(testFile, 'existing content');
+
+      // Create the create tool
+      const create = createTool({
+        allowedFolders: [testDir]
+      });
+
+      // Try to create over existing file
+      const result = await create.execute({
+        file_path: testFile,
+        content: 'new content',
+        overwrite: false
+      });
+
+      expect(result).toContain('Error creating file: File already exists');
+
+      // Verify original content is preserved
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe('existing content');
+    });
+
+    test('should overwrite existing file when overwrite is true', async () => {
+      // Create an existing file
+      await fs.writeFile(testFile, 'existing content');
+
+      // Create the create tool
+      const create = createTool({
+        allowedFolders: [testDir]
+      });
+
+      // Create with overwrite
+      const result = await create.execute({
+        file_path: testFile,
+        content: 'overwritten content',
+        overwrite: true
+      });
+
+      expect(result).toContain('Successfully overwrote');
+
+      // Verify file was overwritten
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe('overwritten content');
+    });
+
+    test('should respect allowed folders restriction', async () => {
+      // Create the create tool with different allowed folder
+      const create = createTool({
+        allowedFolders: ['/some/other/path']
+      });
+
+      // Try to create file outside allowed folders
+      const result = await create.execute({
+        file_path: join(testDir, 'restricted.txt'),
+        content: 'content'
+      });
+
+      expect(result).toContain('Error creating file: Permission denied');
+    });
+
+    test('should handle multi-line content correctly', async () => {
+      const newFile = join(testDir, 'multiline.js');
+      const content = `// JavaScript file
+export function hello(name) {
+  console.log(\`Hello, \${name}!\`);
+  return name;
+}
+
+export default hello;`;
+
+      // Create the create tool
+      const create = createTool({
+        allowedFolders: [testDir]
+      });
+
+      // Create the file
+      const result = await create.execute({
+        file_path: newFile,
+        content: content
+      });
+
+      expect(result).toContain('Successfully created');
+
+      // Verify the content
+      const fileContent = await fs.readFile(newFile, 'utf-8');
+      expect(fileContent).toBe(content);
+      expect(fileContent.split('\n').length).toBe(7); // 7 lines
+    });
+  });
+
+  describe('Integration with relative paths', () => {
+    test('should handle relative paths with cwd', async () => {
+      // Create the edit tool with a working directory
+      const edit = editTool({
+        cwd: testDir,
+        allowedFolders: [testDir]
+      });
+
+      // Create a file
+      await fs.writeFile(testFile, 'original');
+
+      // Edit using relative path
+      const result = await edit.execute({
+        file_path: 'test.txt', // relative path
+        old_string: 'original',
+        new_string: 'modified'
+      });
+
+      expect(result).toBe('Successfully edited test.txt (1 replacement)');
+
+      // Verify the edit
+      const content = await fs.readFile(testFile, 'utf-8');
+      expect(content).toBe('modified');
+    });
+
+    test('should handle absolute paths regardless of cwd', async () => {
+      // Create the create tool with a working directory
+      const create = createTool({
+        cwd: '/some/other/path',
+        allowedFolders: [testDir]
+      });
+
+      const absolutePath = join(testDir, 'absolute.txt');
+
+      // Create using absolute path
+      const result = await create.execute({
+        file_path: absolutePath,
+        content: 'absolute path content'
+      });
+
+      expect(result).toContain('Successfully created');
+      expect(result).toContain('bytes)');
+      expect(existsSync(absolutePath)).toBe(true);
+    });
+  });
+
+  describe('Input Validation', () => {
+    describe('editTool validation', () => {
+      test('should handle invalid file_path', async () => {
+        const edit = editTool({ allowedFolders: [testDir] });
+
+        // Empty string
+        let result = await edit.execute({
+          file_path: '',
+          old_string: 'foo',
+          new_string: 'bar'
+        });
+        expect(result).toContain('Error editing file: Invalid file_path');
+
+        // Null
+        result = await edit.execute({
+          file_path: null,
+          old_string: 'foo',
+          new_string: 'bar'
+        });
+        expect(result).toContain('Error editing file: Invalid file_path');
+
+        // Whitespace only
+        result = await edit.execute({
+          file_path: '   ',
+          old_string: 'foo',
+          new_string: 'bar'
+        });
+        expect(result).toContain('Error editing file: Invalid file_path');
+      });
+
+      test('should handle invalid old_string', async () => {
+        const edit = editTool({ allowedFolders: [testDir] });
+        await fs.writeFile(testFile, 'test content');
+
+        // Undefined
+        let result = await edit.execute({
+          file_path: testFile,
+          old_string: undefined,
+          new_string: 'bar'
+        });
+        expect(result).toContain('Error editing file: Invalid old_string');
+
+        // Null
+        result = await edit.execute({
+          file_path: testFile,
+          old_string: null,
+          new_string: 'bar'
+        });
+        expect(result).toContain('Error editing file: Invalid old_string');
+      });
+
+      test('should handle invalid new_string', async () => {
+        const edit = editTool({ allowedFolders: [testDir] });
+        await fs.writeFile(testFile, 'test content');
+
+        // Undefined
+        let result = await edit.execute({
+          file_path: testFile,
+          old_string: 'test',
+          new_string: undefined
+        });
+        expect(result).toContain('Error editing file: Invalid new_string');
+
+        // Null
+        result = await edit.execute({
+          file_path: testFile,
+          old_string: 'test',
+          new_string: null
+        });
+        expect(result).toContain('Error editing file: Invalid new_string');
+      });
+
+      test('should handle empty strings in old_string and new_string', async () => {
+        const edit = editTool({ allowedFolders: [testDir] });
+        await fs.writeFile(testFile, 'test  content'); // Double space
+
+        // Empty old_string matches everywhere, so it will find multiple occurrences
+        let result = await edit.execute({
+          file_path: testFile,
+          old_string: '',
+          new_string: 'inserted'
+        });
+        // Empty string will match at every position, causing multiple occurrences error
+        expect(result).toContain('Error editing file: Multiple occurrences found');
+
+        // Empty new_string (valid - can replace with empty)
+        await fs.writeFile(testFile, 'test content');
+        result = await edit.execute({
+          file_path: testFile,
+          old_string: ' ',
+          new_string: ''
+        });
+        expect(result).toContain('Successfully edited');
+      });
+    });
+
+    describe('createTool validation', () => {
+      test('should handle invalid file_path', async () => {
+        const create = createTool({ allowedFolders: [testDir] });
+
+        // Empty string
+        let result = await create.execute({
+          file_path: '',
+          content: 'test'
+        });
+        expect(result).toContain('Error creating file: Invalid file_path');
+
+        // Null
+        result = await create.execute({
+          file_path: null,
+          content: 'test'
+        });
+        expect(result).toContain('Error creating file: Invalid file_path');
+      });
+
+      test('should handle invalid content', async () => {
+        const create = createTool({ allowedFolders: [testDir] });
+
+        // Undefined
+        let result = await create.execute({
+          file_path: join(testDir, 'test.txt'),
+          content: undefined
+        });
+        expect(result).toContain('Error creating file: Invalid content');
+
+        // Null
+        result = await create.execute({
+          file_path: join(testDir, 'test.txt'),
+          content: null
+        });
+        expect(result).toContain('Error creating file: Invalid content');
+      });
+
+      test('should handle empty content', async () => {
+        const create = createTool({ allowedFolders: [testDir] });
+
+        // Empty string content is valid (creates empty file)
+        const result = await create.execute({
+          file_path: join(testDir, 'empty.txt'),
+          content: ''
+        });
+        expect(result).toContain('Successfully created');
+        expect(result).toContain('(0 bytes)');
+
+        const content = await fs.readFile(join(testDir, 'empty.txt'), 'utf-8');
+        expect(content).toBe('');
+      });
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle very large files', async () => {
+      // Create a large file (1MB)
+      const largeContent = 'x'.repeat(1024 * 1024);
+      const largeFile = join(testDir, 'large.txt');
+      await fs.writeFile(largeFile, largeContent);
+
+      const edit = editTool({ allowedFolders: [testDir] });
+      const result = await edit.execute({
+        file_path: largeFile,
+        old_string: 'x'.repeat(100),
+        new_string: 'y'.repeat(100),
+        replace_all: true  // Need replace_all since pattern repeats many times
+      });
+
+      expect(result).toContain('Successfully edited');
+    });
+
+    test('should handle files with special characters in path', async () => {
+      const specialFile = join(testDir, 'file with spaces & special.txt');
+
+      const create = createTool({ allowedFolders: [testDir] });
+      let result = await create.execute({
+        file_path: specialFile,
+        content: 'content'
+      });
+      expect(result).toContain('Successfully created');
+
+      const edit = editTool({ allowedFolders: [testDir] });
+      result = await edit.execute({
+        file_path: specialFile,
+        old_string: 'content',
+        new_string: 'new content'
+      });
+      expect(result).toContain('Successfully edited');
+    });
+
+    test('should handle Unicode content correctly', async () => {
+      const unicodeFile = join(testDir, 'unicode.txt');
+      const unicodeContent = '你好世界 🌍 émojis ñ';
+
+      const create = createTool({ allowedFolders: [testDir] });
+      const createResult = await create.execute({
+        file_path: unicodeFile,
+        content: unicodeContent
+      });
+      expect(createResult).toContain('Successfully created');
+
+      const edit = editTool({ allowedFolders: [testDir] });
+      const editResult = await edit.execute({
+        file_path: unicodeFile,
+        old_string: '你好世界',
+        new_string: '再见世界'
+      });
+      expect(editResult).toContain('Successfully edited');
+
+      const content = await fs.readFile(unicodeFile, 'utf-8');
+      expect(content).toContain('再见世界');
+      expect(content).toContain('🌍');
+    });
+
+    test('should handle line endings correctly', async () => {
+      const lineEndingFile = join(testDir, 'lineending.txt');
+
+      // Test with different line endings
+      const windowsContent = 'line1\r\nline2\r\nline3';
+      const unixContent = 'line1\nline2\nline3';
+
+      const create = createTool({ allowedFolders: [testDir] });
+      await create.execute({
+        file_path: lineEndingFile,
+        content: windowsContent
+      });
+
+      const edit = editTool({ allowedFolders: [testDir] });
+      const result = await edit.execute({
+        file_path: lineEndingFile,
+        old_string: 'line2',
+        new_string: 'modified'
+      });
+      expect(result).toContain('Successfully edited');
+
+      const content = await fs.readFile(lineEndingFile, 'utf-8');
+      expect(content).toContain('modified');
+    });
+  });
+});