@dpesch/mantisbt-mcp-server 1.5.8 → 1.6.0

package/tests/helpers/mock-server.ts

@@ -24,9 +24,33 @@ interface ToolDefinition {
   [key: string]: unknown;
 }
 
+export interface PromptMessage {
+  role: string;
+  content: { type: string; text: string };
+}
+
+export interface PromptResult {
+  messages: PromptMessage[];
+}
+
+export interface ResourceResult {
+  contents: Array<{ uri: string; mimeType?: string; text: string }>;
+}
+
+type PromptHandler = (args: Record<string, unknown>) => PromptResult;
+
+type ResourceHandler = (uri: URL) => Promise<ResourceResult>;
+
+interface PromptDefinition {
+  argsSchema?: Record<string, z.ZodTypeAny>;
+  [key: string]: unknown;
+}
+
 export class MockMcpServer {
   private readonly handlers = new Map<string, ToolHandler>();
   private readonly schemas = new Map<string, z.ZodTypeAny>();
+  private readonly promptHandlers = new Map<string, PromptHandler>();
+  private readonly resourceHandlers = new Map<string, ResourceHandler>();
 
   // Nachahmt McpServer.registerTool – fängt Handler und Schema ein
   registerTool(name: string, definition: ToolDefinition, handler: ToolHandler): void {
@@ -36,6 +60,11 @@ export class MockMcpServer {
     }
   }
 
+  // Nachahmt McpServer.registerPrompt
+  registerPrompt(name: string, _definition: PromptDefinition, handler: PromptHandler): void {
+    this.promptHandlers.set(name, handler);
+  }
+
   /**
    * Ruft den Handler auf. Wenn `validate: true`, wird der Input zuerst
    * durch das Zod-Schema geparst (wie der echte MCP-Server es tut).
@@ -66,11 +95,43 @@ export class MockMcpServer {
     return handler(args);
   }
 
+  callPrompt(name: string, args: Record<string, unknown> = {}): PromptResult {
+    const handler = this.promptHandlers.get(name);
+    if (!handler) throw new Error(`Prompt not registered: ${name}`);
+    return handler(args);
+  }
+
   hasToolRegistered(name: string): boolean {
     return this.handlers.has(name);
   }
 
+  hasPromptRegistered(name: string): boolean {
+    return this.promptHandlers.has(name);
+  }
+
   registeredToolNames(): string[] {
     return [...this.handlers.keys()];
   }
+
+  registeredPromptNames(): string[] {
+    return [...this.promptHandlers.keys()];
+  }
+
+  registerResource(name: string, uri: string, _config: unknown, handler: ResourceHandler): void {
+    this.resourceHandlers.set(uri, handler);
+  }
+
+  async callResource(uri: string): Promise<ResourceResult> {
+    const handler = this.resourceHandlers.get(uri);
+    if (!handler) throw new Error(`Resource not registered: ${uri}`);
+    return handler(new URL(uri));
+  }
+
+  hasResourceRegistered(uri: string): boolean {
+    return this.resourceHandlers.has(uri);
+  }
+
+  registeredResourceUris(): string[] {
+    return [...this.resourceHandlers.keys()];
+  }
 }

package/tests/prompts/prompts.test.ts

@@ -0,0 +1,242 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { registerPrompts } from '../../src/prompts/index.js';
+import { MockMcpServer } from '../helpers/mock-server.js';
+
+let mockServer: MockMcpServer;
+
+beforeEach(() => {
+  mockServer = new MockMcpServer();
+  registerPrompts(mockServer as never);
+});
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+describe('prompt registration', () => {
+  it('registers create-bug-report', () => {
+    expect(mockServer.hasPromptRegistered('create-bug-report')).toBe(true);
+  });
+
+  it('registers create-feature-request', () => {
+    expect(mockServer.hasPromptRegistered('create-feature-request')).toBe(true);
+  });
+
+  it('registers summarize-issue', () => {
+    expect(mockServer.hasPromptRegistered('summarize-issue')).toBe(true);
+  });
+
+  it('registers project-status', () => {
+    expect(mockServer.hasPromptRegistered('project-status')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-bug-report
+// ---------------------------------------------------------------------------
+
+describe('create-bug-report', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Login fails',
+      description: 'Cannot log in after password reset',
+    });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+    expect(result.messages[0]!.content.type).toBe('text');
+  });
+
+  it('includes project_id, category, summary, and description in the text', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 7,
+      category: 'Authentication',
+      summary: 'Session expires too early',
+      description: 'Session is invalidated after 5 minutes of inactivity',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('project 7');
+    expect(text).toContain('Authentication');
+    expect(text).toContain('Session expires too early');
+    expect(text).toContain('Session is invalidated after 5 minutes');
+  });
+
+  it('includes optional steps_to_reproduce when provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+      steps_to_reproduce: '1. Open app\n2. Click login',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('Steps to reproduce');
+    expect(result.messages[0]!.content.text).toContain('1. Open app');
+  });
+
+  it('omits optional sections when not provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).not.toContain('Steps to reproduce');
+    expect(text).not.toContain('Expected behavior');
+    expect(text).not.toContain('Actual behavior');
+    expect(text).not.toContain('Environment');
+  });
+
+  it('includes all optional fields when provided', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'UI',
+      summary: 'Button broken',
+      description: 'Save button does nothing',
+      steps_to_reproduce: 'Click Save',
+      expected: 'Form is saved',
+      actual: 'Nothing happens',
+      environment: 'Chrome 120, Windows 11',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('Steps to reproduce');
+    expect(text).toContain('Expected behavior');
+    expect(text).toContain('Actual behavior');
+    expect(text).toContain('Environment');
+    expect(text).toContain('Chrome 120');
+  });
+
+  it('mentions create_issue tool', () => {
+    const result = mockServer.callPrompt('create-bug-report', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Bug',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('create_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// create-feature-request
+// ---------------------------------------------------------------------------
+
+describe('create-feature-request', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 2,
+      category: 'General',
+      summary: 'Dark mode',
+      description: 'Add a dark mode toggle to the UI',
+    });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes project_id, category, summary, and description', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 5,
+      category: 'UX',
+      summary: 'Export to CSV',
+      description: 'Allow exporting issue lists as CSV',
+    });
+
+    const text = result.messages[0]!.content.text;
+    expect(text).toContain('project 5');
+    expect(text).toContain('UX');
+    expect(text).toContain('Export to CSV');
+    expect(text).toContain('Allow exporting issue lists');
+  });
+
+  it('includes use_case when provided', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+      use_case: 'Needed for monthly reporting',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('Needed for monthly reporting');
+  });
+
+  it('omits use_case section when not provided', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).not.toContain('Use case');
+  });
+
+  it('mentions create_issue tool', () => {
+    const result = mockServer.callPrompt('create-feature-request', {
+      project_id: 1,
+      category: 'General',
+      summary: 'Feature',
+      description: 'Desc',
+    });
+
+    expect(result.messages[0]!.content.text).toContain('create_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// summarize-issue
+// ---------------------------------------------------------------------------
+
+describe('summarize-issue', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 42 });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes the issue ID in the text', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 1234 });
+
+    expect(result.messages[0]!.content.text).toContain('1234');
+  });
+
+  it('mentions get_issue tool', () => {
+    const result = mockServer.callPrompt('summarize-issue', { issue_id: 1 });
+
+    expect(result.messages[0]!.content.text).toContain('get_issue');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// project-status
+// ---------------------------------------------------------------------------
+
+describe('project-status', () => {
+  it('returns a single user message', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 3 });
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]!.role).toBe('user');
+  });
+
+  it('includes the project ID in the text', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 99 });
+
+    expect(result.messages[0]!.content.text).toContain('99');
+  });
+
+  it('mentions list_issues tool', () => {
+    const result = mockServer.callPrompt('project-status', { project_id: 1 });
+
+    expect(result.messages[0]!.content.text).toContain('list_issues');
+  });
+});

package/tests/resources/resources.test.ts

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { MantisClient } from '../../src/client.js';
+import { MetadataCache } from '../../src/cache.js';
+import { registerResources } from '../../src/resources/index.js';
+import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
+
+// ---------------------------------------------------------------------------
+// Inline fixtures
+// ---------------------------------------------------------------------------
+
+const USER_FIXTURE = { id: 1, name: 'jsmith', real_name: 'John Smith', email: 'jsmith@example.com' };
+
+const PROJECTS_FIXTURE = [
+  { id: 10, name: 'Alpha', enabled: true },
+  { id: 11, name: 'Beta',  enabled: true },
+];
+
+const ENUM_FIXTURE = {
+  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-resources-test', 86400);
+  registerResources(mockServer as never, client, cache);
+  vi.stubGlobal('fetch', vi.fn());
+});
+
+afterEach(async () => {
+  vi.unstubAllGlobals();
+  await cache.invalidate();
+});
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+describe('resource registration', () => {
+  it('registers mantis://me', () => {
+    expect(mockServer.hasResourceRegistered('mantis://me')).toBe(true);
+  });
+
+  it('registers mantis://projects', () => {
+    expect(mockServer.hasResourceRegistered('mantis://projects')).toBe(true);
+  });
+
+  it('registers mantis://enums', () => {
+    expect(mockServer.hasResourceRegistered('mantis://enums')).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mantis://me
+// ---------------------------------------------------------------------------
+
+describe('mantis://me', () => {
+  it('returns a single content item with application/json', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://me');
+
+    expect(result.contents).toHaveLength(1);
+    expect(result.contents[0]!.mimeType).toBe('application/json');
+  });
+
+  it('sets uri to mantis://me', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://me');
+
+    expect(result.contents[0]!.uri).toBe('mantis://me');
+  });
+
+  it('returns valid JSON with id and name', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(USER_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://me');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as { id: number; name: string };
+    expect(parsed.id).toBe(USER_FIXTURE.id);
+    expect(parsed.name).toBe(USER_FIXTURE.name);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mantis://projects
+// ---------------------------------------------------------------------------
+
+describe('mantis://projects', () => {
+  it('returns a single content item with application/json', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    expect(result.contents).toHaveLength(1);
+    expect(result.contents[0]!.mimeType).toBe('application/json');
+  });
+
+  it('sets uri to mantis://projects', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    expect(result.contents[0]!.uri).toBe('mantis://projects');
+  });
+
+  it('returns a JSON array of projects from live API when cache is empty', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ projects: PROJECTS_FIXTURE })));
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as unknown[];
+    expect(Array.isArray(parsed)).toBe(true);
+    expect(parsed).toHaveLength(2);
+  });
+
+  it('serves from cache without calling the API when cache is valid', async () => {
+    await cache.save({
+      timestamp: Date.now(),
+      projects: PROJECTS_FIXTURE,
+      byProject: {},
+      tags: [],
+    });
+
+    const result = await mockServer.callResource('mantis://projects');
+
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+    const parsed = JSON.parse(result.contents[0]!.text) as unknown[];
+    expect(parsed).toHaveLength(2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mantis://enums
+// ---------------------------------------------------------------------------
+
+describe('mantis://enums', () => {
+  it('returns a single content item with application/json', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://enums');
+
+    expect(result.contents).toHaveLength(1);
+    expect(result.contents[0]!.mimeType).toBe('application/json');
+  });
+
+  it('sets uri to mantis://enums', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://enums');
+
+    expect(result.contents[0]!.uri).toBe('mantis://enums');
+  });
+
+  it('returns parsed enum groups with id and name entries', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://enums');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, Array<{ id: number; name: string }>>;
+    for (const key of ['severity', 'priority', 'status', 'resolution', 'reproducibility']) {
+      expect(Array.isArray(parsed[key])).toBe(true);
+      expect(parsed[key]!.length).toBeGreaterThan(0);
+      expect(parsed[key]![0]).toMatchObject({ id: expect.any(Number), name: expect.any(String) });
+    }
+  });
+
+  it('parses severity values correctly from fixture', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(ENUM_FIXTURE)));
+
+    const result = await mockServer.callResource('mantis://enums');
+
+    const parsed = JSON.parse(result.contents[0]!.text) as Record<string, Array<{ id: number; name: string }>>;
+    expect(parsed['severity']).toContainEqual({ id: 10, name: 'feature' });
+    expect(parsed['severity']).toContainEqual({ id: 50, name: 'minor' });
+  });
+});

package/tests/tools/issues.test.ts

@@ -112,8 +112,10 @@ describe('create_issue', () => {
     expect(mockServer.hasToolRegistered('create_issue')).toBe(true);
   });
 
-  it('sends severity: { name: "minor" } by default when no severity is provided', async () => {
+  it('sends severity as { id: 50 } (minor) by default when no severity is provided', async () => {
     // Regression: omitting severity caused MantisBT to store 0 → displayed as "@0@".
+    // The server now resolves canonical English names to IDs so MantisBT language setting
+    // does not affect how the value is stored.
     // validate: true ensures Zod defaults are applied before the handler runs.
     vi.mocked(fetch).mockResolvedValue(
       makeResponse(201, JSON.stringify({ issue: { id: 100, summary: 'Test' } }))
@@ -126,7 +128,7 @@ describe('create_issue', () => {
     }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ name: 'minor' });
+    expect(body.severity).toEqual({ id: 50 });
   });
 
   it('returns full issue object when API responds with complete issue', async () => {
@@ -137,7 +139,7 @@ describe('create_issue', () => {
 
     const result = await mockServer.callTool('create_issue', {
       summary: 'New issue', project_id: 1, category: 'General',
-    });
+    }, { validate: true });
 
     expect(result.isError).toBeUndefined();
     const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
@@ -155,7 +157,7 @@ describe('create_issue', () => {
 
     const result = await mockServer.callTool('create_issue', {
       summary: 'Created issue', project_id: 1, category: 'General',
-    });
+    }, { validate: true });
 
     expect(result.isError).toBeUndefined();
     const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
@@ -173,7 +175,7 @@ describe('create_issue', () => {
 
     const result = await mockServer.callTool('create_issue', {
       summary: 'Test', project_id: 1, category: 'General',
-    });
+    }, { validate: true });
 
     expect(result.isError).toBeUndefined();
     const parsed = JSON.parse(result.content[0]!.text) as { id: number };
@@ -193,7 +195,21 @@ describe('create_issue', () => {
     }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as Record<string, unknown>;
-    expect(body.severity).toEqual({ name: 'crash' });
+    expect(body.severity).toEqual({ id: 70 });
+  });
+
+  it('returns an error for an unknown severity name', async () => {
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Test',
+      project_id: 1,
+      category: 'General',
+      severity: 'schwerer Fehler',
+    }, { validate: true });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('schwerer Fehler');
+    expect(result.content[0]!.text).toContain('minor');
+    expect(fetch).not.toHaveBeenCalled();
   });
 });
 
@@ -213,7 +229,7 @@ describe('create_issue – handler username', () => {
 
     await server.callTool('create_issue', {
       summary: 'Test', project_id: 1, category: 'General', handler: 'dom',
-    });
+    }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
     expect(body.handler).toEqual({ id: 7 });
@@ -230,7 +246,7 @@ describe('create_issue – handler username', () => {
 
     await server.callTool('create_issue', {
       summary: 'Test', project_id: 1, category: 'General', handler: 'John Doe',
-    });
+    }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
     expect(body.handler).toEqual({ id: 9 });
@@ -247,7 +263,7 @@ describe('create_issue – handler username', () => {
 
     await server.callTool('create_issue', {
       summary: 'Test', project_id: 1, category: 'General', handler: 'alice',
-    });
+    }, { validate: true });
 
     const projectUsersCall = vi.mocked(fetch).mock.calls[0]![0] as string;
     expect(projectUsersCall).toContain('projects/1/users');
@@ -282,7 +298,7 @@ describe('create_issue – handler username', () => {
 
     await server.callTool('create_issue', {
       summary: 'Test', project_id: 1, category: 'General', handler_id: 99, handler: 'dom',
-    });
+    }, { validate: true });
 
     const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
     expect(body.handler).toEqual({ id: 99 });