@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/bdd/entity-search.spec.ts

@@ -1,183 +0,0 @@
-/**
- * BDD tests for Entity Search
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } 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';
-
-const feature = await loadFeature('tests/features/entity-search.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let mockStateOps: StateOperations;
-  let entityOps: EntityOperations;
-  let searchResults: Entity[];
-
-  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 },
-    },
-  ];
-
-  function setupMocks() {
-    mockStateOps = {
-      getStates: vi.fn().mockResolvedValue(mockEntities),
-    } as unknown as StateOperations;
-    entityOps = new EntityOperations(mockStateOps);
-    searchResults = [];
-  }
-
-  Scenario('Search entities by friendly name', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I search for "living"', async () => {
-      searchResults = await entityOps.searchEntities('living');
-    });
-
-    Then('I should find entities with "living" in their friendly name', () => {
-      expect(searchResults.length).toBeGreaterThan(0);
-    });
-
-    And('the results should include "light.living_room"', () => {
-      expect(searchResults.map(e => e.entity_id)).toContain('light.living_room');
-    });
-  });
-
-  Scenario('Search entities by entity ID', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I search for "kitchen"', async () => {
-      searchResults = await entityOps.searchEntities('kitchen');
-    });
-
-    Then('I should find entities with "kitchen" in their entity ID', () => {
-      expect(searchResults.length).toBeGreaterThan(0);
-    });
-
-    And('the results should include "switch.kitchen"', () => {
-      expect(searchResults.map(e => e.entity_id)).toContain('switch.kitchen');
-    });
-  });
-
-  Scenario('Search is case insensitive', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I search for "BEDROOM"', async () => {
-      searchResults = await entityOps.searchEntities('BEDROOM');
-    });
-
-    Then('I should find entities matching "bedroom"', () => {
-      expect(searchResults.length).toBeGreaterThan(0);
-    });
-
-    And('the results should include "light.bedroom"', () => {
-      expect(searchResults.map(e => e.entity_id)).toContain('light.bedroom');
-    });
-  });
-
-  Scenario('Search returns multiple matches', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I search for "light"', async () => {
-      searchResults = await entityOps.searchEntities('light');
-    });
-
-    Then('I should find all entities containing "light"', () => {
-      expect(searchResults.every(e =>
-        e.entity_id.toLowerCase().includes('light') ||
-        (e.attributes.friendly_name as string)?.toLowerCase().includes('light')
-      )).toBe(true);
-    });
-
-    And('the result count should be 2', () => {
-      expect(searchResults).toHaveLength(2);
-    });
-  });
-
-  Scenario('Search returns empty for no matches', ({ Given, When, Then }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I search for "nonexistent"', async () => {
-      searchResults = await entityOps.searchEntities('nonexistent');
-    });
-
-    Then('I should find no entities', () => {
-      expect(searchResults).toHaveLength(0);
-    });
-  });
-
-  Scenario('Get entities by domain', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I get entities for domain "light"', async () => {
-      searchResults = await entityOps.getEntitiesByDomain('light');
-    });
-
-    Then('I should only get light entities', () => {
-      expect(searchResults.length).toBeGreaterThan(0);
-    });
-
-    And('all entity IDs should start with "light."', () => {
-      expect(searchResults.every(e => e.entity_id.startsWith('light.'))).toBe(true);
-    });
-  });
-
-  Scenario('Get entities for empty domain', ({ Given, When, Then }) => {
-    Given('a Home Assistant instance with multiple entities', () => {
-      setupMocks();
-    });
-
-    When('I get entities for domain "climate"', async () => {
-      searchResults = await entityOps.getEntitiesByDomain('climate');
-    });
-
-    Then('I should find no entities', () => {
-      expect(searchResults).toHaveLength(0);
-    });
-  });
-});

package/tests/bdd/history-retrieval.spec.ts

@@ -1,195 +0,0 @@
-/**
- * BDD tests for History Retrieval
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } 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';
-
-const feature = await loadFeature('tests/features/history-retrieval.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let mockRequest: RequestHandler;
-  let historyOps: HistoryOperations;
-  let historyResult: Entity[][];
-  let logEntries: LogbookEntry[];
-  let lastGetCall: { path: string; params: Record<string, unknown> } | null;
-
-  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 },
-      },
-    ],
-  ];
-
-  const mockLogEntries: 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',
-    },
-  ];
-
-  function setupMocks(historyData: Entity[][] = mockHistory, logData: LogbookEntry[] = mockLogEntries) {
-    lastGetCall = null;
-
-    mockRequest = {
-      get: vi.fn().mockImplementation(async (path: string, params?: Record<string, unknown>) => {
-        lastGetCall = { path, params: params || {} };
-        if (path.includes('/history/')) {
-          return historyData;
-        }
-        if (path.includes('/logbook/')) {
-          return logData;
-        }
-        return [];
-      }),
-    } as unknown as RequestHandler;
-
-    historyOps = new HistoryOperations(mockRequest);
-  }
-
-  Scenario('Get entity history for last 24 hours', ({ Given, When, Then, And }) => {
-    Given('an entity "sensor.temperature" with historical data', () => {
-      setupMocks();
-    });
-
-    When('I get the history for the last 24 hours', async () => {
-      historyResult = await historyOps.getHistory('sensor.temperature', 24);
-    });
-
-    Then('I should receive historical state changes', () => {
-      expect(historyResult).toBeDefined();
-      expect(historyResult[0]?.length).toBeGreaterThan(0);
-    });
-
-    And('the history API should be called with the correct time range', () => {
-      expect(lastGetCall?.path).toContain('/history/period/');
-      expect(lastGetCall?.params.filter_entity_id).toBe('sensor.temperature');
-    });
-  });
-
-  Scenario('Get entity history with custom time range', ({ Given, When, Then, And }) => {
-    Given('an entity "sensor.temperature" with historical data', () => {
-      setupMocks();
-    });
-
-    When('I get the history for the last 48 hours', async () => {
-      historyResult = await historyOps.getHistory('sensor.temperature', 48);
-    });
-
-    Then('I should receive historical state changes', () => {
-      expect(historyResult).toBeDefined();
-    });
-
-    And('the time range should be 48 hours', () => {
-      expect(mockRequest.get).toHaveBeenCalled();
-      // The start time in the path should be ~48 hours ago
-      expect(lastGetCall?.path).toContain('/history/period/');
-    });
-  });
-
-  Scenario('Get empty history for entity', ({ Given, When, Then }) => {
-    Given('an entity with no history', () => {
-      setupMocks([[]]);
-    });
-
-    When('I get the history', async () => {
-      historyResult = await historyOps.getHistory('sensor.nonexistent');
-    });
-
-    Then('I should receive an empty history array', () => {
-      expect(historyResult).toEqual([[]]);
-    });
-  });
-
-  Scenario('Get system log entries', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant system log', () => {
-      setupMocks();
-    });
-
-    When('I get the system log', async () => {
-      logEntries = await historyOps.getSystemLog();
-    });
-
-    Then('I should receive logbook entries', () => {
-      expect(logEntries.length).toBeGreaterThan(0);
-    });
-
-    And('each entry should have timestamp and entity information', () => {
-      logEntries.forEach(entry => {
-        expect(entry.when).toBeDefined();
-        expect(entry.entity_id).toBeDefined();
-      });
-    });
-  });
-
-  Scenario('Get system log filtered by entity', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant system log', () => {
-      setupMocks();
-    });
-
-    When('I get the system log for entity "light.living_room"', async () => {
-      logEntries = await historyOps.getSystemLog({ entity_id: 'light.living_room' });
-    });
-
-    Then('I should receive only entries for that entity', () => {
-      expect(logEntries).toBeDefined();
-    });
-
-    And('the entity filter should be applied', () => {
-      expect(lastGetCall?.params.entity).toBe('light.living_room');
-    });
-  });
-
-  Scenario('Get system log with custom time range', ({ Given, When, Then }) => {
-    Given('a Home Assistant system log', () => {
-      setupMocks();
-    });
-
-    When('I get the system log for the last 48 hours', async () => {
-      logEntries = await historyOps.getSystemLog({ hours: 48 });
-    });
-
-    Then('the logbook API should use the 48 hour time range', () => {
-      expect(lastGetCall?.path).toContain('/logbook/');
-      // The start time should be ~48 hours ago
-      expect(mockRequest.get).toHaveBeenCalled();
-    });
-  });
-});

package/tests/bdd/notifications.spec.ts

@@ -1,238 +0,0 @@
-/**
- * BDD tests for Notifications
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } from 'vitest';
-import type { HaClient } from '../../src/haClient/index.js';
-import type { ServiceCallResponse } from '../../src/types/index.js';
-
-// Simulates the notification tool's buildNotificationData function
-function buildNotificationData(args: {
-  tag?: string;
-  group?: string;
-  priority?: string;
-  importance?: string;
-  actions?: Array<{ action: string; title: string; uri?: string }>;
-  image?: string;
-  sticky?: boolean;
-}): Record<string, unknown> {
-  const data: Record<string, unknown> = {};
-  if (args.tag) data.tag = args.tag;
-  if (args.group) data.group = args.group;
-  if (args.priority) data.priority = args.priority;
-  if (args.importance) data.importance = args.importance;
-  if (args.actions && args.actions.length > 0) {
-    data.actions = args.actions.map(action => ({
-      action: action.action,
-      title: action.title,
-      ...(action.uri && { uri: action.uri }),
-    }));
-  }
-  if (args.image) data.image = args.image;
-  if (args.sticky !== undefined) data.sticky = args.sticky;
-  return data;
-}
-
-const feature = await loadFeature('tests/features/notifications.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let mockClient: HaClient;
-  let notificationArgs: {
-    message: string;
-    title?: string;
-    target?: string;
-    actions?: Array<{ action: string; title: string }>;
-    priority?: 'high' | 'normal' | 'low' | 'min';
-  };
-  let result: { success: boolean; service: string; context: unknown } | null;
-  let lastServiceCall: { domain: string; service: string; service_data: Record<string, unknown> } | null;
-
-  // Helper to simulate sendNotification tool behavior
-  async function sendNotification(): Promise<void> {
-    const serviceData: Record<string, unknown> = { message: notificationArgs.message };
-    if (notificationArgs.title) serviceData.title = notificationArgs.title;
-
-    const notificationData = buildNotificationData({
-      actions: notificationArgs.actions,
-      priority: notificationArgs.priority,
-    });
-    if (Object.keys(notificationData).length > 0) {
-      serviceData.data = notificationData;
-    }
-
-    const service = notificationArgs.target || 'persistent_notification';
-    lastServiceCall = {
-      domain: 'notify',
-      service,
-      service_data: serviceData,
-    };
-
-    const callResult = await mockClient.callService({
-      domain: 'notify',
-      service,
-      service_data: serviceData,
-    });
-
-    result = {
-      success: true,
-      service: `notify.${service}`,
-      context: callResult.context,
-    };
-  }
-
-  Scenario('Send a simple notification', ({ Given, When, Then, And }) => {
-    Given('a notification message "Hello from MCP!"', () => {
-      notificationArgs = { message: 'Hello from MCP!' };
-      result = null;
-      lastServiceCall = null;
-
-      mockClient = {
-        callService: vi.fn().mockResolvedValue({
-          context: { id: 'test-ctx' },
-        } as ServiceCallResponse),
-      } as unknown as HaClient;
-    });
-
-    When('I send the notification to "mobile_app_samsung_s25_fe"', async () => {
-      notificationArgs.target = 'mobile_app_samsung_s25_fe';
-      await sendNotification();
-    });
-
-    Then('the notification should be sent successfully', () => {
-      expect(result).not.toBeNull();
-      expect(result?.success).toBe(true);
-    });
-
-    And('the service called should be "notify.mobile_app_samsung_s25_fe"', () => {
-      expect(result?.service).toBe('notify.mobile_app_samsung_s25_fe');
-      expect(lastServiceCall?.service).toBe('mobile_app_samsung_s25_fe');
-    });
-  });
-
-  Scenario('Send notification with title', ({ Given, When, Then, And }) => {
-    Given('a notification message "Motion detected in garage"', () => {
-      notificationArgs = { message: 'Motion detected in garage' };
-      result = null;
-      lastServiceCall = null;
-
-      mockClient = {
-        callService: vi.fn().mockResolvedValue({
-          context: { id: 'test-ctx' },
-        } as ServiceCallResponse),
-      } as unknown as HaClient;
-    });
-
-    And('a notification title "Security Alert"', () => {
-      notificationArgs.title = 'Security Alert';
-    });
-
-    When('I send the notification to "mobile_app_samsung_s25_fe"', async () => {
-      notificationArgs.target = 'mobile_app_samsung_s25_fe';
-      await sendNotification();
-    });
-
-    Then('the notification should be sent successfully', () => {
-      expect(result?.success).toBe(true);
-    });
-
-    And('the title should be included in the service data', () => {
-      expect(lastServiceCall?.service_data.title).toBe('Security Alert');
-    });
-  });
-
-  Scenario('Send notification with action buttons', ({ Given, When, Then, And }) => {
-    Given('a notification message "Someone is at the door"', () => {
-      notificationArgs = { message: 'Someone is at the door', actions: [] };
-      result = null;
-      lastServiceCall = null;
-
-      mockClient = {
-        callService: vi.fn().mockResolvedValue({
-          context: { id: 'test-ctx' },
-        } as ServiceCallResponse),
-      } as unknown as HaClient;
-    });
-
-    And('an action button "OPEN" with title "Open Door"', () => {
-      notificationArgs.actions!.push({ action: 'OPEN', title: 'Open Door' });
-    });
-
-    And('an action button "IGNORE" with title "Ignore"', () => {
-      notificationArgs.actions!.push({ action: 'IGNORE', title: 'Ignore' });
-    });
-
-    When('I send the notification to "mobile_app_samsung_s25_fe"', async () => {
-      notificationArgs.target = 'mobile_app_samsung_s25_fe';
-      await sendNotification();
-    });
-
-    Then('the notification should be sent successfully', () => {
-      expect(result?.success).toBe(true);
-    });
-
-    And('the notification data should contain 2 actions', () => {
-      const data = lastServiceCall?.service_data.data as Record<string, unknown>;
-      const actions = data?.actions as Array<unknown>;
-      expect(actions).toHaveLength(2);
-    });
-  });
-
-  Scenario('Send persistent notification (no target)', ({ Given, When, Then }) => {
-    Given('a notification message "System update available"', () => {
-      notificationArgs = { message: 'System update available' };
-      result = null;
-      lastServiceCall = null;
-
-      mockClient = {
-        callService: vi.fn().mockResolvedValue({
-          context: { id: 'test-ctx' },
-        } as ServiceCallResponse),
-      } as unknown as HaClient;
-    });
-
-    When('I send the notification without a target', async () => {
-      // No target specified - should default to persistent_notification
-      await sendNotification();
-    });
-
-    Then('the notification should be sent to "persistent_notification"', () => {
-      expect(result?.service).toBe('notify.persistent_notification');
-      expect(lastServiceCall?.service).toBe('persistent_notification');
-    });
-  });
-
-  Scenario('Send high priority notification', ({ Given, When, Then, And }) => {
-    Given('a notification message "Water leak detected!"', () => {
-      notificationArgs = { message: 'Water leak detected!' };
-      result = null;
-      lastServiceCall = null;
-
-      mockClient = {
-        callService: vi.fn().mockResolvedValue({
-          context: { id: 'test-ctx' },
-        } as ServiceCallResponse),
-      } as unknown as HaClient;
-    });
-
-    And('priority set to "high"', () => {
-      notificationArgs.priority = 'high';
-    });
-
-    When('I send the notification to "mobile_app_samsung_s25_fe"', async () => {
-      notificationArgs.target = 'mobile_app_samsung_s25_fe';
-      await sendNotification();
-    });
-
-    Then('the notification should be sent successfully', () => {
-      expect(result?.success).toBe(true);
-    });
-
-    And('the notification data should have priority "high"', () => {
-      const data = lastServiceCall?.service_data.data as Record<string, unknown>;
-      expect(data?.priority).toBe('high');
-    });
-  });
-});