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,