From a3557fcdf46d41399cc84183e600ffcc1a5f2c1e Mon Sep 17 00:00:00 2001 From: Niels Kaspers Date: Tue, 20 Jan 2026 23:58:05 +0100 Subject: [PATCH 1/3] Add Vitest tests for Everything Server Adds comprehensive test coverage for the Everything Server including: Tools (10 tools tested): - echo: message echoing with validation - get-sum: number addition with edge cases - get-env: environment variable retrieval - get-tiny-image: image content blocks - get-structured-content: weather data for all cities - get-annotated-message: priority/audience annotations - trigger-long-running-operation: progress notifications - get-resource-links: dynamic resource link generation - get-resource-reference: text/blob resource validation Prompts (4 prompts tested): - simple-prompt: no-argument prompt - args-prompt: city/state arguments - completable-prompt: department/name completions - resource-prompt: embedded resource references Resources: - templates.ts: URI generation, text/blob resources - session.ts: session-scoped resource registration Test infrastructure: - vitest.config.ts with v8 coverage - Mock server helper for capturing registered handlers - 81 tests, all passing Closes #2925 Co-Authored-By: Claude Opus 4.5 --- package-lock.json | 4 +- src/everything/__tests__/prompts.test.ts | 266 ++++++++++ src/everything/__tests__/resources.test.ts | 268 ++++++++++ src/everything/__tests__/tools.test.ts | 579 +++++++++++++++++++++ src/everything/package.json | 7 +- src/everything/vitest.config.ts | 14 + 6 files changed, 1135 insertions(+), 3 deletions(-) create mode 100644 src/everything/__tests__/prompts.test.ts create mode 100644 src/everything/__tests__/resources.test.ts create mode 100644 src/everything/__tests__/tools.test.ts create mode 100644 src/everything/vitest.config.ts diff --git a/package-lock.json b/package-lock.json index 36333dcead..ed839d3f32 100644 --- a/package-lock.json +++ b/package-lock.json @@ -3794,9 +3794,11 @@ "devDependencies": { "@types/cors": "^2.8.19", "@types/express": "^5.0.6", + "@vitest/coverage-v8": "^2.1.8", "prettier": "^2.8.8", "shx": "^0.3.4", - "typescript": "^5.6.2" + "typescript": "^5.6.2", + "vitest": "^2.1.8" } }, "src/filesystem": { diff --git a/src/everything/__tests__/prompts.test.ts b/src/everything/__tests__/prompts.test.ts new file mode 100644 index 0000000000..867d996eec --- /dev/null +++ b/src/everything/__tests__/prompts.test.ts @@ -0,0 +1,266 @@ +import { describe, it, expect, vi } from 'vitest'; +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; +import { registerSimplePrompt } from '../prompts/simple.js'; +import { registerArgumentsPrompt } from '../prompts/args.js'; +import { registerPromptWithCompletions } from '../prompts/completions.js'; +import { registerEmbeddedResourcePrompt } from '../prompts/resource.js'; + +// Helper to capture registered prompt handlers +function createMockServer() { + const handlers: Map = new Map(); + const configs: Map = new Map(); + + const mockServer = { + registerPrompt: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + configs.set(name, config); + }), + } as unknown as McpServer; + + return { mockServer, handlers, configs }; +} + +describe('Prompts', () => { + describe('simple-prompt', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerSimplePrompt(mockServer); + + expect(mockServer.registerPrompt).toHaveBeenCalledWith( + 'simple-prompt', + expect.objectContaining({ + title: 'Simple Prompt', + description: 'A prompt with no arguments', + }), + expect.any(Function) + ); + }); + + it('should return fixed message with no arguments', () => { + const { mockServer, handlers } = createMockServer(); + registerSimplePrompt(mockServer); + + const handler = handlers.get('simple-prompt')!; + const result = handler(); + + expect(result).toEqual({ + messages: [ + { + role: 'user', + content: { + type: 'text', + text: 'This is a simple prompt without arguments.', + }, + }, + ], + }); + }); + + it('should return message with user role', () => { + const { mockServer, handlers } = createMockServer(); + registerSimplePrompt(mockServer); + + const handler = handlers.get('simple-prompt')!; + const result = handler(); + + expect(result.messages).toHaveLength(1); + expect(result.messages[0].role).toBe('user'); + }); + }); + + describe('args-prompt', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerArgumentsPrompt(mockServer); + + expect(mockServer.registerPrompt).toHaveBeenCalledWith( + 'args-prompt', + expect.objectContaining({ + title: 'Arguments Prompt', + description: 'A prompt with two arguments, one required and one optional', + }), + expect.any(Function) + ); + }); + + it('should include city in message', () => { + const { mockServer, handlers } = createMockServer(); + registerArgumentsPrompt(mockServer); + + const handler = handlers.get('args-prompt')!; + const result = handler({ city: 'San Francisco' }); + + expect(result.messages[0].content.text).toBe("What's weather in San Francisco?"); + }); + + it('should include city and state in message', () => { + const { mockServer, handlers } = createMockServer(); + registerArgumentsPrompt(mockServer); + + const handler = handlers.get('args-prompt')!; + const result = handler({ city: 'San Francisco', state: 'California' }); + + expect(result.messages[0].content.text).toBe( + "What's weather in San Francisco, California?" + ); + }); + + it('should handle city only (optional state omitted)', () => { + const { mockServer, handlers } = createMockServer(); + registerArgumentsPrompt(mockServer); + + const handler = handlers.get('args-prompt')!; + const result = handler({ city: 'New York' }); + + expect(result.messages[0].content.text).toBe("What's weather in New York?"); + expect(result.messages[0].content.text).not.toContain(','); + }); + + it('should return message with user role', () => { + const { mockServer, handlers } = createMockServer(); + registerArgumentsPrompt(mockServer); + + const handler = handlers.get('args-prompt')!; + const result = handler({ city: 'Boston' }); + + expect(result.messages).toHaveLength(1); + expect(result.messages[0].role).toBe('user'); + expect(result.messages[0].content.type).toBe('text'); + }); + }); + + describe('completable-prompt', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerPromptWithCompletions(mockServer); + + expect(mockServer.registerPrompt).toHaveBeenCalledWith( + 'completable-prompt', + expect.objectContaining({ + title: 'Team Management', + description: 'First argument choice narrows values for second argument.', + }), + expect.any(Function) + ); + }); + + it('should generate promotion message with department and name', () => { + const { mockServer, handlers } = createMockServer(); + registerPromptWithCompletions(mockServer); + + const handler = handlers.get('completable-prompt')!; + const result = handler({ department: 'Engineering', name: 'Alice' }); + + expect(result.messages[0].content.text).toBe( + 'Please promote Alice to the head of the Engineering team.' + ); + }); + + it('should work with different departments', () => { + const { mockServer, handlers } = createMockServer(); + registerPromptWithCompletions(mockServer); + + const handler = handlers.get('completable-prompt')!; + + const salesResult = handler({ department: 'Sales', name: 'David' }); + expect(salesResult.messages[0].content.text).toContain('Sales'); + expect(salesResult.messages[0].content.text).toContain('David'); + + const marketingResult = handler({ department: 'Marketing', name: 'Grace' }); + expect(marketingResult.messages[0].content.text).toContain('Marketing'); + expect(marketingResult.messages[0].content.text).toContain('Grace'); + }); + + it('should return message with user role', () => { + const { mockServer, handlers } = createMockServer(); + registerPromptWithCompletions(mockServer); + + const handler = handlers.get('completable-prompt')!; + const result = handler({ department: 'Support', name: 'John' }); + + expect(result.messages).toHaveLength(1); + expect(result.messages[0].role).toBe('user'); + }); + }); + + describe('resource-prompt', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + expect(mockServer.registerPrompt).toHaveBeenCalledWith( + 'resource-prompt', + expect.objectContaining({ + title: 'Resource Prompt', + description: 'A prompt that includes an embedded resource reference', + }), + expect.any(Function) + ); + }); + + it('should return text resource reference', () => { + const { mockServer, handlers } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + const handler = handlers.get('resource-prompt')!; + const result = handler({ resourceType: 'Text', resourceId: '1' }); + + expect(result.messages).toHaveLength(2); + expect(result.messages[0].content.text).toContain('Text'); + expect(result.messages[0].content.text).toContain('1'); + expect(result.messages[1].content.type).toBe('resource'); + expect(result.messages[1].content.resource.uri).toContain('text/1'); + }); + + it('should return blob resource reference', () => { + const { mockServer, handlers } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + const handler = handlers.get('resource-prompt')!; + const result = handler({ resourceType: 'Blob', resourceId: '5' }); + + expect(result.messages[0].content.text).toContain('Blob'); + expect(result.messages[1].content.resource.uri).toContain('blob/5'); + }); + + it('should reject invalid resource type', () => { + const { mockServer, handlers } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + const handler = handlers.get('resource-prompt')!; + expect(() => handler({ resourceType: 'Invalid', resourceId: '1' })).toThrow( + 'Invalid resourceType' + ); + }); + + it('should reject invalid resource ID', () => { + const { mockServer, handlers } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + const handler = handlers.get('resource-prompt')!; + expect(() => handler({ resourceType: 'Text', resourceId: '-1' })).toThrow( + 'Invalid resourceId' + ); + expect(() => handler({ resourceType: 'Text', resourceId: '0' })).toThrow( + 'Invalid resourceId' + ); + expect(() => handler({ resourceType: 'Text', resourceId: 'abc' })).toThrow( + 'Invalid resourceId' + ); + }); + + it('should include both intro text and resource messages', () => { + const { mockServer, handlers } = createMockServer(); + registerEmbeddedResourcePrompt(mockServer); + + const handler = handlers.get('resource-prompt')!; + const result = handler({ resourceType: 'Text', resourceId: '3' }); + + expect(result.messages).toHaveLength(2); + expect(result.messages[0].role).toBe('user'); + expect(result.messages[0].content.type).toBe('text'); + expect(result.messages[1].role).toBe('user'); + expect(result.messages[1].content.type).toBe('resource'); + }); + }); +}); diff --git a/src/everything/__tests__/resources.test.ts b/src/everything/__tests__/resources.test.ts new file mode 100644 index 0000000000..c664059b5b --- /dev/null +++ b/src/everything/__tests__/resources.test.ts @@ -0,0 +1,268 @@ +import { describe, it, expect, vi } from 'vitest'; +import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js'; +import { + textResource, + blobResource, + textResourceUri, + blobResourceUri, + RESOURCE_TYPE_TEXT, + RESOURCE_TYPE_BLOB, + RESOURCE_TYPES, + resourceTypeCompleter, + resourceIdForPromptCompleter, + resourceIdForResourceTemplateCompleter, + registerResourceTemplates, +} from '../resources/templates.js'; +import { + getSessionResourceURI, + registerSessionResource, +} from '../resources/session.js'; + +describe('Resource Templates', () => { + describe('Constants', () => { + it('should define text resource type', () => { + expect(RESOURCE_TYPE_TEXT).toBe('Text'); + }); + + it('should define blob resource type', () => { + expect(RESOURCE_TYPE_BLOB).toBe('Blob'); + }); + + it('should include both types in RESOURCE_TYPES array', () => { + expect(RESOURCE_TYPES).toContain(RESOURCE_TYPE_TEXT); + expect(RESOURCE_TYPES).toContain(RESOURCE_TYPE_BLOB); + expect(RESOURCE_TYPES).toHaveLength(2); + }); + }); + + describe('textResourceUri', () => { + it('should create URL for text resource', () => { + const uri = textResourceUri(1); + expect(uri.toString()).toBe('demo://resource/dynamic/text/1'); + }); + + it('should handle different resource IDs', () => { + expect(textResourceUri(5).toString()).toBe('demo://resource/dynamic/text/5'); + expect(textResourceUri(100).toString()).toBe('demo://resource/dynamic/text/100'); + }); + }); + + describe('blobResourceUri', () => { + it('should create URL for blob resource', () => { + const uri = blobResourceUri(1); + expect(uri.toString()).toBe('demo://resource/dynamic/blob/1'); + }); + + it('should handle different resource IDs', () => { + expect(blobResourceUri(5).toString()).toBe('demo://resource/dynamic/blob/5'); + expect(blobResourceUri(100).toString()).toBe('demo://resource/dynamic/blob/100'); + }); + }); + + describe('textResource', () => { + it('should create text resource with correct structure', () => { + const uri = textResourceUri(1); + const resource = textResource(uri, 1); + + expect(resource.uri).toBe(uri.toString()); + expect(resource.mimeType).toBe('text/plain'); + expect(resource.text).toContain('Resource 1'); + expect(resource.text).toContain('plaintext'); + }); + + it('should include timestamp in content', () => { + const uri = textResourceUri(2); + const resource = textResource(uri, 2); + + // Timestamp format varies, just check it contains time-related content + expect(resource.text).toMatch(/\d/); + }); + }); + + describe('blobResource', () => { + it('should create blob resource with correct structure', () => { + const uri = blobResourceUri(1); + const resource = blobResource(uri, 1); + + expect(resource.uri).toBe(uri.toString()); + expect(resource.mimeType).toBe('text/plain'); + expect(resource.blob).toBeDefined(); + }); + + it('should create valid base64 encoded content', () => { + const uri = blobResourceUri(3); + const resource = blobResource(uri, 3); + + // Decode and verify content + const decoded = Buffer.from(resource.blob, 'base64').toString(); + expect(decoded).toContain('Resource 3'); + expect(decoded).toContain('base64 blob'); + }); + }); + + describe('resourceTypeCompleter', () => { + it('should be defined as a completable schema', () => { + // The completer is a zod schema wrapped with completable + expect(resourceTypeCompleter).toBeDefined(); + // It should have the zod parse method + expect(typeof (resourceTypeCompleter as any).parse).toBe('function'); + }); + + it('should validate string resource types', () => { + // Test that valid strings pass validation + expect(() => (resourceTypeCompleter as any).parse('Text')).not.toThrow(); + expect(() => (resourceTypeCompleter as any).parse('Blob')).not.toThrow(); + }); + }); + + describe('resourceIdForPromptCompleter', () => { + it('should be defined as a completable schema', () => { + expect(resourceIdForPromptCompleter).toBeDefined(); + expect(typeof (resourceIdForPromptCompleter as any).parse).toBe('function'); + }); + + it('should validate string IDs', () => { + // Test that valid strings pass validation + expect(() => (resourceIdForPromptCompleter as any).parse('1')).not.toThrow(); + expect(() => (resourceIdForPromptCompleter as any).parse('100')).not.toThrow(); + }); + }); + + describe('resourceIdForResourceTemplateCompleter', () => { + it('should validate positive integer IDs', () => { + expect(resourceIdForResourceTemplateCompleter('1')).toEqual(['1']); + expect(resourceIdForResourceTemplateCompleter('50')).toEqual(['50']); + }); + + it('should reject invalid IDs', () => { + expect(resourceIdForResourceTemplateCompleter('0')).toEqual([]); + expect(resourceIdForResourceTemplateCompleter('-5')).toEqual([]); + expect(resourceIdForResourceTemplateCompleter('not-a-number')).toEqual([]); + }); + }); + + describe('registerResourceTemplates', () => { + it('should register text and blob resource templates', () => { + const registeredResources: any[] = []; + + const mockServer = { + registerResource: vi.fn((...args) => { + registeredResources.push(args); + }), + } as unknown as McpServer; + + registerResourceTemplates(mockServer); + + expect(mockServer.registerResource).toHaveBeenCalledTimes(2); + + // Check text resource registration + const textRegistration = registeredResources.find((r) => + r[0].includes('Text') + ); + expect(textRegistration).toBeDefined(); + expect(textRegistration[1]).toBeInstanceOf(ResourceTemplate); + + // Check blob resource registration + const blobRegistration = registeredResources.find((r) => + r[0].includes('Blob') + ); + expect(blobRegistration).toBeDefined(); + }); + }); +}); + +describe('Session Resources', () => { + describe('getSessionResourceURI', () => { + it('should generate correct URI for resource name', () => { + expect(getSessionResourceURI('test')).toBe('demo://resource/session/test'); + }); + + it('should handle various resource names', () => { + expect(getSessionResourceURI('my-file')).toBe('demo://resource/session/my-file'); + expect(getSessionResourceURI('document_123')).toBe( + 'demo://resource/session/document_123' + ); + }); + }); + + describe('registerSessionResource', () => { + it('should register text resource and return resource link', () => { + const registrations: any[] = []; + const mockServer = { + registerResource: vi.fn((...args) => { + registrations.push(args); + }), + } as unknown as McpServer; + + const resource = { + uri: 'demo://resource/session/test-file', + name: 'test-file', + mimeType: 'text/plain', + description: 'A test file', + }; + + const result = registerSessionResource( + mockServer, + resource, + 'text', + 'Hello, World!' + ); + + expect(result.type).toBe('resource_link'); + expect(result.uri).toBe(resource.uri); + expect(result.name).toBe(resource.name); + + expect(mockServer.registerResource).toHaveBeenCalledWith( + 'test-file', + 'demo://resource/session/test-file', + expect.objectContaining({ + mimeType: 'text/plain', + description: 'A test file', + }), + expect.any(Function) + ); + }); + + it('should register blob resource correctly', () => { + const mockServer = { + registerResource: vi.fn(), + } as unknown as McpServer; + + const resource = { + uri: 'demo://resource/session/binary-file', + name: 'binary-file', + mimeType: 'application/octet-stream', + }; + + const blobContent = Buffer.from('binary data').toString('base64'); + const result = registerSessionResource(mockServer, resource, 'blob', blobContent); + + expect(result.type).toBe('resource_link'); + expect(mockServer.registerResource).toHaveBeenCalled(); + }); + + it('should return resource handler that provides correct content', async () => { + let capturedHandler: Function | null = null; + const mockServer = { + registerResource: vi.fn((_name, _uri, _config, handler) => { + capturedHandler = handler; + }), + } as unknown as McpServer; + + const resource = { + uri: 'demo://resource/session/content-test', + name: 'content-test', + mimeType: 'text/plain', + }; + + registerSessionResource(mockServer, resource, 'text', 'Test content here'); + + expect(capturedHandler).not.toBeNull(); + + const handlerResult = await capturedHandler!(new URL(resource.uri)); + expect(handlerResult.contents).toHaveLength(1); + expect(handlerResult.contents[0].text).toBe('Test content here'); + expect(handlerResult.contents[0].mimeType).toBe('text/plain'); + }); + }); +}); diff --git a/src/everything/__tests__/tools.test.ts b/src/everything/__tests__/tools.test.ts new file mode 100644 index 0000000000..d90ac05f0f --- /dev/null +++ b/src/everything/__tests__/tools.test.ts @@ -0,0 +1,579 @@ +import { describe, it, expect, vi } from 'vitest'; +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; +import { registerEchoTool, EchoSchema } from '../tools/echo.js'; +import { registerGetSumTool } from '../tools/get-sum.js'; +import { registerGetEnvTool } from '../tools/get-env.js'; +import { registerGetTinyImageTool, MCP_TINY_IMAGE } from '../tools/get-tiny-image.js'; +import { registerGetStructuredContentTool } from '../tools/get-structured-content.js'; +import { registerGetAnnotatedMessageTool } from '../tools/get-annotated-message.js'; +import { registerTriggerLongRunningOperationTool } from '../tools/trigger-long-running-operation.js'; +import { registerGetResourceLinksTool } from '../tools/get-resource-links.js'; +import { registerGetResourceReferenceTool } from '../tools/get-resource-reference.js'; + +// Helper to capture registered tool handlers +function createMockServer() { + const handlers: Map = new Map(); + const configs: Map = new Map(); + + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + configs.set(name, config); + }), + server: { + getClientCapabilities: vi.fn(() => ({})), + notification: vi.fn(), + }, + } as unknown as McpServer; + + return { mockServer, handlers, configs }; +} + +describe('Tools', () => { + describe('echo', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerEchoTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'echo', + expect.objectContaining({ + title: 'Echo Tool', + description: 'Echoes back the input string', + }), + expect.any(Function) + ); + }); + + it('should echo back the message', async () => { + const { mockServer, handlers } = createMockServer(); + registerEchoTool(mockServer); + + const handler = handlers.get('echo')!; + const result = await handler({ message: 'Hello, World!' }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'Echo: Hello, World!' }], + }); + }); + + it('should handle empty message', async () => { + const { mockServer, handlers } = createMockServer(); + registerEchoTool(mockServer); + + const handler = handlers.get('echo')!; + const result = await handler({ message: '' }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'Echo: ' }], + }); + }); + + it('should reject invalid input', async () => { + const { mockServer, handlers } = createMockServer(); + registerEchoTool(mockServer); + + const handler = handlers.get('echo')!; + + await expect(handler({})).rejects.toThrow(); + await expect(handler({ message: 123 })).rejects.toThrow(); + }); + }); + + describe('EchoSchema', () => { + it('should validate correct input', () => { + const result = EchoSchema.parse({ message: 'test' }); + expect(result).toEqual({ message: 'test' }); + }); + + it('should reject missing message', () => { + expect(() => EchoSchema.parse({})).toThrow(); + }); + + it('should reject non-string message', () => { + expect(() => EchoSchema.parse({ message: 123 })).toThrow(); + }); + }); + + describe('get-sum', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetSumTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-sum', + expect.objectContaining({ + title: 'Get Sum Tool', + description: 'Returns the sum of two numbers', + }), + expect.any(Function) + ); + }); + + it('should calculate sum of two positive numbers', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetSumTool(mockServer); + + const handler = handlers.get('get-sum')!; + const result = await handler({ a: 5, b: 3 }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'The sum of 5 and 3 is 8.' }], + }); + }); + + it('should calculate sum with negative numbers', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetSumTool(mockServer); + + const handler = handlers.get('get-sum')!; + const result = await handler({ a: -5, b: 3 }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'The sum of -5 and 3 is -2.' }], + }); + }); + + it('should calculate sum with zero', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetSumTool(mockServer); + + const handler = handlers.get('get-sum')!; + const result = await handler({ a: 0, b: 0 }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'The sum of 0 and 0 is 0.' }], + }); + }); + + it('should handle floating point numbers', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetSumTool(mockServer); + + const handler = handlers.get('get-sum')!; + const result = await handler({ a: 1.5, b: 2.5 }); + + expect(result).toEqual({ + content: [{ type: 'text', text: 'The sum of 1.5 and 2.5 is 4.' }], + }); + }); + + it('should reject invalid input', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetSumTool(mockServer); + + const handler = handlers.get('get-sum')!; + + await expect(handler({})).rejects.toThrow(); + await expect(handler({ a: 'not a number', b: 5 })).rejects.toThrow(); + await expect(handler({ a: 5 })).rejects.toThrow(); + }); + }); + + describe('get-env', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetEnvTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-env', + expect.objectContaining({ + title: 'Print Environment Tool', + description: expect.stringContaining('environment variables'), + }), + expect.any(Function) + ); + }); + + it('should return all environment variables as JSON', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetEnvTool(mockServer); + + const handler = handlers.get('get-env')!; + process.env.TEST_VAR_EVERYTHING = 'test_value'; + const result = await handler({}); + + expect(result.content).toHaveLength(1); + expect(result.content[0].type).toBe('text'); + + const envJson = JSON.parse(result.content[0].text); + expect(envJson.TEST_VAR_EVERYTHING).toBe('test_value'); + + delete process.env.TEST_VAR_EVERYTHING; + }); + + it('should return valid JSON', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetEnvTool(mockServer); + + const handler = handlers.get('get-env')!; + const result = await handler({}); + + expect(() => JSON.parse(result.content[0].text)).not.toThrow(); + }); + }); + + describe('get-tiny-image', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetTinyImageTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-tiny-image', + expect.objectContaining({ + title: 'Get Tiny Image Tool', + description: 'Returns a tiny MCP logo image.', + }), + expect.any(Function) + ); + }); + + it('should return image content with text descriptions', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetTinyImageTool(mockServer); + + const handler = handlers.get('get-tiny-image')!; + const result = await handler({}); + + expect(result.content).toHaveLength(3); + expect(result.content[0]).toEqual({ + type: 'text', + text: "Here's the image you requested:", + }); + expect(result.content[1]).toEqual({ + type: 'image', + data: MCP_TINY_IMAGE, + mimeType: 'image/png', + }); + expect(result.content[2]).toEqual({ + type: 'text', + text: 'The image above is the MCP logo.', + }); + }); + + it('should return valid base64 image data', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetTinyImageTool(mockServer); + + const handler = handlers.get('get-tiny-image')!; + const result = await handler({}); + + const imageContent = result.content[1]; + expect(imageContent.type).toBe('image'); + expect(imageContent.mimeType).toBe('image/png'); + // Verify it's valid base64 + expect(() => Buffer.from(imageContent.data, 'base64')).not.toThrow(); + }); + }); + + describe('get-structured-content', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetStructuredContentTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-structured-content', + expect.objectContaining({ + title: 'Get Structured Content Tool', + description: expect.stringContaining('structured content'), + }), + expect.any(Function) + ); + }); + + it('should return weather for New York', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetStructuredContentTool(mockServer); + + const handler = handlers.get('get-structured-content')!; + const result = await handler({ location: 'New York' }); + + expect(result.structuredContent).toEqual({ + temperature: 33, + conditions: 'Cloudy', + humidity: 82, + }); + expect(result.content[0].type).toBe('text'); + expect(JSON.parse(result.content[0].text)).toEqual(result.structuredContent); + }); + + it('should return weather for Chicago', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetStructuredContentTool(mockServer); + + const handler = handlers.get('get-structured-content')!; + const result = await handler({ location: 'Chicago' }); + + expect(result.structuredContent).toEqual({ + temperature: 36, + conditions: 'Light rain / drizzle', + humidity: 82, + }); + }); + + it('should return weather for Los Angeles', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetStructuredContentTool(mockServer); + + const handler = handlers.get('get-structured-content')!; + const result = await handler({ location: 'Los Angeles' }); + + expect(result.structuredContent).toEqual({ + temperature: 73, + conditions: 'Sunny / Clear', + humidity: 48, + }); + }); + }); + + describe('get-annotated-message', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetAnnotatedMessageTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-annotated-message', + expect.objectContaining({ + title: 'Get Annotated Message Tool', + description: expect.stringContaining('annotations'), + }), + expect.any(Function) + ); + }); + + it('should return error message with high priority', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetAnnotatedMessageTool(mockServer); + + const handler = handlers.get('get-annotated-message')!; + const result = await handler({ messageType: 'error', includeImage: false }); + + expect(result.content).toHaveLength(1); + expect(result.content[0].text).toBe('Error: Operation failed'); + expect(result.content[0].annotations).toEqual({ + priority: 1.0, + audience: ['user', 'assistant'], + }); + }); + + it('should return success message with medium priority', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetAnnotatedMessageTool(mockServer); + + const handler = handlers.get('get-annotated-message')!; + const result = await handler({ messageType: 'success', includeImage: false }); + + expect(result.content[0].text).toBe('Operation completed successfully'); + expect(result.content[0].annotations.priority).toBe(0.7); + expect(result.content[0].annotations.audience).toEqual(['user']); + }); + + it('should return debug message with low priority', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetAnnotatedMessageTool(mockServer); + + const handler = handlers.get('get-annotated-message')!; + const result = await handler({ messageType: 'debug', includeImage: false }); + + expect(result.content[0].text).toContain('Debug:'); + expect(result.content[0].annotations.priority).toBe(0.3); + expect(result.content[0].annotations.audience).toEqual(['assistant']); + }); + + it('should include annotated image when requested', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetAnnotatedMessageTool(mockServer); + + const handler = handlers.get('get-annotated-message')!; + const result = await handler({ messageType: 'success', includeImage: true }); + + expect(result.content).toHaveLength(2); + expect(result.content[1].type).toBe('image'); + expect(result.content[1].annotations).toEqual({ + priority: 0.5, + audience: ['user'], + }); + }); + }); + + describe('trigger-long-running-operation', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerTriggerLongRunningOperationTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'trigger-long-running-operation', + expect.objectContaining({ + title: 'Trigger Long Running Operation Tool', + description: expect.stringContaining('long running operation'), + }), + expect.any(Function) + ); + }); + + it('should complete operation and return result', async () => { + const { mockServer, handlers } = createMockServer(); + registerTriggerLongRunningOperationTool(mockServer); + + const handler = handlers.get('trigger-long-running-operation')!; + // Use very short duration for test + const result = await handler( + { duration: 0.1, steps: 2 }, + { _meta: {}, requestId: 'test-123' } + ); + + expect(result.content[0].text).toContain('Long running operation completed'); + expect(result.content[0].text).toContain('Duration: 0.1 seconds'); + expect(result.content[0].text).toContain('Steps: 2'); + }, 10000); + + it('should send progress notifications when progressToken provided', async () => { + const { mockServer, handlers } = createMockServer(); + registerTriggerLongRunningOperationTool(mockServer); + + const handler = handlers.get('trigger-long-running-operation')!; + await handler( + { duration: 0.1, steps: 2 }, + { _meta: { progressToken: 'token-123' }, requestId: 'test-456', sessionId: 'session-1' } + ); + + expect(mockServer.server.notification).toHaveBeenCalledTimes(2); + expect(mockServer.server.notification).toHaveBeenCalledWith( + expect.objectContaining({ + method: 'notifications/progress', + params: expect.objectContaining({ + progressToken: 'token-123', + }), + }), + expect.any(Object) + ); + }, 10000); + }); + + describe('get-resource-links', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetResourceLinksTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-resource-links', + expect.objectContaining({ + title: 'Get Resource Links Tool', + description: expect.stringContaining('resource links'), + }), + expect.any(Function) + ); + }); + + it('should return specified number of resource links', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceLinksTool(mockServer); + + const handler = handlers.get('get-resource-links')!; + const result = await handler({ count: 3 }); + + // 1 intro text + 3 resource links + expect(result.content).toHaveLength(4); + expect(result.content[0].type).toBe('text'); + expect(result.content[0].text).toContain('3 resource links'); + + // Check resource links + for (let i = 1; i < 4; i++) { + expect(result.content[i].type).toBe('resource_link'); + expect(result.content[i].uri).toBeDefined(); + expect(result.content[i].name).toBeDefined(); + } + }); + + it('should alternate between text and blob resources', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceLinksTool(mockServer); + + const handler = handlers.get('get-resource-links')!; + const result = await handler({ count: 4 }); + + // Odd IDs (1, 3) are blob, even IDs (2, 4) are text + expect(result.content[1].name).toContain('Blob'); + expect(result.content[2].name).toContain('Text'); + expect(result.content[3].name).toContain('Blob'); + expect(result.content[4].name).toContain('Text'); + }); + + it('should use default count of 3', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceLinksTool(mockServer); + + const handler = handlers.get('get-resource-links')!; + const result = await handler({}); + + // 1 intro text + 3 resource links (default) + expect(result.content).toHaveLength(4); + }); + }); + + describe('get-resource-reference', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGetResourceReferenceTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-resource-reference', + expect.objectContaining({ + title: 'Get Resource Reference Tool', + description: expect.stringContaining('resource reference'), + }), + expect.any(Function) + ); + }); + + it('should return text resource reference', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceReferenceTool(mockServer); + + const handler = handlers.get('get-resource-reference')!; + const result = await handler({ resourceType: 'Text', resourceId: 1 }); + + expect(result.content).toHaveLength(3); + expect(result.content[0].text).toContain('Resource 1'); + expect(result.content[1].type).toBe('resource'); + expect(result.content[1].resource.uri).toContain('text/1'); + expect(result.content[2].text).toContain('URI'); + }); + + it('should return blob resource reference', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceReferenceTool(mockServer); + + const handler = handlers.get('get-resource-reference')!; + const result = await handler({ resourceType: 'Blob', resourceId: 5 }); + + expect(result.content[1].resource.uri).toContain('blob/5'); + }); + + it('should reject invalid resource type', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceReferenceTool(mockServer); + + const handler = handlers.get('get-resource-reference')!; + await expect(handler({ resourceType: 'Invalid', resourceId: 1 })).rejects.toThrow( + 'Invalid resourceType' + ); + }); + + it('should reject invalid resource ID', async () => { + const { mockServer, handlers } = createMockServer(); + registerGetResourceReferenceTool(mockServer); + + const handler = handlers.get('get-resource-reference')!; + await expect(handler({ resourceType: 'Text', resourceId: -1 })).rejects.toThrow( + 'Invalid resourceId' + ); + await expect(handler({ resourceType: 'Text', resourceId: 0 })).rejects.toThrow( + 'Invalid resourceId' + ); + await expect(handler({ resourceType: 'Text', resourceId: 1.5 })).rejects.toThrow( + 'Invalid resourceId' + ); + }); + }); +}); diff --git a/src/everything/package.json b/src/everything/package.json index 31dd6e659d..3bc1e04c66 100644 --- a/src/everything/package.json +++ b/src/everything/package.json @@ -26,7 +26,8 @@ "start:sse": "node dist/index.js sse", "start:streamableHttp": "node dist/index.js streamableHttp", "prettier:fix": "prettier --write .", - "prettier:check": "prettier --check ." + "prettier:check": "prettier --check .", + "test": "vitest run --coverage" }, "dependencies": { "@modelcontextprotocol/sdk": "^1.25.2", @@ -39,8 +40,10 @@ "devDependencies": { "@types/cors": "^2.8.19", "@types/express": "^5.0.6", + "@vitest/coverage-v8": "^2.1.8", "shx": "^0.3.4", "typescript": "^5.6.2", - "prettier": "^2.8.8" + "prettier": "^2.8.8", + "vitest": "^2.1.8" } } diff --git a/src/everything/vitest.config.ts b/src/everything/vitest.config.ts new file mode 100644 index 0000000000..d414ec8f52 --- /dev/null +++ b/src/everything/vitest.config.ts @@ -0,0 +1,14 @@ +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + test: { + globals: true, + environment: 'node', + include: ['**/__tests__/**/*.test.ts'], + coverage: { + provider: 'v8', + include: ['**/*.ts'], + exclude: ['**/__tests__/**', '**/dist/**'], + }, + }, +}); From 356d52d6e6e4f33cc6ce60c764e42289561f0bfe Mon Sep 17 00:00:00 2001 From: Niels Kaspers Date: Wed, 21 Jan 2026 00:03:36 +0100 Subject: [PATCH 2/3] Add tests for remaining 6 tools Complete test coverage for all 16 Everything Server tools: New tests added: - toggle-simulated-logging: start/stop logging toggle, session handling - toggle-subscriber-updates: start/stop updates toggle, session handling - trigger-sampling-request: capability check, sampling request/response - trigger-elicitation-request: capability check, accept/decline/cancel actions - get-roots-list: capability check, registration - gzip-file-as-resource: compression, resource/resourceLink output types Test count: 102 tests (was 81) Coverage: 64.73% overall, 90.93% tools (was 34%, 40%) Co-Authored-By: Claude Opus 4.5 --- src/everything/__tests__/tools.test.ts | 409 +++++++++++++++++++++++++ 1 file changed, 409 insertions(+) diff --git a/src/everything/__tests__/tools.test.ts b/src/everything/__tests__/tools.test.ts index d90ac05f0f..ebec40a42b 100644 --- a/src/everything/__tests__/tools.test.ts +++ b/src/everything/__tests__/tools.test.ts @@ -9,6 +9,12 @@ import { registerGetAnnotatedMessageTool } from '../tools/get-annotated-message. import { registerTriggerLongRunningOperationTool } from '../tools/trigger-long-running-operation.js'; import { registerGetResourceLinksTool } from '../tools/get-resource-links.js'; import { registerGetResourceReferenceTool } from '../tools/get-resource-reference.js'; +import { registerToggleSimulatedLoggingTool } from '../tools/toggle-simulated-logging.js'; +import { registerToggleSubscriberUpdatesTool } from '../tools/toggle-subscriber-updates.js'; +import { registerTriggerSamplingRequestTool } from '../tools/trigger-sampling-request.js'; +import { registerTriggerElicitationRequestTool } from '../tools/trigger-elicitation-request.js'; +import { registerGetRootsListTool } from '../tools/get-roots-list.js'; +import { registerGZipFileAsResourceTool } from '../tools/gzip-file-as-resource.js'; // Helper to capture registered tool handlers function createMockServer() { @@ -24,6 +30,8 @@ function createMockServer() { getClientCapabilities: vi.fn(() => ({})), notification: vi.fn(), }, + sendLoggingMessage: vi.fn(), + sendResourceUpdated: vi.fn(), } as unknown as McpServer; return { mockServer, handlers, configs }; @@ -576,4 +584,405 @@ describe('Tools', () => { ); }); }); + + describe('toggle-simulated-logging', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerToggleSimulatedLoggingTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'toggle-simulated-logging', + expect.objectContaining({ + title: 'Toggle Simulated Logging', + description: expect.stringContaining('logging'), + }), + expect.any(Function) + ); + }); + + it('should start logging when not active', async () => { + const { mockServer, handlers } = createMockServer(); + registerToggleSimulatedLoggingTool(mockServer); + + const handler = handlers.get('toggle-simulated-logging')!; + const result = await handler({}, { sessionId: 'test-session-1' }); + + expect(result.content[0].text).toContain('Started'); + expect(result.content[0].text).toContain('test-session-1'); + }); + + it('should stop logging when already active', async () => { + const { mockServer, handlers } = createMockServer(); + registerToggleSimulatedLoggingTool(mockServer); + + const handler = handlers.get('toggle-simulated-logging')!; + + // First call starts logging + await handler({}, { sessionId: 'test-session-2' }); + + // Second call stops logging + const result = await handler({}, { sessionId: 'test-session-2' }); + + expect(result.content[0].text).toContain('Stopped'); + expect(result.content[0].text).toContain('test-session-2'); + }); + + it('should handle undefined sessionId', async () => { + const { mockServer, handlers } = createMockServer(); + registerToggleSimulatedLoggingTool(mockServer); + + const handler = handlers.get('toggle-simulated-logging')!; + const result = await handler({}, {}); + + expect(result.content[0].text).toContain('Started'); + }); + }); + + describe('toggle-subscriber-updates', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerToggleSubscriberUpdatesTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'toggle-subscriber-updates', + expect.objectContaining({ + title: 'Toggle Subscriber Updates', + description: expect.stringContaining('subscription updates'), + }), + expect.any(Function) + ); + }); + + it('should start updates when not active', async () => { + const { mockServer, handlers } = createMockServer(); + registerToggleSubscriberUpdatesTool(mockServer); + + const handler = handlers.get('toggle-subscriber-updates')!; + const result = await handler({}, { sessionId: 'sub-session-1' }); + + expect(result.content[0].text).toContain('Started'); + expect(result.content[0].text).toContain('sub-session-1'); + }); + + it('should stop updates when already active', async () => { + const { mockServer, handlers } = createMockServer(); + registerToggleSubscriberUpdatesTool(mockServer); + + const handler = handlers.get('toggle-subscriber-updates')!; + + // First call starts updates + await handler({}, { sessionId: 'sub-session-2' }); + + // Second call stops updates + const result = await handler({}, { sessionId: 'sub-session-2' }); + + expect(result.content[0].text).toContain('Stopped'); + expect(result.content[0].text).toContain('sub-session-2'); + }); + }); + + describe('trigger-sampling-request', () => { + it('should not register when client does not support sampling', () => { + const { mockServer } = createMockServer(); + registerTriggerSamplingRequestTool(mockServer); + + // Tool should not be registered since mock server returns empty capabilities + expect(mockServer.registerTool).not.toHaveBeenCalled(); + }); + + it('should register when client supports sampling', () => { + const handlers: Map = new Map(); + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ sampling: {} })), + }, + } as unknown as McpServer; + + registerTriggerSamplingRequestTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'trigger-sampling-request', + expect.objectContaining({ + title: 'Trigger Sampling Request Tool', + description: expect.stringContaining('Sampling'), + }), + expect.any(Function) + ); + }); + + it('should send sampling request and return result', async () => { + const handlers: Map = new Map(); + const mockSendRequest = vi.fn().mockResolvedValue({ + model: 'test-model', + content: { type: 'text', text: 'LLM response' }, + }); + + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ sampling: {} })), + }, + } as unknown as McpServer; + + registerTriggerSamplingRequestTool(mockServer); + + const handler = handlers.get('trigger-sampling-request')!; + const result = await handler( + { prompt: 'Test prompt', maxTokens: 50 }, + { sendRequest: mockSendRequest } + ); + + expect(mockSendRequest).toHaveBeenCalledWith( + expect.objectContaining({ + method: 'sampling/createMessage', + params: expect.objectContaining({ + maxTokens: 50, + }), + }), + expect.anything() + ); + expect(result.content[0].text).toContain('LLM sampling result'); + }); + }); + + describe('trigger-elicitation-request', () => { + it('should not register when client does not support elicitation', () => { + const { mockServer } = createMockServer(); + registerTriggerElicitationRequestTool(mockServer); + + expect(mockServer.registerTool).not.toHaveBeenCalled(); + }); + + it('should register when client supports elicitation', () => { + const handlers: Map = new Map(); + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ elicitation: {} })), + }, + } as unknown as McpServer; + + registerTriggerElicitationRequestTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'trigger-elicitation-request', + expect.objectContaining({ + title: 'Trigger Elicitation Request Tool', + description: expect.stringContaining('Elicitation'), + }), + expect.any(Function) + ); + }); + + it('should handle accept action with user content', async () => { + const handlers: Map = new Map(); + const mockSendRequest = vi.fn().mockResolvedValue({ + action: 'accept', + content: { + name: 'John Doe', + check: true, + email: 'john@example.com', + }, + }); + + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ elicitation: {} })), + }, + } as unknown as McpServer; + + registerTriggerElicitationRequestTool(mockServer); + + const handler = handlers.get('trigger-elicitation-request')!; + const result = await handler({}, { sendRequest: mockSendRequest }); + + expect(result.content[0].text).toContain('✅'); + expect(result.content[0].text).toContain('provided'); + expect(result.content[1].text).toContain('John Doe'); + }); + + it('should handle decline action', async () => { + const handlers: Map = new Map(); + const mockSendRequest = vi.fn().mockResolvedValue({ + action: 'decline', + }); + + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ elicitation: {} })), + }, + } as unknown as McpServer; + + registerTriggerElicitationRequestTool(mockServer); + + const handler = handlers.get('trigger-elicitation-request')!; + const result = await handler({}, { sendRequest: mockSendRequest }); + + expect(result.content[0].text).toContain('❌'); + expect(result.content[0].text).toContain('declined'); + }); + + it('should handle cancel action', async () => { + const handlers: Map = new Map(); + const mockSendRequest = vi.fn().mockResolvedValue({ + action: 'cancel', + }); + + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ elicitation: {} })), + }, + } as unknown as McpServer; + + registerTriggerElicitationRequestTool(mockServer); + + const handler = handlers.get('trigger-elicitation-request')!; + const result = await handler({}, { sendRequest: mockSendRequest }); + + expect(result.content[0].text).toContain('⚠️'); + expect(result.content[0].text).toContain('cancelled'); + }); + }); + + describe('get-roots-list', () => { + it('should not register when client does not support roots', () => { + const { mockServer } = createMockServer(); + registerGetRootsListTool(mockServer); + + expect(mockServer.registerTool).not.toHaveBeenCalled(); + }); + + it('should register when client supports roots', () => { + const handlers: Map = new Map(); + const mockServer = { + registerTool: vi.fn((name: string, config: any, handler: Function) => { + handlers.set(name, handler); + }), + server: { + getClientCapabilities: vi.fn(() => ({ roots: {} })), + }, + } as unknown as McpServer; + + registerGetRootsListTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'get-roots-list', + expect.objectContaining({ + title: 'Get Roots List Tool', + description: expect.stringContaining('roots'), + }), + expect.any(Function) + ); + }); + }); + + describe('gzip-file-as-resource', () => { + it('should register with correct name and config', () => { + const { mockServer } = createMockServer(); + registerGZipFileAsResourceTool(mockServer); + + expect(mockServer.registerTool).toHaveBeenCalledWith( + 'gzip-file-as-resource', + expect.objectContaining({ + title: 'GZip File as Resource Tool', + description: expect.stringContaining('gzip'), + }), + expect.any(Function) + ); + }); + + it('should compress data URI and return resource link', async () => { + const registeredResources: any[] = []; + const mockServer = { + registerTool: vi.fn(), + registerResource: vi.fn((...args) => { + registeredResources.push(args); + }), + } as unknown as McpServer; + + // Get the handler + let handler: Function | null = null; + (mockServer.registerTool as any).mockImplementation( + (name: string, config: any, h: Function) => { + handler = h; + } + ); + + registerGZipFileAsResourceTool(mockServer); + + // Create a data URI with test content + const testContent = 'Hello, World!'; + const dataUri = `data:text/plain;base64,${Buffer.from(testContent).toString('base64')}`; + + const result = await handler!( + { name: 'test.txt.gz', data: dataUri, outputType: 'resourceLink' } + ); + + expect(result.content[0].type).toBe('resource_link'); + expect(result.content[0].uri).toContain('test.txt.gz'); + }); + + it('should return resource directly when outputType is resource', async () => { + const mockServer = { + registerTool: vi.fn(), + registerResource: vi.fn(), + } as unknown as McpServer; + + let handler: Function | null = null; + (mockServer.registerTool as any).mockImplementation( + (name: string, config: any, h: Function) => { + handler = h; + } + ); + + registerGZipFileAsResourceTool(mockServer); + + const testContent = 'Test content for compression'; + const dataUri = `data:text/plain;base64,${Buffer.from(testContent).toString('base64')}`; + + const result = await handler!( + { name: 'output.gz', data: dataUri, outputType: 'resource' } + ); + + expect(result.content[0].type).toBe('resource'); + expect(result.content[0].resource.mimeType).toBe('application/gzip'); + expect(result.content[0].resource.blob).toBeDefined(); + }); + + it('should reject unsupported URL protocols', async () => { + const mockServer = { + registerTool: vi.fn(), + registerResource: vi.fn(), + } as unknown as McpServer; + + let handler: Function | null = null; + (mockServer.registerTool as any).mockImplementation( + (name: string, config: any, h: Function) => { + handler = h; + } + ); + + registerGZipFileAsResourceTool(mockServer); + + await expect( + handler!({ name: 'test.gz', data: 'ftp://example.com/file.txt', outputType: 'resource' }) + ).rejects.toThrow('Unsupported URL protocol'); + }); + }); }); From a334191e244dbfca0c03aef2049d0726427ae86e Mon Sep 17 00:00:00 2001 From: Niels Kaspers Date: Wed, 21 Jan 2026 00:09:51 +0100 Subject: [PATCH 3/3] Add tests for server factory, registrations, and resources Additional test coverage: - server/index.ts: createServer factory, cleanup function (91% coverage) - tools/index.ts: registerTools, registerConditionalTools (100% coverage) - prompts/index.ts: registerPrompts (100% coverage) - resources/index.ts: registerResources, readInstructions (88% coverage) - resources/files.ts: registerFileResources (54% coverage) - resources/subscriptions.ts: handlers, begin/stop updates (47% coverage) Test count: 124 tests (was 102) Coverage: 71.35% overall (was 64.73%) - Tools: 93.12% - Prompts: 90.53% - Server: 62.93% - Resources: 65.44% Note: Transport files (stdio.ts, sse.ts, streamableHttp.ts) are entry points that start Express servers. These require integration tests rather than unit tests. Co-Authored-By: Claude Opus 4.5 --- .../__tests__/registrations.test.ts | 134 ++++++++++++++++++ src/everything/__tests__/resources.test.ts | 105 +++++++++++++- src/everything/__tests__/server.test.ts | 62 ++++++++ 3 files changed, 300 insertions(+), 1 deletion(-) create mode 100644 src/everything/__tests__/registrations.test.ts create mode 100644 src/everything/__tests__/server.test.ts diff --git a/src/everything/__tests__/registrations.test.ts b/src/everything/__tests__/registrations.test.ts new file mode 100644 index 0000000000..072bc5c6f0 --- /dev/null +++ b/src/everything/__tests__/registrations.test.ts @@ -0,0 +1,134 @@ +import { describe, it, expect, vi } from 'vitest'; +import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; + +// Create mock server +function createMockServer() { + return { + registerTool: vi.fn(), + registerPrompt: vi.fn(), + registerResource: vi.fn(), + server: { + getClientCapabilities: vi.fn(() => ({})), + setRequestHandler: vi.fn(), + }, + sendLoggingMessage: vi.fn(), + sendResourceUpdated: vi.fn(), + } as unknown as McpServer; +} + +describe('Registration Index Files', () => { + describe('tools/index.ts', () => { + it('should register all standard tools', async () => { + const { registerTools } = await import('../tools/index.js'); + const mockServer = createMockServer(); + + registerTools(mockServer); + + // Should register 12 standard tools (non-conditional) + expect(mockServer.registerTool).toHaveBeenCalledTimes(12); + + // Verify specific tools are registered + const registeredTools = (mockServer.registerTool as any).mock.calls.map( + (call: any[]) => call[0] + ); + expect(registeredTools).toContain('echo'); + expect(registeredTools).toContain('get-sum'); + expect(registeredTools).toContain('get-env'); + expect(registeredTools).toContain('get-tiny-image'); + expect(registeredTools).toContain('get-structured-content'); + expect(registeredTools).toContain('get-annotated-message'); + expect(registeredTools).toContain('trigger-long-running-operation'); + expect(registeredTools).toContain('get-resource-links'); + expect(registeredTools).toContain('get-resource-reference'); + expect(registeredTools).toContain('gzip-file-as-resource'); + expect(registeredTools).toContain('toggle-simulated-logging'); + expect(registeredTools).toContain('toggle-subscriber-updates'); + }); + + it('should register conditional tools based on capabilities', async () => { + const { registerConditionalTools } = await import('../tools/index.js'); + + // Server with all capabilities + const mockServerWithCapabilities = { + registerTool: vi.fn(), + server: { + getClientCapabilities: vi.fn(() => ({ + roots: {}, + elicitation: {}, + sampling: {}, + })), + }, + } as unknown as McpServer; + + registerConditionalTools(mockServerWithCapabilities); + + // Should register 3 conditional tools when all capabilities present + expect(mockServerWithCapabilities.registerTool).toHaveBeenCalledTimes(3); + + const registeredTools = ( + mockServerWithCapabilities.registerTool as any + ).mock.calls.map((call: any[]) => call[0]); + expect(registeredTools).toContain('get-roots-list'); + expect(registeredTools).toContain('trigger-elicitation-request'); + expect(registeredTools).toContain('trigger-sampling-request'); + }); + + it('should not register conditional tools when capabilities missing', async () => { + const { registerConditionalTools } = await import('../tools/index.js'); + + const mockServerNoCapabilities = { + registerTool: vi.fn(), + server: { + getClientCapabilities: vi.fn(() => ({})), + }, + } as unknown as McpServer; + + registerConditionalTools(mockServerNoCapabilities); + + // Should not register any tools when capabilities are missing + expect(mockServerNoCapabilities.registerTool).not.toHaveBeenCalled(); + }); + }); + + describe('prompts/index.ts', () => { + it('should register all prompts', async () => { + const { registerPrompts } = await import('../prompts/index.js'); + const mockServer = createMockServer(); + + registerPrompts(mockServer); + + // Should register 4 prompts + expect(mockServer.registerPrompt).toHaveBeenCalledTimes(4); + + const registeredPrompts = (mockServer.registerPrompt as any).mock.calls.map( + (call: any[]) => call[0] + ); + expect(registeredPrompts).toContain('simple-prompt'); + expect(registeredPrompts).toContain('args-prompt'); + expect(registeredPrompts).toContain('completable-prompt'); + expect(registeredPrompts).toContain('resource-prompt'); + }); + }); + + describe('resources/index.ts', () => { + it('should register resource templates', async () => { + const { registerResources } = await import('../resources/index.js'); + const mockServer = createMockServer(); + + registerResources(mockServer); + + // Should register at least the 2 resource templates (text and blob) + expect(mockServer.registerResource).toHaveBeenCalled(); + }); + + it('should read instructions from file', async () => { + const { readInstructions } = await import('../resources/index.js'); + + const instructions = readInstructions(); + + // Should return a string (either content or error message) + expect(typeof instructions).toBe('string'); + expect(instructions.length).toBeGreaterThan(0); + }); + }); +}); diff --git a/src/everything/__tests__/resources.test.ts b/src/everything/__tests__/resources.test.ts index c664059b5b..d766d38baa 100644 --- a/src/everything/__tests__/resources.test.ts +++ b/src/everything/__tests__/resources.test.ts @@ -1,4 +1,4 @@ -import { describe, it, expect, vi } from 'vitest'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js'; import { textResource, @@ -17,6 +17,12 @@ import { getSessionResourceURI, registerSessionResource, } from '../resources/session.js'; +import { registerFileResources } from '../resources/files.js'; +import { + setSubscriptionHandlers, + beginSimulatedResourceUpdates, + stopSimulatedResourceUpdates, +} from '../resources/subscriptions.js'; describe('Resource Templates', () => { describe('Constants', () => { @@ -266,3 +272,100 @@ describe('Session Resources', () => { }); }); }); + +describe('File Resources', () => { + describe('registerFileResources', () => { + it('should register file resources from docs directory', () => { + const mockServer = { + registerResource: vi.fn(), + } as unknown as McpServer; + + // This may or may not register resources depending on if docs/ exists + registerFileResources(mockServer); + + // If docs folder exists and has files, resources should be registered + // If not, the function should not throw + expect(true).toBe(true); + }); + + it('should not throw when docs directory is missing', () => { + const mockServer = { + registerResource: vi.fn(), + } as unknown as McpServer; + + // Should gracefully handle missing docs directory + expect(() => registerFileResources(mockServer)).not.toThrow(); + }); + }); +}); + +describe('Subscriptions', () => { + describe('setSubscriptionHandlers', () => { + it('should set request handlers on server', () => { + const mockServer = { + server: { + setRequestHandler: vi.fn(), + }, + sendLoggingMessage: vi.fn(), + } as unknown as McpServer; + + setSubscriptionHandlers(mockServer); + + // Should set both subscribe and unsubscribe handlers + expect(mockServer.server.setRequestHandler).toHaveBeenCalledTimes(2); + }); + }); + + describe('beginSimulatedResourceUpdates', () => { + afterEach(() => { + // Clean up any intervals + stopSimulatedResourceUpdates('test-session-updates'); + stopSimulatedResourceUpdates(undefined); + }); + + it('should start update interval for session', () => { + const mockServer = { + server: { + notification: vi.fn(), + }, + } as unknown as McpServer; + + // Should not throw + expect(() => + beginSimulatedResourceUpdates(mockServer, 'test-session-updates') + ).not.toThrow(); + }); + + it('should handle undefined sessionId', () => { + const mockServer = { + server: { + notification: vi.fn(), + }, + } as unknown as McpServer; + + expect(() => beginSimulatedResourceUpdates(mockServer, undefined)).not.toThrow(); + }); + }); + + describe('stopSimulatedResourceUpdates', () => { + it('should stop updates for session', () => { + const mockServer = { + server: { + notification: vi.fn(), + }, + } as unknown as McpServer; + + // Start then stop + beginSimulatedResourceUpdates(mockServer, 'stop-test-session'); + expect(() => stopSimulatedResourceUpdates('stop-test-session')).not.toThrow(); + }); + + it('should handle stopping non-existent session', () => { + expect(() => stopSimulatedResourceUpdates('non-existent-session')).not.toThrow(); + }); + + it('should handle undefined sessionId', () => { + expect(() => stopSimulatedResourceUpdates(undefined)).not.toThrow(); + }); + }); +}); diff --git a/src/everything/__tests__/server.test.ts b/src/everything/__tests__/server.test.ts new file mode 100644 index 0000000000..7ee0590c37 --- /dev/null +++ b/src/everything/__tests__/server.test.ts @@ -0,0 +1,62 @@ +import { describe, it, expect, vi } from 'vitest'; +import { createServer } from '../server/index.js'; + +describe('Server Factory', () => { + describe('createServer', () => { + it('should return a ServerFactoryResponse object', () => { + const result = createServer(); + + expect(result).toHaveProperty('server'); + expect(result).toHaveProperty('cleanup'); + }); + + it('should return a cleanup function', () => { + const { cleanup } = createServer(); + + expect(typeof cleanup).toBe('function'); + }); + + it('should create an McpServer instance', () => { + const { server } = createServer(); + + expect(server).toBeDefined(); + expect(server.server).toBeDefined(); + }); + + it('should have tools capability enabled', () => { + const { server } = createServer(); + + // Server should be properly configured + expect(server).toBeDefined(); + }); + + it('should cleanup without throwing errors', () => { + const { cleanup } = createServer(); + + // Cleanup should not throw when called with a session ID + expect(() => cleanup('test-session')).not.toThrow(); + }); + + it('should cleanup without throwing errors when sessionId is undefined', () => { + const { cleanup } = createServer(); + + // Cleanup should not throw when called without a session ID + expect(() => cleanup()).not.toThrow(); + }); + + it('should allow multiple servers to be created', () => { + const result1 = createServer(); + const result2 = createServer(); + + expect(result1.server).toBeDefined(); + expect(result2.server).toBeDefined(); + expect(result1.server).not.toBe(result2.server); + }); + + it('should have an oninitialized handler set', () => { + const { server } = createServer(); + + expect(server.server.oninitialized).toBeDefined(); + }); + }); +});