Add better control over substreams.

tests/test-utils.ts

@@ -11,7 +11,7 @@ import {
 } from '../src/types';
 import { Entity } from '../src/utils/ha/entity-registry/types';
 
-export const createCameraConfig = (config: Partial<CameraConfig>): CameraConfig => {
+export const createCameraConfig = (config: unknown): CameraConfig => {
   return cameraConfigSchema.parse(config);
 };
 

tests/utils/camera.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
+import { CameraManager } from '../../src/camera-manager/manager.js';
+import { CameraManagerStore } from '../../src/camera-manager/store.js';
+import { CameraConfigs } from '../../src/camera-manager/types.js';
+import { getAllDependentCameras, getCameraID } from '../../src/utils/camera.js';
+import { createCameraConfig } from '../test-utils.js';
+
+vi.mock('../../src/camera-manager/manager.js');
+
+describe('getCameraID', () => {
+  it('should get camera id with id', () => {
+    const config = createCameraConfig({ id: 'foo' });
+    expect(getCameraID(config)).toBe('foo');
+  });
+  it('should get camera id with camera_entity', () => {
+    const config = createCameraConfig({ camera_entity: 'foo' });
+    expect(getCameraID(config)).toBe('foo');
+  });
+  it('should get camera id with webrtc entity', () => {
+    const config = createCameraConfig({ webrtc_card: { entity: 'foo' } });
+    expect(getCameraID(config)).toBe('foo');
+  });
+  it('should get camera id with frigate camera_name', () => {
+    const config = createCameraConfig({
+      frigate: { client_id: 'bar', camera_name: 'foo' },
+    });
+    expect(getCameraID(config)).toBe('foo');
+  });
+  it('should get blank id without anything', () => {
+    const config = createCameraConfig({});
+    expect(getCameraID(config)).toBe('');
+  });
+});
+
+describe('getAllDependentCameras', () => {
+  it('should return null without cameraManager', () => {
+    expect(getAllDependentCameras()).toBeNull();
+  });
+  it('should return null without cameraID', () => {
+    expect(getAllDependentCameras(mock<CameraManager>())).toBeNull();
+  });
+  it('should return dependent cameras', () => {
+    const cameraConfigs: CameraConfigs = new Map([
+      [
+        'one',
+        createCameraConfig({
+          dependencies: {
+            cameras: ['two', 'three'],
+          },
+        }),
+      ],
+      ['two', createCameraConfig({})],
+    ]);
+
+    const cameraManager = new CameraManager(mock<CameraManagerEngineFactory>(), {});
+    const store = mock<CameraManagerStore>();
+    vi.mocked(cameraManager.getStore).mockReturnValue(store);
+    store.getCameras.mockReturnValue(cameraConfigs);
+
+    expect(getAllDependentCameras(cameraManager, 'one')).toEqual(
+      new Set(['one', 'two']),
+    );
+  });
+  it('should return all cameras', () => {
+    const cameraConfigs: CameraConfigs = new Map([
+      [
+        'one',
+        createCameraConfig({
+          dependencies: {
+            all_cameras: true,
+          },
+        }),
+      ],
+      ['two', createCameraConfig({})],
+    ]);
+
+    const cameraManager = new CameraManager(mock<CameraManagerEngineFactory>(), {});
+    const store = mock<CameraManagerStore>();
+    vi.mocked(cameraManager.getStore).mockReturnValue(store);
+    store.getCameras.mockReturnValue(cameraConfigs);
+
+    expect(getAllDependentCameras(cameraManager, 'one')).toEqual(
+      new Set(['one', 'two']),
+    );
+  });
+});

tests/utils/debug.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from 'vitest';
+import { log } from '../../src/utils/debug.js';
+
+describe('log', () => {
+  it('should do nothing without debug logging set', () => {
+    const spy = vi.spyOn(global.console, 'debug');
+    log({}, 'foo');
+    expect(spy).not.toBeCalled();
+  });
+  it('should log debug when appropriately configured', () => {
+    const spy = vi.spyOn(global.console, 'debug');
+    log({ debug: { logging: true } }, 'foo');
+    expect(spy).toBeCalledWith('foo');
+  });
+});

tests/utils/substream.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { CameraManager } from '../../src/camera-manager/manager';
+import { getAllDependentCameras } from '../../src/utils/camera';
+import {
+  createViewWithNextStream,
+  createViewWithSelectedSubstream,
+  createViewWithoutSubstream,
+  hasSubstream,
+} from '../../src/utils/substream';
+import { View } from '../../src/view/view';
+
+vi.mock('../../src/utils/camera');
+
+describe('createViewWithSelectedSubstream', () => {
+  it('should create view with selected substream', () => {
+    const view = new View({ view: 'live', camera: 'camera' });
+    const newView = createViewWithSelectedSubstream(view, 'substream');
+    expect(newView?.context?.live?.overrides).toEqual(
+      new Map([['camera', 'substream']]),
+    );
+  });
+
+  it('should create view with selected substream with existing overrides', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera']]),
+        },
+      },
+    });
+    const newView = createViewWithSelectedSubstream(view, 'substream');
+    expect(newView?.context?.live?.overrides).toEqual(
+      new Map([['camera', 'substream']]),
+    );
+  });
+});
+
+describe('createViewWithoutSubstream', () => {
+  it('should create view without substream', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera']]),
+        },
+      },
+    });
+    const newView = createViewWithoutSubstream(view);
+    expect(newView?.context?.live?.overrides).toEqual(new Map());
+  });
+});
+
+describe('hasSubstream', () => {
+  it('should detect substream', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera2']]),
+        },
+      },
+    });
+    expect(hasSubstream(view)).toBeTruthy();
+  });
+  it('should not detect substream when absent', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+    });
+    expect(hasSubstream(view)).toBeFalsy();
+  });
+  it('should not detect substream when main stream', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera']]),
+        },
+      },
+    });
+    expect(hasSubstream(view)).toBeFalsy();
+  });
+});
+
+describe('createViewWithNextStream', () => {
+  it('should create new equal view with no dependencies', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+    });
+    vi.mocked(getAllDependentCameras).mockReturnValue(new Set(['camera']));
+    const cameraManager = mock<CameraManager>();
+    const newView = createViewWithNextStream(cameraManager, view);
+    expect(newView.camera).toBe(view.camera);
+    expect(newView.view).toBe(view.view);
+    expect(newView.context).toEqual(view.context);
+  });
+  it('should create new view with next stream', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+    });
+    vi.mocked(getAllDependentCameras).mockReturnValue(new Set(['camera', 'camera2']));
+    const cameraManager = mock<CameraManager>();
+    const newView = createViewWithNextStream(cameraManager, view);
+    expect(newView.context?.live?.overrides).toEqual(new Map([['camera', 'camera2']]));
+  });
+  it('should create new view with next stream that cycles back', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera2']]),
+        },
+      },
+    });
+    vi.mocked(getAllDependentCameras).mockReturnValue(new Set(['camera', 'camera2']));
+    const cameraManager = mock<CameraManager>();
+    const newView = createViewWithNextStream(cameraManager, view);
+    expect(newView.context?.live?.overrides).toEqual(new Map([['camera', 'camera']]));
+  });
+  it('should create new view with first stream with invalid substream', () => {
+    const view = new View({
+      view: 'live',
+      camera: 'camera',
+      context: {
+        live: {
+          overrides: new Map([['camera', 'camera-that-does-not-exist']]),
+        },
+      },
+    });
+    vi.mocked(getAllDependentCameras).mockReturnValue(new Set(['camera', 'camera2']));
+    const cameraManager = mock<CameraManager>();
+    const newView = createViewWithNextStream(cameraManager, view);
+    expect(newView.context?.live?.overrides).toEqual(new Map([['camera', 'camera']]));
+  });
+});