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,
+    ]);
+  });
+});

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

@@ -7,10 +7,9 @@ import { EventMediaQueries } from '../../src/view/media-queries';
 import { MediaQueriesResults } from '../../src/view/media-queries-results';
 import { View } from '../../src/view/view';
 import {
-  createAggregateCameraCapabilities,
-  createCameraCapabilities,
   createCameraConfig,
   createCameraManager,
+  createCapabilities,
   createCardAPI,
   createConfig,
   createHASS,
@@ -120,6 +119,7 @@ describe('ViewManager.setViewDefault', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ live: true }),
         },
       ]),
     );
@@ -150,9 +150,11 @@ describe('ViewManager.setViewDefault', () => {
       createStore([
         {
           cameraID: 'camera_1',
+          capabilities: createCapabilities({ live: true }),
         },
         {
           cameraID: 'camera_2',
+          capabilities: createCapabilities({ live: true }),
         },
       ]),
     );
@@ -186,9 +188,11 @@ describe('ViewManager.setViewDefault', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
+          capabilities: createCapabilities({ live: true }),
         },
         {
           cameraID: 'camera.office',
+          capabilities: createCapabilities({ live: true }),
         },
       ]),
     );
@@ -216,12 +220,13 @@ describe('ViewManager.setViewByParameters', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
     vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-      createAggregateCameraCapabilities({
-        supportsClips: true,
+      createCapabilities({
+        clips: true,
       }),
     );
 
@@ -242,15 +247,17 @@ describe('ViewManager.setViewByParameters', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
+          capabilities: createCapabilities({ clips: true }),
         },
         {
           cameraID: 'camera.office',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
     vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-      createAggregateCameraCapabilities({
-        supportsClips: true,
+      createCapabilities({
+        clips: true,
       }),
     );
     vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
@@ -276,6 +283,7 @@ describe('ViewManager.setViewByParameters', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
+          capabilities: createCapabilities({ live: true }),
         },
       ]),
     );
@@ -302,49 +310,102 @@ describe('ViewManager.setViewByParameters', () => {
     expect(manager.getView()).toBeNull();
   });
 
-  it('should not set view by parameters without visible cameras', () => {
-    const api = createCardAPI();
-    vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
-    vi.mocked(api.getCameraManager().getStore).mockReturnValue(
-      createStore([
-        {
-          cameraID: 'camera.kitchen',
-          config: createCameraConfig({
-            hide: true,
-          }),
-        },
-      ]),
-    );
-    vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
-
-    const manager = new ViewManager(api);
-    manager.setViewByParameters({
-      viewName: 'live',
-    });
-
-    expect(manager.getView()).toBeNull();
-  });
-
   describe('should handle unsupported view', () => {
-    it('without failsafe', () => {
+    it('without camera without failsafe', () => {
       const api = createCardAPI();
       vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
       vi.mocked(api.getCameraManager().getStore).mockReturnValue(
         createStore([
           {
             cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({ snapshots: false }),
+          },
+        ]),
+      );
+      vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
+
+      const manager = new ViewManager(api);
+      manager.setViewByParameters({
+        // Since no camera is specified, and no camera supports the capabilities
+        // necessary for this view, the view will be null.
+        viewName: 'snapshots',
+      });
+
+      expect(manager.getView()).toBeNull();
+    });
+
+    it('without camera with failsafe', () => {
+      const api = createCardAPI();
+      vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
+      vi.mocked(api.getCameraManager().getStore).mockReturnValue(
+        createStore([
+          {
+            cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({ snapshots: false }),
+          },
+          {
+            cameraID: 'camera.office',
+            // No capabilities.
+            capabilities: null,
+          },
+        ]),
+      );
+      vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
+
+      const manager = new ViewManager(api);
+      manager.setViewByParameters({
+        // Since no camera is specified, and no camera supports the capabilities
+        // necessary for this view, and since failSafe is specified, an error
+        // will be shown.
+        viewName: 'snapshots',
+        failSafe: true,
+      });
+
+      expect(manager.getView()).toBeNull();
+      expect(manager.hasView()).toBeFalsy();
+      expect(api.getMessageManager().setMessageIfHigherPriority).toBeCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          message: 'No cameras support this view',
+          context: {
+            view: 'snapshots',
+            cameras_capabilities: {
+              'camera.kitchen': {
+                'favorite-events': false,
+                'favorite-recordings': false,
+                clips: false,
+                live: false,
+                recordings: false,
+                seek: false,
+                snapshots: false,
+              },
+            },
+          },
+        }),
+      );
+    });
+
+    it('with camera without failsafe', () => {
+      const api = createCardAPI();
+      vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
+      vi.mocked(api.getCameraManager().getStore).mockReturnValue(
+        createStore([
+          {
+            cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({ snapshots: false }),
           },
         ]),
       );
       vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
       vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({
-          supportsSnapshots: false,
+        createCapabilities({
+          snapshots: false,
         }),
       );
 
       const manager = new ViewManager(api);
       manager.setViewByParameters({
+        cameraID: 'camera.kitchen',
         viewName: 'snapshots',
       });
 
@@ -352,25 +413,28 @@ describe('ViewManager.setViewByParameters', () => {
       expect(manager.getView()).toBeNull();
     });
 
-    it('with failsafe', () => {
+    it('with camera with failsafe', () => {
       const api = createCardAPI();
       vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
       vi.mocked(api.getCameraManager().getStore).mockReturnValue(
         createStore([
           {
             cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({ snapshots: false, live: true }),
           },
         ]),
       );
       vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
       vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({
-          supportsSnapshots: false,
+        createCapabilities({
+          snapshots: false,
+          live: true,
         }),
       );
 
       const manager = new ViewManager(api);
       manager.setViewByParameters({
+        cameraID: 'camera.kitchen',
         viewName: 'snapshots',
         failSafe: true,
       });
@@ -378,6 +442,55 @@ describe('ViewManager.setViewByParameters', () => {
       expect(manager.hasView()).toBeTruthy();
       expect(manager.getView()?.view).toBe('live');
     });
+
+    it('with camera with failsafe when live unsupported', () => {
+      const api = createCardAPI();
+      vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
+      vi.mocked(api.getCameraManager().getStore).mockReturnValue(
+        createStore([
+          {
+            cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({ snapshots: false, live: false }),
+          },
+        ]),
+      );
+      vi.mocked(api.getConfigManager().getConfig).mockReturnValue(createConfig());
+      vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
+        createCapabilities({
+          snapshots: false,
+          live: false,
+        }),
+      );
+
+      const manager = new ViewManager(api);
+      manager.setViewByParameters({
+        cameraID: 'camera.kitchen',
+        viewName: 'snapshots',
+        failSafe: true,
+      });
+
+      expect(manager.hasView()).toBeFalsy();
+      expect(manager.getView()).toBeNull();
+      expect(api.getMessageManager().setMessageIfHigherPriority).toBeCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          message: 'The selected camera does not support this view',
+          context: {
+            view: 'snapshots',
+            camera: 'camera.kitchen',
+            camera_capabilities: {
+              'favorite-events': false,
+              'favorite-recordings': false,
+              clips: false,
+              live: false,
+              recordings: false,
+              seek: false,
+              snapshots: false,
+            },
+          },
+        }),
+      );
+    });
   });
 
   describe('should set view by parameters and respect display mode in config for view', () => {
@@ -394,14 +507,21 @@ describe('ViewManager.setViewByParameters', () => {
         createStore([
           {
             cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({
+              live: true,
+              clips: true,
+              recordings: true,
+              snapshots: true,
+            }),
           },
         ]),
       );
       vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({
-          supportsClips: true,
-          supportsRecordings: true,
-          supportsSnapshots: true,
+        createCapabilities({
+          live: true,
+          clips: true,
+          recordings: true,
+          snapshots: true,
         }),
       );
 
@@ -445,14 +565,21 @@ describe('ViewManager.setViewByParameters', () => {
         createStore([
           {
             cameraID: 'camera.kitchen',
+            capabilities: createCapabilities({
+              live: true,
+              clips: true,
+              recordings: true,
+              snapshots: true,
+            }),
           },
         ]),
       );
       vi.mocked(api.getCameraManager().getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({
-          supportsClips: true,
-          supportsRecordings: true,
-          supportsSnapshots: true,
+        createCapabilities({
+          live: true,
+          clips: true,
+          recordings: true,
+          snapshots: true,
         }),
       );
 
@@ -502,18 +629,18 @@ describe('ViewManager.setViewWithNewDisplayMode', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
         {
           cameraID: 'camera.office',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
       ]),
@@ -556,18 +683,18 @@ describe('ViewManager.setViewWithNewDisplayMode', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
         {
           cameraID: 'camera.office',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
       ]),
@@ -614,18 +741,18 @@ describe('ViewManager.setViewWithNewDisplayMode', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
         {
           cameraID: 'camera.office',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
       ]),
@@ -662,18 +789,18 @@ describe('ViewManager.setViewWithNewDisplayMode', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
         {
           cameraID: 'camera.office',
-          capabilities: createCameraCapabilities({
-            supportsClips: true,
-            supportsRecordings: true,
-            supportsSnapshots: true,
+          capabilities: createCapabilities({
+            clips: true,
+            recordings: true,
+            snapshots: true,
           }),
         },
       ]),
@@ -873,7 +1000,7 @@ describe('ViewManager.setViewWithSubstream', () => {
 
 describe('ViewManager.isViewSupportedByCamera', () => {
   it.each([
-    ['live' as const, true],
+    ['live' as const, false],
     ['image' as const, true],
     ['diagnostics' as const, true],
     ['clip' as const, false],
@@ -891,15 +1018,15 @@ describe('ViewManager.isViewSupportedByCamera', () => {
       createStore([
         {
           cameraID: 'camera.kitchen',
-          capabilities: {
-            canFavoriteEvents: false,
-            canFavoriteRecordings: false,
-            canSeek: false,
-            supportsClips: false,
-            supportsRecordings: false,
-            supportsSnapshots: false,
-            supportsTimeline: false,
-          },
+          capabilities: createCapabilities({
+            live: false,
+            'favorite-events': false,
+            'favorite-recordings': false,
+            seek: false,
+            clips: false,
+            recordings: false,
+            snapshots: false,
+          }),
         },
       ]),
     );

tests/components-lib/media-filter-controller.test.ts

@@ -3,6 +3,7 @@ import startOfDay from 'date-fns/startOfDay';
 import sub from 'date-fns/sub';
 import { LitElement } from 'lit';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Capabilities } from '../../src/camera-manager/capabilities';
 import { CameraManagerStore } from '../../src/camera-manager/store';
 import { QueryType } from '../../src/camera-manager/types';
 import {
@@ -10,21 +11,21 @@ import {
   MediaFilterCoreDefaults,
   MediaFilterCoreFavoriteSelection,
   MediaFilterCoreWhen,
-  MediaFilterMediaType
+  MediaFilterMediaType,
 } from '../../src/components-lib/media-filter-controller';
 import { executeMediaQueryForViewWithErrorDispatching } from '../../src/utils/media-to-view';
 import {
   EventMediaQueries,
   MediaQueries,
-  RecordingMediaQueries
+  RecordingMediaQueries,
 } from '../../src/view/media-queries';
 import {
-  createAggregateCameraCapabilities,
   createCameraConfig,
   createCameraManager,
+  createCapabilities,
   createPerformanceConfig,
   createStore,
-  createView
+  createView,
 } from '../test-utils';
 
 vi.mock('../../src/utils/media-to-view');
@@ -35,13 +36,22 @@ const createHost = (): LitElement => {
   return host;
 };
 
-const createCameraStore = (): CameraManagerStore => {
+const createCameraStore = (options?: {
+  capabilities: Capabilities;
+}): CameraManagerStore => {
   return createStore([
     {
       cameraID: 'camera.kitchen',
       config: createCameraConfig({
         camera_entity: 'camera.kitchen',
       }),
+      capabilities:
+        options?.capabilities ??
+        new Capabilities({
+          clips: true,
+          snapshots: true,
+          recordings: true,
+        }),
     },
   ]);
 };
@@ -152,6 +162,27 @@ describe('MediaFilterController', () => {
         ]);
       });
 
+      it('with camera that does not support media', () => {
+        const cameraManager = createCameraManager();
+        vi.mocked(cameraManager.getCameraMetadata).mockReturnValue({
+          title: 'Kitchen Camera',
+          icon: 'mdi:camera',
+        });
+        vi.mocked(cameraManager.getStore).mockReturnValue(
+          createCameraStore({
+            capabilities: new Capabilities({
+              clips: false,
+              snapshots: false,
+              recordings: false,
+            }),
+          }),
+        );
+
+        const controller = new MediaFilterController(createHost());
+        controller.computeCameraOptions(cameraManager);
+        expect(controller.getCameraOptions()).toEqual([]);
+      });
+
       it('without camera metadata', () => {
         const cameraManager = createCameraManager();
         vi.mocked(cameraManager.getCameraMetadata).mockReturnValue(null);
@@ -297,7 +328,7 @@ describe('MediaFilterController', () => {
       const view = createView({ query: new EventMediaQueries() });
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({ canFavoriteEvents: true }),
+        createCapabilities({ 'favorite-events': true }),
       );
 
       const controller = new MediaFilterController(createHost());
@@ -310,7 +341,7 @@ describe('MediaFilterController', () => {
       const view = createView({ query: new RecordingMediaQueries() });
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getAggregateCameraCapabilities).mockReturnValue(
-        createAggregateCameraCapabilities({ canFavoriteRecordings: true }),
+        createCapabilities({ 'favorite-recordings': true }),
       );
 
       const controller = new MediaFilterController(createHost());
@@ -915,7 +946,7 @@ describe('MediaFilterController', () => {
             },
           ]),
           {
-            mediaType: MediaFilterMediaType.Recordings
+            mediaType: MediaFilterMediaType.Recordings,
           },
         ],
       ])(

tests/components-lib/menu-button-controller.test.ts

@@ -18,7 +18,7 @@ import { ViewMedia } from '../../src/view/media';
 import { MediaQueriesResults } from '../../src/view/media-queries-results';
 import { View } from '../../src/view/view';
 import {
-  createCameraCapabilities,
+  createCapabilities,
   createCameraConfig,
   createCameraManager,
   createCardAPI,
@@ -108,7 +108,11 @@ describe('MenuButtonController', () => {
     it('with multiple cameras', () => {
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getStore).mockReturnValue(
-        createStore([{ cameraID: 'camera-1' }, { cameraID: 'camera-2' }]),
+        createStore([
+          { cameraID: 'camera-1', capabilities: createCapabilities({ menu: true }) },
+          { cameraID: 'camera-2', capabilities: createCapabilities({ menu: true }) },
+          { cameraID: 'camera-3', capabilities: createCapabilities({ menu: false }) },
+        ]),
       );
       vi.mocked(cameraManager).getCameraMetadata.mockReturnValue({
         title: 'title',
@@ -181,7 +185,10 @@ describe('MenuButtonController', () => {
             cameraID: 'camera-1',
             config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
           },
-          { cameraID: 'camera-2' },
+          {
+            cameraID: 'camera-2',
+            capabilities: createCapabilities({ substream: true }),
+          },
         ]),
       );
       const buttons = calculateButtons(controller, { cameraManager: cameraManager });
@@ -208,7 +215,10 @@ describe('MenuButtonController', () => {
             cameraID: 'camera-1',
             config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
           },
-          { cameraID: 'camera-2' },
+          {
+            cameraID: 'camera-2',
+            capabilities: createCapabilities({ substream: true }),
+          },
         ]),
       );
       const view = createView({
@@ -248,18 +258,21 @@ describe('MenuButtonController', () => {
               camera_entity: 'camera.1',
               dependencies: { cameras: ['camera-2', 'camera-3'] },
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
           {
             cameraID: 'camera-2',
             config: createCameraConfig({
               camera_entity: 'camera.2',
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
           {
             cameraID: 'camera-3',
             config: createCameraConfig({
               camera_entity: 'camera.3',
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
         ]),
       );
@@ -340,18 +353,21 @@ describe('MenuButtonController', () => {
               camera_entity: 'camera.1',
               dependencies: { cameras: ['camera-2', 'camera-3'] },
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
           {
             cameraID: 'camera-2',
             config: createCameraConfig({
               camera_entity: 'camera.2',
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
           {
             cameraID: 'camera-3',
             config: createCameraConfig({
               camera_entity: 'camera.3',
             }),
+            capabilities: createCapabilities({ substream: true }),
           },
         ]),
       );
@@ -1207,10 +1223,17 @@ describe('MenuButtonController', () => {
     it.each([['single' as const], ['grid' as const]])(
       '%s',
       (displayMode: ViewDisplayMode) => {
-        const view = createView({ view: 'live', displayMode: displayMode });
+        const view = createView({
+          camera: 'camera-1',
+          view: 'live',
+          displayMode: displayMode,
+        });
         const cameraManager = createCameraManager();
         vi.mocked(cameraManager.getStore).mockReturnValue(
-          createStore([{ cameraID: 'camera-1' }, { cameraID: 'camera-2' }]),
+          createStore([
+            { cameraID: 'camera-1', capabilities: createCapabilities({ live: true }) },
+            { cameraID: 'camera-2', capabilities: createCapabilities({ live: true }) },
+          ]),
         );
 
         expect(
@@ -1239,7 +1262,7 @@ describe('MenuButtonController', () => {
     it('when the selected camera is not PTZ enabled', () => {
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getCameraCapabilities).mockReturnValue(
-        createCameraCapabilities(),
+        createCapabilities(),
       );
 
       const buttons = calculateButtons(controller, { cameraManager: cameraManager });
@@ -1264,7 +1287,7 @@ describe('MenuButtonController', () => {
     it('when the selected camera is PTZ enabled', () => {
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getCameraCapabilities).mockReturnValue(
-        createCameraCapabilities({ ptz: {} }),
+        createCapabilities({ ptz: { panTilt: ['relative'] } }),
       );
       const buttons = calculateButtons(controller, { cameraManager: cameraManager });
 
@@ -1288,7 +1311,7 @@ describe('MenuButtonController', () => {
     it('when the context has PTZ visiblity turned off', () => {
       const cameraManager = createCameraManager();
       vi.mocked(cameraManager.getCameraCapabilities).mockReturnValue(
-        createCameraCapabilities({ ptz: {} }),
+        createCapabilities({ ptz: { panTilt: ['relative'] } }),
       );
       const view = createView({
         camera: 'camera-1',
@@ -1328,9 +1351,9 @@ describe('MenuButtonController', () => {
       vi.mocked(cameraManager.getCameraCapabilities).mockImplementation(
         (cameraID: string) => {
           if (cameraID === 'camera-2') {
-            return createCameraCapabilities({ ptz: {} });
+            return createCapabilities({ ptz: { panTilt: ['relative'] } });
           }
-          return createCameraCapabilities();
+          return createCapabilities();
         },
       );
       const view = createView({

tests/components-lib/ptz-controller.test.ts

@@ -10,7 +10,7 @@ import {
   getActionConfigGivenAction,
 } from '../../src/utils/action.js';
 import {
-  createCameraCapabilities,
+  createCapabilities,
   createCameraManager,
   createHASS,
 } from '../test-utils';
@@ -145,7 +145,7 @@ describe('PTZController', () => {
 
           const cameraManager = createCameraManager();
           vi.mocked(cameraManager).getCameraCapabilities.mockReturnValue(
-            createCameraCapabilities({
+            createCapabilities({
               ptz: {
                 panTilt: ['continuous'],
                 zoom: ['continuous'],
@@ -185,7 +185,7 @@ describe('PTZController', () => {
 
           const cameraManager = createCameraManager();
           vi.mocked(cameraManager).getCameraCapabilities.mockReturnValue(
-            createCameraCapabilities({
+            createCapabilities({
               ptz: {
                 panTilt: ['relative'],
                 zoom: ['relative'],
@@ -210,7 +210,7 @@ describe('PTZController', () => {
 
         const cameraManager = createCameraManager();
         vi.mocked(cameraManager).getCameraCapabilities.mockReturnValue(
-          createCameraCapabilities({
+          createCapabilities({
             ptz: {
               presets: ['preset-foo'],
             },
@@ -237,7 +237,7 @@ describe('PTZController', () => {
         ['down' as const],
         ['zoom_in' as const],
         ['zoom_out' as const],
-      ])('%s', (actionName: PTZControlAction) => {
+      ])('configured %s', (actionName: PTZControlAction) => {
         const controller = new PTZController(document.createElement('div'));
         controller.setConfig(
           createConfig({
@@ -253,7 +253,7 @@ describe('PTZController', () => {
         });
       });
 
-      it('home', () => {
+      it('configured home', () => {
         const controller = new PTZController(document.createElement('div'));
         controller.setConfig(
           createConfig({

tests/config/types.test.ts

@@ -22,7 +22,6 @@ describe('config defaults', () => {
         frigate: {
           client_id: 'frigate',
         },
-        hide: false,
         image: {
           refresh_seconds: 1,
         },

tests/test-utils.ts

@@ -3,6 +3,7 @@ import { HassEntities, HassEntity } from 'home-assistant-js-websocket';
 import { expect, 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 { FrigateEvent, FrigateRecording } from '../src/camera-manager/frigate/types';
 import { GenericCameraManagerEngine } from '../src/camera-manager/generic/engine-generic';
@@ -10,10 +11,9 @@ import { CameraManager } from '../src/camera-manager/manager';
 import { CameraManagerStore } from '../src/camera-manager/store';
 import {
   CameraEventCallback,
-  CameraManagerCameraCapabilities,
-  CameraManagerCapabilities,
   CameraManagerMediaCapabilities,
 } from '../src/camera-manager/types';
+import { CapabilitiesRaw } from '../src/types';
 import { ActionsManager } from '../src/card-controller/actions-manager';
 import { AutoUpdateManager } from '../src/card-controller/auto-update-manager';
 import { AutomationsManager } from '../src/card-controller/automations-manager';
@@ -75,7 +75,7 @@ export const createConfig = (config?: RawFrigateCardConfig): FrigateCardConfig =
 export const createCamera = (
   config: CameraConfig,
   engine: CameraManagerEngine,
-  capabilities?: CameraManagerCameraCapabilities,
+  capabilities?: Capabilities,
 ): Camera => {
   return new Camera(config, engine, { capabilities: capabilities });
 };
@@ -185,7 +185,7 @@ export const createStore = (
     cameraID: string;
     engine?: CameraManagerEngine;
     config?: CameraConfig;
-    capabilities?: CameraManagerCameraCapabilities;
+    capabilities?: Capabilities | null;
     eventCallback?: CameraEventCallback;
   }[],
 ): CameraManagerStore => {
@@ -196,7 +196,10 @@ export const createStore = (
       cameraProps.config ?? createCameraConfig(),
       cameraProps.engine ?? new GenericCameraManagerEngine(eventCallback),
       {
-        capabilities: cameraProps.capabilities ?? createCameraCapabilities(),
+        capabilities:
+          cameraProps.capabilities === undefined
+            ? createCapabilities()
+            : cameraProps.capabilities ?? undefined,
         eventCallback: eventCallback,
       },
     );
@@ -212,35 +215,17 @@ export const createCameraManager = (): CameraManager => {
   return cameraManager;
 };
 
-export const createAggregateCameraCapabilities = (
-  capabilities?: Partial<CameraManagerCapabilities>,
-): CameraManagerCapabilities => {
-  return {
-    canFavoriteEvents: false,
-    canFavoriteRecordings: false,
-    canSeek: false,
-    supportsClips: false,
-    supportsRecordings: false,
-    supportsSnapshots: false,
-    supportsTimeline: false,
-    supportsPTZ: false,
+export const createCapabilities = (capabilities?: CapabilitiesRaw): Capabilities => {
+  return new Capabilities({
+    'favorite-events': false,
+    'favorite-recordings': false,
+    clips: false,
+    live: false,
+    recordings: false,
+    seek: false,
+    snapshots: false,
     ...capabilities,
-  };
-};
-
-export const createCameraCapabilities = (
-  capabilities?: Partial<CameraManagerCameraCapabilities>,
-): CameraManagerCameraCapabilities => {
-  return {
-    canFavoriteEvents: false,
-    canFavoriteRecordings: false,
-    canSeek: false,
-    supportsClips: false,
-    supportsRecordings: false,
-    supportsSnapshots: false,
-    supportsTimeline: false,
-    ...capabilities,
-  };
+  });
 };
 
 export const createMediaCapabilities = (

tests/utils/camera.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { getCameraID } from '../../src/utils/camera.js';
 import { createCameraConfig } from '../test-utils.js';
 

tests/utils/endpoint.test.ts

@@ -0,0 +1,85 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getEndpointAddressOrDispatchError } from '../../src/utils/endpoint';
+import { homeAssistantSignPath } from '../../src/utils/ha';
+import { createHASS } from '../test-utils';
+
+vi.mock('../../src/utils/ha');
+
+// @vitest-environment jsdom
+describe('getEndpointAddressOrDispatchError', () => {
+  it('without signing', async () => {
+    expect(
+      await getEndpointAddressOrDispatchError(
+        document.createElement('div'),
+        createHASS(),
+        {
+          endpoint: 'http://example.com',
+          sign: false,
+        },
+      ),
+    ).toBe('http://example.com');
+  });
+
+  describe('with signing', () => {
+    afterEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('successful', async () => {
+      vi.mocked(homeAssistantSignPath).mockResolvedValue('http://signed.com');
+
+      expect(
+        await getEndpointAddressOrDispatchError(
+          document.createElement('div'),
+          createHASS(),
+          {
+            endpoint: 'http://example.com',
+            sign: true,
+          },
+        ),
+      ).toBe('ws://signed.com');
+    });
+
+    it('with null response', async () => {
+      const element = document.createElement('div');
+      const listener = vi.fn();
+      element.addEventListener('frigate-card:message', listener);
+
+      vi.mocked(homeAssistantSignPath).mockResolvedValue(null);
+
+      expect(
+        await getEndpointAddressOrDispatchError(element, createHASS(), {
+          endpoint: 'http://example.com',
+          sign: true,
+        }),
+      ).toBeNull();
+
+      expect(listener).toBeCalledWith(
+        expect.objectContaining({
+          detail: expect.objectContaining({
+            message: 'Could not sign Home Assistant URL',
+          }),
+        }),
+      );
+    });
+
+    it('with exception on signing', async () => {
+      const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+      const element = document.createElement('div');
+      const listener = vi.fn();
+      element.addEventListener('frigate-card:message', listener);
+
+      vi.mocked(homeAssistantSignPath).mockRejectedValue(new Error());
+
+      expect(
+        await getEndpointAddressOrDispatchError(element, createHASS(), {
+          endpoint: 'http://example.com',
+          sign: true,
+        }),
+      ).toBeNull();
+
+      expect(consoleSpy).toBeCalled();
+    });
+  });
+});

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

@@ -1,6 +1,6 @@
 import add from 'date-fns/add';
 import sub from 'date-fns/sub';
-import { beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import { beforeEach, describe, expect, it, Mock, MockedFunction, vi } from 'vitest';
 import { QueryType } from '../../src/camera-manager/types';
 import {
   changeViewToRecentEventsForCameraAndDependents,
@@ -13,6 +13,7 @@ import { ViewMedia } from '../../src/view/media';
 import { EventMediaQueries } from '../../src/view/media-queries';
 import {
   createCameraManager,
+  createCapabilities,
   createPerformanceConfig,
   createStore,
   createView,
@@ -21,8 +22,8 @@ import {
 
 const createElementListenForView = (): {
   element: HTMLElement;
-  viewHandler: Mock<any, any>;
-  messageHandler: Mock<any, any>;
+  viewHandler: EventListener;
+  messageHandler: EventListener;
 } => {
   const element = document.createElement('div');
 
@@ -114,6 +115,7 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
@@ -138,7 +140,9 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
       },
     );
     expect(elementHandler.viewHandler).toBeCalled();
-    expect(getMediaFromHandlerCall(elementHandler.viewHandler)).toBe(mediaArray);
+    expect(getMediaFromHandlerCall(vi.mocked(elementHandler.viewHandler))).toBe(
+      mediaArray,
+    );
   });
 
   it('should dispatch error message on fail', async () => {
@@ -150,6 +154,7 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
@@ -177,6 +182,7 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
@@ -208,6 +214,7 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ clips: true }),
         },
       ]),
     );
@@ -246,6 +253,7 @@ describe('changeViewToRecentEventsForCameraAndDependents', () => {
         createStore([
           {
             cameraID: 'camera',
+            capabilities: createCapabilities({ [mediaType]: true }),
           },
         ]),
       );
@@ -440,6 +448,7 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ recordings: true }),
         },
       ]),
     );
@@ -464,7 +473,9 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
       },
     );
     expect(elementHandler.viewHandler).toBeCalled();
-    expect(getMediaFromHandlerCall(elementHandler.viewHandler)).toBe(mediaArray);
+    expect(getMediaFromHandlerCall(vi.mocked(elementHandler.viewHandler))).toBe(
+      mediaArray,
+    );
   });
 
   it('should respect media chunk size', async () => {
@@ -473,6 +484,7 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ recordings: true }),
         },
       ]),
     );
@@ -504,6 +516,7 @@ describe('changeViewToRecentRecordingForCameraAndDependents', () => {
       createStore([
         {
           cameraID: 'camera',
+          capabilities: createCapabilities({ recordings: true }),
         },
       ]),
     );

tests/utils/ptz.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { FrigateCardPTZConfig, frigateCardPTZSchema } from '../../src/config/types';
 import { hasUsablePTZ } from '../../src/utils/ptz';
-import { createCameraCapabilities } from '../test-utils';
+import { createCapabilities } from '../test-utils';
 
 const createPTZConfig = (
   config?: Partial<FrigateCardPTZConfig>,
@@ -13,7 +13,7 @@ describe('hasUsablePTZ', () => {
   it('should return true with manual actions', () => {
     expect(
       hasUsablePTZ(
-        createCameraCapabilities(),
+        createCapabilities(),
         createPTZConfig({
           actions_left: {},
         }),
@@ -23,14 +23,16 @@ describe('hasUsablePTZ', () => {
   it('should return true with capabilities', () => {
     expect(
       hasUsablePTZ(
-        createCameraCapabilities({
-          ptz: {},
+        createCapabilities({
+          ptz: {
+            panTilt: ['continuous'],
+          },
         }),
         createPTZConfig(),
       ),
     ).toBeTruthy();
   });
   it('should return false with manual actions or capabilities', () => {
-    expect(hasUsablePTZ(createCameraCapabilities(), createPTZConfig())).toBeFalsy();
+    expect(hasUsablePTZ(createCapabilities(), createPTZConfig())).toBeFalsy();
   });
 });

tests/view/view-to-cameras.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from 'vitest';
+import { FrigateCardView } from '../../src/config/types';
+import { CapabilityKey } from '../../src/types';
+import { getCameraIDsForViewName } from '../../src/view/view-to-cameras';
+import {
+  createCameraConfig,
+  createCameraManager,
+  createCapabilities,
+  createStore,
+} from '../test-utils';
+
+describe('getCameraIDsForViewName', () => {
+  describe('views that are always supported', () => {
+    it.each([['image' as const], ['diagnostics' as const]])(
+      '%s',
+      (viewName: FrigateCardView) => {
+        const cameraManager = createCameraManager();
+        vi.mocked(cameraManager.getStore).mockReturnValue(
+          createStore([
+            {
+              cameraID: 'camera-1',
+              config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
+            },
+            { cameraID: 'camera-2' },
+          ]),
+        );
+
+        expect(getCameraIDsForViewName(cameraManager, viewName)).toEqual(
+          new Set(['camera-1', 'camera-2']),
+        );
+        expect(getCameraIDsForViewName(cameraManager, viewName, 'camera-1')).toEqual(
+          new Set(['camera-1', 'camera-2']),
+        );
+        expect(getCameraIDsForViewName(cameraManager, viewName, 'camera-2')).toEqual(
+          new Set(['camera-1', 'camera-2']),
+        );
+      },
+    );
+  });
+
+  describe('views that respect dependencies and need a capability', () => {
+    it.each([
+      ['live' as const, 'live' as const],
+      ['clip' as const, 'clips' as const],
+      ['clips' as const, 'clips' as const],
+      ['snapshot' as const, 'snapshots' as const],
+      ['snapshots' as const, 'snapshots' as const],
+      ['recording' as const, 'recordings' as const],
+      ['recordings' as const, 'recordings' as const],
+      ['media' as const, 'clips' as const],
+      ['media' as const, 'snapshots' as const],
+      ['media' as const, 'recordings' as const],
+    ])('%s', (viewName: FrigateCardView, capabilityKey: CapabilityKey) => {
+      const cameraManager = createCameraManager();
+      vi.mocked(cameraManager.getStore).mockReturnValue(
+        createStore([
+          {
+            cameraID: 'camera-1',
+            config: createCameraConfig({ dependencies: { cameras: ['camera-2'] } }),
+          },
+          {
+            cameraID: 'camera-2',
+            capabilities: createCapabilities({ [capabilityKey]: true }),
+          },
+        ]),
+      );
+
+      expect(getCameraIDsForViewName(cameraManager, viewName)).toEqual(
+        new Set(['camera-2']),
+      );
+      expect(getCameraIDsForViewName(cameraManager, viewName, 'camera-1')).toEqual(
+        new Set(['camera-2']),
+      );
+      expect(getCameraIDsForViewName(cameraManager, viewName, 'camera-2')).toEqual(
+        new Set(['camera-2']),
+      );
+    });
+  });
+});