@dpesch/mantisbt-mcp-server 1.10.3 → 1.10.6

package/tests/tools/config.test.ts

@@ -1,212 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-type EnumEntry = { id: number; name: string; label?: string; canonical_name?: string };
-type EnumResult = Record<string, Array<EnumEntry>>;
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { MantisClient } from '../../src/client.js';
-import { MetadataCache } from '../../src/cache.js';
-import { registerConfigTools } from '../../src/tools/config.js';
-import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const fixturesDir = join(__dirname, '..', 'fixtures');
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const enumFixture = JSON.parse(
-  readFileSync(join(fixturesDir, 'get_issue_enums.json'), 'utf-8')
-) as { configs: Array<{ option: string; value: Array<{ id: number; name: string; label: string }> }> };
-
-// Legacy: some MantisBT versions return value as a comma-separated "id:name" string
-const ENUM_FIXTURE_STRING = {
-  configs: [
-    { option: 'severity_enum_string',        value: '10:feature,50:minor,80:block' },
-    { option: 'status_enum_string',          value: '10:new,80:resolved,90:closed' },
-    { option: 'priority_enum_string',        value: '10:none,30:normal,60:immediate' },
-    { option: 'resolution_enum_string',      value: '10:open,20:fixed' },
-    { option: 'reproducibility_enum_string', value: '10:always,70:have not tried' },
-  ],
-};
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-let mockServer: MockMcpServer;
-let client: MantisClient;
-let cache: MetadataCache;
-
-beforeEach(() => {
-  mockServer = new MockMcpServer();
-  client = new MantisClient('https://mantis.example.com', 'test-token');
-  cache = new MetadataCache('/tmp/cache-test', 86400);
-  registerConfigTools(mockServer as never, client, cache);
-  vi.stubGlobal('fetch', vi.fn());
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-// ---------------------------------------------------------------------------
-// get_issue_enums
-// ---------------------------------------------------------------------------
-
-describe('get_issue_enums', () => {
-  it('ist registriert', () => {
-    expect(mockServer.hasToolRegistered('get_issue_enums')).toBe(true);
-  });
-
-  describe('mit Array-Format (MantisBT 2.x)', () => {
-    let parsed: EnumResult;
-
-    beforeEach(async () => {
-      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
-      const result = await mockServer.callTool('get_issue_enums', {});
-      parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-    });
-
-    it('gibt strukturierte Enum-Arrays für alle 5 Felder zurück', () => {
-      expect(Array.isArray(parsed.severity)).toBe(true);
-      expect(Array.isArray(parsed.status)).toBe(true);
-      expect(Array.isArray(parsed.priority)).toBe(true);
-      expect(Array.isArray(parsed.resolution)).toBe(true);
-      expect(Array.isArray(parsed.reproducibility)).toBe(true);
-    });
-
-    it('id und name korrekt für alle Felder', () => {
-      expect(parsed.severity).toContainEqual(expect.objectContaining({ id: 50, name: 'kleinerer Fehler' }));
-      expect(parsed.severity).toContainEqual(expect.objectContaining({ id: 80, name: 'Blocker' }));
-      expect(parsed.severity).toContainEqual(expect.objectContaining({ id: 200, name: 'Technische Schuld' }));
-      expect(parsed.status).toContainEqual(expect.objectContaining({ id: 10, name: 'new' }));
-      expect(parsed.status).toContainEqual(expect.objectContaining({ id: 80, name: 'resolved' }));
-      expect(parsed.priority).toContainEqual(expect.objectContaining({ id: 30, name: 'normal' }));
-      expect(parsed.reproducibility).toContainEqual(expect.objectContaining({ id: 70, name: 'have not tried' }));
-    });
-
-    it('label wird ausgegeben wenn er sich von name unterscheidet (lokalisierte Installation)', () => {
-      // status: name="new", label="neu" → label muss im Output enthalten sein
-      expect(parsed.status).toContainEqual({ id: 10, name: 'new', label: 'neu' });
-      expect(parsed.status).toContainEqual({ id: 80, name: 'resolved', label: 'erledigt' });
-      // priority: name="none", label="keine" → label muss im Output enthalten sein
-      expect(parsed.priority).toContainEqual({ id: 10, name: 'none', label: 'keine' });
-      // reproducibility: name="always", label="immer" → label muss im Output enthalten sein
-      expect(parsed.reproducibility).toContainEqual({ id: 10, name: 'always', label: 'immer' });
-    });
-
-    it('label wird weggelassen wenn er identisch mit name ist', () => {
-      // severity: name === label (z.B. "Feature-Wunsch" === "Feature-Wunsch") → kein label-Feld
-      // canonical_name is present because "Feature-Wunsch" differs from English "feature"
-      const severityFirst = parsed.severity.find(e => e.id === 10)!;
-      expect(severityFirst).toMatchObject({ id: 10, name: 'Feature-Wunsch', canonical_name: 'feature' });
-      expect(severityFirst).not.toHaveProperty('label');
-
-      // priority: name="normal", label="normal" → kein label-Feld
-      const priorityNormal = parsed.priority.find(e => e.id === 30)!;
-      expect(priorityNormal).toEqual({ id: 30, name: 'normal' });
-      expect(priorityNormal).not.toHaveProperty('label');
-    });
-
-    it('fragt alle 5 Enum-Optionen ab', () => {
-      const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-      expect(calledUrl).toContain('severity_enum_string');
-      expect(calledUrl).toContain('status_enum_string');
-      expect(calledUrl).toContain('priority_enum_string');
-      expect(calledUrl).toContain('resolution_enum_string');
-      expect(calledUrl).toContain('reproducibility_enum_string');
-    });
-  });
-
-  it('parst String-Format (Legacy): "id:name,..."-Strings korrekt', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE_STRING)));
-
-    const result = await mockServer.callTool('get_issue_enums', {});
-
-    const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-
-    expect(parsed.severity).toContainEqual({ id: 50, name: 'minor' });
-    expect(parsed.status).toContainEqual({ id: 80, name: 'resolved' });
-    expect(parsed.reproducibility).toContainEqual({ id: 70, name: 'have not tried' });
-  });
-
-  describe('canonical_name für lokalisierte Installationen', () => {
-    it('fügt canonical_name hinzu wenn name von englischem Standardwert abweicht', async () => {
-      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
-      const result = await mockServer.callTool('get_issue_enums', {});
-      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-
-      // severity: names are German in fixture → canonical_name must be present
-      const minor = parsed.severity.find(e => e.id === 50)!;
-      expect(minor.name).toBe('kleinerer Fehler');
-      expect(minor.canonical_name).toBe('minor');
-
-      const block = parsed.severity.find(e => e.id === 80)!;
-      expect(block.name).toBe('Blocker');
-      expect(block.canonical_name).toBe('block');
-    });
-
-    it('lässt canonical_name weg wenn name bereits englischer Standardwert ist', async () => {
-      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
-      const result = await mockServer.callTool('get_issue_enums', {});
-      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-
-      // status: names are already English → no canonical_name
-      const statusNew = parsed.status.find(e => e.id === 10)!;
-      expect(statusNew.name).toBe('new');
-      expect(statusNew).not.toHaveProperty('canonical_name');
-
-      // priority: "normal" is already the canonical name
-      const priorityNormal = parsed.priority.find(e => e.id === 30)!;
-      expect(priorityNormal.name).toBe('normal');
-      expect(priorityNormal).not.toHaveProperty('canonical_name');
-    });
-
-    it('lässt canonical_name weg für unbekannte/benutzerdefinierte IDs', async () => {
-      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
-      const result = await mockServer.callTool('get_issue_enums', {});
-      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-
-      // severity ID 200 ("Technische Schuld") is a custom entry with no canonical mapping
-      const custom = parsed.severity.find(e => e.id === 200)!;
-      expect(custom).toBeDefined();
-      expect(custom).not.toHaveProperty('canonical_name');
-    });
-
-    it('fügt canonical_name auch im String-Format (Legacy) hinzu', async () => {
-      // Override: use German names in legacy string format
-      const germanStringFixture = {
-        configs: [
-          { option: 'severity_enum_string', value: '50:kleinerer Fehler,80:Blocker' },
-          { option: 'status_enum_string',   value: '10:new,80:resolved' },
-          { option: 'priority_enum_string', value: '30:normal' },
-          { option: 'resolution_enum_string', value: '20:fixed' },
-          { option: 'reproducibility_enum_string', value: '10:always' },
-        ],
-      };
-      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(germanStringFixture)));
-      const result = await mockServer.callTool('get_issue_enums', {});
-      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
-
-      const minor = parsed.severity.find(e => e.id === 50)!;
-      expect(minor.canonical_name).toBe('minor');
-
-      // status "new" is already canonical — no canonical_name
-      const statusNew = parsed.status.find(e => e.id === 10)!;
-      expect(statusNew).not.toHaveProperty('canonical_name');
-    });
-  });
-
-  it('gibt isError: true bei API-Fehler zurück', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(403, JSON.stringify({ message: 'Access denied' })));
-
-    const result = await mockServer.callTool('get_issue_enums', {});
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Error:');
-  });
-});

package/tests/tools/files.test.ts

@@ -1,343 +0,0 @@
-import path from 'node:path';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { MantisClient } from '../../src/client.js';
-import { registerFileTools } from '../../src/tools/files.js';
-import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
-
-vi.mock('node:fs/promises', () => ({
-  readFile: vi.fn(),
-}));
-
-// Import after mock so the mock is in place
-import { readFile } from 'node:fs/promises';
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-let mockServer: MockMcpServer;
-let client: MantisClient;
-
-beforeEach(() => {
-  mockServer = new MockMcpServer();
-  client = new MantisClient('https://mantis.example.com', 'test-token');
-  registerFileTools(mockServer as never, client, undefined);
-  vi.stubGlobal('fetch', vi.fn());
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.clearAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// list_issue_files
-// ---------------------------------------------------------------------------
-
-describe('list_issue_files', () => {
-  it('is registered', () => {
-    expect(mockServer.hasToolRegistered('list_issue_files')).toBe(true);
-  });
-
-  it('returns an attachment array', async () => {
-    const apiResponse = {
-      issues: [{
-        id: 42,
-        attachments: [
-          { id: 1, file_name: 'screenshot.png', size: 12345, content_type: 'image/png' },
-        ],
-      }],
-    };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(apiResponse)));
-
-    const result = await mockServer.callTool('list_issue_files', { issue_id: 42 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as Array<{ file_name: string }>;
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed[0]!.file_name).toBe('screenshot.png');
-  });
-
-  it('returns an empty array when there are no attachments', async () => {
-    const apiResponse = { issues: [{ id: 42 }] };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(apiResponse)));
-
-    const result = await mockServer.callTool('list_issue_files', { issue_id: 42 });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as unknown[];
-    expect(parsed).toEqual([]);
-  });
-
-  it('calls the correct endpoint', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ issues: [{ id: 42 }] })));
-
-    await mockServer.callTool('list_issue_files', { issue_id: 42 });
-
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    expect(calledUrl).toContain('issues/42');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// upload_file – file_path mode
-// ---------------------------------------------------------------------------
-
-describe('upload_file', () => {
-  it('is registered', () => {
-    expect(mockServer.hasToolRegistered('upload_file')).toBe(true);
-  });
-
-  it('reads the file and posts to the correct endpoint', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('file content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5, file_name: 'report.pdf' })));
-
-    await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/report.pdf' });
-
-    expect(readFile).toHaveBeenCalledWith('/tmp/report.pdf');
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    expect(calledUrl).toContain('issues/42/files');
-  });
-
-  it('sends a POST request with a JSON body', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/test.txt' });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    expect(options.method).toBe('POST');
-    const body = JSON.parse(options.body as string) as { files: Array<{ name: string; type: string; content: string }> };
-    expect(Array.isArray(body.files)).toBe(true);
-    expect(body.files[0]!.name).toBe('test.txt');
-  });
-
-  it('sets Content-Type header to application/json', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/test.txt' });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    const headers = options.headers as Record<string, string>;
-    expect(headers['Content-Type']).toBe('application/json');
-  });
-
-  it('includes description in JSON body when provided', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/test.txt', description: 'My attachment' });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    const body = JSON.parse(options.body as string) as { description: string };
-    expect(body.description).toBe('My attachment');
-  });
-
-  it('returns the API response', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    const apiResponse = { id: 5, file_name: 'report.pdf', size: 7 };
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(apiResponse)));
-
-    const result = await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/report.pdf' });
-
-    expect(result.isError).toBeUndefined();
-    const parsed = JSON.parse(result.content[0]!.text) as { file_name: string };
-    expect(parsed.file_name).toBe('report.pdf');
-  });
-
-  it('returns isError when the file is not found', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error("ENOENT: no such file or directory, open '/tmp/missing.txt'") as never);
-
-    const result = await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/missing.txt' });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Error:');
-  });
-
-  it('returns isError on API error', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(403, JSON.stringify({ message: 'Forbidden' })));
-
-    const result = await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/test.txt' });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Error:');
-  });
-
-  it('overrides the filename when filename is provided', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    await mockServer.callTool('upload_file', { issue_id: 42, file_path: '/tmp/report.pdf', filename: 'custom-name.pdf' });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    const body = JSON.parse(options.body as string) as { files: Array<{ name: string }> };
-    expect(body.files[0]!.name).toBe('custom-name.pdf');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// upload_file – Base64 mode
-// ---------------------------------------------------------------------------
-
-describe('upload_file (Base64)', () => {
-  it('decodes Base64 content and uploads it', async () => {
-    const originalContent = 'Hello, World!';
-    const base64Content = Buffer.from(originalContent).toString('base64');
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 7, file_name: 'hello.txt' })));
-
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      content: base64Content,
-      filename: 'hello.txt',
-    });
-
-    expect(result.isError).toBeUndefined();
-    expect(readFile).not.toHaveBeenCalled();
-    const calledUrl = vi.mocked(fetch).mock.calls[0]![0] as string;
-    expect(calledUrl).toContain('issues/42/files');
-  });
-
-  it('uses the provided filename', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 7 })));
-
-    await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      content: Buffer.from('data').toString('base64'),
-      filename: 'export.csv',
-    });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    const body = JSON.parse(options.body as string) as { files: Array<{ name: string }> };
-    expect(body.files[0]!.name).toBe('export.csv');
-  });
-
-  it('sets the content_type when provided', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 7 })));
-
-    await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      content: Buffer.from('data').toString('base64'),
-      filename: 'image.png',
-      content_type: 'image/png',
-    });
-
-    const options = vi.mocked(fetch).mock.calls[0]![1] as RequestInit;
-    const body = JSON.parse(options.body as string) as { files: Array<{ type: string }> };
-    expect(body.files[0]!.type).toBe('image/png');
-  });
-
-  it('returns isError when neither file_path nor content is provided', async () => {
-    const result = await mockServer.callTool('upload_file', { issue_id: 42 });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Either file_path or content');
-  });
-
-  it('returns isError when both file_path and content are provided', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('x') as never);
-
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      file_path: '/tmp/test.txt',
-      content: Buffer.from('x').toString('base64'),
-      filename: 'test.txt',
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Only one of');
-  });
-
-  it('returns isError when content is provided without filename', async () => {
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      content: Buffer.from('data').toString('base64'),
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('filename is required');
-  });
-
-  it('returns isError on API error', async () => {
-    vi.mocked(fetch).mockResolvedValue(makeResponse(500, JSON.stringify({ message: 'Internal Server Error' })));
-
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      content: Buffer.from('data').toString('base64'),
-      filename: 'test.txt',
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('Error:');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// upload_file – Path Traversal protection (uploadDir)
-// ---------------------------------------------------------------------------
-
-describe('upload_file (uploadDir restriction)', () => {
-  const uploadDir = path.resolve('/tmp/uploads');
-
-  beforeEach(() => {
-    // Override the server registered in the outer beforeEach with one that
-    // has uploadDir set.
-    mockServer = new MockMcpServer();
-    client = new MantisClient('https://mantis.example.com', 'test-token');
-    registerFileTools(mockServer as never, client, uploadDir);
-    vi.stubGlobal('fetch', vi.fn());
-  });
-
-  it('allows file_path inside uploadDir', async () => {
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      file_path: path.join(uploadDir, 'report.pdf'),
-    });
-
-    expect(result.isError).toBeUndefined();
-    expect(readFile).toHaveBeenCalled();
-  });
-
-  it('blocks file_path outside uploadDir', async () => {
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      file_path: '/etc/passwd',
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('not allowed');
-    expect(readFile).not.toHaveBeenCalled();
-  });
-
-  it('blocks path traversal escaping uploadDir', async () => {
-    const result = await mockServer.callTool('upload_file', {
-      issue_id: 42,
-      file_path: path.join(uploadDir, '..', 'secret.txt'),
-    });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0]!.text).toContain('not allowed');
-    expect(readFile).not.toHaveBeenCalled();
-  });
-
-  it('allows any file_path when uploadDir is undefined (no restriction)', async () => {
-    // This uses the outer beforeEach server (uploadDir = undefined).
-    const unrestrictedServer = new MockMcpServer();
-    registerFileTools(unrestrictedServer as never, client, undefined);
-
-    vi.mocked(readFile).mockResolvedValue(Buffer.from('content') as never);
-    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
-
-    const result = await unrestrictedServer.callTool('upload_file', {
-      issue_id: 42,
-      file_path: '/etc/passwd',
-    });
-
-    expect(result.isError).toBeUndefined();
-    expect(readFile).toHaveBeenCalledWith('/etc/passwd');
-  });
-});