Use custom websocket to avoid needing admin privileges.

tests/camera-manager/camera.test.ts

@@ -2,51 +2,69 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../../src/camera-manager/camera.js';
 import { GenericCameraManagerEngine } from '../../src/camera-manager/generic/engine-generic.js';
-import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
+import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
 import {
-  callHASubscribeMessageHandler,
+  callStateWatcherCallback,
   createCameraConfig,
   createCapabilities,
-  createHASS,
+  createStateEntity,
 } from '../test-utils.js';
 
 describe('Camera', () => {
   it('should get config', async () => {
     const config = createCameraConfig();
-    const camera = new Camera(config, new GenericCameraManagerEngine());
+    const camera = new Camera(
+      config,
+      new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+    );
     expect(camera.getConfig()).toBe(config);
   });
 
   describe('should get capabilities', async () => {
     it('when populated', async () => {
       const capabilities = createCapabilities();
-      const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine(), {
-        capabilities: capabilities,
-      });
+      const camera = new Camera(
+        createCameraConfig(),
+        new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+        {
+          capabilities: capabilities,
+        },
+      );
       expect(camera.getCapabilities()).toBe(capabilities);
     });
 
     it('when unpopulated', async () => {
-      const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
+      const camera = new Camera(
+        createCameraConfig(),
+        new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+      );
       expect(camera.getCapabilities()).toBeNull();
     });
   });
 
   it('should get engine', async () => {
-    const engine = new GenericCameraManagerEngine();
+    const engine = new GenericCameraManagerEngine(
+      mock<StateWatcherSubscriptionInterface>(),
+    );
     const camera = new Camera(createCameraConfig(), engine);
     expect(camera.getEngine()).toBe(engine);
   });
 
   it('should set and get id', async () => {
-    const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
+    const camera = new Camera(
+      createCameraConfig(),
+      new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+    );
     camera.setID('foo');
     expect(camera.getID()).toBe('foo');
     expect(camera.getConfig().id).toBe('foo');
   });
 
   it('should throw without id', async () => {
-    const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
+    const camera = new Camera(
+      createCameraConfig(),
+      new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+    );
     expect(() => camera.getID()).toThrowError(
       'Could not determine camera id for the following ' +
         "camera, may need to set 'id' parameter manually",
@@ -60,39 +78,19 @@ describe('Camera', () => {
           entities: ['camera.foo'],
         },
       }),
-      new GenericCameraManagerEngine(),
+      new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
     );
-    const hass = createHASS();
-    const unsubcribeCallback = vi.fn();
 
-    vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubcribeCallback);
+    const stateWatcher = mock<StateWatcherSubscriptionInterface>();
+    await camera.initialize({
+      stateWatcher: stateWatcher,
+    });
 
-    await camera.initialize(hass, mock<EntityRegistryManager>());
-
-    expect(hass.connection.subscribeMessage).toBeCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        type: 'subscribe_trigger',
-        trigger: {
-          entity_id: ['camera.foo'],
-          platform: 'state',
-          from: null,
-          to: null,
-        },
-      }),
-    );
-    expect(unsubcribeCallback).not.toBeCalled();
+    expect(stateWatcher.subscribe).toBeCalledWith(expect.any(Function), ['camera.foo']);
 
     await camera.destroy();
-    expect(unsubcribeCallback).toBeCalled();
-  });
 
-  it('should not subscribe without trigger entities', async () => {
-    const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
-    const hass = createHASS();
-
-    await camera.initialize(hass, mock<EntityRegistryManager>());
-    expect(hass.connection.subscribeMessage).not.toBeCalled();
+    expect(stateWatcher.unsubscribe).toBeCalled();
   });
 
   describe('should handle trigger state changes', () => {
@@ -100,28 +98,6 @@ describe('Camera', () => {
       vi.restoreAllMocks();
     });
 
-    it('when malformed', async () => {
-      vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
-
-      const eventCallback = vi.fn();
-      const camera = new Camera(
-        createCameraConfig({
-          triggers: {
-            entities: ['camera.foo'],
-          },
-        }),
-        new GenericCameraManagerEngine(),
-        { eventCallback: eventCallback },
-      );
-
-      const hass = createHASS();
-      await camera.initialize(hass, mock<EntityRegistryManager>());
-
-      callHASubscribeMessageHandler(hass, 'MALFORMED_DATA');
-
-      expect(eventCallback).not.toBeCalled();
-    });
-
     it.each([
       ['off' as const, 'on' as const, 'new' as const],
       ['on' as const, 'off' as const, 'end' as const],
@@ -138,28 +114,22 @@ describe('Camera', () => {
               entities: ['binary_sensor.foo'],
             },
           }),
-          new GenericCameraManagerEngine(),
+          new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
           { eventCallback: eventCallback },
         );
 
-        const hass = createHASS();
-        await camera.initialize(hass, mock<EntityRegistryManager>());
-
-        callHASubscribeMessageHandler(hass, {
-          variables: {
-            trigger: {
-              from_state: {
-                entity_id: 'binary_sensor.foo',
-                state: stateFrom,
-              },
-              to_state: {
-                entity_id: 'binary_sensor.foo',
-                state: stateTo,
-              },
-            },
-          },
+        const stateWatcher = mock<StateWatcherSubscriptionInterface>();
+        await camera.initialize({
+          stateWatcher: stateWatcher,
         });
 
+        const diff = {
+          entityID: 'sensor.force_update',
+          oldState: createStateEntity({ state: stateFrom }),
+          newState: createStateEntity({ state: stateTo }),
+        };
+        callStateWatcherCallback(stateWatcher, diff);
+
         expect(eventCallback).toBeCalledWith({
           cameraID: 'camera_1',
           type: eventType,