@nahisaho/katashiro-mcp-server 0.1.0

package/tests/unit/protocol-handler.test.ts

@@ -0,0 +1,331 @@
+/**
+ * Protocol Handler テスト
+ *
+ * @task TSK-061
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { KatashiroMCPServer } from '../../src/server/mcp-server.js';
+import {
+  MCPProtocolHandler,
+  MCP_PROTOCOL_VERSION,
+} from '../../src/protocol/protocol-handler.js';
+import type {
+  JsonRpcRequest,
+  JsonRpcNotification,
+} from '../../src/transport/stdio-transport.js';
+
+describe('MCPProtocolHandler', () => {
+  let server: KatashiroMCPServer;
+  let handler: MCPProtocolHandler;
+
+  beforeEach(() => {
+    server = new KatashiroMCPServer();
+    handler = new MCPProtocolHandler(server);
+  });
+
+  describe('initialization', () => {
+    it('should start in uninitialized state', () => {
+      expect(handler.getState()).toBe('uninitialized');
+    });
+
+    it('should have null client info before initialization', () => {
+      expect(handler.getClientInfo()).toBeNull();
+    });
+  });
+
+  describe('initialize method', () => {
+    it('should handle initialize request', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: {
+            name: 'test-client',
+            version: '1.0.0',
+          },
+        },
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response).toBeDefined();
+      expect(response?.result).toBeDefined();
+
+      const result = response?.result as {
+        protocolVersion: string;
+        serverInfo: { name: string; version: string };
+      };
+      expect(result.protocolVersion).toBe(MCP_PROTOCOL_VERSION);
+      expect(result.serverInfo.name).toBe('katashiro');
+      expect(handler.getState()).toBe('initializing');
+    });
+
+    it('should store client info after initialization', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: {
+            name: 'test-client',
+            version: '1.0.0',
+          },
+        },
+      };
+
+      await handler.handleMessage(request);
+
+      expect(handler.getClientInfo()).toEqual({
+        name: 'test-client',
+        version: '1.0.0',
+      });
+    });
+
+    it('should reject double initialization', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      };
+
+      // First initialization
+      await handler.handleMessage(request);
+
+      // Second initialization should fail
+      const response2 = await handler.handleMessage({ ...request, id: 2 });
+
+      expect(response2?.error).toBeDefined();
+    });
+  });
+
+  describe('notifications', () => {
+    it('should handle initialized notification', async () => {
+      // First initialize
+      const initRequest: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      };
+      await handler.handleMessage(initRequest);
+
+      // Then send initialized notification
+      const notification: JsonRpcNotification = {
+        jsonrpc: '2.0',
+        method: 'notifications/initialized',
+      };
+
+      const result = await handler.handleMessage(notification);
+
+      expect(result).toBeUndefined(); // Notifications don't return responses
+      expect(handler.getState()).toBe('ready');
+    });
+  });
+
+  describe('ping method', () => {
+    it('should respond to ping', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'ping',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toEqual({});
+    });
+  });
+
+  describe('tools methods', () => {
+    beforeEach(async () => {
+      // Initialize first
+      await handler.handleMessage({
+        jsonrpc: '2.0',
+        id: 0,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      });
+    });
+
+    it('should list tools', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+      const result = response?.result as { tools: unknown[] };
+      expect(Array.isArray(result.tools)).toBe(true);
+      expect(result.tools.length).toBeGreaterThan(0);
+    });
+
+    it('should call tool', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+          name: 'web_search',
+          arguments: { query: 'test' },
+        },
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+      expect(response?.error).toBeUndefined();
+    });
+
+    it('should return error for missing tool name', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {},
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.error).toBeDefined();
+      expect(response?.error?.message).toContain('Tool name required');
+    });
+  });
+
+  describe('resources methods', () => {
+    beforeEach(async () => {
+      await handler.handleMessage({
+        jsonrpc: '2.0',
+        id: 0,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      });
+    });
+
+    it('should list resources', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'resources/list',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+      const result = response?.result as { resources: unknown[] };
+      expect(Array.isArray(result.resources)).toBe(true);
+    });
+
+    it('should read resource', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'resources/read',
+        params: {
+          uri: 'katashiro://knowledge/graph',
+        },
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+    });
+  });
+
+  describe('prompts methods', () => {
+    beforeEach(async () => {
+      await handler.handleMessage({
+        jsonrpc: '2.0',
+        id: 0,
+        method: 'initialize',
+        params: {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' },
+        },
+      });
+    });
+
+    it('should list prompts', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'prompts/list',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+      const result = response?.result as { prompts: unknown[] };
+      expect(Array.isArray(result.prompts)).toBe(true);
+    });
+
+    it('should get prompt', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'prompts/get',
+        params: {
+          name: 'research_topic',
+          arguments: { topic: 'AI' },
+        },
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.result).toBeDefined();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return method not found for unknown methods', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'unknown/method',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.error).toBeDefined();
+      expect(response?.error?.code).toBe(-32601); // Method not found
+    });
+
+    it('should reject operations before initialization', async () => {
+      const request: JsonRpcRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/list',
+      };
+
+      const response = await handler.handleMessage(request);
+
+      expect(response?.error).toBeDefined();
+    });
+  });
+});

package/tests/unit/resource-manager.test.ts

@@ -0,0 +1,162 @@
+/**
+ * ResourceManager テスト
+ *
+ * @task TSK-063
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ResourceManager } from '../../src/resources/resource-manager.js';
+import { isOk } from '@nahisaho/katashiro-core';
+
+describe('ResourceManager', () => {
+  let manager: ResourceManager;
+
+  beforeEach(() => {
+    manager = new ResourceManager();
+  });
+
+  describe('registration', () => {
+    it('should register a resource', () => {
+      const result = manager.register({
+        uri: 'katashiro://test/resource',
+        name: 'Test Resource',
+        description: 'A test resource',
+        mimeType: 'application/json',
+      });
+
+      expect(isOk(result)).toBe(true);
+    });
+
+    it('should register resource with content provider', () => {
+      const result = manager.register({
+        uri: 'katashiro://dynamic/data',
+        name: 'Dynamic Data',
+        provider: async () => ({ content: 'Dynamic content' }),
+      });
+
+      expect(isOk(result)).toBe(true);
+    });
+
+    it('should reject duplicate URI', () => {
+      manager.register({
+        uri: 'katashiro://test',
+        name: 'First',
+      });
+
+      const result = manager.register({
+        uri: 'katashiro://test',
+        name: 'Second',
+      });
+
+      expect(isOk(result)).toBe(false);
+    });
+  });
+
+  describe('listing', () => {
+    it('should list all resources', () => {
+      manager.register({ uri: 'katashiro://a', name: 'A' });
+      manager.register({ uri: 'katashiro://b', name: 'B' });
+
+      const result = manager.list();
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(result.value).toHaveLength(2);
+      }
+    });
+
+    it('should filter by prefix', () => {
+      manager.register({ uri: 'katashiro://data/one', name: 'One' });
+      manager.register({ uri: 'katashiro://data/two', name: 'Two' });
+      manager.register({ uri: 'katashiro://other/three', name: 'Three' });
+
+      const result = manager.list({ prefix: 'katashiro://data/' });
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(result.value).toHaveLength(2);
+      }
+    });
+  });
+
+  describe('reading', () => {
+    it('should read static content', async () => {
+      manager.register({
+        uri: 'katashiro://static',
+        name: 'Static',
+        content: 'Static content here',
+      });
+
+      const result = await manager.read('katashiro://static');
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(result.value.content).toBe('Static content here');
+      }
+    });
+
+    it('should read dynamic content from provider', async () => {
+      manager.register({
+        uri: 'katashiro://dynamic',
+        name: 'Dynamic',
+        provider: async () => ({ content: 'Generated content' }),
+      });
+
+      const result = await manager.read('katashiro://dynamic');
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(result.value.content).toBe('Generated content');
+      }
+    });
+
+    it('should return error for unknown resource', async () => {
+      const result = await manager.read('katashiro://unknown');
+      expect(isOk(result)).toBe(false);
+    });
+  });
+
+  describe('subscriptions', () => {
+    it('should subscribe to resource changes', () => {
+      manager.register({ uri: 'katashiro://watched', name: 'Watched' });
+
+      const result = manager.subscribe('katashiro://watched', () => {});
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(result.value).toBeDefined(); // subscription id
+      }
+    });
+
+    it('should unsubscribe', () => {
+      manager.register({ uri: 'katashiro://watched', name: 'Watched' });
+      const subResult = manager.subscribe('katashiro://watched', () => {});
+
+      if (isOk(subResult)) {
+        const result = manager.unsubscribe(subResult.value);
+        expect(isOk(result)).toBe(true);
+      }
+    });
+
+    it('should notify subscribers on update', async () => {
+      let notified = false;
+      manager.register({
+        uri: 'katashiro://notify-test',
+        name: 'Notify Test',
+        content: 'Initial',
+      });
+
+      manager.subscribe('katashiro://notify-test', () => {
+        notified = true;
+      });
+
+      await manager.update('katashiro://notify-test', 'Updated');
+      expect(notified).toBe(true);
+    });
+  });
+
+  describe('templates', () => {
+    it('should list resource templates', () => {
+      const result = manager.listTemplates();
+      expect(isOk(result)).toBe(true);
+      if (isOk(result)) {
+        expect(Array.isArray(result.value)).toBe(true);
+      }
+    });
+  });
+});

package/tests/unit/stdio-transport.test.ts

@@ -0,0 +1,180 @@
+/**
+ * STDIO Transport テスト
+ *
+ * @task TSK-061
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Readable, Writable } from 'stream';
+import {
+  StdioTransport,
+  createSuccessResponse,
+  createErrorResponse,
+  JsonRpcErrorCode,
+} from '../../src/transport/stdio-transport.js';
+
+/**
+ * Create a mock readable stream
+ */
+function createMockReadable(): Readable {
+  return new Readable({
+    read() {
+      // Do nothing - we'll push data manually
+    },
+  });
+}
+
+/**
+ * Create a mock writable stream that captures output
+ */
+function createMockWritable(): { writable: Writable; output: string[] } {
+  const output: string[] = [];
+  const writable = new Writable({
+    write(chunk, _encoding, callback) {
+      output.push(chunk.toString());
+      callback();
+    },
+  });
+  return { writable, output };
+}
+
+describe('StdioTransport', () => {
+  let transport: StdioTransport;
+  let mockInput: Readable;
+  let mockOutput: { writable: Writable; output: string[] };
+
+  beforeEach(() => {
+    mockInput = createMockReadable();
+    mockOutput = createMockWritable();
+    transport = new StdioTransport(mockInput, mockOutput.writable);
+  });
+
+  describe('initialization', () => {
+    it('should start in disconnected state', () => {
+      expect(transport.getState()).toBe('disconnected');
+    });
+
+    it('should transition to connected state on start', () => {
+      transport.start();
+      expect(transport.getState()).toBe('connected');
+    });
+
+    it('should transition to closed state on stop', () => {
+      transport.start();
+      transport.stop();
+      expect(transport.getState()).toBe('closed');
+    });
+  });
+
+  describe('message handling', () => {
+    it('should call message handler on valid JSON-RPC message', async () => {
+      let receivedMessage: unknown = null;
+
+      transport.onMessage(async (message) => {
+        receivedMessage = message;
+        return createSuccessResponse(1, { result: 'ok' });
+      });
+
+      transport.start();
+
+      const message = JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'test',
+        params: {},
+      });
+
+      mockInput.push(message + '\n');
+
+      // Wait for async processing
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(receivedMessage).not.toBeNull();
+      expect((receivedMessage as { method: string }).method).toBe('test');
+    });
+
+    it('should handle notifications (no id)', async () => {
+      let receivedMessage: unknown = null;
+
+      transport.onMessage(async (message) => {
+        receivedMessage = message;
+        return;
+      });
+
+      transport.start();
+
+      const notification = JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'notifications/test',
+        params: {},
+      });
+
+      mockInput.push(notification + '\n');
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(receivedMessage).not.toBeNull();
+    });
+  });
+
+  describe('message sending', () => {
+    it('should send response to output', () => {
+      transport.start();
+
+      const response = createSuccessResponse(1, { data: 'test' });
+      transport.send(response);
+
+      expect(mockOutput.output.length).toBe(1);
+      const sent = JSON.parse(mockOutput.output[0].trim());
+      expect(sent.jsonrpc).toBe('2.0');
+      expect(sent.id).toBe(1);
+      expect(sent.result).toEqual({ data: 'test' });
+    });
+
+    it('should throw if transport not connected', () => {
+      const response = createSuccessResponse(1, {});
+      expect(() => transport.send(response)).toThrow('Transport not connected');
+    });
+  });
+});
+
+describe('JSON-RPC Response Helpers', () => {
+  describe('createSuccessResponse', () => {
+    it('should create valid success response', () => {
+      const response = createSuccessResponse(1, { data: 'test' });
+      expect(response.jsonrpc).toBe('2.0');
+      expect(response.id).toBe(1);
+      expect(response.result).toEqual({ data: 'test' });
+      expect(response.error).toBeUndefined();
+    });
+
+    it('should handle string id', () => {
+      const response = createSuccessResponse('abc-123', { value: 42 });
+      expect(response.id).toBe('abc-123');
+    });
+  });
+
+  describe('createErrorResponse', () => {
+    it('should create valid error response', () => {
+      const response = createErrorResponse(
+        1,
+        JsonRpcErrorCode.MethodNotFound,
+        'Method not found'
+      );
+      expect(response.jsonrpc).toBe('2.0');
+      expect(response.id).toBe(1);
+      expect(response.error?.code).toBe(-32601);
+      expect(response.error?.message).toBe('Method not found');
+    });
+
+    it('should include optional data', () => {
+      const response = createErrorResponse(
+        1,
+        JsonRpcErrorCode.InvalidParams,
+        'Invalid params',
+        { field: 'name' }
+      );
+      expect(response.error?.data).toEqual({ field: 'name' });
+    });
+  });
+});