Allow camera capabilities to be configured.

tests/camera-manager/camera.test.ts

@@ -5,8 +5,8 @@ import { GenericCameraManagerEngine } from '../../src/camera-manager/generic/eng
 import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
 import {
   callHASubscribeMessageHandler,
-  createCameraCapabilities,
   createCameraConfig,
+  createCapabilities,
   createHASS,
 } from '../test-utils.js';
 
@@ -19,7 +19,7 @@ describe('Camera', () => {
 
   describe('should get capabilities', async () => {
     it('when populated', async () => {
-      const capabilities = createCameraCapabilities();
+      const capabilities = createCapabilities();
       const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine(), {
         capabilities: capabilities,
       });

tests/camera-manager/capabilities.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import { Capabilities } from '../../src/camera-manager/capabilities';
+import { CapabilityKey, PTZCapabilities, capabilityKeys } from '../../src/types';
+
+describe('Capabilities', () => {
+  it('default capabilities', () => {
+    const capabilities = new Capabilities({});
+    for (const key of capabilityKeys) {
+      expect(capabilities.has(key)).toBeFalsy();
+    }
+  });
+
+  describe('simple presence checks', () => {
+    it.each([
+      'clips',
+      'favorite-events',
+      'favorite-recordings',
+      'live',
+      'menu',
+      'recordings',
+      'seek',
+      'snapshots',
+      'substream',
+    ] as const)('%s', (capability: CapabilityKey) => {
+      const capabilities = new Capabilities({
+        [capability]: true,
+      });
+      expect(capabilities.has(capability)).toBeTruthy();
+    });
+  });
+
+  describe('complex matches', () => {
+    it('string matcher', () => {
+      const capabilities = new Capabilities({
+        live: true,
+      });
+      expect(capabilities.matches('live')).toBeTruthy();
+      expect(capabilities.matches('clips')).toBeFalsy();
+    });
+
+    it('allCapabilities matcher', () => {
+      const capabilities = new Capabilities({
+        live: true,
+        clips: true,
+      });
+      expect(capabilities.matches({ allCapabilities: ['live', 'clips'] })).toBeTruthy();
+      expect(
+        capabilities.matches({ allCapabilities: ['live', 'snapshots'] }),
+      ).toBeFalsy();
+    });
+
+    it('anyCapabilities matcher', () => {
+      const capabilities = new Capabilities({
+        live: true,
+        clips: true,
+      });
+      expect(capabilities.matches({ anyCapabilities: ['live', 'clips'] })).toBeTruthy();
+      expect(
+        capabilities.matches({ anyCapabilities: ['live', 'snapshots'] }),
+      ).toBeTruthy();
+      expect(
+        capabilities.matches({ anyCapabilities: ['snapshots', 'menu'] }),
+      ).toBeFalsy();
+    });
+  });
+
+  describe('getPTZCapabilities', () => {
+    it('when unset', () => {
+      const capabilities = new Capabilities({});
+      expect(capabilities.getPTZCapabilities()).toBeNull();
+    });
+
+    it('when set', () => {
+      const ptz: PTZCapabilities = {
+        panTilt: ['continuous' as const],
+        presets: ['1', '2'],
+      };
+      const capabilities = new Capabilities({
+        ptz: ptz,
+      });
+      expect(capabilities.getPTZCapabilities()).toBe(ptz);
+    });
+  });
+
+  describe('disable capabilities', () => {
+    it('disable', () => {
+      const capabilities = new Capabilities(
+        {
+          live: true,
+          clips: true,
+          snapshots: true,
+        },
+        {
+          disable: ['live', 'clips'],
+        },
+      );
+      expect(capabilities.has('live')).toBeFalsy();
+      expect(capabilities.has('clips')).toBeFalsy();
+      expect(capabilities.has('snapshots')).toBeTruthy();
+    });
+
+    it('disableExcept', () => {
+      const capabilities = new Capabilities(
+        {
+          live: true,
+          clips: true,
+          snapshots: true,
+        },
+        {
+          disableExcept: ['live', 'clips'],
+        },
+      );
+      expect(capabilities.has('live')).toBeTruthy();
+      expect(capabilities.has('clips')).toBeTruthy();
+      expect(capabilities.has('snapshots')).toBeFalsy();
+    });
+  });
+});

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

@@ -131,16 +131,6 @@ describe('FrigateCamera', () => {
   });
 
   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({
@@ -153,7 +143,13 @@ describe('FrigateCamera', () => {
 
       await camera.initialize(createHASS(), mock<EntityRegistryManager>());
 
-      expect(camera.getCapabilities()).toEqual(nonBirdseyeBaseCapabilities);
+      expect(camera.getCapabilities()?.has('favorite-events')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('favorite-recordings')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('seek')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('clips')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('live')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('snapshots')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('recordings')).toBeTruthy();
       expect(vi.mocked(getPTZInfo)).toBeCalled();
     });
 
@@ -169,15 +165,13 @@ describe('FrigateCamera', () => {
 
       await camera.initialize(createHASS(), mock<EntityRegistryManager>());
 
-      expect(camera.getCapabilities()).toEqual({
-        ...nonBirdseyeBaseCapabilities,
-        canFavoriteEvents: false,
-        canFavoriteRecordings: false,
-        supportsClips: false,
-        supportsSnapshots: false,
-        supportsRecordings: false,
-        supportsTimeline: false,
-      });
+      expect(camera.getCapabilities()?.has('favorite-events')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('favorite-recordings')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('seek')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('clips')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('live')).toBeTruthy();
+      expect(camera.getCapabilities()?.has('snapshots')).toBeFalsy();
+      expect(camera.getCapabilities()?.has('recordings')).toBeFalsy();
       expect(vi.mocked(getPTZInfo)).not.toBeCalled();
     });
 
@@ -196,9 +190,7 @@ describe('FrigateCamera', () => {
         vi.mocked(getPTZInfo).mockRejectedValue(new Error());
         await camera.initialize(createHASS(), mock<EntityRegistryManager>());
 
-        expect(camera.getCapabilities()).toEqual({
-          ...nonBirdseyeBaseCapabilities,
-        });
+        expect(camera.getCapabilities()?.has('ptz')).toBeFalsy();
         expect(consoleSpy).toBeCalled();
       });
 
@@ -220,13 +212,11 @@ describe('FrigateCamera', () => {
         });
         await camera.initialize(createHASS(), mock<EntityRegistryManager>());
 
-        expect(camera.getCapabilities()).toEqual({
-          ...nonBirdseyeBaseCapabilities,
-          ptz: {
-            panTilt: ['continuous'],
-            zoom: ['continuous'],
-            presets: ['preset01'],
-          },
+        expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
+        expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
+          panTilt: ['continuous'],
+          zoom: ['continuous'],
+          presets: ['preset01'],
         });
       });
 
@@ -248,13 +238,11 @@ describe('FrigateCamera', () => {
         });
         await camera.initialize(createHASS(), mock<EntityRegistryManager>());
 
-        expect(camera.getCapabilities()).toEqual({
-          ...nonBirdseyeBaseCapabilities,
-          ptz: {
-            panTilt: ['relative'],
-            zoom: ['relative'],
-            presets: ['preset01'],
-          },
+        expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
+        expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
+          panTilt: ['relative'],
+          zoom: ['relative'],
+          presets: ['preset01'],
         });
       });
     });

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

@@ -34,15 +34,13 @@ describe('GenericCameraManagerEngine', () => {
     );
 
     expect(camera.getConfig()).toEqual(config);
-    expect(camera.getCapabilities()).toEqual({
-      canFavoriteEvents: false,
-      canFavoriteRecordings: false,
-      canSeek: false,
-      supportsClips: false,
-      supportsRecordings: false,
-      supportsSnapshots: false,
-      supportsTimeline: false,
-    });
+    expect(camera.getCapabilities()).toBeTruthy();
+    expect(camera.getCapabilities()?.has('favorite-events')).toBeFalsy();
+    expect(camera.getCapabilities()?.has('favorite-recordings')).toBeFalsy();
+    expect(camera.getCapabilities()?.has('seek')).toBeFalsy();
+    expect(camera.getCapabilities()?.has('clips')).toBeFalsy();
+    expect(camera.getCapabilities()?.has('recordings')).toBeFalsy();
+    expect(camera.getCapabilities()?.has('snapshots')).toBeFalsy();
   });
 
   it('should generate default event query', () => {

tests/camera-manager/manager.test.ts

@@ -3,6 +3,7 @@ import add from 'date-fns/add';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../../src/camera-manager/camera';
+import { Capabilities } from '../../src/camera-manager/capabilities';
 import { CameraManagerEngine } from '../../src/camera-manager/engine';
 import { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
 import {
@@ -16,7 +17,6 @@ import {
   CameraEndpoints,
   CameraEndpointsContext,
   CameraEvent,
-  CameraManagerCameraCapabilities,
   CameraManagerCameraMetadata,
   CameraManagerMediaCapabilities,
   Engine,
@@ -27,7 +27,7 @@ import {
   QueryResultsType,
   QueryType,
 } from '../../src/camera-manager/types';
-import { sortMedia } from '../../src/camera-manager/utils';
+import { sortMedia } from '../../src/camera-manager/utils/sort-media';
 import { CardController } from '../../src/card-controller/controller';
 import { CameraConfig } from '../../src/config/types';
 import { EntityRegistryManager } from '../../src/utils/ha/entity-registry';
@@ -35,8 +35,8 @@ import { ViewMedia } from '../../src/view/media';
 import {
   TestViewMedia,
   createCamera,
-  createCameraCapabilities,
   createCameraConfig,
+  createCapabilities,
   createCardAPI,
   createConfig,
   createHASS,
@@ -219,7 +219,7 @@ describe('CameraManager', async () => {
     cameras: {
       config?: CameraConfig;
       engineType?: Engine | null;
-      capabilties?: CameraManagerCameraCapabilities;
+      capabilties?: Capabilities;
     }[] = [{}],
     factory?: CameraManagerEngineFactory,
   ): CameraManager => {
@@ -249,7 +249,7 @@ describe('CameraManager', async () => {
             createCamera(
               cameraConfig,
               mockEngine,
-              camera.capabilties ?? createCameraCapabilities(),
+              camera.capabilties ?? createCapabilities(),
             ),
         );
       }
@@ -367,19 +367,6 @@ describe('CameraManager', async () => {
       );
     });
 
-    it('with no cameras', async () => {
-      const api = createCardAPI();
-      vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
-
-      const manager = createCameraManager(api, mock<CameraManagerEngine>(), []);
-      expect(await manager.initializeCamerasFromConfig()).toBeFalsy();
-      expect(api.getMessageManager().setErrorIfHigherPriority).toBeCalledWith(
-        new Error(
-          'No visible cameras found, you must configure at least one non-hidden camera',
-        ),
-      );
-    });
-
     it('should pass events to triggers manager', async () => {
       const api = createCardAPI();
       vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
@@ -1043,74 +1030,72 @@ describe('CameraManager', async () => {
       vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
 
       expect(await manager.initializeCamerasFromConfig()).toBeTruthy();
-      expect(manager.getCameraCapabilities('id')).toEqual(createCameraCapabilities());
+      expect(manager.getCameraCapabilities('id')).toEqual(createCapabilities());
     });
   });
 
   describe('should get aggregate camera capabilities', () => {
     it('without camera', () => {
       const manager = createCameraManager(createCardAPI());
-      expect(manager.getAggregateCameraCapabilities()).toEqual({
-        canFavoriteEvents: false,
-        canFavoriteRecordings: false,
-        canSeek: false,
+      const capabilities = manager.getAggregateCameraCapabilities();
 
-        supportsClips: false,
-        supportsRecordings: false,
-        supportsSnapshots: false,
-        supportsTimeline: false,
+      expect(capabilities.has('favorite-events')).toBeFalsy();
+      expect(capabilities.has('favorite-recordings')).toBeFalsy();
+      expect(capabilities.has('seek')).toBeFalsy();
 
-        supportsPTZ: false,
-      });
+      expect(capabilities.has('live')).toBeFalsy();
+      expect(capabilities.has('clips')).toBeFalsy();
+      expect(capabilities.has('recordings')).toBeFalsy();
+      expect(capabilities.has('snapshots')).toBeFalsy();
     });
 
     it('successfully', async () => {
       const api = createCardAPI();
       const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
         {
-          capabilties: {
-            canFavoriteEvents: false,
-            canFavoriteRecordings: false,
-            canSeek: false,
+          capabilties: new Capabilities({
+            'favorite-events': false,
+            'favorite-recordings': false,
+            seek: false,
 
-            supportsClips: false,
-            supportsRecordings: false,
-            supportsSnapshots: false,
-            supportsTimeline: false,
-          },
+            live: false,
+            clips: false,
+            recordings: false,
+            snapshots: false,
+          }),
         },
         {
           config: createCameraConfig({ baseCameraConfig, id: 'another' }),
-          capabilties: {
-            canFavoriteEvents: true,
-            canFavoriteRecordings: true,
-            canSeek: true,
+          capabilties: new Capabilities({
+            'favorite-events': true,
+            'favorite-recordings': true,
+            seek: true,
 
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
-            supportsTimeline: true,
+            live: true,
+            clips: true,
+            recordings: true,
+            snapshots: true,
 
-            ptz: {},
-          },
+            ptz: {
+              panTilt: ['continuous'],
+            },
+          }),
         },
       ]);
       const hass = createHASS();
       vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
       expect(await manager.initializeCamerasFromConfig()).toBeTruthy();
 
-      expect(manager.getAggregateCameraCapabilities()).toEqual({
-        canFavoriteEvents: true,
-        canFavoriteRecordings: true,
-        canSeek: true,
+      const capabilities = manager.getAggregateCameraCapabilities();
 
-        supportsClips: true,
-        supportsRecordings: true,
-        supportsSnapshots: true,
-        supportsTimeline: true,
+      expect(capabilities.has('favorite-events')).toBeTruthy();
+      expect(capabilities.has('favorite-recordings')).toBeTruthy();
+      expect(capabilities.has('seek')).toBeTruthy();
 
-        supportsPTZ: true,
-      });
+      expect(capabilities.has('live')).toBeTruthy();
+      expect(capabilities.has('clips')).toBeTruthy();
+      expect(capabilities.has('recordings')).toBeTruthy();
+      expect(capabilities.has('snapshots')).toBeTruthy();
     });
   });
 

tests/camera-manager/store.test.ts

@@ -1,12 +1,13 @@
 import { describe, expect, it, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../../src/camera-manager/camera.js';
+import { Capabilities } from '../../src/camera-manager/capabilities.js';
 import { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
 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 { createCameraConfig, TestViewMedia } from '../test-utils.js';
+import { TestViewMedia, createCameraConfig } from '../test-utils.js';
 
 describe('CameraManagerStore', async () => {
   const configVisible = createCameraConfig({
@@ -56,11 +57,6 @@ describe('CameraManagerStore', async () => {
     expect(store.getCameraCount()).toBe(2);
   });
 
-  it('getVisibleCameraCount', async () => {
-    const store = setupStore();
-    expect(store.getVisibleCameraCount()).toBe(1);
-  });
-
   describe('getDefaultCameraID', () => {
     it('with camera', async () => {
       const store = setupStore();
@@ -127,11 +123,6 @@ describe('CameraManagerStore', async () => {
     expect(store.getCameraIDs()).toEqual(new Set(['camera-visible', 'camera-hidden']));
   });
 
-  it('getVisibleCameraIDs', async () => {
-    const store = setupStore();
-    expect(store.getVisibleCameraIDs()).toEqual(new Set(['camera-visible']));
-  });
-
   it('reset', async () => {
     const store = setupStore();
     const cameras = [...store.getCameras().values()];
@@ -139,7 +130,6 @@ describe('CameraManagerStore', async () => {
     await store.reset();
 
     expect(store.getCameraCount()).toBe(0);
-    expect(store.getVisibleCameraCount()).toBe(0);
     for (const camera of cameras) {
       expect(camera.destroy).toBeCalled();
     }
@@ -258,5 +248,60 @@ describe('CameraManagerStore', async () => {
       );
       expect(store.getAllDependentCameras('one')).toEqual(new Set(['one', 'two']));
     });
+
+    it('should return cameras with specific capabilities', () => {
+      const store = new CameraManagerStore();
+      store.addCamera(
+        new Camera(
+          createCameraConfig({
+            id: 'one',
+            dependencies: {
+              all_cameras: true,
+            },
+          }),
+          engineGeneric,
+        ),
+      );
+      store.addCamera(
+        new Camera(
+          createCameraConfig({
+            id: 'two',
+          }),
+          engineGeneric,
+          {
+            capabilities: new Capabilities({
+              clips: true,
+            }),
+          },
+        ),
+      );
+      expect(store.getAllDependentCameras('one', 'clips')).toEqual(new Set(['two']));
+    });
+  });
+
+  it('getCameraIDsWithCapability', () => {
+    const store = new CameraManagerStore();
+    store.addCamera(
+      new Camera(
+        createCameraConfig({
+          id: 'one',
+        }),
+        engineGeneric,
+        {
+          capabilities: new Capabilities({
+            clips: true,
+          }),
+        },
+      ),
+    );
+    store.addCamera(
+      new Camera(
+        createCameraConfig({
+          id: 'two',
+        }),
+        engineGeneric,
+      ),
+    );
+    expect(store.getCameraIDsWithCapability('clips')).toEqual(new Set(['one']));
   });
 });

tests/camera-manager/utils.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import {
-  capEndDate,
-  convertRangeToCacheFriendlyTimes,
-  getCameraEntityFromConfig,
-  getDefaultGo2RTCEndpoint,
-  sortMedia,
-} from '../../src/camera-manager/utils.js';
-import { CameraConfig, cameraConfigSchema } from '../../src/config/types.js';
-import { TestViewMedia, createCameraConfig } from '../test-utils.js';
-
-describe('convertRangeToCacheFriendlyTimes', () => {
-  it('should return cache friendly within hour range', () => {
-    expect(
-      convertRangeToCacheFriendlyTimes({
-        start: new Date('2023-04-29T14:01:02'),
-        end: new Date('2023-04-29T14:11:03'),
-      }),
-    ).toEqual({
-      start: new Date('2023-04-29T14:00:00'),
-      end: new Date('2023-04-29T14:59:59.999'),
-    });
-  });
-
-  it('should return cache friendly within day range', () => {
-    expect(
-      convertRangeToCacheFriendlyTimes({
-        start: new Date('2023-04-29T14:01:02'),
-        end: new Date('2023-04-29T15:11:03'),
-      }),
-    ).toEqual({
-      start: new Date('2023-04-29T00:00:00'),
-      end: new Date('2023-04-29T23:59:59.999'),
-    });
-  });
-
-  it('should cap end date', () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2023-04-29T14:25'));
-    expect(
-      convertRangeToCacheFriendlyTimes(
-        {
-          start: new Date('2023-04-29T14:01:02'),
-          end: new Date('2023-04-29T14:11:03'),
-        },
-        { endCap: true },
-      ),
-    ).toEqual({
-      start: new Date('2023-04-29T14:00:00'),
-      end: new Date('2023-04-29T14:25:59.999'),
-    });
-    vi.useRealTimers();
-  });
-});
-
-describe('capEndDate', () => {
-  it('should cap end date', () => {
-    const fakeNow = new Date('2023-04-29T14:25');
-    vi.useFakeTimers();
-    vi.setSystemTime(fakeNow);
-
-    expect(capEndDate(new Date('2023-04-29T15:02'))).toEqual(fakeNow);
-
-    vi.useRealTimers();
-  });
-
-  it('should not cap end date', () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2023-04-29T14:25'));
-
-    const testDate = new Date('2023-04-29T14:24');
-    expect(capEndDate(testDate)).toEqual(testDate);
-
-    vi.useRealTimers();
-  });
-});
-
-describe('sortMedia', () => {
-  const media_1 = new TestViewMedia({
-    id: 'id-1',
-    startTime: new Date('2023-04-29T14:25'),
-    cameraID: 'camera-1',
-  });
-  const media_2 = new TestViewMedia({
-    id: 'id-2',
-    startTime: new Date('2023-04-29T14:26'),
-    cameraID: 'camera-1',
-  });
-  const media_3_dup_id = new TestViewMedia({
-    id: 'id-2',
-    startTime: new Date('2023-04-29T14:26'),
-    cameraID: 'camera-1',
-  });
-  const media_4_no_id = new TestViewMedia({
-    id: null,
-    startTime: new Date('2023-04-29T14:27'),
-    cameraID: 'camera-1',
-  });
-
-  it('should sort sorted media', () => {
-    const media = [media_1, media_2];
-    expect(sortMedia(media)).toEqual(media);
-  });
-  it('should sort unsorted media', () => {
-    expect(sortMedia([media_2, media_1])).toEqual([media_1, media_2]);
-  });
-  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,
-      media_2,
-      media_4_no_id,
-    ]);
-  });
-});
-
-describe('getCameraEntityFromConfig', () => {
-  const createCameraConfig = (config: Partial<CameraConfig>): CameraConfig => {
-    return cameraConfigSchema.parse(config);
-  };
-
-  it('should get camera_entity', () => {
-    expect(getCameraEntityFromConfig(createCameraConfig({ camera_entity: 'foo' }))).toBe(
-      'foo',
-    );
-  });
-  it('should get camera_entity from webrtc_card config', () => {
-    expect(
-      getCameraEntityFromConfig(createCameraConfig({ webrtc_card: { entity: 'bar' } })),
-    ).toBe('bar');
-  });
-  it('should get no camera_entity', () => {
-    expect(getCameraEntityFromConfig(createCameraConfig({}))).toBeNull();
-  });
-});
-
-describe('getDefaultGo2RTCEndpoint', () => {
-  it('with local configuration', () => {
-    expect(
-      getDefaultGo2RTCEndpoint(
-        createCameraConfig({
-          go2rtc: {
-            stream: 'stream',
-            url: '/local/path',
-          },
-        }),
-      ),
-    ).toEqual({
-      endpoint: '/local/path/api/ws?src=stream',
-      sign: true,
-    });
-  });
-
-  it('with remote configuration', () => {
-    expect(
-      getDefaultGo2RTCEndpoint(
-        createCameraConfig({
-          go2rtc: {
-            stream: 'stream',
-            url: 'https://my-custom-go2rtc',
-          },
-        }),
-      ),
-    ).toEqual({
-      endpoint: 'https://my-custom-go2rtc/api/ws?src=stream',
-      sign: false,
-    });
-  });
-
-  it('without configuration', () => {
-    expect(getDefaultGo2RTCEndpoint(createCameraConfig())).toBeNull();
-  });
-});

tests/camera-manager/utils/camera-entity-from-config.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { getCameraEntityFromConfig } from '../../../src/camera-manager/utils/camera-entity-from-config.js';
+import { CameraConfig, cameraConfigSchema } from '../../../src/config/types.js';
+
+describe('getCameraEntityFromConfig', () => {
+  const createCameraConfig = (config: Partial<CameraConfig>): CameraConfig => {
+    return cameraConfigSchema.parse(config);
+  };
+
+  it('should get camera_entity', () => {
+    expect(getCameraEntityFromConfig(createCameraConfig({ camera_entity: 'foo' }))).toBe(
+      'foo',
+    );
+  });
+  it('should get camera_entity from webrtc_card config', () => {
+    expect(
+      getCameraEntityFromConfig(createCameraConfig({ webrtc_card: { entity: 'bar' } })),
+    ).toBe('bar');
+  });
+  it('should get no camera_entity', () => {
+    expect(getCameraEntityFromConfig(createCameraConfig({}))).toBeNull();
+  });
+});

tests/camera-manager/utils/cap-end-date.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from 'vitest';
+import { capEndDate } from '../../../src/camera-manager/utils/cap-end-date';
+
+describe('capEndDate', () => {
+  it('should cap end date', () => {
+    const fakeNow = new Date('2023-04-29T14:25');
+    vi.useFakeTimers();
+    vi.setSystemTime(fakeNow);
+
+    expect(capEndDate(new Date('2023-04-29T15:02'))).toEqual(fakeNow);
+
+    vi.useRealTimers();
+  });
+
+  it('should not cap end date', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2023-04-29T14:25'));
+
+    const testDate = new Date('2023-04-29T14:24');
+    expect(capEndDate(testDate)).toEqual(testDate);
+
+    vi.useRealTimers();
+  });
+});

tests/camera-manager/utils/go2rtc-endpoint.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { getDefaultGo2RTCEndpoint } from '../../../src/camera-manager/utils/go2rtc-endpoint.js';
+import { createCameraConfig } from '../../test-utils.js';
+
+describe('getDefaultGo2RTCEndpoint', () => {
+  it('with local configuration', () => {
+    expect(
+      getDefaultGo2RTCEndpoint(
+        createCameraConfig({
+          go2rtc: {
+            stream: 'stream',
+            url: '/local/path',
+          },
+        }),
+      ),
+    ).toEqual({
+      endpoint: '/local/path/api/ws?src=stream',
+      sign: true,
+    });
+  });
+
+  it('with remote configuration', () => {
+    expect(
+      getDefaultGo2RTCEndpoint(
+        createCameraConfig({
+          go2rtc: {
+            stream: 'stream',
+            url: 'https://my-custom-go2rtc',
+          },
+        }),
+      ),
+    ).toEqual({
+      endpoint: 'https://my-custom-go2rtc/api/ws?src=stream',
+      sign: false,
+    });
+  });
+
+  it('without configuration', () => {
+    expect(getDefaultGo2RTCEndpoint(createCameraConfig())).toBeNull();
+  });
+});

tests/camera-manager/utils/range-to-cache-friendly.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi } from 'vitest';
+import { convertRangeToCacheFriendlyTimes } from '../../../src/camera-manager/utils/range-to-cache-friendly';
+
+describe('convertRangeToCacheFriendlyTimes', () => {
+  it('should return cache friendly within hour range', () => {
+    expect(
+      convertRangeToCacheFriendlyTimes({
+        start: new Date('2023-04-29T14:01:02'),
+        end: new Date('2023-04-29T14:11:03'),
+      }),
+    ).toEqual({
+      start: new Date('2023-04-29T14:00:00'),
+      end: new Date('2023-04-29T14:59:59.999'),
+    });
+  });
+
+  it('should return cache friendly within day range', () => {
+    expect(
+      convertRangeToCacheFriendlyTimes({
+        start: new Date('2023-04-29T14:01:02'),
+        end: new Date('2023-04-29T15:11:03'),
+      }),
+    ).toEqual({
+      start: new Date('2023-04-29T00:00:00'),
+      end: new Date('2023-04-29T23:59:59.999'),
+    });
+  });
+
+  it('should cap end date', () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2023-04-29T14:25'));
+    expect(
+      convertRangeToCacheFriendlyTimes(
+        {
+          start: new Date('2023-04-29T14:01:02'),
+          end: new Date('2023-04-29T14:11:03'),
+        },
+        { endCap: true },
+      ),
+    ).toEqual({
+      start: new Date('2023-04-29T14:00:00'),
+      end: new Date('2023-04-29T14:25:59.999'),
+    });
+    vi.useRealTimers();
+  });
+});

tests/camera-manager/utils/sort-media.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { sortMedia } from '../../../src/camera-manager/utils/sort-media.js';
+import { TestViewMedia } from '../../test-utils.js';
+
+describe('sortMedia', () => {
+  const media_1 = new TestViewMedia({
+    id: 'id-1',
+    startTime: new Date('2023-04-29T14:25'),
+    cameraID: 'camera-1',
+  });
+  const media_2 = new TestViewMedia({
+    id: 'id-2',
+    startTime: new Date('2023-04-29T14:26'),
+    cameraID: 'camera-1',
+  });
+  const media_3_dup_id = new TestViewMedia({
+    id: 'id-2',
+    startTime: new Date('2023-04-29T14:26'),
+    cameraID: 'camera-1',
+  });
+  const media_4_no_id = new TestViewMedia({
+    id: null,
+    startTime: new Date('2023-04-29T14:27'),
+    cameraID: 'camera-1',
+  });
+
+  it('should sort sorted media', () => {
+    const media = [media_1, media_2];
+    expect(sortMedia(media)).toEqual(media);
+  });
+  it('should sort unsorted media', () => {
+    expect(sortMedia([media_2, media_1])).toEqual([media_1, media_2]);
+  });
+  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,
+      media_2,
+      media_4_no_id,
+    ]);
+  });
+});