@coffeerunhobby/mcp-ha-connect 0.5.0

package/tests/haClient/index.test.ts

@@ -0,0 +1,221 @@
+/**
+ * HaClient aggregator tests
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { EnvironmentConfig } from '../../src/config.js';
+
+// Mock all operation modules
+const statesModule = vi.hoisted(() => {
+  const instance = {
+    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 StateOperations = vi.fn(() => instance);
+  return { instance, StateOperations };
+});
+
+const servicesModule = vi.hoisted(() => {
+  const instance = {
+    callService: vi.fn().mockResolvedValue({ context: { id: 'ctx-1' } }),
+    restartServer: vi.fn().mockResolvedValue(undefined),
+  };
+  const ServiceOperations = vi.fn(() => instance);
+  return { instance, ServiceOperations };
+});
+
+const entitiesModule = vi.hoisted(() => {
+  const instance = {
+    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 EntityOperations = vi.fn(() => instance);
+  return { instance, EntityOperations };
+});
+
+const automationsModule = vi.hoisted(() => {
+  const instance = {
+    getAutomations: vi.fn().mockResolvedValue([{ id: 'automation.test' }]),
+  };
+  const AutomationOperations = vi.fn(() => instance);
+  return { instance, AutomationOperations };
+});
+
+const historyModule = vi.hoisted(() => {
+  const instance = {
+    getHistory: vi.fn().mockResolvedValue([[{ entity_id: 'sensor.test' }]]),
+    getSystemLog: vi.fn().mockResolvedValue([{ when: '2026-01-08T10:00:00Z' }]),
+  };
+  const HistoryOperations = vi.fn(() => instance);
+  return { instance, HistoryOperations };
+});
+
+const updatesModule = vi.hoisted(() => {
+  const instance = {
+    getAvailableUpdates: vi.fn().mockResolvedValue({ updates: [], entities: [] }),
+  };
+  const UpdateOperations = vi.fn(() => instance);
+  return { instance, UpdateOperations };
+});
+
+const configModule = vi.hoisted(() => {
+  const instance = {
+    getConfig: vi.fn().mockResolvedValue({ version: '2026.1.0' }),
+    checkApi: vi.fn().mockResolvedValue({ message: 'API running.' }),
+    getVersion: vi.fn().mockResolvedValue({ version: '2026.1.0' }),
+  };
+  const ConfigOperations = vi.fn(() => instance);
+  return { instance, ConfigOperations };
+});
+
+const requestModule = vi.hoisted(() => {
+  const instance = {
+    request: vi.fn().mockResolvedValue({}),
+    get: vi.fn().mockResolvedValue({}),
+    post: vi.fn().mockResolvedValue({}),
+  };
+  const RequestHandler = vi.fn(() => instance);
+  return { instance, RequestHandler };
+});
+
+// Apply mocks
+vi.mock('../../src/haClient/states.js', () => ({ StateOperations: statesModule.StateOperations }));
+vi.mock('../../src/haClient/services.js', () => ({ ServiceOperations: servicesModule.ServiceOperations }));
+vi.mock('../../src/haClient/entities.js', () => ({ EntityOperations: entitiesModule.EntityOperations }));
+vi.mock('../../src/haClient/automations.js', () => ({ AutomationOperations: automationsModule.AutomationOperations }));
+vi.mock('../../src/haClient/history.js', () => ({ HistoryOperations: historyModule.HistoryOperations }));
+vi.mock('../../src/haClient/updates.js', () => ({ UpdateOperations: updatesModule.UpdateOperations }));
+vi.mock('../../src/haClient/config.js', () => ({ ConfigOperations: configModule.ConfigOperations }));
+vi.mock('../../src/haClient/request.js', () => ({ RequestHandler: requestModule.RequestHandler }));
+
+const baseConfig: EnvironmentConfig = {
+  baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+  token: 'test-token',
+  strictSsl: false,
+  timeout: 30000,
+  aiProvider: 'ollama',
+  aiUrl: 'http://ollama.10.0.0.17.nip.io:11434',
+  aiModel: 'phi4:14b',
+  aiTimeout: 60000,
+  logLevel: 'error',
+  logFormat: 'plain',
+  useHttp: false,
+  stateful: false,
+  httpTransport: 'stream',
+  httpEnableHealthcheck: true,
+  httpAllowCors: true,
+};
+
+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(requestModule.RequestHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseUrl: 'http://homeassistant.10.0.0.19.nip.io:8123',
+        token: 'test-token',
+      })
+    );
+    expect(statesModule.StateOperations).toHaveBeenCalledWith(requestModule.instance);
+    expect(servicesModule.ServiceOperations).toHaveBeenCalledWith(requestModule.instance);
+    expect(entitiesModule.EntityOperations).toHaveBeenCalledWith(statesModule.instance);
+    expect(automationsModule.AutomationOperations).toHaveBeenCalledWith(
+      statesModule.instance,
+      servicesModule.instance,
+      requestModule.instance
+    );
+    expect(historyModule.HistoryOperations).toHaveBeenCalledWith(requestModule.instance);
+    expect(updatesModule.UpdateOperations).toHaveBeenCalledWith(entitiesModule.instance);
+    expect(configModule.ConfigOperations).toHaveBeenCalledWith(requestModule.instance);
+  });
+
+  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(statesModule.instance.getStates).toHaveBeenCalled();
+    expect(statesModule.instance.getState).toHaveBeenCalledWith('light.test');
+    expect(statesModule.instance.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(servicesModule.instance.callService).toHaveBeenCalledWith(serviceData);
+    expect(servicesModule.instance.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(entitiesModule.instance.getEntitiesByDomain).toHaveBeenCalledWith('light');
+    expect(entitiesModule.instance.searchEntities).toHaveBeenCalledWith('test');
+    expect(entitiesModule.instance.getDomainSummary).toHaveBeenCalledWith('light');
+    expect(entitiesModule.instance.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(automationsModule.instance.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(historyModule.instance.getHistory).toHaveBeenCalledWith('sensor.test', 24);
+    expect(historyModule.instance.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(updatesModule.instance.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(configModule.instance.getConfig).toHaveBeenCalled();
+    expect(configModule.instance.checkApi).toHaveBeenCalled();
+    expect(configModule.instance.getVersion).toHaveBeenCalled();
+  });
+});

package/tests/haClient/request.test.ts

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

package/tests/haClient/services.test.ts

@@ -0,0 +1,120 @@
+/**
+ * ServiceOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ServiceOperations } from '../../src/haClient/services.js';
+import type { RequestHandler } from '../../src/haClient/request.js';
+
+describe('ServiceOperations', () => {
+  let mockRequest: RequestHandler;
+  let serviceOps: ServiceOperations;
+
+  beforeEach(() => {
+    mockRequest = {
+      post: vi.fn(),
+    } as unknown as RequestHandler;
+
+    serviceOps = new ServiceOperations(mockRequest);
+  });
+
+  describe('callService', () => {
+    it('should call service with domain and service name', async () => {
+      const mockResponse = {
+        context: { id: 'ctx-123', parent_id: null, user_id: 'user-456' },
+      };
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      const result = await serviceOps.callService({
+        domain: 'light',
+        service: 'turn_on',
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/light/turn_on', {});
+    });
+
+    it('should include target entity_id', async () => {
+      const mockResponse = {
+        context: { id: 'ctx-123', parent_id: null, user_id: null },
+      };
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      await serviceOps.callService({
+        domain: 'light',
+        service: 'turn_on',
+        target: { entity_id: 'light.living_room' },
+      });
+
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/light/turn_on', {
+        entity_id: 'light.living_room',
+      });
+    });
+
+    it('should include service_data', async () => {
+      const mockResponse = {
+        context: { id: 'ctx-123', parent_id: null, user_id: null },
+      };
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      await serviceOps.callService({
+        domain: 'light',
+        service: 'turn_on',
+        target: { entity_id: 'light.living_room' },
+        service_data: { brightness: 255, color_temp: 370 },
+      });
+
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/light/turn_on', {
+        entity_id: 'light.living_room',
+        brightness: 255,
+        color_temp: 370,
+      });
+    });
+
+    it('should handle multiple entity targets', async () => {
+      const mockResponse = {
+        context: { id: 'ctx-123', parent_id: null, user_id: null },
+      };
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      await serviceOps.callService({
+        domain: 'light',
+        service: 'turn_off',
+        target: { entity_id: ['light.living_room', 'light.bedroom'] },
+      });
+
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/light/turn_off', {
+        entity_id: ['light.living_room', 'light.bedroom'],
+      });
+    });
+
+    it('should call climate service with temperature', async () => {
+      const mockResponse = {
+        context: { id: 'ctx-123', parent_id: null, user_id: null },
+      };
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+
+      await serviceOps.callService({
+        domain: 'climate',
+        service: 'set_temperature',
+        target: { entity_id: 'climate.living_room' },
+        service_data: { temperature: 22 },
+      });
+
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/climate/set_temperature', {
+        entity_id: 'climate.living_room',
+        temperature: 22,
+      });
+    });
+  });
+
+  describe('restartServer', () => {
+    it('should call homeassistant restart service', async () => {
+      (mockRequest.post as ReturnType<typeof vi.fn>).mockResolvedValue({});
+
+      await serviceOps.restartServer();
+
+      expect(mockRequest.post).toHaveBeenCalledWith('/services/homeassistant/restart', {});
+    });
+  });
+});

package/tests/haClient/states.test.ts

@@ -0,0 +1,119 @@
+/**
+ * StateOperations tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { StateOperations } from '../../src/haClient/states.js';
+import type { RequestHandler } from '../../src/haClient/request.js';
+import type { Entity } from '../../src/types/index.js';
+import { ApiError } from '../../src/types/index.js';
+
+describe('StateOperations', () => {
+  let mockRequest: RequestHandler;
+  let stateOps: StateOperations;
+
+  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: '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-2', parent_id: null, user_id: null },
+    },
+    {
+      entity_id: 'binary_sensor.motion',
+      state: 'off',
+      attributes: { friendly_name: 'Motion Sensor', device_class: 'motion' },
+      last_changed: '2026-01-08T09:00:00.000Z',
+      last_updated: '2026-01-08T10:00:00.000Z',
+      context: { id: 'ctx-3', parent_id: null, user_id: null },
+    },
+  ];
+
+  beforeEach(() => {
+    mockRequest = {
+      get: vi.fn(),
+    } as unknown as RequestHandler;
+
+    stateOps = new StateOperations(mockRequest);
+  });
+
+  describe('getStates', () => {
+    it('should fetch all states', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntities);
+
+      const states = await stateOps.getStates();
+
+      expect(states).toEqual(mockEntities);
+      expect(mockRequest.get).toHaveBeenCalledWith('/states');
+    });
+
+    it('should return empty array when no entities exist', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+      const states = await stateOps.getStates();
+
+      expect(states).toEqual([]);
+    });
+  });
+
+  describe('getState', () => {
+    it('should fetch specific entity state', async () => {
+      const entity = mockEntities[0];
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(entity);
+
+      const state = await stateOps.getState('light.living_room');
+
+      expect(state).toEqual(entity);
+      expect(mockRequest.get).toHaveBeenCalledWith('/states/light.living_room');
+    });
+
+    it('should return null when entity not found', async () => {
+      const error = new ApiError('Not found', 404, { path: '/states/nonexistent' });
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockRejectedValue(error);
+
+      const state = await stateOps.getState('nonexistent');
+
+      expect(state).toBeNull();
+    });
+
+    it('should throw error for non-404 errors', async () => {
+      const error = new ApiError('Server error', 500, { path: '/states/test' });
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockRejectedValue(error);
+
+      await expect(stateOps.getState('test')).rejects.toThrow(ApiError);
+    });
+  });
+
+  describe('getAllSensors', () => {
+    it('should return only sensor and binary_sensor entities', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue(mockEntities);
+
+      const sensors = await stateOps.getAllSensors();
+
+      expect(sensors).toHaveLength(2);
+      expect(sensors.map(s => s.entity_id)).toContain('sensor.temperature');
+      expect(sensors.map(s => s.entity_id)).toContain('binary_sensor.motion');
+      expect(sensors.map(s => s.entity_id)).not.toContain('light.living_room');
+    });
+
+    it('should return empty array when no sensors exist', async () => {
+      (mockRequest.get as ReturnType<typeof vi.fn>).mockResolvedValue([
+        { ...mockEntities[0] }, // Only light entity
+      ]);
+
+      const sensors = await stateOps.getAllSensors();
+
+      expect(sensors).toEqual([]);
+    });
+  });
+});