@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.3.1

package/tests/bdd/calendar.spec.ts

@@ -1,190 +0,0 @@
-/**
- * BDD tests for Calendar Operations
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect, vi } from 'vitest';
-import { CalendarOperations } from '../../src/haClient/calendars.js';
-import type { RequestHandler } from '../../src/haClient/request.js';
-import type { Calendar, CalendarEvent } from '../../src/types/index.js';
-
-const feature = await loadFeature('tests/features/calendar.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let mockRequest: RequestHandler;
-  let calendarOps: CalendarOperations;
-  let calendars: Calendar[];
-  let events: CalendarEvent[];
-  let allCalendarEvents: Array<{ calendar: string; events: CalendarEvent[] }>;
-  let startDate: Date;
-  let endDate: Date;
-
-  const mockCalendarList = [
-    { entity_id: 'calendar.family', name: 'Family Calendar' },
-    { entity_id: 'calendar.work', name: 'Work Calendar' },
-    { entity_id: 'calendar.reminders', name: 'Reminders' },
-    { entity_id: 'calendar.empty', name: 'Empty Calendar' },
-  ];
-
-  const mockEvents: CalendarEvent[] = [
-    {
-      summary: 'Team Meeting',
-      start: { dateTime: '2026-01-15T10:00:00.000Z' },
-      end: { dateTime: '2026-01-15T11:00:00.000Z' },
-      description: 'Weekly sync',
-    },
-    {
-      summary: 'Doctor Appointment',
-      start: { date: '2026-01-20' },
-      end: { date: '2026-01-20' },
-      location: 'Medical Center',
-    },
-  ];
-
-  function setupMocks(calendarEvents: Record<string, CalendarEvent[]> = {}) {
-    mockRequest = {
-      get: vi.fn().mockImplementation(async (path: string) => {
-        // Handle /calendars endpoint (list all calendars)
-        if (path === '/calendars') {
-          return mockCalendarList;
-        }
-        // Handle /calendars/{entity_id} endpoint (get events)
-        const match = path.match(/\/calendars\/(calendar\.[^?]+)/);
-        if (match) {
-          const calId = match[1];
-          return calendarEvents[calId] || [];
-        }
-        return [];
-      }),
-    } as unknown as RequestHandler;
-
-    calendarOps = new CalendarOperations(mockRequest);
-  }
-
-  Scenario('List all calendars', ({ Given, When, Then, And }) => {
-    Given('a Home Assistant with calendar entities', () => {
-      setupMocks();
-    });
-
-    When('I list all calendars', async () => {
-      calendars = await calendarOps.getCalendars();
-    });
-
-    Then('I should see all calendar entities', () => {
-      expect(calendars).toHaveLength(4);
-    });
-
-    And('each calendar should have entity_id, name, and state', () => {
-      calendars.forEach(cal => {
-        expect(cal.entity_id).toBeDefined();
-        expect(cal.name).toBeDefined();
-        expect(cal.state).toBeDefined();
-      });
-    });
-  });
-
-  Scenario('Get events from a specific calendar', ({ Given, When, Then, And }) => {
-    Given('a calendar "calendar.family" with events', () => {
-      setupMocks({ 'calendar.family': mockEvents });
-    });
-
-    When('I get events from "calendar.family"', async () => {
-      events = await calendarOps.getCalendarEvents('calendar.family');
-    });
-
-    Then('I should receive calendar events', () => {
-      expect(events.length).toBeGreaterThan(0);
-    });
-
-    And('each event should have summary and start date', () => {
-      events.forEach(event => {
-        expect(event.summary).toBeDefined();
-        expect(event.start).toBeDefined();
-        expect(event.start.dateTime || event.start.date).toBeDefined();
-      });
-    });
-  });
-
-  Scenario('Get events with custom date range', ({ Given, When, Then }) => {
-    Given('a calendar "calendar.work" with events', () => {
-      setupMocks({ 'calendar.work': mockEvents });
-    });
-
-    When('I get events from January 1 to January 31', async () => {
-      startDate = new Date('2026-01-01');
-      endDate = new Date('2026-01-31');
-      events = await calendarOps.getCalendarEvents('calendar.work', startDate, endDate);
-    });
-
-    Then('the events should be within the date range', () => {
-      // Verify the API was called with correct date range
-      expect(mockRequest.get).toHaveBeenCalledWith(
-        expect.stringContaining('/calendars/calendar.work'),
-        expect.objectContaining({
-          start: startDate.toISOString(),
-          end: endDate.toISOString(),
-        })
-      );
-    });
-  });
-
-  Scenario('Get events using days parameter', ({ Given, When, Then }) => {
-    Given('a calendar "calendar.reminders" with events', () => {
-      setupMocks({ 'calendar.reminders': mockEvents });
-    });
-
-    When('I get events for the next 7 days', async () => {
-      startDate = new Date();
-      endDate = new Date(startDate.getTime() + 7 * 24 * 60 * 60 * 1000);
-      events = await calendarOps.getCalendarEvents('calendar.reminders', startDate, endDate);
-    });
-
-    Then('the end date should be 7 days from now', () => {
-      const expectedEnd = new Date(startDate.getTime() + 7 * 24 * 60 * 60 * 1000);
-      // Allow for small time differences
-      expect(Math.abs(endDate.getTime() - expectedEnd.getTime())).toBeLessThan(1000);
-    });
-  });
-
-  Scenario('Get events from all calendars', ({ Given, When, Then, And }) => {
-    Given('multiple calendars with events', () => {
-      setupMocks({
-        'calendar.family': [mockEvents[0]],
-        'calendar.work': [mockEvents[1]],
-        'calendar.reminders': [],
-        'calendar.empty': [],
-      });
-    });
-
-    When('I get events without specifying a calendar', async () => {
-      allCalendarEvents = await calendarOps.getAllCalendarEvents();
-    });
-
-    Then('I should receive events from all calendars', () => {
-      expect(allCalendarEvents.length).toBe(4);
-    });
-
-    And('results should be grouped by calendar', () => {
-      const calendarIds = allCalendarEvents.map(c => c.calendar);
-      expect(calendarIds).toContain('calendar.family');
-      expect(calendarIds).toContain('calendar.work');
-      expect(calendarIds).toContain('calendar.reminders');
-    });
-  });
-
-  Scenario('Get events from calendar with no events', ({ Given, When, Then }) => {
-    Given('a calendar "calendar.empty" with no events', () => {
-      setupMocks({ 'calendar.empty': [] });
-    });
-
-    When('I get events from "calendar.empty"', async () => {
-      events = await calendarOps.getCalendarEvents('calendar.empty');
-    });
-
-    Then('I should receive an empty events list', () => {
-      expect(events).toEqual([]);
-    });
-  });
-});

package/tests/bdd/configuration.spec.ts

@@ -1,283 +0,0 @@
-/**
- * BDD tests for Server Configuration
- * Uses vitest-cucumber for Gherkin syntax
- */
-
-import { loadFeature, describeFeature } from '@amiceli/vitest-cucumber';
-import { expect } from 'vitest';
-import { loadConfig } from '../../src/config.js';
-import type { EnvironmentConfig } from '../../src/config.js';
-
-const feature = await loadFeature('tests/features/configuration.feature');
-
-describeFeature(feature, ({ Scenario }) => {
-  // Shared test state
-  let env: Record<string, string>;
-  let config: EnvironmentConfig;
-  let error: Error | null;
-
-  Scenario('Load valid configuration', ({ Given, When, Then, And }) => {
-    Given('environment variables with HA_URL and HA_TOKEN', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token-12345',
-      };
-      error = null;
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('the configuration should be valid', () => {
-      expect(config).toBeDefined();
-    });
-
-    And('baseUrl should be set correctly', () => {
-      expect(config.baseUrl).toBe('http://homeassistant.local:8123');
-    });
-
-    And('token should be set correctly', () => {
-      expect(config.token).toBe('test-token-12345');
-    });
-  });
-
-  Scenario('Apply default values for optional settings', ({ Given, When, Then, And }) => {
-    Given('only required environment variables', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('strictSsl should default to true', () => {
-      expect(config.strictSsl).toBe(true);
-    });
-
-    And('timeout should default to 30000', () => {
-      expect(config.timeout).toBe(30000);
-    });
-
-    And('logLevel should default to "info"', () => {
-      expect(config.logLevel).toBe('info');
-    });
-
-    And('logFormat should default to "plain"', () => {
-      expect(config.logFormat).toBe('plain');
-    });
-  });
-
-  Scenario('Remove trailing slash from URL', ({ Given, When, Then }) => {
-    Given('HA_URL with trailing slash "http://ha.local:8123/"', () => {
-      env = {
-        HA_URL: 'http://ha.local:8123/',
-        HA_TOKEN: 'test-token',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('baseUrl should not have a trailing slash', () => {
-      expect(config.baseUrl).toBe('http://ha.local:8123');
-      expect(config.baseUrl.endsWith('/')).toBe(false);
-    });
-  });
-
-  Scenario('Allow missing HA_URL for Omada-only mode', ({ Given, When, Then }) => {
-    Given('environment variables without HA_URL', () => {
-      env = {
-        HA_TOKEN: 'test-token',
-      };
-      error = null;
-    });
-
-    When('I attempt to load the configuration', () => {
-      try {
-        config = loadConfig(env);
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('it should load successfully with baseUrl undefined', () => {
-      expect(error).toBeNull();
-      expect(config?.baseUrl).toBeUndefined();
-      expect(config?.token).toBe('test-token');
-    });
-  });
-
-  Scenario('Allow missing HA_TOKEN for Omada-only mode', ({ Given, When, Then }) => {
-    Given('environment variables without HA_TOKEN', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-      };
-      error = null;
-    });
-
-    When('I attempt to load the configuration', () => {
-      try {
-        config = loadConfig(env);
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('it should load successfully with token undefined', () => {
-      expect(error).toBeNull();
-      expect(config?.baseUrl).toBe('http://homeassistant.local:8123');
-      expect(config?.token).toBeUndefined();
-    });
-  });
-
-  Scenario('Reject invalid URL format', ({ Given, When, Then }) => {
-    Given('HA_URL with invalid format "not-a-url"', () => {
-      env = {
-        HA_URL: 'not-a-url',
-        HA_TOKEN: 'test-token',
-      };
-      error = null;
-    });
-
-    When('I attempt to load the configuration', () => {
-      try {
-        config = loadConfig(env);
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('it should throw an error about invalid configuration', () => {
-      expect(error).not.toBeNull();
-      expect(error?.message).toContain('Invalid environment configuration');
-    });
-  });
-
-  Scenario('Parse HTTP server configuration', ({ Given, When, Then, And }) => {
-    Given('HTTP mode is enabled', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_SERVER_USE_HTTP: 'true',
-        MCP_HTTP_PORT: '3000',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('useHttp should be true', () => {
-      expect(config.useHttp).toBe(true);
-    });
-
-    And('httpPort should be set', () => {
-      expect(config.httpPort).toBe(3000);
-    });
-  });
-
-  Scenario('Validate bind address format', ({ Given, When, Then }) => {
-    Given('an invalid bind address "invalid-ip"', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_HTTP_BIND_ADDR: 'invalid-ip',
-      };
-      error = null;
-    });
-
-    When('I attempt to load the configuration', () => {
-      try {
-        config = loadConfig(env);
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then('it should throw an error about invalid bind address', () => {
-      expect(error).not.toBeNull();
-      expect(error?.message).toContain('MCP_HTTP_BIND_ADDR must be a valid IPv4 or IPv6 address');
-    });
-  });
-
-  Scenario('Accept valid IPv4 bind address', ({ Given, When, Then }) => {
-    Given('a valid IPv4 bind address "192.168.1.100"', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_HTTP_BIND_ADDR: '192.168.1.100',
-        // H5: a non-loopback bind requires authentication.
-        MCP_AUTH_METHOD: 'bearer',
-        MCP_AUTH_SECRET: 'test-secret-key-32chars-minimum!',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('httpBindAddr should be "192.168.1.100"', () => {
-      expect(config.httpBindAddr).toBe('192.168.1.100');
-    });
-  });
-
-  Scenario('Accept valid IPv6 bind address', ({ Given, When, Then }) => {
-    Given('a valid IPv6 bind address "::1"', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_HTTP_BIND_ADDR: '::1',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('httpBindAddr should be "::1"', () => {
-      expect(config.httpBindAddr).toBe('::1');
-    });
-  });
-
-  Scenario('Handle wildcard in allowed origins', ({ Given, When, Then }) => {
-    Given('allowed origins set to "*"', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_HTTP_ALLOWED_ORIGINS: '*',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('httpAllowedOrigins should be an empty array', () => {
-      expect(config.httpAllowedOrigins).toEqual([]);
-    });
-  });
-
-  Scenario('Parse comma-separated allowed origins', ({ Given, When, Then }) => {
-    Given('allowed origins "http://localhost:3000,http://192.168.1.100"', () => {
-      env = {
-        HA_URL: 'http://homeassistant.local:8123',
-        HA_TOKEN: 'test-token',
-        MCP_HTTP_ALLOWED_ORIGINS: 'http://localhost:3000,http://192.168.1.100',
-      };
-    });
-
-    When('I load the configuration', () => {
-      config = loadConfig(env);
-    });
-
-    Then('httpAllowedOrigins should contain both origins', () => {
-      expect(config.httpAllowedOrigins).toContain('http://localhost:3000');
-      expect(config.httpAllowedOrigins).toContain('http://192.168.1.100');
-    });
-  });
-});