@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/haClient/history.test.ts

@@ -1,228 +0,0 @@
-/**
- * HistoryOperations tests
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { HistoryOperations } from '../../src/haClient/history.js';
-import type { RequestHandler } from '../../src/haClient/request.js';
-import type { Entity, LogbookEntry } from '../../src/types/index.js';
-
-describe('HistoryOperations', () => {
-  let mockRequest: RequestHandler;
-  let historyOps: HistoryOperations;
-
-  beforeEach(() => {
-    mockRequest = {
-      get: vi.fn(),
-    } as unknown as RequestHandler;
-
-    historyOps = new HistoryOperations(mockRequest);
-  });
-
-  describe('getHistory', () => {
-    it('should fetch history for entity', async () => {
-      const mockHistory: Entity[][] = [
-        [
-          {
-            entity_id: 'sensor.temperature',
-            state: '20.0',
-            attributes: { unit_of_measurement: '°C' },
-            last_changed: '2026-01-08T08:00:00.000Z',
-            last_updated: '2026-01-08T08:00:00.000Z',
-            context: { id: 'ctx-1', parent_id: null, user_id: null },
-          },
-          {
-            entity_id: 'sensor.temperature',
-            state: '21.5',
-            attributes: { unit_of_measurement: '°C' },
-            last_changed: '2026-01-08T09:00:00.000Z',
-            last_updated: '2026-01-08T09:00:00.000Z',
-            context: { id: 'ctx-2', parent_id: null, user_id: null },
-          },
-          {
-            entity_id: 'sensor.temperature',
-            state: '22.5',
-            attributes: { unit_of_measurement: '°C' },
-            last_changed: '2026-01-08T10:00:00.000Z',
-            last_updated: '2026-01-08T10:00:00.000Z',
-            context: { id: 'ctx-3', parent_id: null, user_id: null },
-          },
-        ],
-      ];
-
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockHistory);
-
-      const history = await historyOps.getHistory('sensor.temperature', 24);
-
-      expect(history).toEqual(mockHistory);
-      expect(mockRequest.get).toHaveBeenCalledWith(
-        expect.stringContaining('/history/period/'),
-        expect.objectContaining({
-          filter_entity_id: 'sensor.temperature',
-          end_time: expect.any(String),
-        })
-      );
-    });
-
-    it('should use default 24 hours', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([[]]);
-
-      await historyOps.getHistory('sensor.test');
-
-      expect(mockRequest.get).toHaveBeenCalled();
-    });
-
-    it('should handle custom hours parameter', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([[]]);
-
-      await historyOps.getHistory('sensor.test', 48);
-
-      expect(mockRequest.get).toHaveBeenCalled();
-    });
-
-    it('should return empty history', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([[]]);
-
-      const history = await historyOps.getHistory('sensor.nonexistent');
-
-      expect(history).toEqual([[]]);
-    });
-  });
-
-  describe('getSystemLog', () => {
-    it('should fetch logbook entries', async () => {
-      const mockEntries: LogbookEntry[] = [
-        {
-          when: '2026-01-08T10:00:00.000Z',
-          name: 'Living Room Light',
-          entity_id: 'light.living_room',
-          state: 'on',
-          domain: 'light',
-        },
-        {
-          when: '2026-01-08T09:30:00.000Z',
-          name: 'Motion detected',
-          entity_id: 'binary_sensor.motion',
-          state: 'on',
-          domain: 'binary_sensor',
-        },
-      ];
-
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntries);
-
-      const entries = await historyOps.getSystemLog();
-
-      expect(entries).toEqual(mockEntries);
-      expect(mockRequest.get).toHaveBeenCalledWith(
-        expect.stringContaining('/logbook/'),
-        expect.objectContaining({
-          end_time: expect.any(String),
-        })
-      );
-    });
-
-    it('should filter by entity_id', async () => {
-      const mockEntries: LogbookEntry[] = [
-        {
-          when: '2026-01-08T10:00:00.000Z',
-          name: 'Living Room Light',
-          entity_id: 'light.living_room',
-          state: 'on',
-        },
-      ];
-
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntries);
-
-      await historyOps.getSystemLog({ entity_id: 'light.living_room' });
-
-      expect(mockRequest.get).toHaveBeenCalledWith(
-        expect.any(String),
-        expect.objectContaining({
-          entity: 'light.living_room',
-        })
-      );
-    });
-
-    it('should use custom hours parameter', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-      await historyOps.getSystemLog({ hours: 48 });
-
-      expect(mockRequest.get).toHaveBeenCalled();
-    });
-
-    it('should use default 24 hours', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-      await historyOps.getSystemLog();
-
-      expect(mockRequest.get).toHaveBeenCalled();
-    });
-
-    it('should return empty array when no logs', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-      const entries = await historyOps.getSystemLog();
-
-      expect(entries).toEqual([]);
-    });
-
-    it('should apply limit to results', async () => {
-      // Create 150 mock entries
-      const mockEntries: LogbookEntry[] = Array.from({ length: 150 }, (_, i) => ({
-        when: `2026-01-08T${String(i % 24).padStart(2, '0')}:00:00.000Z`,
-        name: `Entity ${i}`,
-        entity_id: `sensor.test_${i}`,
-        state: 'on',
-        domain: 'sensor',
-      }));
-
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntries);
-
-      // Default limit is 100
-      const entries = await historyOps.getSystemLog();
-
-      expect(entries).toHaveLength(100);
-      // Should return the LAST 100 entries (most recent)
-      expect(entries[0].entity_id).toBe('sensor.test_50');
-      expect(entries[99].entity_id).toBe('sensor.test_149');
-    });
-
-    it('should respect custom limit', async () => {
-      const mockEntries: LogbookEntry[] = Array.from({ length: 50 }, (_, i) => ({
-        when: `2026-01-08T${String(i % 24).padStart(2, '0')}:00:00.000Z`,
-        name: `Entity ${i}`,
-        entity_id: `sensor.test_${i}`,
-        state: 'on',
-        domain: 'sensor',
-      }));
-
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntries);
-
-      const entries = await historyOps.getSystemLog({ limit: 10 });
-
-      expect(entries).toHaveLength(10);
-      // Should return the LAST 10 entries
-      expect(entries[0].entity_id).toBe('sensor.test_40');
-      expect(entries[9].entity_id).toBe('sensor.test_49');
-    });
-
-    it('should cap hours at 168 (1 week)', async () => {
-      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-      await historyOps.getSystemLog({ hours: 500 });
-
-      // Verify that the start time is capped at 168 hours ago
-      const call = (mockRequest.get as ReturnType<typeof vi.fn>).mock.calls[0];
-      const path = call[0] as string;
-      const startTimeStr = path.replace('/logbook/', '');
-      const startTime = new Date(startTimeStr);
-      const now = new Date();
-      const hoursDiff = (now.getTime() - startTime.getTime()) / (1000 * 60 * 60);
-
-      // Should be approximately 168 hours, not 500
-      expect(hoursDiff).toBeGreaterThan(160);
-      expect(hoursDiff).toBeLessThan(175);
-    });
-  });
-});

package/tests/haClient/index.test.ts

@@ -1,243 +0,0 @@
-/**
- * HaClient aggregator tests
- */
-
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-// Create mock instances
-const statesInstance = {
-  getStates: vi.fn().mockResolvedValue([{ entity_id: 'light.test' }]),
-  getState: vi.fn().mockResolvedValue({ entity_id: 'light.test' }),
-  getAllSensors: vi.fn().mockResolvedValue([{ entity_id: 'sensor.test' }]),
-};
-
-const servicesInstance = {
-  callService: vi.fn().mockResolvedValue({ context: { id: 'ctx-1' } }),
-  restartServer: vi.fn().mockResolvedValue(undefined),
-};
-
-const entitiesInstance = {
-  getEntitiesByDomain: vi.fn().mockResolvedValue([{ entity_id: 'light.test' }]),
-  searchEntities: vi.fn().mockResolvedValue([{ entity_id: 'light.test' }]),
-  getDomainSummary: vi.fn().mockResolvedValue({ domain: 'light', count: 1 }),
-  listEntities: vi.fn().mockResolvedValue([{ entity_id: 'light.test' }]),
-};
-
-const automationsInstance = {
-  getAutomations: vi.fn().mockResolvedValue([{ id: 'automation.test' }]),
-};
-
-const historyInstance = {
-  getHistory: vi.fn().mockResolvedValue([[{ entity_id: 'sensor.test' }]]),
-  getSystemLog: vi.fn().mockResolvedValue([{ when: '2026-01-08T10:00:00Z' }]),
-};
-
-const updatesInstance = {
-  getAvailableUpdates: vi.fn().mockResolvedValue({ updates: [], entities: [] }),
-};
-
-const configInstance = {
-  getConfig: vi.fn().mockResolvedValue({ version: '2026.1.0' }),
-  checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
-  getVersion: vi.fn().mockResolvedValue({ version: '2026.1.0' }),
-};
-
-const requestInstance = {
-  request: vi.fn().mockResolvedValue({}),
-  get: vi.fn().mockResolvedValue({}),
-  post: vi.fn().mockResolvedValue({}),
-};
-
-// Mock classes for vitest 4.x compatibility
-const StateOperationsMock = vi.fn().mockImplementation(() => statesInstance);
-const ServiceOperationsMock = vi.fn().mockImplementation(() => servicesInstance);
-const EntityOperationsMock = vi.fn().mockImplementation(() => entitiesInstance);
-const AutomationOperationsMock = vi.fn().mockImplementation(() => automationsInstance);
-const HistoryOperationsMock = vi.fn().mockImplementation(() => historyInstance);
-const UpdateOperationsMock = vi.fn().mockImplementation(() => updatesInstance);
-const ConfigOperationsMock = vi.fn().mockImplementation(() => configInstance);
-const RequestHandlerMock = vi.fn().mockImplementation(() => requestInstance);
-
-// Apply mocks with class-style factories
-vi.mock('../../src/haClient/states.js', () => ({
-  StateOperations: class {
-    constructor() {
-      StateOperationsMock();
-      return statesInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/services.js', () => ({
-  ServiceOperations: class {
-    constructor() {
-      ServiceOperationsMock();
-      return servicesInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/entities.js', () => ({
-  EntityOperations: class {
-    constructor() {
-      EntityOperationsMock();
-      return entitiesInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/automations.js', () => ({
-  AutomationOperations: class {
-    constructor() {
-      AutomationOperationsMock();
-      return automationsInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/history.js', () => ({
-  HistoryOperations: class {
-    constructor() {
-      HistoryOperationsMock();
-      return historyInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/updates.js', () => ({
-  UpdateOperations: class {
-    constructor() {
-      UpdateOperationsMock();
-      return updatesInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/config.js', () => ({
-  ConfigOperations: class {
-    constructor() {
-      ConfigOperationsMock();
-      return configInstance;
-    }
-  },
-}));
-
-vi.mock('../../src/haClient/request.js', () => ({
-  RequestHandler: class {
-    constructor() {
-      RequestHandlerMock();
-      return requestInstance;
-    }
-  },
-}));
-
-import type { HaClientOptions } from '../../src/haClient/index.js';
-
-const baseConfig: HaClientOptions = {
-  baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
-  token: 'test-token',
-  strictSsl: false,
-  timeout: 30000,
-};
-
-describe('HaClient aggregator', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('initializes all operation modules', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    expect(RequestHandlerMock).toHaveBeenCalled();
-    expect(StateOperationsMock).toHaveBeenCalled();
-    expect(ServiceOperationsMock).toHaveBeenCalled();
-    expect(EntityOperationsMock).toHaveBeenCalled();
-    expect(AutomationOperationsMock).toHaveBeenCalled();
-    expect(HistoryOperationsMock).toHaveBeenCalled();
-    expect(UpdateOperationsMock).toHaveBeenCalled();
-    expect(ConfigOperationsMock).toHaveBeenCalled();
-  });
-
-  it('proxies state operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getStates()).resolves.toEqual([{ entity_id: 'light.test' }]);
-    await expect(client.getState('light.test')).resolves.toEqual({ entity_id: 'light.test' });
-    await expect(client.getAllSensors()).resolves.toEqual([{ entity_id: 'sensor.test' }]);
-
-    expect(statesInstance.getStates).toHaveBeenCalled();
-    expect(statesInstance.getState).toHaveBeenCalledWith('light.test');
-    expect(statesInstance.getAllSensors).toHaveBeenCalled();
-  });
-
-  it('proxies service operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    const serviceData = { domain: 'light', service: 'turn_on' };
-    await expect(client.callService(serviceData)).resolves.toEqual({ context: { id: 'ctx-1' } });
-    await expect(client.restartServer()).resolves.toBeUndefined();
-
-    expect(servicesInstance.callService).toHaveBeenCalledWith(serviceData);
-    expect(servicesInstance.restartServer).toHaveBeenCalled();
-  });
-
-  it('proxies entity operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getEntitiesByDomain('light')).resolves.toEqual([{ entity_id: 'light.test' }]);
-    await expect(client.searchEntities('test')).resolves.toEqual([{ entity_id: 'light.test' }]);
-    await expect(client.getDomainSummary('light')).resolves.toEqual({ domain: 'light', count: 1 });
-    await expect(client.listEntities({ domain: 'light' })).resolves.toEqual([{ entity_id: 'light.test' }]);
-
-    expect(entitiesInstance.getEntitiesByDomain).toHaveBeenCalledWith('light');
-    expect(entitiesInstance.searchEntities).toHaveBeenCalledWith('test');
-    expect(entitiesInstance.getDomainSummary).toHaveBeenCalledWith('light');
-    expect(entitiesInstance.listEntities).toHaveBeenCalledWith({ domain: 'light' });
-  });
-
-  it('proxies automation operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getAutomations()).resolves.toEqual([{ id: 'automation.test' }]);
-
-    expect(automationsInstance.getAutomations).toHaveBeenCalled();
-  });
-
-  it('proxies history operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getHistory('sensor.test', 24)).resolves.toEqual([[{ entity_id: 'sensor.test' }]]);
-    await expect(client.getSystemLog({ hours: 24 })).resolves.toEqual([{ when: '2026-01-08T10:00:00Z' }]);
-
-    expect(historyInstance.getHistory).toHaveBeenCalledWith('sensor.test', 24);
-    expect(historyInstance.getSystemLog).toHaveBeenCalledWith({ hours: 24 });
-  });
-
-  it('proxies update operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getAvailableUpdates()).resolves.toEqual({ updates: [], entities: [] });
-
-    expect(updatesInstance.getAvailableUpdates).toHaveBeenCalled();
-  });
-
-  it('proxies config operations', async () => {
-    const { HaClient } = await import('../../src/haClient/index.js');
-    const client = new HaClient(baseConfig);
-
-    await expect(client.getConfig()).resolves.toEqual({ version: '2026.1.0' });
-    await expect(client.checkApi()).resolves.toEqual({ message: 'API running.' });
-    await expect(client.getVersion()).resolves.toEqual({ version: '2026.1.0' });
-
-    expect(configInstance.getConfig).toHaveBeenCalled();
-    expect(configInstance.checkApi).toHaveBeenCalled();
-    expect(configInstance.getVersion).toHaveBeenCalled();
-  });
-});

package/tests/haClient/request.test.ts

@@ -1,217 +0,0 @@
-/**
- * RequestHandler tests
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { RequestHandler } from '../../src/haClient/request.js';
-import { AuthenticationError, ApiError } from '../../src/types/index.js';
-
-// Mock fetch globally
-global.fetch = vi.fn();
-
-describe('RequestHandler', () => {
-  let handler: RequestHandler;
-
-  beforeEach(() => {
-    handler = new RequestHandler({
-      baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
-      token: 'test-token-12345',
-      timeout: 30000,
-      strictSsl: false,
-    });
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('request', () => {
-    it('should make GET request with authorization header', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({ data: 'test' }),
-      });
-
-      await handler.request('/test');
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'http://homeassistant.10.0.0.19.nip.io:8123/api/test',
-        expect.objectContaining({
-          method: 'GET',
-          headers: expect.objectContaining({
-            'Authorization': 'Bearer test-token-12345',
-            'Content-Type': 'application/json',
-          }),
-        })
-      );
-    });
-
-    it('should make POST request with body', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({ success: true }),
-      });
-
-      await handler.request('/test', {
-        method: 'POST',
-        body: { key: 'value' },
-      });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'http://homeassistant.10.0.0.19.nip.io:8123/api/test',
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify({ key: 'value' }),
-        })
-      );
-    });
-
-    it('should add query parameters to URL', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({}),
-      });
-
-      await handler.request('/test', {
-        params: { filter: 'active', limit: 10 },
-      });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('filter=active'),
-        expect.any(Object)
-      );
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('limit=10'),
-        expect.any(Object)
-      );
-    });
-
-    it('should throw AuthenticationError on 401', async () => {
-      const mockResponse = {
-        ok: false,
-        status: 401,
-        statusText: 'Unauthorized',
-        text: async () => 'Invalid token',
-      };
-      (global.fetch as any).mockResolvedValueOnce(mockResponse);
-
-      const error = await handler.request('/test').catch((e) => e);
-      expect(error).toBeInstanceOf(AuthenticationError);
-      expect(error.message).toBe('Invalid Home Assistant token');
-    });
-
-    it('should throw ApiError on other HTTP errors', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        text: async () => 'Server error',
-      });
-
-      await expect(handler.request('/test')).rejects.toThrow(ApiError);
-    });
-
-    it('should handle empty responses', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'text/plain']]),
-      });
-
-      const result = await handler.request('/test');
-
-      expect(result).toEqual({});
-    });
-
-    it('should handle network errors', async () => {
-      (global.fetch as any).mockRejectedValueOnce(new Error('Network timeout'));
-
-      await expect(handler.request('/test')).rejects.toThrow('Network timeout');
-    });
-  });
-
-  describe('get', () => {
-    it('should make GET request', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({ data: 'result' }),
-      });
-
-      const result = await handler.get<{ data: string }>('/states');
-
-      expect(result).toEqual({ data: 'result' });
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/states'),
-        expect.objectContaining({ method: 'GET' })
-      );
-    });
-
-    it('should pass query parameters', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({}),
-      });
-
-      await handler.get('/history', { entity_id: 'light.living_room' });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('entity_id=light.living_room'),
-        expect.any(Object)
-      );
-    });
-  });
-
-  describe('post', () => {
-    it('should make POST request with body', async () => {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: new Map([['content-type', 'application/json']]),
-        json: async () => ({ context: { id: '123' } }),
-      });
-
-      const result = await handler.post('/services/light/turn_on', {
-        entity_id: 'light.living_room',
-      });
-
-      expect(result).toEqual({ context: { id: '123' } });
-      expect(global.fetch).toHaveBeenCalledWith(
-        expect.stringContaining('/services/light/turn_on'),
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify({ entity_id: 'light.living_room' }),
-        })
-      );
-    });
-  });
-
-  describe('SSL configuration', () => {
-    it('should create HTTPS agent when strictSsl is false', () => {
-      const handlerNoSsl = new RequestHandler({
-        baseUrl: 'https://homeassistant.10.0.0.19.nip.io:8123',
-        token: 'token',
-        timeout: 30000,
-        strictSsl: false,
-      });
-
-      // Handler is created successfully with strictSsl: false
-      expect(handlerNoSsl).toBeDefined();
-    });
-
-    it('should not create HTTPS agent when strictSsl is true', () => {
-      const handlerWithSsl = new RequestHandler({
-        baseUrl: 'https://homeassistant.10.0.0.19.nip.io:8123',
-        token: 'token',
-        timeout: 30000,
-        strictSsl: true,
-      });
-
-      // Handler is created successfully with strictSsl: true
-      expect(handlerWithSsl).toBeDefined();
-    });
-  });
-});