@coffeerunhobby/mcp-ha-connect 0.5.0

package/tests/localAI/ollama.test.ts

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OllamaProvider } from '../../src/localAI/providers/ollama.js';
+import type { AIProviderConfig, SensorData } from '../../src/localAI/types.js';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('OllamaProvider', () => {
+  const defaultConfig: AIProviderConfig = {
+    provider: 'ollama',
+    baseUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+    model: 'qwen3:14b',
+    timeout: 60000,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getProviderName', () => {
+    it('should return "ollama"', () => {
+      const provider = new OllamaProvider(defaultConfig);
+      expect(provider.getProviderName()).toBe('ollama');
+    });
+  });
+
+  describe('checkHealth', () => {
+    it('should return true when Ollama is available', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true });
+
+      const provider = new OllamaProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://ollama.10.0.0.17.nip.io:11434/api/tags',
+        expect.objectContaining({
+          signal: expect.any(AbortSignal),
+        })
+      );
+    });
+
+    it('should return false when Ollama is not available', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
+
+      const provider = new OllamaProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when Ollama returns non-ok response', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false });
+
+      const provider = new OllamaProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('analyzeSensors', () => {
+    const sensorData: SensorData = {
+      'sensor.temperature': {
+        state: '45',
+        unit: '°C',
+        attributes: { friendly_name: 'Indoor Temperature' },
+      },
+    };
+
+    it('should analyze sensors successfully', async () => {
+      const mockResponse = {
+        severity: 'critical',
+        issue: 'High temperature detected',
+        reasoning: 'Temperature is above 40°C',
+        recommended_actions: ['Check HVAC', 'Open windows'],
+        ssh_diagnostics: ['systemctl status hvac'],
+        confidence: 0.95,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ response: JSON.stringify(mockResponse) }),
+      });
+
+      const provider = new OllamaProvider(defaultConfig);
+      const result = await provider.analyzeSensors(sensorData);
+
+      expect(result.severity).toBe('critical');
+      expect(result.issue).toBe('High temperature detected');
+      expect(result.model).toBe('qwen3:14b');
+      expect(result.provider).toBe('ollama');
+      expect(result.response_time).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should throw error on API failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        text: async () => 'Internal Server Error',
+      });
+
+      const provider = new OllamaProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('Ollama request failed');
+    });
+
+    it('should throw error on empty response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ response: '' }),
+      });
+
+      const provider = new OllamaProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('Empty response from ollama');
+    });
+
+    it('should throw error when no JSON in response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ response: 'This is not JSON' }),
+      });
+
+      const provider = new OllamaProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('No JSON found in AI response');
+    });
+
+    it('should extract JSON from response with extra text', async () => {
+      const mockResponse = {
+        severity: 'medium',
+        issue: 'Minor issue',
+        reasoning: 'Test',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.8,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          response: `Here is the analysis:\n${JSON.stringify(mockResponse)}\n\nEnd of analysis.`,
+        }),
+      });
+
+      const provider = new OllamaProvider(defaultConfig);
+      const result = await provider.analyzeSensors(sensorData);
+
+      expect(result.severity).toBe('medium');
+    });
+
+    it('should include auth headers when API key is set', async () => {
+      const configWithKey: AIProviderConfig = {
+        ...defaultConfig,
+        apiKey: 'test-api-key',
+      };
+
+      const mockResponse = {
+        severity: 'low',
+        issue: 'Test',
+        reasoning: 'Test',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.9,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ response: JSON.stringify(mockResponse) }),
+      });
+
+      const provider = new OllamaProvider(configWithKey);
+      await provider.analyzeSensors(sensorData);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-api-key',
+          }),
+        })
+      );
+    });
+  });
+});

package/tests/localAI/openai.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OpenAICompatibleProvider } from '../../src/localAI/providers/openai.js';
+import type { AIProviderConfig, SensorData } from '../../src/localAI/types.js';
+
+// Mock fetch globally
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe('OpenAICompatibleProvider', () => {
+  const defaultConfig: AIProviderConfig = {
+    provider: 'openai',
+    baseUrl: 'http://localhost:8080',
+    model: 'gpt-3.5-turbo',
+    timeout: 60000,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getProviderName', () => {
+    it('should return "openai-compatible"', () => {
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      expect(provider.getProviderName()).toBe('openai-compatible');
+    });
+  });
+
+  describe('checkHealth', () => {
+    it('should return true when API is available', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/v1/models',
+        expect.objectContaining({
+          signal: expect.any(AbortSignal),
+        })
+      );
+    });
+
+    it('should return false when API is not available', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when API returns non-ok response', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: false });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      const result = await provider.checkHealth();
+
+      expect(result).toBe(false);
+    });
+
+    it('should include auth headers in health check when API key is set', async () => {
+      const configWithKey: AIProviderConfig = {
+        ...defaultConfig,
+        apiKey: 'test-api-key',
+      };
+
+      mockFetch.mockResolvedValueOnce({ ok: true });
+
+      const provider = new OpenAICompatibleProvider(configWithKey);
+      await provider.checkHealth();
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-api-key',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('analyzeSensors', () => {
+    const sensorData: SensorData = {
+      'sensor.temperature': {
+        state: '45',
+        unit: '°C',
+        attributes: { friendly_name: 'Indoor Temperature' },
+      },
+    };
+
+    it('should analyze sensors successfully', async () => {
+      const mockResponse = {
+        severity: 'critical',
+        issue: 'High temperature detected',
+        reasoning: 'Temperature is above 40°C',
+        recommended_actions: ['Check HVAC', 'Open windows'],
+        ssh_diagnostics: ['systemctl status hvac'],
+        confidence: 0.95,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [
+            {
+              message: {
+                content: JSON.stringify(mockResponse),
+              },
+            },
+          ],
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      const result = await provider.analyzeSensors(sensorData);
+
+      expect(result.severity).toBe('critical');
+      expect(result.issue).toBe('High temperature detected');
+      expect(result.model).toBe('gpt-3.5-turbo');
+      expect(result.provider).toBe('openai-compatible');
+      expect(result.response_time).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should use chat completions endpoint', async () => {
+      const mockResponse = {
+        severity: 'low',
+        issue: 'Test',
+        reasoning: 'Test',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.9,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: JSON.stringify(mockResponse) } }],
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      await provider.analyzeSensors(sensorData);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/v1/chat/completions',
+        expect.objectContaining({
+          method: 'POST',
+          body: expect.stringContaining('"messages"'),
+        })
+      );
+    });
+
+    it('should send messages in OpenAI format', async () => {
+      const mockResponse = {
+        severity: 'low',
+        issue: 'Test',
+        reasoning: 'Test',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.9,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: JSON.stringify(mockResponse) } }],
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+      await provider.analyzeSensors(sensorData);
+
+      const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+      expect(callBody.messages).toHaveLength(2);
+      expect(callBody.messages[0].role).toBe('system');
+      expect(callBody.messages[1].role).toBe('user');
+      expect(callBody.model).toBe('gpt-3.5-turbo');
+      expect(callBody.temperature).toBe(0.3);
+      expect(callBody.max_tokens).toBe(2000);
+    });
+
+    it('should throw error on API failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        text: async () => 'Internal Server Error',
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('OpenAI-compatible API request failed');
+    });
+
+    it('should throw error on API error response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          error: { message: 'Model not found' },
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('API error: Model not found');
+    });
+
+    it('should throw error on empty response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: '' } }],
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(defaultConfig);
+
+      await expect(provider.analyzeSensors(sensorData)).rejects.toThrow('Empty response from openai-compatible');
+    });
+
+    it('should include auth headers when API key is set', async () => {
+      const configWithKey: AIProviderConfig = {
+        ...defaultConfig,
+        apiKey: 'sk-test-key',
+      };
+
+      const mockResponse = {
+        severity: 'low',
+        issue: 'Test',
+        reasoning: 'Test',
+        recommended_actions: [],
+        ssh_diagnostics: [],
+        confidence: 0.9,
+      };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: JSON.stringify(mockResponse) } }],
+        }),
+      });
+
+      const provider = new OpenAICompatibleProvider(configWithKey);
+      await provider.analyzeSensors(sensorData);
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer sk-test-key',
+          }),
+        })
+      );
+    });
+  });
+});

package/tests/server/common.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Server common functionality tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createServer } from '../../src/server/common.js';
+import { HaClient } from '../../src/haClient/index.js';
+import type { EnvironmentConfig } from '../../src/config.js';
+
+// Mock the tools registry
+vi.mock('../../src/tools/registry.js', () => ({
+  registerAllTools: vi.fn(),
+}));
+
+describe('createServer', () => {
+  let mockClient: HaClient;
+  let mockConfig: EnvironmentConfig;
+
+  beforeEach(() => {
+    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,
+    };
+
+    mockClient = new HaClient(mockConfig);
+  });
+
+  it('should create MCP server with correct name and version', () => {
+    const server = createServer(mockClient);
+
+    expect(server).toBeDefined();
+    // Server should have the correct configuration
+    // Note: We can't easily test internal properties, but we can verify it was created
+  });
+
+  it('should register all tools on server creation', async () => {
+    const { registerAllTools } = await import('../../src/tools/registry.js');
+    const server = createServer(mockClient);
+
+    // Third argument (ollamaClient) is optional
+    expect(registerAllTools).toHaveBeenCalledWith(server, mockClient, undefined);
+  });
+
+  it('should create server with tools capability', () => {
+    const server = createServer(mockClient);
+
+    // The server should be created successfully
+    expect(server).toBeDefined();
+    expect(typeof server.connect).toBe('function');
+  });
+});