@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/localAI/ollama.test.ts

@@ -1,187 +0,0 @@
-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

@@ -1,257 +0,0 @@
-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/omadaClient/actions.test.ts

@@ -1,161 +0,0 @@
-/**
- * Unit tests for the v1.6 Omada action operations:
- *  - DeviceOperations.cyclePoePorts (PoE recovery = remote hard-reboot of PoE devices)
- *  - NetworkOperations.setSsidEnabled (SSID on/off via the WLAN-schedule mechanism)
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-import { DeviceOperations } from '../../src/omadaClient/device.js';
-import { NetworkOperations, ALWAYS_PROFILE_NAME } from '../../src/omadaClient/network.js';
-import type { RequestHandler } from '../../src/omadaClient/request.js';
-import type { SiteOperations } from '../../src/omadaClient/site.js';
-
-const buildPath = (p: string): string => `/openapi/v1/omadac1${p.startsWith('/') ? p : `/${p}`}`;
-
-function createMockRequest() {
-    return {
-        get: vi.fn(),
-        post: vi.fn(),
-        patch: vi.fn(),
-        fetchPaginated: vi.fn(),
-        // Mirrors the real ensureSuccess: unwrap result, throw on errorCode !== 0
-        ensureSuccess: vi.fn((response: { errorCode: number; msg?: string; result?: unknown }) => {
-            if (response.errorCode !== 0) {
-                throw new Error(response.msg ?? `Omada error ${String(response.errorCode)}`);
-            }
-            return response.result;
-        }),
-    };
-}
-
-const mockSite = { resolveSiteId: vi.fn(() => 'site-1') } as unknown as SiteOperations;
-
-const ok = (result?: unknown) => ({ errorCode: 0, msg: 'Success', result });
-
-describe('DeviceOperations.cyclePoePorts', () => {
-    let request: ReturnType<typeof createMockRequest>;
-    let ops: DeviceOperations;
-
-    beforeEach(() => {
-        request = createMockRequest();
-        ops = new DeviceOperations(request as unknown as RequestHandler, mockSite, buildPath);
-    });
-
-    it('POSTs the poe-recovery endpoint with the ports payload', async () => {
-        request.post.mockResolvedValue(ok());
-
-        await ops.cyclePoePorts('AA-BB-CC-DD-EE-FF', [1, 3]);
-
-        expect(request.post).toHaveBeenCalledWith(
-            '/openapi/v1/omadac1/sites/site-1/switches/AA-BB-CC-DD-EE-FF/multi-ports/poe-recovery',
-            { ports: [1, 3] }
-        );
-    });
-
-    it('rejects a missing switchMac with an actionable hint', async () => {
-        await expect(ops.cyclePoePorts('', [1])).rejects.toThrow(/switchMac.*omada_listDevices/);
-        expect(request.post).not.toHaveBeenCalled();
-    });
-
-    it('rejects an empty ports array', async () => {
-        await expect(ops.cyclePoePorts('AA-BB-CC-DD-EE-FF', [])).rejects.toThrow(/at least one port/i);
-        expect(request.post).not.toHaveBeenCalled();
-    });
-
-    it('propagates controller errors via ensureSuccess', async () => {
-        request.post.mockResolvedValue({ errorCode: -1, msg: 'port not PoE capable' });
-        await expect(ops.cyclePoePorts('AA-BB-CC-DD-EE-FF', [9])).rejects.toThrow('port not PoE capable');
-    });
-});
-
-describe('NetworkOperations.setSsidEnabled', () => {
-    let request: ReturnType<typeof createMockRequest>;
-    let ops: NetworkOperations;
-
-    const WLANS = [
-        {
-            wlanId: 'wlan-1',
-            wlanName: 'Default',
-            ssidList: [
-                { ssidId: 'ssid-main', ssidName: 'Tower' },
-                { ssidId: 'ssid-guest', ssidName: 'Tower-Guest' },
-            ],
-        },
-    ];
-
-    beforeEach(() => {
-        request = createMockRequest();
-        ops = new NetworkOperations(request as unknown as RequestHandler, mockSite, buildPath);
-    });
-
-    it('enables an SSID by simply disabling its WLAN schedule', async () => {
-        request.get.mockResolvedValueOnce(ok(WLANS)); // listAllSsids
-        request.patch.mockResolvedValue(ok());
-
-        const result = await ops.setSsidEnabled('Tower-Guest', true);
-
-        expect(request.patch).toHaveBeenCalledWith(
-            '/openapi/v1/omadac1/sites/site-1/wireless-network/wlans/wlan-1/ssids/ssid-guest/update-wlan-schedule',
-            { wlanScheduleEnable: false }
-        );
-        expect(result).toMatchObject({ ssidId: 'ssid-guest', ssidName: 'Tower-Guest', enabled: true });
-    });
-
-    it('resolves the SSID case-insensitively by name, or exactly by ssidId', async () => {
-        request.get.mockResolvedValue(ok(WLANS));
-        request.patch.mockResolvedValue(ok());
-
-        await ops.setSsidEnabled('tower-guest', true);
-        await ops.setSsidEnabled('ssid-main', true);
-
-        expect(request.patch).toHaveBeenCalledTimes(2);
-        expect(request.patch.mock.calls[1][0]).toContain('/ssids/ssid-main/');
-    });
-
-    it('disables an SSID by applying a radio-off schedule with the reusable 24/7 profile', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(WLANS)) // listAllSsids
-            .mockResolvedValueOnce(ok([{ profileId: 'prof-247', name: ALWAYS_PROFILE_NAME }])); // profiles: exists
-        request.patch.mockResolvedValue(ok());
-
-        const result = await ops.setSsidEnabled('Tower-Guest', false);
-
-        expect(request.post).not.toHaveBeenCalled(); // profile existed — no create
-        expect(request.patch).toHaveBeenCalledWith(
-            expect.stringContaining('/ssids/ssid-guest/update-wlan-schedule'),
-            { wlanScheduleEnable: true, action: 0, scheduleId: 'prof-247' }
-        );
-        expect(result).toMatchObject({ enabled: false, scheduleId: 'prof-247' });
-    });
-
-    it('creates the 24/7 profile once when missing (and re-lists for its id — the API returns none)', async () => {
-        request.get
-            .mockResolvedValueOnce(ok(WLANS)) // listAllSsids
-            .mockResolvedValueOnce(ok([{ profileId: 'other', name: 'unrelated' }])) // profiles: missing
-            .mockResolvedValueOnce(ok([{ profileId: 'prof-new', name: ALWAYS_PROFILE_NAME }])); // re-list after create
-        request.post.mockResolvedValue(ok());
-        request.patch.mockResolvedValue(ok());
-
-        const result = await ops.setSsidEnabled('Tower-Guest', false);
-
-        expect(request.post).toHaveBeenCalledWith(
-            '/openapi/v1/omadac1/sites/site-1/time-range-profiles',
-            expect.objectContaining({
-                name: ALWAYS_PROFILE_NAME,
-                dayMode: 0,
-                timeList: [expect.objectContaining({ startTimeH: 0, endTimeH: 24 })],
-            })
-        );
-        expect(result.scheduleId).toBe('prof-new');
-    });
-
-    it('rejects an unknown SSID and lists the available ones', async () => {
-        request.get.mockResolvedValueOnce(ok(WLANS));
-
-        await expect(ops.setSsidEnabled('DoesNotExist', false)).rejects.toThrow(
-            /not found.*Tower.*Tower-Guest/s
-        );
-        expect(request.patch).not.toHaveBeenCalled();
-    });
-});