Allow camera engines to signal events to the card.

tests/camera-manager/browse-media/camera.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { BrowseMediaCamera } from '../../../src/camera-manager/browse-media/camera';
+import { CameraManagerEngine } from '../../../src/camera-manager/engine';
+import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
+import { Entity } from '../../../src/utils/ha/entity-registry/types';
+import { createCameraConfig, createHASS } from '../../test-utils';
+
+describe('BrowseMediaCamera', () => {
+  describe('should initialize', () => {
+    it('without a camera_entity', async () => {
+      const camera = new BrowseMediaCamera(
+        createCameraConfig(),
+        mock<CameraManagerEngine>(),
+      );
+
+      expect(
+        async () => await camera.initialize(createHASS(), mock<EntityRegistryManager>()),
+      ).rejects.toThrowError(/Could not find camera entity/);
+    });
+
+    it('with a camera_entity', async () => {
+      const camera = new BrowseMediaCamera(
+        createCameraConfig({
+          camera_entity: 'camera.foo',
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const entityRegistryManager = mock<EntityRegistryManager>();
+      const entity = mock<Entity>();
+      entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+      expect(await camera.initialize(createHASS(), entityRegistryManager)).toBe(camera);
+      expect(camera.getEntity()).toBe(entity);
+    });
+  });
+});

tests/camera-manager/camera.test.ts

@@ -1,57 +1,170 @@
-import { describe, expect, it } from 'vitest';
+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 { createCameraCapabilities, createCameraConfig } from '../test-utils.js';
+import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
+import {
+  callHASubscribeMessageHandler,
+  createCameraCapabilities,
+  createCameraConfig,
+  createHASS,
+} from '../test-utils.js';
 
 describe('Camera', () => {
   it('should get config', async () => {
     const config = createCameraConfig();
-    const camera = new Camera(
-      config,
-      new GenericCameraManagerEngine(),
-      createCameraCapabilities(),
-    );
+    const camera = new Camera(config, new GenericCameraManagerEngine());
     expect(camera.getConfig()).toBe(config);
   });
 
-  it('should get capabilities', async () => {
-    const capabilities = createCameraCapabilities();
-    const camera = new Camera(
-      createCameraConfig(),
-      new GenericCameraManagerEngine(),
-      capabilities,
-    );
-    expect(camera.getCapabilities()).toBe(capabilities);
+  describe('should get capabilities', async () => {
+    it('when populated', async () => {
+      const capabilities = createCameraCapabilities();
+      const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine(), {
+        capabilities: capabilities,
+      });
+      expect(camera.getCapabilities()).toBe(capabilities);
+    });
+
+    it('when unpopulated', async () => {
+      const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
+      expect(camera.getCapabilities()).toBeNull();
+    });
   });
 
   it('should get engine', async () => {
     const engine = new GenericCameraManagerEngine();
-    const camera = new Camera(createCameraConfig(), engine, createCameraCapabilities());
+    const camera = new Camera(createCameraConfig(), engine);
     expect(camera.getEngine()).toBe(engine);
   });
 
   it('should set and get id', async () => {
-    const config = createCameraConfig();
-    const camera = new Camera(
-      config,
-      new GenericCameraManagerEngine(),
-      createCameraCapabilities(),
-    );
+    const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
     camera.setID('foo');
     expect(camera.getID()).toBe('foo');
     expect(camera.getConfig().id).toBe('foo');
   });
 
   it('should throw without id', async () => {
-    const config = createCameraConfig();
-    const camera = new Camera(
-      config,
-      new GenericCameraManagerEngine(),
-      createCameraCapabilities(),
-    );
+    const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
     expect(() => camera.getID()).toThrowError(
       'Could not determine camera id for the following ' +
         "camera, may need to set 'id' parameter manually",
     );
   });
+
+  it('should initialize and destroy', async () => {
+    const camera = new Camera(
+      createCameraConfig({
+        triggers: {
+          entities: ['camera.foo'],
+        },
+      }),
+      new GenericCameraManagerEngine(),
+    );
+    const hass = createHASS();
+    const unsubcribeCallback = vi.fn();
+
+    vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubcribeCallback);
+
+    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();
+
+    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();
+  });
+
+  describe('should handle trigger state changes', () => {
+    beforeEach(() => {
+      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],
+    ])(
+      'from %s to %s',
+      async (stateFrom: string, stateTo: string, eventType: 'new' | 'end') => {
+        vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+        const eventCallback = vi.fn();
+        const camera = new Camera(
+          createCameraConfig({
+            id: 'camera_1',
+            triggers: {
+              entities: ['binary_sensor.foo'],
+            },
+          }),
+          new GenericCameraManagerEngine(),
+          { 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,
+              },
+            },
+          },
+        });
+
+        expect(eventCallback).toBeCalledWith({
+          cameraID: 'camera_1',
+          type: eventType,
+        });
+      },
+    );
+  });
 });

tests/camera-manager/frigate/camera.test.ts

@@ -0,0 +1,965 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { CameraManagerEngine } from '../../../src/camera-manager/engine';
+import { FrigateCamera } from '../../../src/camera-manager/frigate/camera';
+import { getPTZInfo } from '../../../src/camera-manager/frigate/requests';
+import {
+  FrigateEventChange,
+  FrigateEventChangeTriggerResponse,
+  FrigateEventChangeType,
+} from '../../../src/camera-manager/frigate/types';
+import { CameraTriggerEventType } from '../../../src/config/types';
+import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
+import { Entity } from '../../../src/utils/ha/entity-registry/types';
+import {
+  callHASubscribeMessageHandler,
+  createCameraConfig,
+  createHASS,
+  createRegistryEntity,
+} from '../../test-utils';
+
+vi.mock('../../../src/camera-manager/frigate/requests');
+
+const createFrigateEventChangeTrigger = (
+  type: FrigateEventChangeType,
+  before: FrigateEventChange,
+  after: FrigateEventChange,
+): FrigateEventChangeTriggerResponse => {
+  return {
+    variables: {
+      trigger: {
+        payload_json: {
+          before: before,
+          after: after,
+          type: type,
+        },
+      },
+    },
+  };
+};
+
+describe('FrigateCamera', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(getPTZInfo).mockResolvedValue({});
+  });
+
+  describe('should initialize config', () => {
+    describe('should detect camera name', () => {
+      it('without a camera_entity', async () => {
+        const config = createCameraConfig();
+        const camera = new FrigateCamera(config, mock<CameraManagerEngine>());
+        const beforeConfig = { ...config };
+
+        await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+        expect(beforeConfig).toEqual(camera.getConfig());
+      });
+
+      it('with a missing camera_entity', async () => {
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            camera_entity: 'camera.not_here',
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockRejectedValue(null);
+
+        expect(
+          async () => await camera.initialize(createHASS(), entityRegistryManager),
+        ).rejects.toThrowError(/Could not find camera entity/);
+      });
+
+      it('with a valid camera_entity', async () => {
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            camera_entity: 'camera.front_door',
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        const entity = createRegistryEntity({
+          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:camera:fnt_dr',
+          platform: 'frigate',
+        });
+        entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+        await camera.initialize(createHASS(), entityRegistryManager);
+
+        expect(camera.getConfig().frigate.camera_name).toBe('fnt_dr');
+      });
+
+      it('with a camera_entity without camera_name match', async () => {
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            camera_entity: 'camera.front_door',
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        const entity = createRegistryEntity({
+          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:WRONG:fnt_dr',
+          platform: 'frigate',
+        });
+        entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+        await camera.initialize(createHASS(), entityRegistryManager);
+
+        expect(camera.getConfig().frigate.camera_name).toBeUndefined();
+      });
+
+      it('with a camera_entity without platform match', async () => {
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            camera_entity: 'camera.front_door',
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        const entity = createRegistryEntity({
+          unique_id: '8c4e19d258359e82bc0cf9d47b021c46:camera:fnt_dr',
+          platform: 'something_else',
+        });
+        entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+        await camera.initialize(createHASS(), entityRegistryManager);
+
+        expect(camera.getConfig().frigate.camera_name).toBeUndefined();
+      });
+    });
+  });
+
+  describe('should detect capabilities', () => {
+    const nonBirdseyeBaseCapabilities = {
+      canFavoriteEvents: true,
+      canFavoriteRecordings: true,
+      canSeek: true,
+      supportsClips: true,
+      supportsSnapshots: true,
+      supportsRecordings: true,
+      supportsTimeline: true,
+    };
+
+    it('basic non-birdseye', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig(),
+        mock<CameraManagerEngine>(),
+      );
+
+      await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+      expect(camera.getCapabilities()).toEqual(nonBirdseyeBaseCapabilities);
+    });
+
+    it('basic birdseye', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          frigate: {
+            camera_name: 'birdseye',
+          },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+
+      await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+      expect(camera.getCapabilities()).toEqual({
+        ...nonBirdseyeBaseCapabilities,
+        canFavoriteEvents: false,
+        canFavoriteRecordings: false,
+        supportsClips: false,
+        supportsSnapshots: false,
+        supportsRecordings: false,
+        supportsTimeline: false,
+      });
+    });
+
+    describe('with ptz', () => {
+      it('when getPTZInfo call fails', async () => {
+        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        vi.mocked(getPTZInfo).mockRejectedValue(new Error());
+        await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+        expect(camera.getCapabilities()).toEqual({
+          ...nonBirdseyeBaseCapabilities,
+        });
+        expect(consoleSpy).toBeCalled();
+      });
+
+      it('when getPTZInfo call succeeds with continuous motion', async () => {
+        vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        vi.mocked(getPTZInfo).mockResolvedValue({
+          features: ['pt', 'zoom'],
+          name: 'front_door',
+          presets: ['preset01'],
+        });
+        await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+        expect(camera.getCapabilities()).toEqual({
+          ...nonBirdseyeBaseCapabilities,
+          ptz: {
+            panTilt: ['continuous'],
+            zoom: ['continuous'],
+            presets: ['preset01'],
+          },
+        });
+      });
+
+      it('when getPTZInfo call succeeds with relative motion', async () => {
+        vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        vi.mocked(getPTZInfo).mockResolvedValue({
+          features: ['pt-r', 'zoom-r'],
+          name: 'front_door',
+          presets: ['preset01'],
+        });
+        await camera.initialize(createHASS(), mock<EntityRegistryManager>());
+
+        expect(camera.getCapabilities()).toEqual({
+          ...nonBirdseyeBaseCapabilities,
+          ptz: {
+            panTilt: ['relative'],
+            zoom: ['relative'],
+            presets: ['preset01'],
+          },
+        });
+      });
+    });
+  });
+
+  describe('should handle events', () => {
+    it('should subscribe', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          frigate: {
+            client_id: 'CLIENT_ID',
+            camera_name: 'CAMERA',
+          },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const hass = createHASS();
+
+      await camera.initialize(hass, mock<EntityRegistryManager>());
+
+      expect(hass.connection.subscribeMessage).toBeCalledWith(expect.anything(), {
+        type: 'subscribe_trigger',
+        trigger: {
+          platform: 'mqtt',
+          topic: `CLIENT_ID/events`,
+          payload: 'CAMERA',
+          value_template: '{{ value_json.after.camera }}',
+        },
+      });
+    });
+
+    it('should not subscribe with no trigger events', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          frigate: {
+            client_id: 'CLIENT_ID',
+            camera_name: 'CAMERA',
+          },
+          triggers: {
+            events: [],
+          },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const hass = createHASS();
+
+      await camera.initialize(hass, mock<EntityRegistryManager>());
+
+      expect(hass.connection.subscribeMessage).not.toBeCalled();
+    });
+
+    it('should not subscribe with no camera name', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          frigate: {
+            client_id: 'CLIENT_ID',
+          },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const hass = createHASS();
+
+      await camera.initialize(hass, mock<EntityRegistryManager>());
+
+      expect(hass.connection.subscribeMessage).not.toBeCalled();
+    });
+
+    it('should unsubscribe on destroy', async () => {
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          frigate: { camera_name: 'front_door' },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const hass = createHASS();
+      const unsubscribeCallback = vi.fn();
+      vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubscribeCallback);
+
+      await camera.initialize(hass, mock<EntityRegistryManager>());
+      expect(unsubscribeCallback).not.toBeCalled();
+
+      await camera.destroy();
+      expect(unsubscribeCallback).toBeCalled();
+    });
+
+    describe('should call handler correctly', () => {
+      it('with malformed Frigate event', async () => {
+        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: { camera_name: 'front_door' },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+
+        const hass = createHASS();
+        await camera.initialize(hass, mock<EntityRegistryManager>());
+
+        callHASubscribeMessageHandler(hass, 'GARBAGE');
+
+        expect(consoleSpy).toBeCalledWith(
+          'Ignoring unparseable Frigate event',
+          'GARBAGE',
+        );
+      });
+
+      it('with wrong camera', async () => {
+        const eventCallback = vi.fn();
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            id: 'CAMERA_1',
+            frigate: {
+              camera_name: 'camera.front_door',
+            },
+          }),
+          mock<CameraManagerEngine>(),
+          {
+            eventCallback: eventCallback,
+          },
+        );
+
+        const hass = createHASS();
+        await camera.initialize(hass, mock<EntityRegistryManager>());
+
+        callHASubscribeMessageHandler(
+          hass,
+          createFrigateEventChangeTrigger(
+            'new',
+            {
+              camera: 'camera.back_door',
+              snapshot: null,
+              has_clip: false,
+              has_snapshot: false,
+              label: 'person',
+              current_zones: [],
+            },
+            {
+              camera: 'camera.back_door',
+              snapshot: null,
+              has_clip: false,
+              has_snapshot: true,
+              label: 'person',
+              current_zones: [],
+            },
+          ),
+        );
+
+        expect(eventCallback).not.toBeCalled();
+      });
+
+      describe('should handle event type correctly', () => {
+        it.each([
+          [
+            ['events' as const, 'snapshots' as const, 'clips' as const],
+            false,
+            false,
+            true,
+          ],
+          [
+            ['events' as const, 'snapshots' as const, 'clips' as const],
+            false,
+            true,
+            true,
+          ],
+          [
+            ['events' as const, 'snapshots' as const, 'clips' as const],
+            true,
+            false,
+            true,
+          ],
+          [
+            ['events' as const, 'snapshots' as const, 'clips' as const],
+            true,
+            true,
+            true,
+          ],
+
+          [['events' as const, 'snapshots' as const], false, false, true],
+          [['events' as const, 'snapshots' as const], false, true, true],
+          [['events' as const, 'snapshots' as const], true, false, true],
+          [['events' as const, 'snapshots' as const], true, true, true],
+
+          [['events' as const, 'clips' as const], false, false, true],
+          [['events' as const, 'clips' as const], false, true, true],
+          [['events' as const, 'clips' as const], true, false, true],
+          [['events' as const, 'clips' as const], true, true, true],
+
+          [['events' as const], false, false, true],
+          [['events' as const], false, true, true],
+          [['events' as const], true, false, true],
+          [['events' as const], true, true, true],
+
+          [['snapshots' as const, 'clips' as const], false, false, false],
+          [['snapshots' as const, 'clips' as const], false, true, true],
+          [['snapshots' as const, 'clips' as const], true, false, true],
+          [['snapshots' as const, 'clips' as const], true, true, true],
+
+          [['snapshots' as const], false, false, false],
+          [['snapshots' as const], false, true, false],
+          [['snapshots' as const], true, false, true],
+          [['snapshots' as const], true, true, true],
+
+          [['clips' as const], false, false, false],
+          [['clips' as const], false, true, true],
+          [['clips' as const], true, false, false],
+          [['clips' as const], true, true, true],
+        ])(
+          'with events %s when snapshot %s and clip %s',
+          async (
+            events: CameraTriggerEventType[],
+            hasSnapshot: boolean,
+            hasClip: boolean,
+            call: boolean,
+          ) => {
+            const eventCallback = vi.fn();
+            const camera = new FrigateCamera(
+              createCameraConfig({
+                id: 'CAMERA_1',
+                frigate: {
+                  camera_name: 'camera.front_door',
+                },
+                triggers: {
+                  events: events,
+                },
+              }),
+              mock<CameraManagerEngine>(),
+              {
+                eventCallback: eventCallback,
+              },
+            );
+
+            const hass = createHASS();
+            await camera.initialize(hass, mock<EntityRegistryManager>());
+
+            callHASubscribeMessageHandler(
+              hass,
+              createFrigateEventChangeTrigger(
+                'new',
+                {
+                  camera: 'camera.front_door',
+                  snapshot: null,
+                  has_clip: false,
+                  has_snapshot: false,
+                  label: 'person',
+                  current_zones: [],
+                },
+                {
+                  camera: 'camera.front_door',
+                  snapshot: null,
+                  has_clip: hasClip,
+                  has_snapshot: hasSnapshot,
+                  label: 'person',
+                  current_zones: [],
+                },
+              ),
+            );
+
+            if (call) {
+              expect(eventCallback).toBeCalledWith({
+                type: 'new',
+                cameraID: 'CAMERA_1',
+                clip: hasClip && events.includes('clips'),
+                snapshot: hasSnapshot && events.includes('snapshots'),
+                fidelity: 'high',
+              });
+            } else {
+              expect(eventCallback).not.toBeCalled();
+            }
+          },
+        );
+      });
+
+      describe('should handle zones correctly', () => {
+        it.each([
+          ['has no zone', [], false],
+          ['has mismatched zone', ['fence'], false],
+          ['has matching zone', ['front_steps'], true],
+        ])('%s', async (_name: string, zones: string[], call: boolean) => {
+          const eventCallback = vi.fn();
+          const camera = new FrigateCamera(
+            createCameraConfig({
+              id: 'CAMERA_1',
+              frigate: {
+                camera_name: 'camera.front_door',
+                zones: ['front_steps'],
+              },
+            }),
+            mock<CameraManagerEngine>(),
+            {
+              eventCallback: eventCallback,
+            },
+          );
+
+          const hass = createHASS();
+          await camera.initialize(hass, mock<EntityRegistryManager>());
+
+          callHASubscribeMessageHandler(
+            hass,
+            createFrigateEventChangeTrigger(
+              'new',
+              {
+                camera: 'camera.front_door',
+                snapshot: null,
+                has_clip: false,
+                has_snapshot: false,
+                label: 'person',
+                current_zones: [],
+              },
+              {
+                camera: 'camera.front_door',
+                snapshot: null,
+                has_clip: false,
+                has_snapshot: true,
+                label: 'person',
+                current_zones: zones,
+              },
+            ),
+          );
+
+          expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
+        });
+      });
+
+      describe('should handle labels correctly', () => {
+        it.each([
+          ['has mismatched label', 'car', false],
+          ['has matching label', 'person', true],
+        ])('%s', async (_name: string, label: string, call: boolean) => {
+          const eventCallback = vi.fn();
+          const camera = new FrigateCamera(
+            createCameraConfig({
+              id: 'CAMERA_1',
+              frigate: {
+                camera_name: 'camera.front_door',
+                labels: ['person'],
+              },
+            }),
+            mock<CameraManagerEngine>(),
+            {
+              eventCallback: eventCallback,
+            },
+          );
+
+          const hass = createHASS();
+          await camera.initialize(hass, mock<EntityRegistryManager>());
+
+          callHASubscribeMessageHandler(
+            hass,
+            createFrigateEventChangeTrigger(
+              'new',
+              {
+                camera: 'camera.front_door',
+                snapshot: null,
+                has_clip: false,
+                has_snapshot: false,
+                // Even new events appear to have the event label in the
+                // 'before' dictionary.
+                label: label,
+                current_zones: [],
+              },
+              {
+                camera: 'camera.front_door',
+                snapshot: null,
+                has_clip: false,
+                has_snapshot: true,
+                label: label,
+                current_zones: [],
+              },
+            ),
+          );
+
+          expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
+        });
+      });
+    });
+  });
+
+  describe('should handle triggers', () => {
+    const cameraEntity: Partial<Entity> = {
+      config_entry_id: 'config_entry_id',
+    };
+
+    const occupancySensorEntityAll: Partial<Entity> = {
+      config_entry_id: 'config_entry_id',
+      disabled_by: null,
+      entity_id: 'binary_sensor.foo',
+      unique_id: '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:front_door_all',
+    };
+
+    const motionSensorEntity: Partial<Entity> = {
+      config_entry_id: 'config_entry_id',
+      disabled_by: null,
+      entity_id: 'binary_sensor.foo',
+      unique_id: '8c4e19d258359e82bc0cf9d47b021c46:motion_sensor:front_door',
+    };
+
+    describe('should detect motion sensor', () => {
+      it('without a camera name', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(motionSensorEntity),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            triggers: {
+              motion: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual([]);
+      });
+
+      it('with camera entity and name', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(motionSensorEntity),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            camera_entity: 'camera.front_door',
+            frigate: {
+              camera_name: 'front_door',
+            },
+            triggers: {
+              motion: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
+      });
+
+      it('with matching entity', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(motionSensorEntity),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+            triggers: {
+              motion: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
+      });
+
+      it('without matching entity', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+            triggers: {
+              motion: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual([]);
+      });
+    });
+
+    describe('should detect occupancy sensor', () => {
+      it('without a camera name', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(occupancySensorEntityAll),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual([]);
+      });
+
+      it('without a camera name but with occupancy trigger', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(occupancySensorEntityAll),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual([]);
+      });
+
+      it('with matching entity', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity(occupancySensorEntityAll),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
+      });
+
+      it('without matching entity', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+            },
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual([]);
+      });
+
+      it('with zones', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity({
+            ...occupancySensorEntityAll,
+            unique_id: '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:zone_all',
+          }),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+              zones: ['zone'],
+            },
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
+      });
+
+      it('with labels', async () => {
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        entityRegistryManager.getEntity.mockResolvedValue(
+          createRegistryEntity(cameraEntity),
+        );
+        entityRegistryManager.getMatchingEntities.mockResolvedValue([
+          createRegistryEntity({
+            ...occupancySensorEntityAll,
+            unique_id:
+              '8c4e19d258359e82bc0cf9d47b021c46:occupancy_sensor:front_door_car',
+          }),
+        ]);
+        const camera = new FrigateCamera(
+          createCameraConfig({
+            frigate: {
+              camera_name: 'front_door',
+              labels: ['car'],
+            },
+            triggers: {
+              occupancy: true,
+            },
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        const hass = createHASS();
+        await camera.initialize(hass, entityRegistryManager);
+
+        expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
+      });
+    });
+
+    it('should filter entities with correct function', async () => {
+      const entityRegistryManager = mock<EntityRegistryManager>();
+      entityRegistryManager.getEntity.mockResolvedValue(
+        createRegistryEntity(cameraEntity),
+      );
+      entityRegistryManager.getMatchingEntities.mockResolvedValue([
+        createRegistryEntity({
+          ...occupancySensorEntityAll,
+        }),
+      ]);
+      const camera = new FrigateCamera(
+        createCameraConfig({
+          camera_entity: 'camera.foo',
+          triggers: {
+            occupancy: true,
+          },
+        }),
+        mock<CameraManagerEngine>(),
+      );
+      const hass = createHASS();
+      await camera.initialize(hass, entityRegistryManager);
+
+      const filterFunc = entityRegistryManager.getMatchingEntities.mock.calls[0][1];
+
+      expect(
+        filterFunc(
+          createRegistryEntity({
+            config_entry_id: cameraEntity.config_entry_id,
+            disabled_by: '',
+            entity_id: 'binary_sensor.foo',
+          }),
+        ),
+      ).toBeTruthy();
+
+      expect(
+        filterFunc(
+          createRegistryEntity({
+            config_entry_id: cameraEntity.config_entry_id,
+            disabled_by: 'user',
+            entity_id: 'binary_sensor.foo',
+          }),
+        ),
+      ).toBeFalsy();
+
+      expect(
+        filterFunc(
+          createRegistryEntity({
+            config_entry_id: cameraEntity.config_entry_id,
+            disabled_by: '',
+            entity_id: 'camera.is_not_a_binary_sensor',
+          }),
+        ),
+      ).toBeFalsy();
+
+      expect(
+        filterFunc(
+          createRegistryEntity({
+            config_entry_id: 'not_a_matching_config_entry_id',
+            disabled_by: '',
+            entity_id: 'binary_sensor.foo',
+          }),
+        ),
+      ).toBeFalsy();
+    });
+  });
+});

tests/camera-manager/generic/engine-generic.test.ts

@@ -27,7 +27,7 @@ describe('GenericCameraManagerEngine', () => {
 
   it('should initialize camera', async () => {
     const config = createGenericCameraConfig();
-    const camera = await createEngine().initializeCamera(
+    const camera = await createEngine().createCamera(
       createHASS(),
       mock<EntityRegistryManager>(),
       config,

tests/camera-manager/store.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../../src/camera-manager/camera.js';
 import { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
@@ -6,11 +6,7 @@ import { CameraManagerStore } from '../../src/camera-manager/store.js';
 import { Engine } from '../../src/camera-manager/types.js';
 import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
 import { ResolvedMediaCache } from '../../src/utils/ha/resolved-media.js';
-import {
-  TestViewMedia,
-  createCameraCapabilities,
-  createCameraConfig,
-} from '../test-utils.js';
+import { createCameraConfig, TestViewMedia } from '../test-utils.js';
 
 describe('CameraManagerStore', async () => {
   const configVisible = createCameraConfig({
@@ -31,10 +27,14 @@ describe('CameraManagerStore', async () => {
 
   const setupStore = (): CameraManagerStore => {
     const store = new CameraManagerStore();
-    store.addCamera(
-      new Camera(configVisible, engineGeneric, createCameraCapabilities()),
-    );
-    store.addCamera(new Camera(configHidden, engineFrigate, createCameraCapabilities()));
+    const camera_1 = new Camera(configVisible, engineGeneric);
+    const camera_2 = new Camera(configHidden, engineFrigate);
+
+    camera_1.destroy = vi.fn();
+    camera_2.destroy = vi.fn();
+
+    store.addCamera(camera_1);
+    store.addCamera(camera_2);
     return store;
   };
 
@@ -123,11 +123,15 @@ describe('CameraManagerStore', async () => {
 
   it('reset', async () => {
     const store = setupStore();
+    const cameras = [...store.getCameras().values()];
 
-    store.reset();
+    await store.reset();
 
     expect(store.getCameraCount()).toBe(0);
     expect(store.getVisibleCameraCount()).toBe(0);
+    for (const camera of cameras) {
+      expect(camera.destroy).toBeCalled();
+    }
   });
 
   it('getCameraConfigForMedia', async () => {
@@ -169,7 +173,6 @@ describe('CameraManagerStore', async () => {
             id: 'camera-visible2',
           },
           engineGeneric,
-          createCameraCapabilities(),
         ),
       );
 
@@ -209,7 +212,6 @@ describe('CameraManagerStore', async () => {
             },
           }),
           engineGeneric,
-          createCameraCapabilities(),
         ),
       );
       store.addCamera(
@@ -218,7 +220,6 @@ describe('CameraManagerStore', async () => {
             id: 'two',
           }),
           engineGeneric,
-          createCameraCapabilities(),
         ),
       );
       expect(store.getAllDependentCameras('one')).toEqual(new Set(['one', 'two']));
@@ -234,7 +235,6 @@ describe('CameraManagerStore', async () => {
             },
           }),
           engineGeneric,
-          createCameraCapabilities(),
         ),
       );
       store.addCamera(
@@ -243,7 +243,6 @@ describe('CameraManagerStore', async () => {
             id: 'two',
           }),
           engineGeneric,
-          createCameraCapabilities(),
         ),
       );
       expect(store.getAllDependentCameras('one')).toEqual(new Set(['one', 'two']));

tests/camera-manager/utils.test.ts

@@ -107,6 +107,19 @@ describe('sortMedia', () => {
   it('should remove duplicate id', () => {
     expect(sortMedia([media_1, media_2, media_3_dup_id])).toEqual([media_1, media_2]);
   });
+  it('should sort by id when time not available', () => {
+    expect(
+      sortMedia([
+        new TestViewMedia({ id: 'snake' }),
+        new TestViewMedia({ id: 'zebra' }),
+        new TestViewMedia({ id: 'aardvark' }),
+      ]),
+    ).toEqual([
+      new TestViewMedia({ id: 'aardvark' }),
+      new TestViewMedia({ id: 'snake' }),
+      new TestViewMedia({ id: 'zebra' }),
+    ]);
+  });
   it('should remove de-duplicate by object if no id', () => {
     expect(sortMedia([media_1, media_2, media_4_no_id, media_4_no_id])).toEqual([
       media_1,

tests/card-controller/card-element-manager.test.ts

@@ -154,6 +154,8 @@ describe('CardElementManager', () => {
     element.removeEventListener = removeEventListener;
 
     const api = createCardAPI();
+    vi.mocked(api.getCameraManager().reset).mockResolvedValue();
+
     const manager = new CardElementManager(
       api,
       element,
@@ -184,5 +186,7 @@ describe('CardElementManager', () => {
       expect.anything(),
     );
     expect(windowRemoveEventListener).toBeCalledWith('popstate', expect.anything());
+
+    expect(api.getCameraManager().reset).toBeCalled();
   });
 });

tests/card-controller/conditions-manager.test.ts

@@ -206,6 +206,14 @@ describe('ConditionsManager', () => {
     expect(epoch_1).not.toBe(epoch_2);
   });
 
+  it('should get state', () => {
+    const state = { fullscreen: true };
+
+    const manager = new ConditionsManager(createCardAPI());
+    manager.setState(state);
+    expect(manager.getState()).toEqual(state);
+  });
+
   it('should not return hasHAStateConditions without HA state conditions', () => {
     const manager = new ConditionsManager(createCardAPI());
     expect(manager.hasHAStateConditions()).toBeFalsy();

tests/card-controller/hass-manager.test.ts

@@ -66,18 +66,6 @@ describe('HASSManager', () => {
     });
   });
 
-  it('should update triggered cameras', () => {
-    const api = createAPIWithoutMediaPlayers();
-    const manager = new HASSManager(api);
-
-    const originalHASS = createHASS();
-    manager.setHASS(originalHASS);
-    expect(api.getTriggersManager().updateTriggerHAState).toBeCalledWith(null);
-
-    manager.setHASS(createHASS());
-    expect(api.getTriggersManager().updateTriggerHAState).toBeCalledWith(originalHASS);
-  });
-
   describe('should handle connection state change when', () => {
     it('initially disconnected', () => {
       const api = createAPIWithoutMediaPlayers();
@@ -156,37 +144,6 @@ describe('HASSManager', () => {
   });
 
   describe('should set default view when', () => {
-    it('selected camera trigger entity changes', () => {
-      const api = createAPIWithoutMediaPlayers();
-      vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
-      vi.mocked(api.getCameraManager().getStore).mockReturnValue(
-        createStore([
-          {
-            cameraID: 'camera.foo',
-            config: createCameraConfig({
-              triggers: {
-                entities: ['binary_sensor.motion'],
-              },
-            }),
-          },
-        ]),
-      );
-      vi.mocked(api.getViewManager().getView).mockReturnValue(
-        createView({
-          camera: 'camera.foo',
-        }),
-      );
-
-      const manager = new HASSManager(api);
-      const hass = createHASS({
-        'binary_sensor.motion': createStateEntity(),
-      });
-
-      manager.setHASS(hass);
-
-      expect(api.getViewManager().setViewDefault).toBeCalled();
-    });
-
     it('selected camera is unknown', () => {
       const api = createAPIWithoutMediaPlayers();
       vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());

tests/card-controller/triggers-manager.test.ts

@@ -1,22 +1,22 @@
 import add from 'date-fns/add';
-import { HassEntities } from 'home-assistant-js-websocket';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { CardController } from '../../src/card-controller/controller';
 import { TriggersManager } from '../../src/card-controller/triggers-manager';
-import { ScanOptions, scanSchema } from '../../src/config/types';
+import { TriggersOptions, triggersSchema } from '../../src/config/types';
 import {
   createCameraConfig,
   createCameraManager,
   createCardAPI,
   createConfig,
-  createHASS,
-  createStateEntity,
   createStore,
   createView,
 } from '../test-utils';
 
-const baseScanConfig: Partial<ScanOptions> = {
-  enabled: true,
+vi.mock('lodash-es/throttle', () => ({
+  default: vi.fn((fn) => fn),
+}));
+
+const baseTriggersConfig: Partial<TriggersOptions> = {
   untrigger_seconds: 10,
   filter_selected_camera: false,
   actions: {
@@ -29,21 +29,20 @@ const baseScanConfig: Partial<ScanOptions> = {
 // Creating and mocking a trigger API is a lot of boilerplate, this convenience
 // function reduces it.
 const createTriggerAPI = (options?: {
-  config?: Partial<ScanOptions>;
-  hassStates?: HassEntities;
+  config?: Partial<TriggersOptions>;
   interaction?: boolean;
 }): CardController => {
   const api = createCardAPI();
   vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
     createConfig({
       view: {
-        scan: options?.config ? scanSchema.parse(options.config) : baseScanConfig,
+        triggers: options?.config
+          ? triggersSchema.parse(options.config)
+          : baseTriggersConfig,
       },
     }),
   );
-  vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-    createHASS(options?.hassStates),
-  );
+  vi.mocked(api.getConditionsManager().getState).mockReturnValue({});
   vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
   vi.mocked(api.getCameraManager().getStore).mockReturnValue(
     createStore([
@@ -60,22 +59,22 @@ const createTriggerAPI = (options?: {
   vi.mocked(api.getInteractionManager().hasInteraction).mockReturnValue(
     options?.interaction ?? false,
   );
+  vi.mocked(api.getViewManager().getView).mockReturnValue(
+    createView({
+      camera: 'camera_1' as const,
+    }),
+  );
 
   return api;
 };
 
 // @vitest-environment jsdom
 describe('TriggersManager', () => {
-  const hassActiveState = {
-    'binary_sensor.motion': createStateEntity({ state: 'on' }),
-  };
-  const hassInactiveState = {
-    'binary_sensor.motion': createStateEntity({ state: 'off' }),
-  };
+  const start = new Date('2023-10-01T17:14');
 
   beforeEach(() => {
-    vi.resetAllMocks();
     vi.useFakeTimers();
+    vi.setSystemTime(start);
   });
 
   it('should not be triggered by default', () => {
@@ -83,23 +82,8 @@ describe('TriggersManager', () => {
     expect(manager.isTriggered()).toBeFalsy();
   });
 
-  it('should not trigger when scan mode disabled default', () => {
-    const api = createTriggerAPI({
-      config: { enabled: false },
-      hassStates: hassActiveState,
-    });
-    const manager = new TriggersManager(api);
-
-    manager.updateTriggerHAState(null);
-
-    expect(manager.isTriggered()).toBeFalsy();
-  });
-
-  it('should not trigger without a scan config', () => {
-    const api = createTriggerAPI({
-      hassStates: hassActiveState,
-    });
-
+  it('should not trigger without a triggers config', () => {
+    const api = createTriggerAPI();
     vi.mocked(api.getViewManager().getView).mockReturnValue(
       createView({
         camera: 'camera_1' as const,
@@ -108,19 +92,23 @@ describe('TriggersManager', () => {
     vi.mocked(api.getConfigManager().getConfig).mockReturnValue(null);
 
     const manager = new TriggersManager(api);
-    manager.updateView(null);
+
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
+
     expect(manager.isTriggered()).toBeFalsy();
   });
 
-  it('should trigger and untrigger based on entity state', () => {
-    const start = new Date('2023-10-01T17:14');
-    vi.setSystemTime(start);
-    const api = createTriggerAPI({
-      hassStates: hassActiveState,
-    });
+  it('should trigger and untrigger based on low fidelity event', () => {
+    const api = createTriggerAPI();
     const manager = new TriggersManager(api);
 
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
 
     expect(manager.isTriggered()).toBeTruthy();
     expect(api.getConditionsManager().setState).toHaveBeenLastCalledWith({
@@ -132,14 +120,14 @@ describe('TriggersManager', () => {
       cameraID: 'camera_1' as const,
     });
 
-    vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-      createHASS(hassInactiveState),
-    );
+    vi.mocked(api.getConditionsManager().getState).mockReturnValue({
+      triggered: new Set(['camera_1']),
+    });
 
-    manager.updateTriggerHAState(createHASS(hassActiveState));
-
-    // Intentional state update with no change.
-    manager.updateTriggerHAState(createHASS(hassActiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'end',
+    });
 
     // Will still be triggered, but untrigger timer will be running.
     expect(manager.isTriggered()).toBeTruthy();
@@ -155,34 +143,141 @@ describe('TriggersManager', () => {
     expect(api.getViewManager().setViewDefault).toBeCalled();
   });
 
-  it('should trigger when entity state is active on startup', () => {
+  describe('should treat high fidelity events appropriately', () => {
+    it('with no media', () => {
+      const api = createTriggerAPI();
+      vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
+        createConfig({
+          view: {
+            default: 'clips',
+          },
+        }),
+      );
+
+      const manager = new TriggersManager(api);
+      manager.handleCameraEvent({
+        cameraID: 'camera_1',
+        type: 'new',
+        fidelity: 'high',
+
+        // Intentionally blank.
+      });
+
+      expect(manager.isTriggered()).toBeTruthy();
+      expect(api.getViewManager().setViewByParameters).not.toBeCalled();
+    });
+
+    it('with media', () => {
+      const api = createTriggerAPI();
+      vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
+        createConfig({
+          view: {
+            default: 'clips',
+          },
+        }),
+      );
+
+      const manager = new TriggersManager(api);
+      manager.handleCameraEvent({
+        cameraID: 'camera_1',
+        type: 'new',
+        fidelity: 'high',
+        clip: true,
+      });
+
+      expect(manager.isTriggered()).toBeTruthy();
+      expect(api.getViewManager().setViewDefault).toBeCalled();
+    });
+  });
+
+  it('should change to default view when suitably configured', () => {
     const api = createTriggerAPI({
-      hassStates: hassActiveState,
+      config: {
+        actions: {
+          interaction_mode: 'all',
+          trigger: 'default',
+          untrigger: 'none',
+        },
+      },
     });
     const manager = new TriggersManager(api);
-    expect(manager.isTriggered()).toBeFalsy();
 
-    manager.updateTriggerHAState(null);
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
+
     expect(manager.isTriggered()).toBeTruthy();
+    expect(api.getViewManager().setViewDefault).toBeCalledWith({
+      cameraID: 'camera_1',
+    });
+  });
+
+  describe('should change to media view', () => {
+    it.each([
+      [false, false, null],
+      [false, true, 'clip' as const],
+      [true, false, 'snapshot' as const],
+      [true, true, 'clip' as const],
+    ])(
+      'with snapshot %s and clip %s',
+      async (
+        hasSnapshot: boolean,
+        hasClip: boolean,
+        viewName: 'clip' | 'snapshot' | null,
+      ) => {
+        const api = createTriggerAPI({
+          config: {
+            actions: {
+              interaction_mode: 'all',
+              trigger: 'media',
+              untrigger: 'none',
+            },
+          },
+        });
+        const manager = new TriggersManager(api);
+
+        manager.handleCameraEvent({
+          cameraID: 'camera_1',
+          type: 'new',
+          fidelity: 'high',
+          snapshot: hasSnapshot,
+          clip: hasClip,
+        });
+
+        if (!viewName) {
+          expect(api.getViewManager().setViewByParameters).not.toBeCalled();
+        } else {
+          expect(manager.isTriggered()).toBeTruthy();
+          expect(api.getViewManager().setViewByParameters).toBeCalledWith({
+            cameraID: 'camera_1',
+            viewName: viewName,
+          });
+        }
+      },
+    );
   });
 
   it('should take no actions with human interactions', () => {
-    const start = new Date('2023-10-01T17:14');
     const api = createTriggerAPI({
-      hassStates: hassActiveState,
       // Interaction present.
       interaction: true,
     });
     const manager = new TriggersManager(api);
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
+
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
+
     expect(manager.isTriggered()).toBeTruthy();
 
     expect(api.getViewManager().setViewByParameters).not.toBeCalled();
 
-    vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-      createHASS(hassInactiveState),
-    );
-    manager.updateTriggerHAState(createHASS(hassActiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'end',
+    });
 
     vi.setSystemTime(add(start, { seconds: 10 }));
     vi.runOnlyPendingTimers();
@@ -193,11 +288,8 @@ describe('TriggersManager', () => {
   });
 
   it('should take no actions when actions are set to none', () => {
-    const start = new Date('2023-10-01T17:14');
     const api = createTriggerAPI({
-      hassStates: hassActiveState,
       config: {
-        enabled: true,
         actions: {
           interaction_mode: 'all',
           trigger: 'none',
@@ -206,32 +298,31 @@ describe('TriggersManager', () => {
       },
     });
     const manager = new TriggersManager(api);
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
     expect(manager.isTriggered()).toBeTruthy();
-
     expect(api.getViewManager().setViewByParameters).not.toBeCalled();
 
-    vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-      createHASS(hassInactiveState),
-    );
-    manager.updateTriggerHAState(createHASS(hassActiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'end',
+    });
 
     vi.setSystemTime(add(start, { seconds: 10 }));
     vi.runOnlyPendingTimers();
 
     expect(manager.isTriggered()).toBeFalsy();
-
     expect(api.getViewManager().setViewDefault).not.toBeCalled();
   });
 
   it('should take actions with human interactions when interaction mode is active', () => {
-    const start = new Date('2023-10-01T17:14');
     const api = createTriggerAPI({
-      hassStates: hassActiveState,
       // Interaction present.
       interaction: true,
       config: {
-        ...baseScanConfig,
+        ...baseTriggersConfig,
         actions: {
           trigger: 'live' as const,
           untrigger: 'default' as const,
@@ -240,18 +331,21 @@ describe('TriggersManager', () => {
       },
     });
     const manager = new TriggersManager(api);
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
-    expect(manager.isTriggered()).toBeTruthy();
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
 
+    expect(manager.isTriggered()).toBeTruthy();
     expect(api.getViewManager().setViewByParameters).toBeCalledWith({
       viewName: 'live' as const,
       cameraID: 'camera_1' as const,
     });
 
-    vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-      createHASS(hassInactiveState),
-    );
-    manager.updateTriggerHAState(createHASS(hassActiveState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'end',
+    });
 
     vi.setSystemTime(add(start, { seconds: 10 }));
     vi.runOnlyPendingTimers();
@@ -262,14 +356,7 @@ describe('TriggersManager', () => {
   });
 
   it('should report multiple triggered cameras', () => {
-    const start = new Date('2023-10-01T17:14');
-    const bothOnState = {
-      'binary_sensor.one': createStateEntity({ state: 'on' }),
-      'binary_sensor.two': createStateEntity({ state: 'on' }),
-    };
-    const api = createTriggerAPI({
-      hassStates: bothOnState,
-    });
+    const api = createTriggerAPI();
     vi.mocked(api.getCameraManager().getStore).mockReturnValue(
       createStore([
         {
@@ -297,7 +384,15 @@ describe('TriggersManager', () => {
     expect(manager.getMostRecentlyTriggeredCameraID()).toBeNull();
     expect(manager.getTriggeredCameraIDs()).toEqual(new Set());
 
-    manager.updateTriggerHAState(null);
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'new',
+    });
+    manager.handleCameraEvent({
+      cameraID: 'camera_2',
+      type: 'new',
+    });
+
     expect(manager.isTriggered()).toBeTruthy();
     expect(manager.getTriggeredCameraIDs()).toEqual(new Set(['camera_1', 'camera_2']));
 
@@ -306,14 +401,10 @@ describe('TriggersManager', () => {
       manager.getMostRecentlyTriggeredCameraID(),
     );
 
-    vi.mocked(api.getHASSManager().getHASS).mockReturnValue(
-      createHASS({
-        'binary_sensor.one': createStateEntity({ state: 'off' }),
-        'binary_sensor.two': createStateEntity({ state: 'on' }),
-      }),
-    );
-
-    manager.updateTriggerHAState(createHASS(bothOnState));
+    manager.handleCameraEvent({
+      cameraID: 'camera_1',
+      type: 'end',
+    });
 
     vi.setSystemTime(add(start, { seconds: 10 }));
     vi.runOnlyPendingTimers();
@@ -322,75 +413,87 @@ describe('TriggersManager', () => {
     expect(manager.getMostRecentlyTriggeredCameraID()).toBe('camera_2');
   });
 
-  it('should filter triggers by camera', () => {
-    const start = new Date('2023-10-01T17:14');
-    const api = createTriggerAPI({
-      config: {
-        ...baseScanConfig,
-        // Filter triggers to selected camera only.
-        filter_selected_camera: true,
-      },
-      hassStates: hassActiveState,
-    });
-    const manager = new TriggersManager(api);
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
-    expect(manager.isTriggered()).toBeFalsy();
+  describe('should filter triggers by camera', () => {
+    it('no dependencies', () => {
+      const api = createTriggerAPI({
+        config: {
+          ...baseTriggersConfig,
+          // Filter triggers to selected camera only.
+          filter_selected_camera: true,
+        },
+      });
+      const manager = new TriggersManager(api);
+      expect(manager.isTriggered()).toBeFalsy();
 
-    const otherCameraSelected = createView({
-      camera: 'camera_SOME_OTHER_CAMERA' as const,
+      const otherCameraSelected = createView({
+        camera: 'camera_SOME_OTHER_CAMERA' as const,
+      });
+      vi.mocked(api.getViewManager().getView).mockReturnValue(otherCameraSelected);
+
+      manager.handleCameraEvent({
+        cameraID: 'camera_1',
+        type: 'new',
+      });
+      expect(manager.isTriggered()).toBeFalsy();
+
+      const thisCameraSelected = createView({
+        camera: 'camera_1' as const,
+      });
+      vi.mocked(api.getViewManager().getView).mockReturnValue(thisCameraSelected);
+
+      manager.handleCameraEvent({
+        cameraID: 'camera_1',
+        type: 'new',
+      });
+      expect(manager.isTriggered()).toBeTruthy();
     });
 
-    vi.mocked(api.getViewManager().getView).mockReturnValue(otherCameraSelected);
-    manager.updateView(null);
-    expect(manager.isTriggered()).toBeFalsy();
+    it('dependencies', () => {
+      const api = createTriggerAPI({
+        config: {
+          ...baseTriggersConfig,
+          // Filter triggers to selected camera only.
+          filter_selected_camera: true,
+        },
+      });
+      vi.mocked(api.getCameraManager().getStore).mockReturnValue(
+        createStore([
+          {
+            cameraID: 'camera_primary',
+            config: createCameraConfig({
+              triggers: {
+                entities: ['binary_sensor.motion'],
+              },
+              dependencies: {
+                all_cameras: true,
+              },
+            }),
+          },
+          {
+            cameraID: 'camera_secondary',
+            config: createCameraConfig({
+              triggers: {
+                entities: ['binary_sensor.motion'],
+              },
+            }),
+          },
+        ]),
+      );
 
-    const thisCameraSelected = createView({
-      camera: 'camera_1' as const,
+      const manager = new TriggersManager(api);
+
+      const primaryCameraView = createView({
+        camera: 'camera_primary' as const,
+      });
+      vi.mocked(api.getViewManager().getView).mockReturnValue(primaryCameraView);
+
+      // Events for the secondary will still trigger when filter_selected_camera
+      // is true.
+      manager.handleCameraEvent({
+        cameraID: 'camera_secondary',
+        type: 'new',
+      });
+      expect(manager.isTriggered()).toBeTruthy();
     });
-
-    vi.mocked(api.getViewManager().getView).mockReturnValue(thisCameraSelected);
-    manager.updateView(otherCameraSelected);
-    expect(manager.isTriggered()).toBeTruthy();
-
-    // Ensure a view change to the same camera stays triggered.
-    vi.mocked(api.getViewManager().getView).mockReturnValue(thisCameraSelected);
-    manager.updateView(thisCameraSelected);
-    expect(manager.isTriggered()).toBeTruthy();
-  });
-
-  it('should not untrigger triggers by camera', () => {
-    const start = new Date('2023-10-01T17:14');
-    const api = createTriggerAPI({
-      config: {
-        ...baseScanConfig,
-        // Filter triggers to selected camera only.
-        filter_selected_camera: true,
-      },
-      hassStates: hassActiveState,
-    });
-    const manager = new TriggersManager(api);
-    manager.updateTriggerHAState(createHASS(hassInactiveState));
-    expect(manager.isTriggered()).toBeFalsy();
-
-    const otherCameraSelected = createView({
-      camera: 'camera_SOME_OTHER_CAMERA' as const,
-    });
-
-    vi.mocked(api.getViewManager().getView).mockReturnValue(otherCameraSelected);
-    manager.updateView(null);
-    expect(manager.isTriggered()).toBeFalsy();
-
-    const thisCameraSelected = createView({
-      camera: 'camera_1' as const,
-    });
-
-    vi.mocked(api.getViewManager().getView).mockReturnValue(thisCameraSelected);
-    manager.updateView(otherCameraSelected);
-    expect(manager.isTriggered()).toBeTruthy();
-
-    // Ensure a view change to the same camera stays triggered.
-    vi.mocked(api.getViewManager().getView).mockReturnValue(thisCameraSelected);
-    manager.updateView(thisCameraSelected);
-    expect(manager.isTriggered()).toBeTruthy();
   });
 });

tests/config-mgmt.test.ts

@@ -4,6 +4,7 @@ import {
   createRangedTransform,
   deleteConfigValue,
   deleteTransform,
+  deleteWithOverrides,
   getArrayConfigPath,
   getConfigValue,
   isConfigUpgradeable,
@@ -344,6 +345,12 @@ describe('upgrade functions', () => {
   it('should have upgrades with bad input data', () => {
     expect(upgradeConfig(3 as unknown as RawFrigateCardConfig)).toBeFalsy();
   });
+
+  it('should delete properties', () => {
+    const config = { c: 10, d: 10 };
+    expect(deleteWithOverrides('c')(config)).toBeTruthy();
+    expect(config).toEqual({ d: 10 });
+  });
 });
 
 describe('should handle version specific upgrades', () => {
@@ -1167,52 +1174,6 @@ describe('should handle version specific upgrades', () => {
       });
     });
 
-    describe('should move and transform untrigger_reset', () => {
-      it('when true', () => {
-        const config = {
-          type: 'custom:frigate-card',
-          cameras: [{ camera_entity: 'camera.office' }],
-          view: {
-            scan: {
-              untrigger_reset: true,
-            },
-          },
-        };
-        expect(upgradeConfig(config)).toBeTruthy();
-        expect(config).toEqual({
-          type: 'custom:frigate-card',
-          cameras: [{ camera_entity: 'camera.office' }],
-          view: {
-            scan: {
-              actions: {
-                untrigger: 'default',
-              },
-            },
-          },
-        });
-      });
-
-      it('when false', () => {
-        const config = {
-          type: 'custom:frigate-card',
-          cameras: [{ camera_entity: 'camera.office' }],
-          view: {
-            scan: {
-              untrigger_reset: false,
-            },
-          },
-        };
-        expect(upgradeConfig(config)).toBeTruthy();
-        expect(config).toEqual({
-          type: 'custom:frigate-card',
-          cameras: [{ camera_entity: 'camera.office' }],
-          view: {
-            scan: {},
-          },
-        });
-      });
-    });
-
     it('should move view.timeout_seconds', () => {
       const config = {
         type: 'custom:frigate-card',
@@ -1690,5 +1651,92 @@ describe('should handle version specific upgrades', () => {
         },
       );
     });
+
+    describe('should transform scan mode', () => {
+      describe('should move and transform untrigger_reset', () => {
+        it('when true', () => {
+          const config = {
+            type: 'custom:frigate-card',
+            cameras: [{ camera_entity: 'camera.office' }],
+            view: {
+              scan: {
+                untrigger_reset: true,
+              },
+            },
+          };
+          expect(upgradeConfig(config)).toBeTruthy();
+          expect(config).toEqual({
+            type: 'custom:frigate-card',
+            cameras: [{ camera_entity: 'camera.office' }],
+            view: {
+              triggers: {
+                actions: {
+                  untrigger: 'default',
+                },
+              },
+            },
+          });
+        });
+
+        it('when false', () => {
+          const config = {
+            type: 'custom:frigate-card',
+            cameras: [{ camera_entity: 'camera.office' }],
+            view: {
+              scan: {
+                untrigger_reset: false,
+              },
+            },
+          };
+          expect(upgradeConfig(config)).toBeTruthy();
+          expect(config).toEqual({
+            type: 'custom:frigate-card',
+            cameras: [{ camera_entity: 'camera.office' }],
+            view: {
+              triggers: {},
+            },
+          });
+        });
+      });
+
+      describe('should rename view.scan.enabled to a trigger action', () => {
+        it('when true', () => {
+          const config = {
+            view: {
+              scan: {
+                enabled: true,
+              },
+            },
+          };
+          expect(upgradeConfig(config)).toBeTruthy();
+          expect(config).toEqual({
+            view: {
+              triggers: {
+                filter_selected_camera: false,
+                actions: {
+                  trigger: 'live',
+                },
+              },
+            },
+          });
+        });
+
+        it('when false', () => {
+          const config = {
+            view: {
+              scan: {
+                enabled: false,
+              },
+            },
+          };
+          expect(upgradeConfig(config)).toBeTruthy();
+          expect(config).toEqual({
+            view: {
+              triggers: {},
+            },
+          });
+        });
+      });
+    });
   });
 });

tests/config/types.test.ts

@@ -38,9 +38,10 @@ describe('config defaults', () => {
           },
         },
         triggers: {
+          events: ['events', 'clips', 'snapshots'],
           entities: [],
           motion: false,
-          occupancy: true,
+          occupancy: false,
         },
       },
       debug: {
@@ -279,16 +280,15 @@ describe('config defaults', () => {
         camera_select: 'current',
         dark_mode: 'off',
         default: 'live',
-        scan: {
-          enabled: false,
-          show_trigger_status: true,
+        triggers: {
+          show_trigger_status: false,
           untrigger_seconds: 0,
           actions: {
-            trigger: 'live',
-            untrigger: 'default',
+            trigger: 'default',
+            untrigger: 'none',
             interaction_mode: 'inactive',
           },
-          filter_selected_camera: false,
+          filter_selected_camera: true,
         },
         interaction_seconds: 300,
         reset_after_interaction: true,

tests/test-utils.ts

@@ -1,5 +1,6 @@
+import { HomeAssistant } from '@dermotduffy/custom-card-helpers';
 import { HassEntities, HassEntity } from 'home-assistant-js-websocket';
-import { vi } from 'vitest';
+import { expect, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../src/camera-manager/camera';
 import { CameraManagerEngine } from '../src/camera-manager/engine';
@@ -8,6 +9,7 @@ import { GenericCameraManagerEngine } from '../src/camera-manager/generic/engine
 import { CameraManager } from '../src/camera-manager/manager';
 import { CameraManagerStore } from '../src/camera-manager/store';
 import {
+  CameraEventCallback,
   CameraManagerCameraCapabilities,
   CameraManagerCapabilities,
   CameraManagerMediaCapabilities,
@@ -36,16 +38,17 @@ import { TriggersManager } from '../src/card-controller/triggers-manager';
 import { ViewManager } from '../src/card-controller/view-manager';
 import {
   CameraConfig,
-  cameraConfigSchema,
   FrigateCardCondition,
-  frigateCardConditionSchema,
   FrigateCardConfig,
-  frigateCardConfigSchema,
   PerformanceConfig,
-  performanceConfigSchema,
   RawFrigateCardConfig,
+  cameraConfigSchema,
+  frigateCardConditionSchema,
+  frigateCardConfigSchema,
+  performanceConfigSchema,
 } from '../src/config/types';
 import { ExtendedHomeAssistant, MediaLoadedInfo } from '../src/types';
+import { EntityRegistryManager } from '../src/utils/ha/entity-registry';
 import { Entity } from '../src/utils/ha/entity-registry/types';
 import { ViewMedia, ViewMediaType } from '../src/view/media';
 import { MediaQueriesResults } from '../src/view/media-queries-results';
@@ -69,11 +72,20 @@ export const createConfig = (config?: RawFrigateCardConfig): FrigateCardConfig =
   });
 };
 
+export const createCamera = (
+  config: CameraConfig,
+  engine: CameraManagerEngine,
+  capabilities?: CameraManagerCameraCapabilities,
+): Camera => {
+  return new Camera(config, engine, { capabilities: capabilities });
+};
+
 export const createHASS = (states?: HassEntities): ExtendedHomeAssistant => {
   const hass = mock<ExtendedHomeAssistant>();
   if (states) {
     hass.states = states;
   }
+  hass.connection.subscribeMessage = vi.fn();
   return hass;
 };
 
@@ -158,14 +170,19 @@ export const createStore = (
     engine?: CameraManagerEngine;
     config?: CameraConfig;
     capabilities?: CameraManagerCameraCapabilities;
+    eventCallback?: CameraEventCallback;
   }[],
 ): CameraManagerStore => {
   const store = new CameraManagerStore();
   for (const cameraProps of cameras ?? []) {
+    const eventCallback = cameraProps.eventCallback ?? vi.fn();
     const camera = new Camera(
       cameraProps.config ?? createCameraConfig(),
-      cameraProps.engine ?? new GenericCameraManagerEngine(),
-      cameraProps.capabilities ?? createCameraCapabilities(),
+      cameraProps.engine ?? new GenericCameraManagerEngine(eventCallback),
+      {
+        capabilities: cameraProps.capabilities ?? createCameraCapabilities(),
+        eventCallback: eventCallback,
+      },
     );
     camera.setID(cameraProps.cameraID);
     store.addCamera(camera);
@@ -260,10 +277,10 @@ export class TestViewMedia extends ViewMedia {
 
   constructor(options?: {
     id?: string | null;
-    startTime?: Date;
+    startTime?: Date | null;
     mediaType?: ViewMediaType;
     cameraID?: string;
-    endTime?: Date;
+    endTime?: Date | null;
     inProgress?: boolean;
     contentID?: string;
     title?: string;
@@ -364,6 +381,7 @@ export const createCardAPI = (): CardController => {
   api.getConditionsManager.mockReturnValue(mock<ConditionsManager>());
   api.getConfigManager.mockReturnValue(mock<ConfigManager>());
   api.getDownloadManager.mockReturnValue(mock<DownloadManager>());
+  api.getEntityRegistryManager.mockReturnValue(mock<EntityRegistryManager>());
   api.getExpandManager.mockReturnValue(mock<ExpandManager>());
   api.getFullscreenManager.mockReturnValue(mock<FullscreenManager>());
   api.getHASSManager.mockReturnValue(mock<HASSManager>());
@@ -380,3 +398,13 @@ export const createCardAPI = (): CardController => {
 
   return api;
 };
+
+export const callHASubscribeMessageHandler = (
+  hass: HomeAssistant,
+  ev: unknown,
+  n = 0,
+): void => {
+  const mock = vi.mocked(hass.connection.subscribeMessage).mock;
+  expect(mock.calls.length).greaterThan(n);
+  mock.calls[n][0](ev);
+};

tests/utils/ha/index.test.ts

@@ -1,8 +1,10 @@
 import { HomeAssistant } from '@dermotduffy/custom-card-helpers';
-import { describe, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   getEntityIcon,
   hasHAConnectionStateChanged,
+  parseStateChangeTrigger,
+  subscribeToTrigger,
 } from '../../../src/utils/ha/index.js';
 import { createHASS, createStateEntity } from '../../test-utils.js';
 
@@ -67,3 +69,105 @@ describe('getEntityIcon', () => {
     expect(getEntityIcon(createHASS(), 'camera.test')).toBe('mdi:video');
   });
 });
+
+describe('should subscribe to trigger', () => {
+  it('mqtt', async () => {
+    const hass = createHASS();
+    const callback = vi.fn();
+
+    await subscribeToTrigger(hass, callback, {
+      platform: 'mqtt',
+      topic: 'topic',
+      payload: 'payload',
+      valueTemplate: 'value_template',
+    });
+
+    expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
+      type: 'subscribe_trigger',
+      trigger: {
+        platform: 'mqtt',
+        topic: 'topic',
+        payload: 'payload',
+        value_template: 'value_template',
+      },
+    });
+  });
+
+  it('state and attributes', async () => {
+    const hass = createHASS();
+    const callback = vi.fn();
+
+    await subscribeToTrigger(hass, callback, {
+      platform: 'state',
+      entityID: 'camera.foo',
+    });
+
+    expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
+      type: 'subscribe_trigger',
+      trigger: {
+        platform: 'state',
+        entity_id: 'camera.foo',
+      },
+    });
+  });
+
+  it('state only', async () => {
+    const hass = createHASS();
+    const callback = vi.fn();
+
+    await subscribeToTrigger(hass, callback, {
+      platform: 'state',
+      entityID: 'camera.foo',
+      stateOnly: true,
+    });
+
+    expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
+      type: 'subscribe_trigger',
+      trigger: {
+        platform: 'state',
+        entity_id: 'camera.foo',
+        from: null,
+        to: null,
+      },
+    });
+  });
+});
+
+describe('should parse state change response', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('malformed response', async () => {
+    const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+    expect(parseStateChangeTrigger('INVALID')).toBeNull();
+
+    expect(consoleSpy).toBeCalledWith('Ignoring unparseable HA state change', 'INVALID');
+  });
+
+  it('valid response', async () => {
+    const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+    const stateChange = {
+      from_state: {
+        entity_id: 'camera.foo',
+        state: 'off',
+      },
+      to_state: {
+        entity_id: 'camera.foo',
+        state: 'on',
+      },
+    };
+
+    expect(
+      parseStateChangeTrigger({
+        variables: {
+          trigger: stateChange,
+        },
+      }),
+    ).toEqual(stateChange);
+
+    expect(consoleSpy).not.toBeCalled();
+  });
+});

tests/utils/media-to-view.test.ts

@@ -202,6 +202,40 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
     );
   });
 
+  it('should respect useCache', async () => {
+    const cameraManager = createCameraManager();
+    vi.mocked(cameraManager.getStore).mockReturnValue(
+      createStore([
+        {
+          cameraID: 'camera',
+        },
+      ]),
+    );
+    vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue([
+      {
+        type: QueryType.Event,
+        cameraIDs: new Set(['camera']),
+      },
+    ]);
+
+    await changeViewToRecentEventsForCameraAndDependents(
+      createElementListenForView().element,
+      cameraManager,
+      {},
+      createView(),
+      {
+        useCache: false,
+      },
+    );
+
+    expect(vi.mocked(cameraManager.executeMediaQueries)).toBeCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        useCache: false,
+      }),
+    );
+  });
+
   describe('should respect request for media type', () => {
     it.each([
       ['snapshots' as const, 'hasSnapshot'],
@@ -463,6 +497,42 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
       }),
     );
   });
+
+  it('should respect useCache', async () => {
+    const cameraManager = createCameraManager();
+    vi.mocked(cameraManager.getStore).mockReturnValue(
+      createStore([
+        {
+          cameraID: 'camera',
+        },
+      ]),
+    );
+    vi.mocked(cameraManager.generateDefaultRecordingQueries).mockReturnValue([
+      {
+        type: QueryType.Recording,
+        cameraIDs: new Set(['camera']),
+      },
+    ]);
+
+    await changeViewToRecentRecordingForCameraAndDependents(
+      createElementListenForView().element,
+      cameraManager,
+      {},
+      createView(),
+      {
+        targetView: 'recordings',
+        select: 'latest',
+        useCache: false,
+      },
+    );
+
+    expect(vi.mocked(cameraManager.executeMediaQueries)).toBeCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        useCache: false,
+      }),
+    );
+  });
 });
 
 // @vitest-environment jsdom