@coffeerunhobby/mcp-ha-connect 0.5.0

package/tests/haClient/automations.test.ts

@@ -0,0 +1,133 @@
+/**
+ * AutomationOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AutomationOperations } from '../../src/haClient/automations.js';
+import type { StateOperations } from '../../src/haClient/states.js';
+import type { Entity } from '../../src/types/index.js';
+
+describe('AutomationOperations', () => {
+  let mockStateOps: StateOperations;
+  let automationOps: AutomationOperations;
+
+  const mockAutomationEntities: Entity[] = [
+    {
+      entity_id: 'automation.morning_lights',
+      state: 'on',
+      attributes: {
+        friendly_name: 'Morning Lights',
+        last_triggered: '2026-01-08T06:00:00.000Z',
+        description: 'Turn on lights at sunrise',
+        mode: 'single',
+      },
+      last_changed: '2026-01-08T06:00:00.000Z',
+      last_updated: '2026-01-08T06:00:00.000Z',
+      context: { id: 'ctx-1', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'automation.night_mode',
+      state: 'off',
+      attributes: {
+        friendly_name: 'Night Mode',
+        last_triggered: null,
+        mode: 'restart',
+      },
+      last_changed: '2026-01-07T22:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-2', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'automation.motion_alert',
+      state: 'on',
+      attributes: {
+        friendly_name: 'Motion Alert',
+        last_triggered: '2026-01-08T09:30:00.000Z',
+        mode: 'queued',
+      },
+      last_changed: '2026-01-08T09:30:00.000Z',
+      last_updated: '2026-01-08T09:30:00.000Z',
+      context: { id: 'ctx-3', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'light.living_room', // Non-automation entity
+      state: 'on',
+      attributes: { friendly_name: 'Living Room Light' },
+      last_changed: '2026-01-08T10:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-4', parent_id: null, user_id: null },
+    },
+  ];
+
+  beforeEach(() => {
+    mockStateOps = {
+      getStates: vi.fn().mockResolvedValue(mockAutomationEntities),
+    } as unknown as StateOperations;
+
+    automationOps = new AutomationOperations(mockStateOps);
+  });
+
+  describe('getAutomations', () => {
+    it('should return only automation entities', async () => {
+      const automations = await automationOps.getAutomations();
+
+      expect(automations).toHaveLength(3);
+      expect(automations.every(a => a.id.startsWith('automation.'))).toBe(true);
+    });
+
+    it('should map entity to Automation type', async () => {
+      const automations = await automationOps.getAutomations();
+
+      const morning = automations.find(a => a.id === 'automation.morning_lights');
+      expect(morning).toEqual({
+        id: 'automation.morning_lights',
+        alias: 'Morning Lights',
+        state: 'on',
+        last_triggered: '2026-01-08T06:00:00.000Z',
+        description: 'Turn on lights at sunrise',
+        mode: 'single',
+      });
+    });
+
+    it('should handle automations without friendly_name', async () => {
+      (mockStateOps.getStates as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          entity_id: 'automation.unnamed',
+          state: 'on',
+          attributes: {},
+          last_changed: '2026-01-08T10:00:00.000Z',
+          last_updated: '2026-01-08T10:00:00.000Z',
+          context: { id: 'ctx-1', parent_id: null, user_id: null },
+        },
+      ]);
+
+      const automations = await automationOps.getAutomations();
+
+      expect(automations[0].alias).toBe('unnamed');
+    });
+
+    it('should handle null last_triggered', async () => {
+      const automations = await automationOps.getAutomations();
+
+      const nightMode = automations.find(a => a.id === 'automation.night_mode');
+      expect(nightMode?.last_triggered).toBeNull();
+    });
+
+    it('should return empty array when no automations exist', async () => {
+      (mockStateOps.getStates as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          entity_id: 'light.test',
+          state: 'on',
+          attributes: {},
+          last_changed: '2026-01-08T10:00:00.000Z',
+          last_updated: '2026-01-08T10:00:00.000Z',
+          context: { id: 'ctx-1', parent_id: null, user_id: null },
+        },
+      ]);
+
+      const automations = await automationOps.getAutomations();
+
+      expect(automations).toEqual([]);
+    });
+  });
+});

package/tests/haClient/config.test.ts

@@ -0,0 +1,96 @@
+/**
+ * ConfigOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ConfigOperations } from '../../src/haClient/config.js';
+import type { RequestHandler } from '../../src/haClient/request.js';
+import type { HaVersion } from '../../src/types/index.js';
+
+describe('ConfigOperations', () => {
+  let mockRequest: RequestHandler;
+  let configOps: ConfigOperations;
+
+  const mockConfig: HaVersion = {
+    version: '2026.1.0',
+    config_dir: '/config',
+    location_name: 'Home',
+    time_zone: 'Europe/London',
+    unit_system: {
+      length: 'km',
+      mass: 'kg',
+      temperature: '°C',
+      volume: 'L',
+    },
+    components: ['homeassistant', 'frontend', 'light', 'switch', 'sensor', 'automation'],
+    state: 'RUNNING',
+  };
+
+  beforeEach(() => {
+    mockRequest = {
+      get: vi.fn(),
+    } as unknown as RequestHandler;
+
+    configOps = new ConfigOperations(mockRequest);
+  });
+
+  describe('getConfig', () => {
+    it('should fetch configuration', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockConfig);
+
+      const config = await configOps.getConfig();
+
+      expect(config).toEqual(mockConfig);
+      expect(mockRequest.get).toHaveBeenCalledWith('/config');
+    });
+  });
+
+  describe('checkApi', () => {
+    it('should return API health status', async () => {
+      const mockApiResponse = { message: 'API running.' };
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockApiResponse);
+
+      const result = await configOps.checkApi();
+
+      expect(result).toEqual(mockApiResponse);
+      expect(mockRequest.get).toHaveBeenCalledWith('/');
+    });
+  });
+
+  describe('getVersion', () => {
+    it('should return version information', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockConfig);
+
+      const version = await configOps.getVersion();
+
+      expect(version).toEqual(mockConfig);
+      expect(version.version).toBe('2026.1.0');
+      expect(mockRequest.get).toHaveBeenCalledWith('/config');
+    });
+
+    it('should include all config fields', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockConfig);
+
+      const version = await configOps.getVersion();
+
+      expect(version.config_dir).toBe('/config');
+      expect(version.location_name).toBe('Home');
+      expect(version.time_zone).toBe('Europe/London');
+      expect(version.state).toBe('RUNNING');
+      expect(version.components).toContain('homeassistant');
+    });
+
+    it('should include unit_system', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockConfig);
+
+      const version = await configOps.getVersion();
+
+      expect(version.unit_system).toEqual({
+        length: 'km',
+        mass: 'kg',
+        temperature: '°C',
+        volume: 'L',
+      });
+    });
+  });
+});

package/tests/haClient/entities.test.ts

@@ -0,0 +1,188 @@
+/**
+ * EntityOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { EntityOperations } from '../../src/haClient/entities.js';
+import type { StateOperations } from '../../src/haClient/states.js';
+import type { Entity } from '../../src/types/index.js';
+
+describe('EntityOperations', () => {
+  let mockStateOps: StateOperations;
+  let entityOps: EntityOperations;
+
+  const mockEntities: Entity[] = [
+    {
+      entity_id: 'light.living_room',
+      state: 'on',
+      attributes: { friendly_name: 'Living Room Light', brightness: 255 },
+      last_changed: '2026-01-08T10:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-1', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'light.bedroom',
+      state: 'off',
+      attributes: { friendly_name: 'Bedroom Light' },
+      last_changed: '2026-01-08T09:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-2', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'sensor.temperature',
+      state: '22.5',
+      attributes: { friendly_name: 'Temperature', 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 },
+    },
+    {
+      entity_id: 'switch.kitchen',
+      state: 'on',
+      attributes: { friendly_name: 'Kitchen Switch' },
+      last_changed: '2026-01-08T08:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-4', parent_id: null, user_id: null },
+    },
+  ];
+
+  beforeEach(() => {
+    mockStateOps = {
+      getStates: vi.fn().mockResolvedValue(mockEntities),
+    } as unknown as StateOperations;
+
+    entityOps = new EntityOperations(mockStateOps);
+  });
+
+  describe('getEntitiesByDomain', () => {
+    it('should filter entities by domain', async () => {
+      const lights = await entityOps.getEntitiesByDomain('light');
+
+      expect(lights).toHaveLength(2);
+      expect(lights.map(e => e.entity_id)).toContain('light.living_room');
+      expect(lights.map(e => e.entity_id)).toContain('light.bedroom');
+    });
+
+    it('should return empty array for non-existent domain', async () => {
+      const climate = await entityOps.getEntitiesByDomain('climate');
+
+      expect(climate).toEqual([]);
+    });
+
+    it('should return single entity domain', async () => {
+      const switches = await entityOps.getEntitiesByDomain('switch');
+
+      expect(switches).toHaveLength(1);
+      expect(switches[0].entity_id).toBe('switch.kitchen');
+    });
+  });
+
+  describe('searchEntities', () => {
+    it('should find entities by friendly name', async () => {
+      const results = await entityOps.searchEntities('living');
+
+      expect(results).toHaveLength(1);
+      expect(results[0].entity_id).toBe('light.living_room');
+    });
+
+    it('should find entities by entity_id', async () => {
+      const results = await entityOps.searchEntities('kitchen');
+
+      expect(results).toHaveLength(1);
+      expect(results[0].entity_id).toBe('switch.kitchen');
+    });
+
+    it('should be case insensitive', async () => {
+      const results = await entityOps.searchEntities('BEDROOM');
+
+      expect(results).toHaveLength(1);
+      expect(results[0].entity_id).toBe('light.bedroom');
+    });
+
+    it('should return multiple matches', async () => {
+      const results = await entityOps.searchEntities('light');
+
+      expect(results).toHaveLength(2);
+    });
+
+    it('should return empty array for no matches', async () => {
+      const results = await entityOps.searchEntities('nonexistent');
+
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe('getDomainSummary', () => {
+    it('should return domain summary with counts', async () => {
+      const summary = await entityOps.getDomainSummary('light');
+
+      expect(summary.domain).toBe('light');
+      expect(summary.count).toBe(2);
+      expect(summary.states).toEqual({ on: 1, off: 1 });
+    });
+
+    it('should include entity list with state and name', async () => {
+      const summary = await entityOps.getDomainSummary('light');
+
+      expect(summary.entities).toHaveLength(2);
+      expect(summary.entities).toContainEqual({
+        entity_id: 'light.living_room',
+        state: 'on',
+        friendly_name: 'Living Room Light',
+      });
+    });
+
+    it('should return empty summary for non-existent domain', async () => {
+      const summary = await entityOps.getDomainSummary('climate');
+
+      expect(summary.domain).toBe('climate');
+      expect(summary.count).toBe(0);
+      expect(summary.states).toEqual({});
+      expect(summary.entities).toEqual([]);
+    });
+  });
+
+  describe('listEntities', () => {
+    it('should list all entities without filters', async () => {
+      const entities = await entityOps.listEntities();
+
+      expect(entities).toEqual(mockEntities);
+    });
+
+    it('should filter by domain', async () => {
+      const entities = await entityOps.listEntities({ domain: 'light' });
+
+      expect(entities).toHaveLength(2);
+      expect(entities.every(e => e.entity_id.startsWith('light.'))).toBe(true);
+    });
+
+    it('should filter by state', async () => {
+      const entities = await entityOps.listEntities({ state: 'on' });
+
+      expect(entities).toHaveLength(2);
+      expect(entities.every(e => e.state === 'on')).toBe(true);
+    });
+
+    it('should filter by search query', async () => {
+      const entities = await entityOps.listEntities({ search: 'room' });
+
+      expect(entities).toHaveLength(2); // living_room and bedroom
+    });
+
+    it('should apply limit', async () => {
+      const entities = await entityOps.listEntities({ limit: 2 });
+
+      expect(entities).toHaveLength(2);
+    });
+
+    it('should combine multiple filters', async () => {
+      const entities = await entityOps.listEntities({
+        domain: 'light',
+        state: 'on',
+      });
+
+      expect(entities).toHaveLength(1);
+      expect(entities[0].entity_id).toBe('light.living_room');
+    });
+  });
+});

package/tests/haClient/history.test.ts

@@ -0,0 +1,170 @@
+/**
+ * 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([]);
+    });
+  });
+});