import { describe, it, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert/strict';
import * as fs from 'fs/promises';
import * as path from 'path';
import { exec } from 'child_process';
import { promisify } from 'util';
const execAsync = promisify(exec);
describe('mcp-smalledit', () => {
const TEST_DIR = '/tmp/mcp-smalledit-test';
const TEST_FILE = path.join(TEST_DIR, 'test.txt');
const BACKUP_FILE = `${TEST_FILE}.bak`;
beforeEach(async () => {
// Create test directory and file
await fs.mkdir(TEST_DIR, { recursive: true });
await fs.writeFile(TEST_FILE, 'Hello World\nThis is a test file\nWith multiple lines\n');
});
afterEach(async () => {
// Clean up
await fs.rm(TEST_DIR, { recursive: true, force: true });
});
describe('Tool Configuration', () => {
it('should define all expected tools', () => {
const expectedTools = [
'sed_edit',
'sed_multifile',
'awk_process',
'quick_replace',
'line_edit',
'perl_edit',
'diff_preview',
'restore_backup',
'list_backups',
'help'
];
assert.strictEqual(expectedTools.length, 10);
expectedTools.forEach(tool => {
assert.ok(tool.includes('_') || tool === 'help');
});
});
});
describe('sed_edit', () => {
it('should perform simple substitution', async () => {
const pattern = 's/World/Universe/g';
// Simulate sed edit
const { stdout } = await execAsync(`sed '${pattern}' ${TEST_FILE}`);
assert.ok(stdout.includes('Hello Universe'));
assert.ok(!stdout.includes('Hello World'));
});
it('should handle line-specific edits', async () => {
const pattern = '2s/test/TEST/';
const { stdout } = await execAsync(`sed '${pattern}' ${TEST_FILE}`);
const lines = stdout.split('\n');
assert.strictEqual(lines[1], 'This is a TEST file');
});
it('should create backup when requested', async () => {
// Write backup
await fs.copyFile(TEST_FILE, BACKUP_FILE);
// Verify backup exists
const backupExists = await fs.access(BACKUP_FILE).then(() => true).catch(() => false);
assert.ok(backupExists);
// Verify backup content matches original
const original = await fs.readFile(TEST_FILE, 'utf-8');
const backup = await fs.readFile(BACKUP_FILE, 'utf-8');
assert.strictEqual(original, backup);
});
it('should validate sed pattern syntax', () => {
const validPatterns = [
's/old/new/g',
'1,5s/foo/bar/',
'/pattern/d',
'10a\\New line',
'$d'
];
const invalidPatterns = [
's/missing/delimiter',
'invalid command',
''
];
validPatterns.forEach(pattern => {
assert.ok(pattern.length > 0);
});
invalidPatterns.forEach(pattern => {
// These patterns are invalid - they should be empty or not match sed command pattern
const isInvalid = !pattern || pattern.length === 0 || pattern === 'invalid command' || pattern === 's/missing/delimiter';
assert.ok(isInvalid);
});
});
});
describe('quick_replace', () => {
it('should replace all occurrences by default', async () => {
const content = 'foo bar foo baz foo';
await fs.writeFile(TEST_FILE, content);
// Simulate replace all
const replaced = content.replace(/foo/g, 'qux');
assert.strictEqual(replaced, 'qux bar qux baz qux');
assert.strictEqual((replaced.match(/qux/g) || []).length, 3);
});
it('should replace only first occurrence when specified', async () => {
const content = 'foo bar foo baz foo';
await fs.writeFile(TEST_FILE, content);
// Simulate replace first only
const replaced = content.replace(/foo/, 'qux');
assert.strictEqual(replaced, 'qux bar foo baz foo');
assert.strictEqual((replaced.match(/qux/g) || []).length, 1);
});
it('should handle special characters in literal replacement', () => {
const content = 'Price is $10.99';
const find = '$10.99';
const replace = '$15.99';
// Escape special regex characters
const escapedFind = find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
const result = content.replace(new RegExp(escapedFind), replace);
assert.strictEqual(result, 'Price is $15.99');
});
});
describe('line_edit', () => {
it('should edit specific line by number', async () => {
const lines = (await fs.readFile(TEST_FILE, 'utf-8')).split('\n');
// Replace line 2 (0-indexed as 1)
lines[1] = 'This is the new second line';
const result = lines.join('\n');
assert.ok(result.includes('This is the new second line'));
});
it('should delete specific line', async () => {
const lines = (await fs.readFile(TEST_FILE, 'utf-8')).split('\n').filter(l => l);
const originalCount = lines.length;
// Delete line 2
lines.splice(1, 1);
assert.strictEqual(lines.length, originalCount - 1);
assert.ok(!lines.includes('This is a test file'));
});
it('should insert line after specific line', async () => {
const lines = (await fs.readFile(TEST_FILE, 'utf-8')).split('\n').filter(l => l);
// Insert after line 1
lines.splice(1, 0, 'Inserted line');
assert.strictEqual(lines[1], 'Inserted line');
assert.strictEqual(lines[2], 'This is a test file');
});
it('should handle line ranges', () => {
const range = '10,20';
const match = range.match(/^(\d+),(\d+)$/);
assert.ok(match);
const start = parseInt(match[1]);
const end = parseInt(match[2]);
assert.strictEqual(start, 10);
assert.strictEqual(end, 20);
assert.ok(start <= end);
});
});
describe('awk_process', () => {
it('should process CSV-like data', async () => {
const csvContent = 'name,age,city\nJohn,30,NYC\nJane,25,LA\n';
await fs.writeFile(TEST_FILE, csvContent);
// Simulate AWK column extraction
const { stdout } = await execAsync(`awk -F',' '{print $1}' ${TEST_FILE}`);
const names = stdout.trim().split('\n');
assert.deepStrictEqual(names, ['name', 'John', 'Jane']);
});
it('should perform calculations', async () => {
const dataContent = '10\n20\n30\n40\n50\n';
await fs.writeFile(TEST_FILE, dataContent);
// Simulate AWK sum calculation
const { stdout } = await execAsync(`awk '{sum+=$1} END {print sum}' ${TEST_FILE}`);
const sum = parseInt(stdout.trim());
assert.strictEqual(sum, 150);
});
it('should filter based on conditions', async () => {
const dataContent = '1\n5\n10\n15\n20\n';
await fs.writeFile(TEST_FILE, dataContent);
// Simulate AWK filtering (values > 10)
const { stdout } = await execAsync(`awk '$1 > 10' ${TEST_FILE}`);
const filtered = stdout.trim().split('\n').map(Number);
assert.deepStrictEqual(filtered, [15, 20]);
});
});
describe('perl_edit', () => {
it('should handle multi-line replacements', () => {
const content = 'start\nmiddle\nend';
const pattern = 's/start.*end/replaced/s';
// Perl's /s flag makes . match newlines
// This would replace entire content in multiline mode
assert.ok(pattern.includes('/s'));
});
it('should support advanced regex features', () => {
const patterns = [
's/(?<=prefix)text/newtext/g', // Positive lookbehind
's/text(?=suffix)/newtext/g', // Positive lookahead
's/(\\w+)\\s+\\1/$1/g', // Backreferences
's/\\bword\\b/WORD/g' // Word boundaries
];
patterns.forEach(pattern => {
assert.ok(pattern.match(/s\/.*\/.*\//));
});
});
});
describe('Backup Management', () => {
it('should create timestamped backups', async () => {
const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
const backupName = `${TEST_FILE}.${timestamp}.bak`;
// Create backup
await fs.copyFile(TEST_FILE, backupName);
// Verify backup exists
const exists = await fs.access(backupName).then(() => true).catch(() => false);
assert.ok(exists);
// Clean up
await fs.unlink(backupName);
});
it('should list backups in directory', async () => {
// Create multiple backups
await fs.copyFile(TEST_FILE, `${TEST_FILE}.bak`);
await fs.copyFile(TEST_FILE, `${TEST_FILE}.bak1`);
await fs.copyFile(TEST_FILE, `${TEST_FILE}.backup`);
const files = await fs.readdir(TEST_DIR);
const backups = files.filter(f => f.includes('.bak'));
assert.strictEqual(backups.length, 2);
assert.ok(backups.includes('test.txt.bak'));
assert.ok(backups.includes('test.txt.bak1'));
});
it('should restore from backup', async () => {
const originalContent = await fs.readFile(TEST_FILE, 'utf-8');
// Create backup
await fs.copyFile(TEST_FILE, BACKUP_FILE);
// Modify original
await fs.writeFile(TEST_FILE, 'Modified content');
// Restore from backup
await fs.copyFile(BACKUP_FILE, TEST_FILE);
const restoredContent = await fs.readFile(TEST_FILE, 'utf-8');
assert.strictEqual(restoredContent, originalContent);
});
});
describe('Error Handling', () => {
it('should handle non-existent files', async () => {
const fakePath = path.join(TEST_DIR, 'non-existent.txt');
try {
await fs.readFile(fakePath);
assert.fail('Should throw error for non-existent file');
} catch (error) {
assert.ok(error);
}
});
it('should handle invalid patterns', () => {
const invalidPatterns = [
's/unclosed',
'\\invalid escape',
null,
undefined,
''
];
invalidPatterns.forEach(pattern => {
// Check that these are indeed invalid patterns
const isInvalid = pattern === null ||
pattern === undefined ||
pattern === '' ||
(typeof pattern === 'string' && (pattern.includes('unclosed') || pattern.includes('invalid')));
assert.ok(isInvalid);
});
});
it('should handle permission errors gracefully', async () => {
// This test would need actual permission manipulation
// For now, we just verify the error handling structure
const handleError = (error: any) => {
if (error.code === 'EACCES') {
return 'Permission denied';
}
return 'Unknown error';
};
const mockError = { code: 'EACCES' };
assert.strictEqual(handleError(mockError), 'Permission denied');
});
});
});
