@coffeerunhobby/mcp-ha-connect 0.5.0

package/tests/server/http.test.ts

@@ -0,0 +1,326 @@
+/**
+ * HTTP server tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { HaClient } from '../../src/haClient/index.js';
+import type { EnvironmentConfig } from '../../src/config.js';
+
+// Mock dependencies
+vi.mock('node:http');
+vi.mock('../../src/server/sse.js');
+vi.mock('../../src/server/stream.js');
+vi.mock('../../src/utils/logger.js');
+
+describe('HTTP Server', () => {
+  let mockClient: HaClient;
+  let mockConfig: EnvironmentConfig;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockClient = {
+      checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
+      getStates: vi.fn(),
+      getState: vi.fn(),
+      callService: vi.fn(),
+      getEntitiesByDomain: vi.fn(),
+      searchEntities: vi.fn(),
+    } as any;
+
+    mockConfig = {
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      token: 'test-token',
+      strictSsl: false,
+      timeout: 30000,
+      aiProvider: 'ollama',
+      aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+      aiModel: 'qwen3:14b',
+      aiTimeout: 60000,
+      logLevel: 'info',
+      logFormat: 'plain',
+      useHttp: true,
+      stateful: false,
+      httpPort: 3000,
+      httpTransport: 'stream',
+      httpBindAddr: '127.0.0.1',
+      httpPath: '/mcp',
+      httpEnableHealthcheck: true,
+      httpHealthcheckPath: '/health',
+      httpAllowCors: true,
+      httpAllowedOrigins: ['127.0.0.1', 'localhost'],
+    };
+  });
+
+  describe('Health Check Handler', () => {
+    it('should return health status for stream transport', () => {
+      const expectedResponse = {
+        status: 'healthy',
+        version: '0.1.0',
+        transport: 'stream',
+        stateful: false,
+      };
+
+      expect(expectedResponse.status).toBe('healthy');
+      expect(expectedResponse.transport).toBe('stream');
+      expect(expectedResponse.stateful).toBe(false);
+    });
+
+    it('should return health status for SSE transport', () => {
+      const sseConfig = { ...mockConfig, httpTransport: 'sse' as const };
+
+      const expectedResponse = {
+        status: 'healthy',
+        version: '0.1.0',
+        transport: sseConfig.httpTransport,
+        stateful: sseConfig.stateful,
+      };
+
+      expect(expectedResponse.transport).toBe('sse');
+    });
+
+    it('should include stateful flag when enabled', () => {
+      const statefulConfig = { ...mockConfig, stateful: true };
+
+      const expectedResponse = {
+        status: 'healthy',
+        version: '0.1.0',
+        transport: statefulConfig.httpTransport,
+        stateful: statefulConfig.stateful,
+      };
+
+      expect(expectedResponse.stateful).toBe(true);
+    });
+  });
+
+  describe('CORS Handler', () => {
+    it('should not set CORS headers when CORS is disabled', () => {
+      const noCorsConfig = { ...mockConfig, httpAllowCors: false };
+
+      expect(noCorsConfig.httpAllowCors).toBe(false);
+    });
+
+    it('should allow specific origins', () => {
+      const allowedOrigins = ['http://mcpserver.10.0.0.18.nip.io:3000', 'http://192.168.0.10:8080'];
+      const corsConfig = { ...mockConfig, httpAllowedOrigins: allowedOrigins };
+
+      expect(corsConfig.httpAllowedOrigins).toContain('http://mcpserver.10.0.0.18.nip.io:3000');
+      expect(corsConfig.httpAllowedOrigins).toContain('http://192.168.0.10:8080');
+    });
+
+    it('should allow all origins when list is empty (wildcard)', () => {
+      const wildcardConfig = { ...mockConfig, httpAllowedOrigins: [] };
+
+      // Empty array means wildcard was used
+      expect(wildcardConfig.httpAllowedOrigins).toEqual([]);
+    });
+
+    it('should set correct CORS headers', () => {
+      const expectedHeaders = {
+        'Access-Control-Allow-Origin': 'http://mcpserver.10.0.0.18.nip.io:3000',
+        'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Mcp-Session-Id',
+        'Access-Control-Max-Age': '86400',
+      };
+
+      expect(expectedHeaders['Access-Control-Allow-Methods']).toContain('GET');
+      expect(expectedHeaders['Access-Control-Allow-Methods']).toContain('POST');
+      expect(expectedHeaders['Access-Control-Allow-Headers']).toContain('Mcp-Session-Id');
+    });
+  });
+
+  describe('Server Configuration', () => {
+    it('should use default port if not specified', () => {
+      const configWithoutPort = { ...mockConfig };
+      delete configWithoutPort.httpPort;
+
+      const port = configWithoutPort.httpPort ?? 3000;
+      expect(port).toBe(3000);
+    });
+
+    it('should use default bind address if not specified', () => {
+      const configWithoutBind = { ...mockConfig };
+      delete configWithoutBind.httpBindAddr;
+
+      const bindAddr = configWithoutBind.httpBindAddr ?? '127.0.0.1';
+      expect(bindAddr).toBe('127.0.0.1');
+    });
+
+    it('should use default health check path if not specified', () => {
+      const configWithoutHealthPath = { ...mockConfig };
+      delete configWithoutHealthPath.httpHealthcheckPath;
+
+      const healthPath = configWithoutHealthPath.httpHealthcheckPath ?? '/health';
+      expect(healthPath).toBe('/health');
+    });
+
+    it('should support custom configuration', () => {
+      const customConfig = {
+        ...mockConfig,
+        httpPort: 8080,
+        httpBindAddr: '0.0.0.0',
+        httpPath: '/custom-mcp',
+        httpHealthcheckPath: '/status',
+      };
+
+      expect(customConfig.httpPort).toBe(8080);
+      expect(customConfig.httpBindAddr).toBe('0.0.0.0');
+      expect(customConfig.httpPath).toBe('/custom-mcp');
+      expect(customConfig.httpHealthcheckPath).toBe('/status');
+    });
+  });
+
+  describe('Request Routing', () => {
+    it('should route to health check for /health', () => {
+      const healthPath = mockConfig.httpHealthcheckPath;
+      const requestUrl = '/health';
+
+      expect(requestUrl).toBe(healthPath);
+    });
+
+    it('should route to MCP endpoint for stream transport', () => {
+      const mcpPath = mockConfig.httpPath;
+      const requestUrl = '/mcp';
+
+      expect(requestUrl).toBe(mcpPath);
+      expect(mockConfig.httpTransport).toBe('stream');
+    });
+
+    it('should route to SSE endpoint for SSE transport', () => {
+      const sseConfig = { ...mockConfig, httpTransport: 'sse' as const, httpPath: '/sse' };
+      const requestUrl = '/sse';
+
+      expect(requestUrl).toBe(sseConfig.httpPath);
+      expect(sseConfig.httpTransport).toBe('sse');
+    });
+
+    it('should handle OPTIONS requests for CORS preflight', () => {
+      const method = 'OPTIONS';
+
+      expect(method).toBe('OPTIONS');
+      // Should return 204 No Content
+    });
+
+    it('should return 404 for unknown paths', () => {
+      const unknownPath = '/unknown-endpoint';
+      const validPaths = [mockConfig.httpPath, mockConfig.httpHealthcheckPath];
+
+      expect(validPaths).not.toContain(unknownPath);
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should create new session when stateful mode is disabled', () => {
+      expect(mockConfig.stateful).toBe(false);
+      // Each request should create a new transport
+    });
+
+    it('should reuse session when stateful mode is enabled', () => {
+      const statefulConfig = { ...mockConfig, stateful: true };
+
+      expect(statefulConfig.stateful).toBe(true);
+      // Should maintain sessions in Map
+    });
+
+    it('should require Mcp-Session-Id header for stateful SSE', () => {
+      const statefulSseConfig = {
+        ...mockConfig,
+        httpTransport: 'sse' as const,
+        stateful: true,
+      };
+
+      expect(statefulSseConfig.stateful).toBe(true);
+      expect(statefulSseConfig.httpTransport).toBe('sse');
+      // Should validate session ID from header
+    });
+
+    it('should return error for invalid session ID', () => {
+      const statefulConfig = { ...mockConfig, stateful: true };
+
+      expect(statefulConfig.stateful).toBe(true);
+      // Should return 400 error for missing/invalid session
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle request parsing errors', () => {
+      const invalidJson = 'not-valid-json';
+
+      expect(() => JSON.parse(invalidJson)).toThrow();
+      // Should return 500 with error message
+    });
+
+    it('should not send headers if already sent', () => {
+      let headersSent = true;
+
+      if (!headersSent) {
+        // Would send error response
+      }
+
+      expect(headersSent).toBe(true);
+    });
+
+    it('should log errors with request details', () => {
+      const error = new Error('Test error');
+      const requestMethod = 'POST';
+      const requestUrl = '/mcp';
+
+      const logData = {
+        error,
+        method: requestMethod,
+        url: requestUrl,
+      };
+
+      expect(logData.method).toBe('POST');
+      expect(logData.url).toBe('/mcp');
+      expect(logData.error).toBe(error);
+    });
+  });
+
+  describe('JSON Response Helper', () => {
+    it('should format JSON response correctly', () => {
+      const statusCode = 200;
+      const data = { status: 'healthy', version: '0.1.0' };
+
+      const expectedContentType = 'application/json';
+      const expectedBody = JSON.stringify(data);
+
+      expect(expectedContentType).toBe('application/json');
+      expect(expectedBody).toBe('{"status":"healthy","version":"0.1.0"}');
+    });
+
+    it('should handle error responses', () => {
+      const statusCode = 500;
+      const errorData = {
+        error: 'Internal server error',
+        message: 'Something went wrong',
+      };
+
+      const expectedBody = JSON.stringify(errorData);
+
+      expect(statusCode).toBe(500);
+      expect(JSON.parse(expectedBody).error).toBe('Internal server error');
+    });
+  });
+
+  describe('Body Parsing', () => {
+    it('should parse valid JSON body', () => {
+      const jsonBody = '{"key":"value"}';
+      const parsed = JSON.parse(jsonBody);
+
+      expect(parsed).toEqual({ key: 'value' });
+    });
+
+    it('should return undefined for empty body', () => {
+      const emptyBody = '';
+
+      expect(emptyBody || undefined).toBeUndefined();
+    });
+
+    it('should throw error for invalid JSON', () => {
+      const invalidJson = '{invalid}';
+
+      expect(() => JSON.parse(invalidJson)).toThrow();
+    });
+  });
+});

package/tests/server/sse.test.ts

@@ -0,0 +1,240 @@
+/**
+ * SSE (Server-Sent Events) transport tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { HaClient } from '../../src/haClient/index.js';
+import type { EnvironmentConfig } from '../../src/config.js';
+
+// Mock dependencies
+vi.mock('@modelcontextprotocol/sdk/server/sse.js');
+vi.mock('../../src/server/common.js');
+vi.mock('../../src/utils/logger.js');
+
+describe('SSE Transport', () => {
+  let mockClient: HaClient;
+  let mockConfig: EnvironmentConfig;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockClient = {
+      checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
+      getStates: vi.fn(),
+      getState: vi.fn(),
+      callService: vi.fn(),
+      getEntitiesByDomain: vi.fn(),
+      searchEntities: vi.fn(),
+    } as any;
+
+    mockConfig = {
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      token: 'test-token',
+      strictSsl: false,
+      timeout: 30000,
+      aiProvider: 'ollama',
+      aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+      aiModel: 'qwen3:14b',
+      aiTimeout: 60000,
+      logLevel: 'info',
+      logFormat: 'plain',
+      useHttp: true,
+      stateful: true,
+      httpPort: 3000,
+      httpTransport: 'sse',
+      httpBindAddr: '127.0.0.1',
+      httpPath: '/sse',
+      httpEnableHealthcheck: true,
+      httpHealthcheckPath: '/health',
+      httpAllowCors: true,
+      httpAllowedOrigins: ['127.0.0.1', 'localhost'],
+    };
+  });
+
+  describe('getSseMessagePath', () => {
+    it('should return correct message path', async () => {
+      const { getSseMessagePath } = await import('../../src/server/sse.js');
+
+      const messagePath = getSseMessagePath();
+      expect(messagePath).toBe('/messages');
+    });
+  });
+
+  describe('SSE Connection', () => {
+    it('should create SSE transport with correct configuration', () => {
+      const endpoint = '/sse';
+
+      expect(mockConfig.httpTransport).toBe('sse');
+      expect(mockConfig.httpPath).toBe(endpoint);
+    });
+
+    it('should generate session ID for stateful connections', () => {
+      const sessionId = `sse-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+      expect(sessionId).toMatch(/^sse-\d+-[a-z0-9]+$/);
+      expect(sessionId.length).toBeGreaterThan(10);
+    });
+
+    it('should set correct SSE headers', () => {
+      const sseHeaders = {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      };
+
+      expect(sseHeaders['Content-Type']).toBe('text/event-stream');
+      expect(sseHeaders['Cache-Control']).toBe('no-cache');
+      expect(sseHeaders['Connection']).toBe('keep-alive');
+    });
+
+    it('should include session ID in stateful mode', () => {
+      expect(mockConfig.stateful).toBe(true);
+
+      const sessionId = 'sse-123456-abc';
+      const sseHeaders = {
+        'Mcp-Session-Id': sessionId,
+      };
+
+      expect(sseHeaders['Mcp-Session-Id']).toBe(sessionId);
+    });
+  });
+
+  describe('SSE Message Handling', () => {
+    it('should require session ID for stateful mode', () => {
+      expect(mockConfig.stateful).toBe(true);
+
+      const sessionId = undefined;
+      const isValid = !!sessionId;
+
+      expect(isValid).toBe(false);
+      // Should return 400 error
+    });
+
+    it('should validate session exists', () => {
+      const sessions = new Map();
+      const sessionId = 'sse-123';
+      const session = sessions.get(sessionId);
+
+      expect(session).toBeUndefined();
+      // Should return 400 error for invalid session
+    });
+
+    it('should handle valid session', () => {
+      const sessions = new Map();
+      const sessionId = 'sse-123';
+      const mockSession = {
+        transport: { sessionId },
+        server: {},
+      };
+      sessions.set(sessionId, mockSession);
+
+      const session = sessions.get(sessionId);
+
+      expect(session).toBeDefined();
+      expect(session?.transport.sessionId).toBe(sessionId);
+    });
+
+    it('should parse message body', () => {
+      const messageBody = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+          name: 'getStates',
+          arguments: {},
+        },
+      };
+
+      expect(messageBody.method).toBe('tools/call');
+      expect(messageBody.params.name).toBe('getStates');
+    });
+  });
+
+  describe('SSE Protocol', () => {
+    it('should use legacy MCP protocol version', () => {
+      const protocolVersion = '2024-11-05';
+
+      expect(protocolVersion).toBe('2024-11-05');
+      // This is the legacy SSE protocol version
+    });
+
+    it('should support text/event-stream content type', () => {
+      const contentType = 'text/event-stream';
+
+      expect(contentType).toBe('text/event-stream');
+    });
+
+    it('should maintain persistent connection', () => {
+      const connection = 'keep-alive';
+
+      expect(connection).toBe('keep-alive');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle missing session gracefully', () => {
+      const sessionId = undefined;
+      const errorResponse = {
+        error: 'Invalid or missing session',
+      };
+
+      expect(sessionId).toBeUndefined();
+      expect(errorResponse.error).toBe('Invalid or missing session');
+    });
+
+    it('should handle invalid session ID', () => {
+      const sessions = new Map();
+      const invalidSessionId = 'invalid-session';
+      const session = sessions.get(invalidSessionId);
+
+      expect(session).toBeUndefined();
+      // Should return 400 error
+    });
+
+    it('should handle malformed message body', () => {
+      const invalidJson = 'not-json';
+
+      expect(() => JSON.parse(invalidJson)).toThrow();
+      // Should return error response
+    });
+  });
+
+  describe('Transport State', () => {
+    it('should store transport and server in state', () => {
+      const state = {
+        transport: { sessionId: 'sse-123' },
+        server: { connect: vi.fn() },
+      };
+
+      expect(state.transport).toBeDefined();
+      expect(state.server).toBeDefined();
+      expect(state.transport.sessionId).toBe('sse-123');
+    });
+
+    it('should validate transport has sessionId property', () => {
+      const state = {
+        transport: { sessionId: 'sse-123' },
+        server: {},
+      };
+
+      const hasSessionId = 'sessionId' in state.transport;
+
+      expect(hasSessionId).toBe(true);
+    });
+
+    it('should distinguish SSE from Stream transport', () => {
+      const sseState = {
+        transport: { sessionId: 'sse-123' },
+        server: {},
+      };
+
+      const streamState = {
+        transport: {}, // No sessionId
+        server: {},
+      };
+
+      expect('sessionId' in sseState.transport).toBe(true);
+      expect('sessionId' in streamState.transport).toBe(false);
+    });
+  });
+});

package/tests/server/stdio.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Stdio server tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { HaClient } from '../../src/haClient/index.js';
+import type { EnvironmentConfig } from '../../src/config.js';
+
+// Mock dependencies
+vi.mock('../../src/server/common.js');
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js');
+vi.mock('../../src/utils/logger.js');
+
+describe('startStdioServer', () => {
+  let mockClient: HaClient;
+  let mockConfig: EnvironmentConfig;
+  let startStdioServer: any;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.resetModules();
+
+    mockConfig = {
+      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+      token: 'test-token',
+      strictSsl: false,
+      timeout: 30000,
+      aiProvider: 'ollama',
+      aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+      aiModel: 'qwen3:14b',
+      aiTimeout: 60000,
+      logLevel: 'info',
+      logFormat: 'plain',
+      useHttp: false,
+      stateful: false,
+      httpTransport: 'stream',
+      httpEnableHealthcheck: true,
+      httpAllowCors: true,
+    };
+
+    // Mock HaClient
+    mockClient = {
+      checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
+      getStates: vi.fn(),
+      getState: vi.fn(),
+      callService: vi.fn(),
+      getEntitiesByDomain: vi.fn(),
+      searchEntities: vi.fn(),
+    } as any;
+
+    // Import the function to test
+    const stdioModule = await import('../../src/server/stdio.js');
+    startStdioServer = stdioModule.startStdioServer;
+  });
+
+  it('should create and start stdio server', async () => {
+    const { createServer } = await import('../../src/server/common.js');
+    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+
+    const mockServer = {
+      connect: vi.fn().mockResolvedValue(undefined),
+    };
+    vi.mocked(createServer).mockReturnValue(mockServer as any);
+
+    const mockTransport = {};
+    vi.mocked(StdioServerTransport).mockImplementation(() => mockTransport as any);
+
+    await startStdioServer(mockClient);
+
+    // Second argument (ollamaClient) is optional
+    expect(createServer).toHaveBeenCalledWith(mockClient, undefined);
+    expect(StdioServerTransport).toHaveBeenCalled();
+    expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+  });
+
+  it('should log server startup', async () => {
+    const { logger } = await import('../../src/utils/logger.js');
+    const { createServer } = await import('../../src/server/common.js');
+
+    const mockServer = {
+      connect: vi.fn().mockResolvedValue(undefined),
+    };
+    vi.mocked(createServer).mockReturnValue(mockServer as any);
+
+    await startStdioServer(mockClient);
+
+    expect(logger.info).toHaveBeenCalledWith('Starting stdio server');
+    expect(logger.info).toHaveBeenCalledWith('Connecting stdio server');
+    expect(logger.info).toHaveBeenCalledWith('Stdio server connected and ready');
+  });
+
+  it('should handle connection errors', async () => {
+    const { createServer } = await import('../../src/server/common.js');
+
+    const mockServer = {
+      connect: vi.fn().mockRejectedValue(new Error('Connection failed')),
+    };
+    vi.mocked(createServer).mockReturnValue(mockServer as any);
+
+    await expect(startStdioServer(mockClient)).rejects.toThrow('Connection failed');
+  });
+});