1966 lines
66 KiB
TypeScript
1966 lines
66 KiB
TypeScript
import { add } from 'date-fns';
|
|
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
import { mock } from 'vitest-mock-extended';
|
|
|
|
import type { Camera } from '../../src/camera-manager/camera.js';
|
|
import { Capabilities } from '../../src/camera-manager/capabilities.js';
|
|
import type { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
|
|
import type { CameraManagerEngine } from '../../src/camera-manager/engine.js';
|
|
import {
|
|
CameraDuplicateIDError,
|
|
CameraNoEngineError,
|
|
CameraNoIDError,
|
|
} from '../../src/camera-manager/error.js';
|
|
import {
|
|
CameraManager,
|
|
CameraQueryClassifier,
|
|
QueryResultClassifier,
|
|
} from '../../src/camera-manager/manager.js';
|
|
import type { CameraManagerStore } from '../../src/camera-manager/store.js';
|
|
import {
|
|
Engine,
|
|
QueryResultsType,
|
|
QueryType,
|
|
type CameraEvent,
|
|
type CameraManagerCameraMetadata,
|
|
type EventQuery,
|
|
type EventQueryResults,
|
|
type MediaMetadata,
|
|
type QueryResults,
|
|
type RecordingQuery,
|
|
type RecordingSegmentsQuery,
|
|
type ReviewQuery,
|
|
} from '../../src/camera-manager/types.js';
|
|
import type { CardController } from '../../src/card-controller/controller.js';
|
|
import type { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
|
|
import { sortItems } from '../../src/card-controller/view/sort.js';
|
|
import type { CameraConfig } from '../../src/config/schema/cameras.js';
|
|
import { advancedCameraCardConfigSchema } from '../../src/config/schema/types.js';
|
|
import { QuerySource } from '../../src/query-source.js';
|
|
import { PTZMovementType, type Endpoint } from '../../src/types.js';
|
|
import { ViewFolder, type ViewItem, type ViewMedia } from '../../src/view/item.js';
|
|
import type { ViewItemCapabilities } from '../../src/view/types.js';
|
|
import { createCameraConfig, createConfig } from '../config/test-utils';
|
|
import { createCardAPI, createFolder, createHASS } from '../test-utils.js';
|
|
import { generateViewMediaArray, TestViewMedia } from '../view/test-utils';
|
|
import { createCapabilities, createInitializedCamera } from './test-utils';
|
|
|
|
describe('QueryClassifier', () => {
|
|
it('should classify event query', () => {
|
|
expect(CameraQueryClassifier.isEventQuery({ type: QueryType.Event })).toBeTruthy();
|
|
expect(
|
|
CameraQueryClassifier.isEventQuery({ type: QueryType.Recording }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isEventQuery({ type: QueryType.RecordingSegments }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isEventQuery({ type: QueryType.MediaMetadata }),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify recording query', () => {
|
|
expect(
|
|
CameraQueryClassifier.isRecordingQuery({ type: QueryType.Event }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingQuery({ type: QueryType.Recording }),
|
|
).toBeTruthy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingQuery({ type: QueryType.RecordingSegments }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingQuery({ type: QueryType.MediaMetadata }),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify recording segments query', () => {
|
|
expect(
|
|
CameraQueryClassifier.isRecordingSegmentsQuery({ type: QueryType.Event }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingSegmentsQuery({ type: QueryType.Recording }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingSegmentsQuery({
|
|
type: QueryType.RecordingSegments,
|
|
}),
|
|
).toBeTruthy();
|
|
expect(
|
|
CameraQueryClassifier.isRecordingSegmentsQuery({ type: QueryType.MediaMetadata }),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify media metadata query', () => {
|
|
expect(
|
|
CameraQueryClassifier.isMediaMetadataQuery({ type: QueryType.Event }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isMediaMetadataQuery({ type: QueryType.Recording }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isMediaMetadataQuery({ type: QueryType.RecordingSegments }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isMediaMetadataQuery({ type: QueryType.MediaMetadata }),
|
|
).toBeTruthy();
|
|
});
|
|
it('should classify review query', () => {
|
|
expect(CameraQueryClassifier.isReviewQuery({ type: QueryType.Event })).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isReviewQuery({ type: QueryType.Recording }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isReviewQuery({ type: QueryType.RecordingSegments }),
|
|
).toBeFalsy();
|
|
expect(
|
|
CameraQueryClassifier.isReviewQuery({ type: QueryType.MediaMetadata }),
|
|
).toBeFalsy();
|
|
expect(CameraQueryClassifier.isReviewQuery({ type: QueryType.Review })).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe('QueryResultClassifier', async () => {
|
|
const createResults = (type: Partial<QueryResultsType>): QueryResults => {
|
|
return {
|
|
type: type,
|
|
engine: Engine.Generic,
|
|
};
|
|
};
|
|
|
|
it('should classify event query result', async () => {
|
|
expect(
|
|
QueryResultClassifier.isEventQueryResult(createResults(QueryResultsType.Event)),
|
|
).toBeTruthy();
|
|
expect(
|
|
QueryResultClassifier.isEventQueryResult(
|
|
createResults(QueryResultsType.Recording),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isEventQueryResult(
|
|
createResults(QueryResultsType.RecordingSegments),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isEventQueryResult(
|
|
createResults(QueryResultsType.MediaMetadata),
|
|
),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify recording query result', async () => {
|
|
expect(
|
|
QueryResultClassifier.isRecordingQueryResult(
|
|
createResults(QueryResultsType.Event),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingQueryResult(
|
|
createResults(QueryResultsType.Recording),
|
|
),
|
|
).toBeTruthy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingQueryResult(
|
|
createResults(QueryResultsType.RecordingSegments),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingQueryResult(
|
|
createResults(QueryResultsType.MediaMetadata),
|
|
),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify recording segments query result', async () => {
|
|
expect(
|
|
QueryResultClassifier.isRecordingSegmentsQueryResult(
|
|
createResults(QueryResultsType.Event),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingSegmentsQueryResult(
|
|
createResults(QueryResultsType.Recording),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingSegmentsQueryResult(
|
|
createResults(QueryResultsType.RecordingSegments),
|
|
),
|
|
).toBeTruthy();
|
|
expect(
|
|
QueryResultClassifier.isRecordingSegmentsQueryResult(
|
|
createResults(QueryResultsType.MediaMetadata),
|
|
),
|
|
).toBeFalsy();
|
|
});
|
|
it('should classify media metadata query result', async () => {
|
|
expect(
|
|
QueryResultClassifier.isMediaMetadataQueryResult(
|
|
createResults(QueryResultsType.Event),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isMediaMetadataQueryResult(
|
|
createResults(QueryResultsType.Recording),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isMediaMetadataQueryResult(
|
|
createResults(QueryResultsType.RecordingSegments),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isMediaMetadataQueryResult(
|
|
createResults(QueryResultsType.MediaMetadata),
|
|
),
|
|
).toBeTruthy();
|
|
});
|
|
it('should classify review query result', async () => {
|
|
expect(
|
|
QueryResultClassifier.isReviewQueryResult(createResults(QueryResultsType.Event)),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isReviewQueryResult(
|
|
createResults(QueryResultsType.Recording),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isReviewQueryResult(
|
|
createResults(QueryResultsType.RecordingSegments),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isReviewQueryResult(
|
|
createResults(QueryResultsType.MediaMetadata),
|
|
),
|
|
).toBeFalsy();
|
|
expect(
|
|
QueryResultClassifier.isReviewQueryResult(createResults(QueryResultsType.Review)),
|
|
).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe('CameraManager', () => {
|
|
const baseCameraConfig = {
|
|
id: 'id',
|
|
camera_entity: 'camera.foo',
|
|
engine: 'generic',
|
|
};
|
|
|
|
const baseEventQuery: EventQuery = {
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Event as const,
|
|
cameraIDs: new Set(['id']),
|
|
};
|
|
|
|
const baseEventQueryResults: EventQueryResults = {
|
|
type: QueryResultsType.Event as const,
|
|
engine: Engine.Generic,
|
|
};
|
|
|
|
const baseRecordingQuery = {
|
|
source: QuerySource.Camera as const,
|
|
type: QueryType.Recording as const,
|
|
cameraIDs: new Set(['id']),
|
|
};
|
|
|
|
const baseRecordingQueryResults = {
|
|
type: QueryResultsType.Recording as const,
|
|
engine: Engine.Generic,
|
|
};
|
|
|
|
const createCameraManager = (
|
|
api: CardController,
|
|
engine?: CameraManagerEngine,
|
|
cameras: {
|
|
config?: CameraConfig;
|
|
|
|
// Replaces what the engine does for this camera, for cases the default
|
|
// path cannot express (e.g. failing, or completing out of order).
|
|
createCamera?: (cameraConfig: CameraConfig) => Promise<Camera>;
|
|
|
|
engineType?: Engine | null;
|
|
capabilties?: Capabilities;
|
|
stateWatcher?: StateWatcherSubscriptionInterface;
|
|
}[] = [{}],
|
|
factory?: CameraManagerEngineFactory,
|
|
): CameraManager => {
|
|
const camerasConfig = cameras?.map(
|
|
(camera) => camera.config ?? createCameraConfig(baseCameraConfig),
|
|
);
|
|
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
|
|
createConfig({
|
|
cameras: camerasConfig,
|
|
}),
|
|
);
|
|
|
|
const mockFactory = factory ?? mock<CameraManagerEngineFactory>();
|
|
const mockEngine = engine ?? mock<CameraManagerEngine>();
|
|
vi.mocked(mockFactory.createEngine).mockResolvedValueOnce(mockEngine);
|
|
|
|
for (const camera of cameras ?? []) {
|
|
const engineType =
|
|
camera.engineType === undefined ? Engine.Generic : camera.engineType;
|
|
if (engineType) {
|
|
vi.mocked(mockEngine.createCamera).mockImplementationOnce(
|
|
camera.createCamera ??
|
|
(async (cameraConfig: CameraConfig): Promise<Camera> =>
|
|
await createInitializedCamera(
|
|
cameraConfig,
|
|
mockEngine,
|
|
camera.capabilties ?? createCapabilities(),
|
|
camera.stateWatcher,
|
|
)),
|
|
);
|
|
}
|
|
vi.mocked(mockFactory.getEngineForCamera).mockResolvedValueOnce(engineType);
|
|
}
|
|
|
|
return new CameraManager(api, { factory: mockFactory });
|
|
};
|
|
|
|
it('should construct', () => {
|
|
const manager = new CameraManager(createCardAPI());
|
|
expect(manager.getStore()).toBeTruthy();
|
|
});
|
|
|
|
describe('should initialize cameras from config', () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(manager.getStore().getCameraCount()).toBe(1);
|
|
expect(manager.isInitialized()).toBeTruthy();
|
|
});
|
|
|
|
it('should handle missing hass', async () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should handle missing config', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(null);
|
|
|
|
const manager = createCameraManager(api);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should handle missing cameras in config', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
|
|
advancedCameraCardConfigSchema.parse({
|
|
type: 'advanced-camera-card' as const,
|
|
}),
|
|
);
|
|
|
|
const manager = new CameraManager(api);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should reject missing id', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{
|
|
config: createCameraConfig({
|
|
// No id.
|
|
engine: 'generic',
|
|
}),
|
|
},
|
|
]);
|
|
await expect(manager.initializeCamerasFromConfig()).rejects.toThrow(
|
|
CameraNoIDError,
|
|
);
|
|
});
|
|
|
|
it('should reject duplicate id', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const cameraConfig = createCameraConfig({
|
|
id: 'DUPLICATE',
|
|
engine: 'generic',
|
|
});
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{
|
|
config: cameraConfig,
|
|
},
|
|
{
|
|
config: cameraConfig,
|
|
},
|
|
]);
|
|
await expect(manager.initializeCamerasFromConfig()).rejects.toThrow(
|
|
CameraDuplicateIDError,
|
|
);
|
|
});
|
|
|
|
it('should await camera destruction before throwing on duplicate id', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const cameraConfig = createCameraConfig({
|
|
id: 'DUPLICATE',
|
|
engine: 'generic',
|
|
});
|
|
|
|
// Camera.destroy() awaits its _destroyCallbacks, one of which is the
|
|
// trigger-path unsubscribe. By returning a deferred Promise from each
|
|
// camera's stateWatcher.unsubscribe, we make destroy completion
|
|
// externally observable without spying on any Camera method.
|
|
const order: string[] = [];
|
|
const buildStateWatcher = (): StateWatcherSubscriptionInterface => {
|
|
const watcher = mock<StateWatcherSubscriptionInterface>();
|
|
vi.mocked(watcher.unsubscribe).mockImplementation(
|
|
() =>
|
|
new Promise<void>((resolve) =>
|
|
setTimeout(() => {
|
|
order.push('destroy-done');
|
|
resolve();
|
|
}, 0),
|
|
),
|
|
);
|
|
return watcher;
|
|
};
|
|
|
|
const cameraEntry = {
|
|
config: cameraConfig,
|
|
capabilties: createCapabilities({ trigger: true }),
|
|
};
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{ ...cameraEntry, stateWatcher: buildStateWatcher() },
|
|
{ ...cameraEntry, stateWatcher: buildStateWatcher() },
|
|
]);
|
|
|
|
await manager.initializeCamerasFromConfig().catch(() => order.push('throw'));
|
|
|
|
expect(order).toEqual(['destroy-done', 'destroy-done', 'throw']);
|
|
});
|
|
|
|
describe('should handle a camera that fails to initialize', () => {
|
|
const createAPI = (): CardController => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
return api;
|
|
};
|
|
|
|
it('should destroy a camera that initialized before the failure', async () => {
|
|
const stateWatcher = mock<StateWatcherSubscriptionInterface>();
|
|
const error = new Error('initialization failed');
|
|
|
|
const manager = createCameraManager(createAPI(), mock<CameraManagerEngine>(), [
|
|
{ capabilties: createCapabilities({ trigger: true }), stateWatcher },
|
|
{ createCamera: () => Promise.reject(error) },
|
|
]);
|
|
|
|
await expect(manager.initializeCamerasFromConfig()).rejects.toThrow(error);
|
|
|
|
expect(stateWatcher.unsubscribe).toHaveBeenCalled();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should destroy a camera that initialized after the failure', async () => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
const stateWatcher = mock<StateWatcherSubscriptionInterface>();
|
|
const error = new Error('initialization failed');
|
|
|
|
let releaseSlowCamera: () => void = () => {};
|
|
const slowCameraReady = new Promise<void>((resolve) => {
|
|
releaseSlowCamera = resolve;
|
|
});
|
|
|
|
const manager = createCameraManager(createAPI(), engine, [
|
|
{ createCamera: () => Promise.reject(error) },
|
|
{
|
|
createCamera: async (cameraConfig) => {
|
|
await slowCameraReady;
|
|
return await createInitializedCamera(
|
|
cameraConfig,
|
|
engine,
|
|
createCapabilities({ trigger: true }),
|
|
stateWatcher,
|
|
);
|
|
},
|
|
},
|
|
]);
|
|
|
|
const initialization = manager.initializeCamerasFromConfig();
|
|
releaseSlowCamera();
|
|
|
|
await expect(initialization).rejects.toThrow(error);
|
|
|
|
expect(stateWatcher.unsubscribe).toHaveBeenCalled();
|
|
});
|
|
|
|
it('should report the initialization failure when a camera cannot be destroyed', async () => {
|
|
const error = new Error('initialization failed');
|
|
|
|
const unluckyWatcher = mock<StateWatcherSubscriptionInterface>();
|
|
vi.mocked(unluckyWatcher.unsubscribe).mockRejectedValue(
|
|
new Error('destroy failed'),
|
|
);
|
|
|
|
// Destroy completion is observable through the trigger-path
|
|
// unsubscribe, without spying on any Camera method.
|
|
const slowWatcher = mock<StateWatcherSubscriptionInterface>();
|
|
let releaseSlowDestroy: () => void = () => {};
|
|
vi.mocked(slowWatcher.unsubscribe).mockImplementation(
|
|
() =>
|
|
new Promise<void>((resolve) => {
|
|
releaseSlowDestroy = resolve;
|
|
}),
|
|
);
|
|
|
|
const cameraEntry = { capabilties: createCapabilities({ trigger: true }) };
|
|
const manager = createCameraManager(createAPI(), mock<CameraManagerEngine>(), [
|
|
{ ...cameraEntry, stateWatcher: unluckyWatcher },
|
|
{ ...cameraEntry, stateWatcher: slowWatcher },
|
|
{ createCamera: () => Promise.reject(error) },
|
|
]);
|
|
|
|
let settled = false;
|
|
const initialization = manager
|
|
.initializeCamerasFromConfig()
|
|
.catch((e: unknown) => {
|
|
settled = true;
|
|
throw e;
|
|
});
|
|
|
|
await vi.waitFor(() => expect(slowWatcher.unsubscribe).toHaveBeenCalled());
|
|
expect(settled).toBe(false);
|
|
|
|
releaseSlowDestroy();
|
|
|
|
// The failing destroy neither masks the initialization error nor
|
|
// prevents the other camera from being destroyed.
|
|
await expect(initialization).rejects.toThrow(error);
|
|
expect(unluckyWatcher.unsubscribe).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('should discard cameras nothing will own', () => {
|
|
const createSlowManager = (): {
|
|
manager: CameraManager;
|
|
stateWatcher: StateWatcherSubscriptionInterface;
|
|
releaseCamera: () => void;
|
|
} => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const stateWatcher = mock<StateWatcherSubscriptionInterface>();
|
|
|
|
let releaseCamera: () => void = () => {};
|
|
const cameraReady = new Promise<void>((resolve) => {
|
|
releaseCamera = resolve;
|
|
});
|
|
|
|
const manager = createCameraManager(api, engine, [
|
|
{
|
|
createCamera: async (cameraConfig) => {
|
|
await cameraReady;
|
|
return await createInitializedCamera(
|
|
cameraConfig,
|
|
engine,
|
|
createCapabilities({ trigger: true }),
|
|
stateWatcher,
|
|
);
|
|
},
|
|
},
|
|
]);
|
|
|
|
return { manager, stateWatcher, releaseCamera: () => releaseCamera() };
|
|
};
|
|
|
|
it('should destroy cameras built after the manager was destroyed', async () => {
|
|
const { manager, stateWatcher, releaseCamera } = createSlowManager();
|
|
|
|
const initialization = manager.initializeCamerasFromConfig();
|
|
await manager.destroy();
|
|
releaseCamera();
|
|
await initialization;
|
|
|
|
expect(stateWatcher.unsubscribe).toHaveBeenCalled();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should destroy cameras built by a superseded initialization', async () => {
|
|
const { manager, stateWatcher, releaseCamera } = createSlowManager();
|
|
|
|
const superseded = manager.initializeCamerasFromConfig();
|
|
|
|
// A second initialization takes over. It cannot build cameras of its
|
|
// own from the exhausted mocks; what is under test is that the first
|
|
// initialization's cameras are discarded rather than stored.
|
|
const current = manager.initializeCamerasFromConfig();
|
|
releaseCamera();
|
|
|
|
await expect(current).rejects.toThrow(CameraNoEngineError);
|
|
await superseded;
|
|
|
|
expect(stateWatcher.unsubscribe).toHaveBeenCalled();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should discard cameras superseded by a call that cannot proceed', async () => {
|
|
const { manager, stateWatcher, releaseCamera } = createSlowManager();
|
|
|
|
const superseded = manager.initializeCamerasFromConfig();
|
|
|
|
// A newer call that returns early still supersedes: the cameras being
|
|
// built belong to a configuration that no longer applies.
|
|
vi.mocked(manager['_api'].getConfigManager().getConfig).mockReturnValue(null);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
releaseCamera();
|
|
await superseded;
|
|
|
|
expect(stateWatcher.unsubscribe).toHaveBeenCalled();
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
|
|
it('should not reset the store while a commit is in flight', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
|
|
createConfig({ cameras: [{ id: 'id', engine: 'generic' }] }),
|
|
);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const factory = mock<CameraManagerEngineFactory>();
|
|
vi.mocked(factory.createEngine).mockResolvedValue(engine);
|
|
vi.mocked(factory.getEngineForCamera).mockResolvedValue(Engine.Generic);
|
|
vi.mocked(engine.createCamera).mockImplementation(
|
|
async (cameraConfig: CameraConfig) =>
|
|
await createInitializedCamera(cameraConfig, engine, createCapabilities()),
|
|
);
|
|
|
|
// The real store mutates incrementally; a mock makes the commit window
|
|
// externally controllable.
|
|
const order: string[] = [];
|
|
const store = mock<CameraManagerStore>();
|
|
let releaseCommit: () => void = () => {};
|
|
vi.mocked(store.setCameras).mockImplementation(
|
|
() =>
|
|
new Promise<void>((resolve) => {
|
|
order.push('commit-start');
|
|
releaseCommit = () => {
|
|
order.push('commit-end');
|
|
resolve();
|
|
};
|
|
}),
|
|
);
|
|
vi.mocked(store.reset).mockImplementation(async () => {
|
|
order.push('reset');
|
|
});
|
|
|
|
const manager = new CameraManager(api, { factory, store });
|
|
|
|
const initialization = manager.initializeCamerasFromConfig();
|
|
await vi.waitFor(() => expect(store.setCameras).toHaveBeenCalled());
|
|
|
|
const destruction = manager.destroy();
|
|
releaseCommit();
|
|
await Promise.all([initialization, destruction]);
|
|
|
|
// The reset waits for the commit rather than interleaving with it.
|
|
expect(order).toEqual(['commit-start', 'commit-end', 'reset']);
|
|
});
|
|
});
|
|
|
|
it('should reject missing engine', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{
|
|
config: createCameraConfig({
|
|
id: 'id',
|
|
}),
|
|
engineType: null,
|
|
},
|
|
]);
|
|
await expect(manager.initializeCamerasFromConfig()).rejects.toThrow(
|
|
CameraNoEngineError,
|
|
);
|
|
});
|
|
|
|
it('should pass events to triggers manager', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const factory = mock<CameraManagerEngineFactory>();
|
|
const manager = createCameraManager(
|
|
api,
|
|
mock<CameraManagerEngine>(),
|
|
[{}],
|
|
factory,
|
|
);
|
|
await manager.initializeCamerasFromConfig();
|
|
const eventCallback = factory.createEngine.mock.calls[0][1].eventCallback;
|
|
|
|
const cameraEvent: CameraEvent = {
|
|
cameraID: 'camera',
|
|
id: 'event-1',
|
|
type: 'new',
|
|
};
|
|
eventCallback?.(cameraEvent);
|
|
expect(api.getCameraTriggersManager().handleCameraEvent).toHaveBeenCalledWith(
|
|
cameraEvent,
|
|
);
|
|
});
|
|
|
|
describe('should fetch entity list when required', () => {
|
|
it.each([['occupancy' as const], ['motion' as const], ['doorbell' as const]])(
|
|
'should fetch with %s trigger',
|
|
async (triggerKey) => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{
|
|
config: createCameraConfig({
|
|
...baseCameraConfig,
|
|
triggers: {
|
|
[triggerKey]: true,
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(api.getEntityRegistryManager().fetchEntityList).toHaveBeenCalled();
|
|
},
|
|
);
|
|
|
|
it('should skip without entity based trigger', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(api.getEntityRegistryManager().fetchEntityList).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('generate default queries', () => {
|
|
const setupManagerWithEngine = async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
return { engine, manager };
|
|
};
|
|
|
|
it('should generate default event queries', async () => {
|
|
const { engine, manager } = await setupManagerWithEngine();
|
|
const queries: EventQuery[] = [baseEventQuery];
|
|
|
|
engine.generateDefaultEventQuery.mockReturnValue(queries);
|
|
|
|
expect(manager.generateDefaultEventQueries('id')).toEqual(queries);
|
|
});
|
|
|
|
it('should generate default recording queries', async () => {
|
|
const { engine, manager } = await setupManagerWithEngine();
|
|
const queries: RecordingQuery[] = [baseRecordingQuery];
|
|
|
|
engine.generateDefaultRecordingQuery.mockReturnValue(queries);
|
|
|
|
expect(manager.generateDefaultRecordingQueries('id')).toEqual(queries);
|
|
});
|
|
|
|
it('should generate default recording segments queries', async () => {
|
|
const { engine, manager } = await setupManagerWithEngine();
|
|
const queries: RecordingSegmentsQuery[] = [
|
|
{
|
|
type: QueryType.RecordingSegments,
|
|
cameraIDs: new Set(['id']),
|
|
start: new Date(),
|
|
end: new Date(),
|
|
},
|
|
];
|
|
|
|
engine.generateDefaultRecordingSegmentsQuery.mockReturnValue(queries);
|
|
|
|
expect(manager.generateDefaultRecordingSegmentsQueries('id')).toEqual(queries);
|
|
});
|
|
|
|
it('should generate default review queries', async () => {
|
|
const { engine, manager } = await setupManagerWithEngine();
|
|
const queries: ReviewQuery[] = [
|
|
{
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Review,
|
|
cameraIDs: new Set(['id']),
|
|
},
|
|
];
|
|
|
|
engine.generateDefaultReviewQuery.mockReturnValue(queries);
|
|
|
|
expect(manager.generateDefaultReviewQueries('id')).toEqual(queries);
|
|
});
|
|
|
|
it('should handle missing camera', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>());
|
|
|
|
expect(manager.generateDefaultEventQueries('not_a_camera')).toBeNull();
|
|
});
|
|
|
|
it('should handle missing queries', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
engine.generateDefaultEventQuery.mockReturnValue(null);
|
|
expect(manager.generateDefaultEventQueries('id')).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('getDefaultQueryParameters', () => {
|
|
it('should return empty object for non-existent camera', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>());
|
|
|
|
expect(
|
|
manager.getDefaultQueryParameters('not_a_camera', QueryType.Event),
|
|
).toEqual({});
|
|
});
|
|
|
|
it('should return parameters from engine for existing camera', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
engine.getDefaultQueryParameters.mockReturnValue({ what: new Set(['person']) });
|
|
expect(manager.getDefaultQueryParameters('id', QueryType.Event)).toEqual({
|
|
what: new Set(['person']),
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should merge defaults correctly', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine, [
|
|
{
|
|
config: createCameraConfig({
|
|
...baseCameraConfig,
|
|
triggers: {
|
|
media_events: ['snapshots'],
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(
|
|
manager.getStore().getCamera('id')?.getConfig().triggers.media_events,
|
|
).toEqual(['snapshots']);
|
|
});
|
|
});
|
|
|
|
describe('should get media metadata', () => {
|
|
const query = {
|
|
type: QueryType.MediaMetadata as const,
|
|
cameraIDs: new Set('id'),
|
|
};
|
|
|
|
it('should handle empty metadata', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const queryResults = {
|
|
type: QueryResultsType.MediaMetadata as const,
|
|
engine: Engine.Generic,
|
|
metadata: {},
|
|
};
|
|
|
|
engine.getMediaMetadata.mockResolvedValue(new Map([[query, queryResults]]));
|
|
expect(await manager.getMediaMetadata()).toBeNull();
|
|
});
|
|
|
|
it.each([['days'], ['tags'], ['where'], ['what']])(
|
|
'with %s',
|
|
async (metadataType: string) => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const metadata: MediaMetadata = {
|
|
[metadataType]: new Set(['data']),
|
|
};
|
|
const queryResults = {
|
|
type: QueryResultsType.MediaMetadata as const,
|
|
engine: Engine.Generic,
|
|
metadata: metadata,
|
|
};
|
|
|
|
engine.getMediaMetadata.mockResolvedValue(new Map([[query, queryResults]]));
|
|
expect(await manager.getMediaMetadata()).toEqual(metadata);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should get events', () => {
|
|
it('should handle missing hass', async () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(await manager.getEvents(baseEventQuery)).toEqual(new Map());
|
|
});
|
|
|
|
it('should handle missing cameras', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const manager = createCameraManager(api);
|
|
expect(await manager.getEvents(baseEventQuery)).toEqual(new Map());
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const engineOptions = {};
|
|
const results = new Map([[baseEventQuery, baseEventQueryResults]]);
|
|
engine.getEvents.mockResolvedValue(results);
|
|
expect(await manager.getEvents(baseEventQuery, engineOptions)).toEqual(results);
|
|
expect(engine.getEvents).toHaveBeenCalledWith(
|
|
hass,
|
|
expect.anything(),
|
|
baseEventQuery,
|
|
engineOptions,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should review media', () => {
|
|
it('should handle missing camera', async () => {
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api);
|
|
const media = new TestViewMedia();
|
|
|
|
await manager.reviewMedia(media, true);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
const media = new TestViewMedia({ cameraID: 'id' });
|
|
|
|
await manager.reviewMedia(media, true);
|
|
|
|
expect(engine.reviewMedia).toHaveBeenCalledWith(
|
|
hass,
|
|
expect.anything(),
|
|
media,
|
|
true,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should get recordings', () => {
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const engineOptions = {};
|
|
const results = new Map([[baseRecordingQuery, baseRecordingQueryResults]]);
|
|
engine.getRecordings.mockResolvedValue(results);
|
|
expect(await manager.getRecordings(baseRecordingQuery, engineOptions)).toEqual(
|
|
results,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should get recording segments', () => {
|
|
const query = {
|
|
type: QueryType.RecordingSegments as const,
|
|
cameraIDs: new Set(['id']),
|
|
start: new Date(),
|
|
end: new Date(),
|
|
};
|
|
|
|
const queryResults = {
|
|
type: QueryResultsType.RecordingSegments as const,
|
|
engine: Engine.Generic,
|
|
segments: [],
|
|
};
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const engineOptions = {};
|
|
const results = new Map([[query, queryResults]]);
|
|
engine.getRecordingSegments.mockResolvedValue(results);
|
|
expect(await manager.getRecordingSegments(query, engineOptions)).toEqual(results);
|
|
});
|
|
});
|
|
|
|
describe('should execute media queries', () => {
|
|
it('should handle events', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const results = new Map([[baseEventQuery, baseEventQueryResults]]);
|
|
engine.getEvents.mockResolvedValue(results);
|
|
const media = sortItems(generateViewMediaArray({ count: 5 }));
|
|
engine.generateMediaFromEvents.mockReturnValue(media);
|
|
|
|
expect(await manager.executeMediaQueries([baseEventQuery])).toEqual(media);
|
|
});
|
|
|
|
it('should handle no converted media', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const results = new Map([[baseEventQuery, baseEventQueryResults]]);
|
|
engine.getEvents.mockResolvedValue(results);
|
|
engine.generateMediaFromEvents.mockReturnValue(null);
|
|
|
|
expect(await manager.executeMediaQueries([baseEventQuery])).toEqual([]);
|
|
});
|
|
|
|
it('should handle missing camera engine during conversion', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const results = new Map([
|
|
[baseEventQuery, { ...baseEventQueryResults, engine: Engine.MotionEye }],
|
|
]);
|
|
engine.getEvents.mockResolvedValue(results);
|
|
|
|
expect(await manager.executeMediaQueries([baseEventQuery])).toEqual([]);
|
|
});
|
|
|
|
it('should handle recordings', async () => {
|
|
const api = createCardAPI();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const results = new Map([[baseRecordingQuery, baseRecordingQueryResults]]);
|
|
engine.getRecordings.mockResolvedValue(results);
|
|
const media = sortItems(generateViewMediaArray({ count: 5 }));
|
|
engine.generateMediaFromRecordings.mockReturnValue(media);
|
|
|
|
expect(await manager.executeMediaQueries([baseRecordingQuery])).toEqual(media);
|
|
});
|
|
|
|
it('should handle missing hass', async () => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(createCardAPI(), engine);
|
|
const results = new Map([[baseEventQuery, baseEventQueryResults]]);
|
|
engine.getEvents.mockResolvedValue(results);
|
|
|
|
expect(await manager.executeMediaQueries([baseEventQuery])).toEqual([]);
|
|
});
|
|
|
|
describe('should merge compatible queries', () => {
|
|
it('should merge queries with identical properties', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, engine, [
|
|
{ config: createCameraConfig({ ...baseCameraConfig, id: 'cam1' }) },
|
|
{ config: createCameraConfig({ ...baseCameraConfig, id: 'cam2' }) },
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const query1: EventQuery = {
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Event,
|
|
cameraIDs: new Set(['cam1']),
|
|
reviewed: false,
|
|
};
|
|
const query2: EventQuery = {
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Event,
|
|
cameraIDs: new Set(['cam2']),
|
|
reviewed: false,
|
|
};
|
|
|
|
engine.getEvents.mockResolvedValue(new Map());
|
|
engine.generateMediaFromEvents.mockReturnValue([]);
|
|
|
|
await manager.executeMediaQueries([query1, query2]);
|
|
|
|
// Should be called once with merged cameraIDs
|
|
expect(engine.getEvents).toHaveBeenCalledTimes(1);
|
|
expect(engine.getEvents).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
cameraIDs: new Set(['cam1', 'cam2']),
|
|
reviewed: false,
|
|
}),
|
|
undefined,
|
|
);
|
|
});
|
|
|
|
it('should not merge queries with different properties', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, engine, [
|
|
{ config: createCameraConfig({ ...baseCameraConfig, id: 'cam1' }) },
|
|
{ config: createCameraConfig({ ...baseCameraConfig, id: 'cam2' }) },
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const query1: EventQuery = {
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Event,
|
|
cameraIDs: new Set(['cam1']),
|
|
reviewed: false,
|
|
};
|
|
const query2: EventQuery = {
|
|
source: QuerySource.Camera,
|
|
type: QueryType.Event,
|
|
cameraIDs: new Set(['cam2']),
|
|
reviewed: true,
|
|
};
|
|
|
|
engine.getEvents.mockResolvedValue(new Map());
|
|
engine.generateMediaFromEvents.mockReturnValue([]);
|
|
|
|
await manager.executeMediaQueries([query1, query2]);
|
|
|
|
// Should be called twice for different queries
|
|
expect(engine.getEvents).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('should handle single query without merging', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
engine.getEvents.mockResolvedValue(
|
|
new Map([[baseEventQuery, baseEventQueryResults]]),
|
|
);
|
|
engine.generateMediaFromEvents.mockReturnValue([]);
|
|
|
|
await manager.executeMediaQueries([baseEventQuery]);
|
|
|
|
expect(engine.getEvents).toHaveBeenCalledTimes(1);
|
|
expect(engine.getEvents).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.anything(),
|
|
baseEventQuery,
|
|
undefined,
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('should extend media queries', () => {
|
|
const dateBase = new Date('2024-03-01T20:01:00');
|
|
const mediaTwoCameras = generateViewMediaArray({ count: 5 });
|
|
const mediaMixedStart: ViewItem[] = [
|
|
new TestViewMedia({
|
|
startTime: dateBase,
|
|
}),
|
|
new TestViewMedia({
|
|
startTime: add(dateBase, { days: 1 }),
|
|
}),
|
|
new TestViewMedia({
|
|
startTime: add(dateBase, { days: 2 }),
|
|
}),
|
|
new ViewFolder(createFolder(), []),
|
|
];
|
|
|
|
it('should handle missing hass', async () => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const manager = createCameraManager(createCardAPI(), engine);
|
|
expect(await manager.extendMediaQueries([baseEventQuery], [], 'later')).toBeNull();
|
|
});
|
|
|
|
it.each([
|
|
['empty query and results', new Map(), [], [], [], null],
|
|
[
|
|
'query without existing media',
|
|
new Map([[baseEventQuery, baseEventQueryResults]]),
|
|
[],
|
|
[{ ...baseEventQuery, limit: 50 }],
|
|
generateViewMediaArray({ count: 5 }),
|
|
{
|
|
queries: [{ ...baseEventQuery, limit: 50 }],
|
|
results: sortItems(generateViewMediaArray({ count: 5 })),
|
|
},
|
|
],
|
|
[
|
|
'query that extends existing results',
|
|
new Map([[baseEventQuery, baseEventQueryResults]]),
|
|
generateViewMediaArray({ count: 5, cameraIDs: ['kitchen'] }),
|
|
[{ ...baseEventQuery, limit: 50 }],
|
|
generateViewMediaArray({ count: 5, cameraIDs: ['office'] }),
|
|
{
|
|
queries: [{ ...baseEventQuery, limit: 50 }],
|
|
results: sortItems(mediaTwoCameras),
|
|
},
|
|
],
|
|
[
|
|
'query with existing media but no new media',
|
|
new Map([[baseEventQuery, baseEventQueryResults]]),
|
|
mediaTwoCameras,
|
|
[
|
|
{
|
|
...baseEventQuery,
|
|
limit: 50,
|
|
},
|
|
],
|
|
|
|
// Fetch identical media again.
|
|
mediaTwoCameras,
|
|
|
|
// Returns null to signify nothing new.
|
|
null,
|
|
],
|
|
[
|
|
'query fetching later',
|
|
new Map([[{ ...baseEventQuery, start: dateBase }, baseEventQueryResults]]),
|
|
mediaMixedStart,
|
|
[
|
|
{
|
|
...baseEventQuery,
|
|
limit: 50,
|
|
start: add(dateBase, { days: 2 }),
|
|
},
|
|
],
|
|
mediaTwoCameras,
|
|
{
|
|
queries: [{ ...baseEventQuery, limit: 50, start: dateBase }],
|
|
results: sortItems(mediaMixedStart.concat(mediaTwoCameras)),
|
|
},
|
|
'later' as const,
|
|
],
|
|
[
|
|
'query fetching earlier',
|
|
new Map([[{ ...baseEventQuery, start: dateBase }, baseEventQueryResults]]),
|
|
mediaMixedStart,
|
|
[
|
|
{
|
|
...baseEventQuery,
|
|
limit: 50,
|
|
end: dateBase,
|
|
},
|
|
],
|
|
mediaTwoCameras,
|
|
{
|
|
queries: [{ ...baseEventQuery, limit: 50, start: dateBase }],
|
|
results: sortItems(mediaMixedStart.concat(mediaTwoCameras)),
|
|
},
|
|
'earlier' as const,
|
|
],
|
|
])(
|
|
'handles %s',
|
|
async (
|
|
_name: string,
|
|
// The previously submitted query & results.
|
|
inputQueries: Map<EventQuery, EventQueryResults>,
|
|
|
|
// The previously received media.
|
|
inputResults: ViewItem[],
|
|
|
|
// The queries expected to be dispatched.
|
|
newChunkQueries: EventQuery[],
|
|
|
|
// The media received from the new queries.
|
|
outputMediaResults: ViewMedia[],
|
|
|
|
// The expect extended queries and results.
|
|
expected?: {
|
|
queries: EventQuery[];
|
|
results: ViewItem[];
|
|
} | null,
|
|
direction?: 'earlier' | 'later',
|
|
) => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(engine.getEngineType).mockReturnValue(Engine.Generic);
|
|
|
|
const api = createCardAPI();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
const manager = createCameraManager(api, engine);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
engine.getEvents.mockResolvedValue(inputQueries);
|
|
engine.generateMediaFromEvents.mockReturnValue(outputMediaResults);
|
|
|
|
expect(
|
|
await manager.extendMediaQueries(
|
|
[...inputQueries.keys()],
|
|
inputResults,
|
|
direction ?? 'later',
|
|
),
|
|
).toEqual(expected);
|
|
|
|
// Make sure the issued queries are correct.
|
|
for (const query of newChunkQueries) {
|
|
expect(engine.getEvents).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.anything(),
|
|
query,
|
|
undefined,
|
|
);
|
|
}
|
|
},
|
|
);
|
|
});
|
|
|
|
describe('should get media download path', () => {
|
|
it('should handle missing camera', async () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(await manager.getMediaDownloadPath(new TestViewMedia())).toBeNull();
|
|
});
|
|
|
|
it('should handle missing hass', async () => {
|
|
const api = createCardAPI();
|
|
const manager = createCameraManager(api);
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(null);
|
|
expect(await manager.getMediaDownloadPath(new TestViewMedia())).toBeNull();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const result: Endpoint = {
|
|
endpoint: 'http://localhost/path/to/media',
|
|
};
|
|
vi.mocked(engine.getMediaDownloadPath).mockResolvedValue(result);
|
|
expect(
|
|
await manager.getMediaDownloadPath(new TestViewMedia({ cameraID: 'id' })),
|
|
).toBe(result);
|
|
});
|
|
});
|
|
|
|
describe('should get media capabilities', () => {
|
|
it('should handle missing camera', async () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(manager.getMediaCapabilities(new TestViewMedia())).toBeNull();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const result: ViewItemCapabilities = {
|
|
canFavorite: false,
|
|
canDownload: false,
|
|
};
|
|
vi.mocked(engine.getMediaCapabilities).mockReturnValue(result);
|
|
expect(manager.getMediaCapabilities(new TestViewMedia({ cameraID: 'id' }))).toBe(
|
|
result,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should favorite media', () => {
|
|
it('should handle missing camera', async () => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(createCardAPI(), engine);
|
|
manager.favoriteMedia(new TestViewMedia(), true);
|
|
|
|
expect(engine.favoriteMedia).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const media = new TestViewMedia({ cameraID: 'id' });
|
|
manager.favoriteMedia(media, true);
|
|
expect(engine.favoriteMedia).toHaveBeenCalledWith(
|
|
hass,
|
|
expect.anything(),
|
|
media,
|
|
true,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should get camera endpoints', () => {
|
|
it('should handle missing camera', () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(manager.getCameraEndpoints('BAD')).toBeNull();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
expect(manager.getCameraEndpoints('id', { view: 'live' })).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe('should get camera metadata', () => {
|
|
it('should handle missing camera', () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(manager.getCameraMetadata('BAD')).toBeNull();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const result: CameraManagerCameraMetadata = {
|
|
title: 'My Camera',
|
|
icon: {
|
|
icon: 'mdi:camera',
|
|
},
|
|
};
|
|
vi.mocked(engine.getCameraMetadata).mockReturnValue(result);
|
|
|
|
expect(manager.getCameraMetadata('id')).toBe(result);
|
|
});
|
|
});
|
|
|
|
describe('should get camera capabilities', () => {
|
|
it('should handle missing camera', () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
expect(manager.getCameraCapabilities('BAD')).toBeNull();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
expect(manager.getCameraCapabilities('id')).toEqual(createCapabilities());
|
|
});
|
|
});
|
|
|
|
describe('should get aggregate camera capabilities', () => {
|
|
it('should handle missing camera', () => {
|
|
const manager = createCameraManager(createCardAPI());
|
|
const capabilities = manager.getAggregateCameraCapabilities();
|
|
|
|
expect(capabilities.has('favorite-events')).toBeFalsy();
|
|
expect(capabilities.has('favorite-recordings')).toBeFalsy();
|
|
expect(capabilities.has('seek')).toBeFalsy();
|
|
|
|
expect(capabilities.has('live')).toBeFalsy();
|
|
expect(capabilities.has('clips')).toBeFalsy();
|
|
expect(capabilities.has('recordings')).toBeFalsy();
|
|
expect(capabilities.has('snapshots')).toBeFalsy();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const manager = createCameraManager(api, mock<CameraManagerEngine>(), [
|
|
{
|
|
capabilties: new Capabilities({
|
|
'favorite-events': false,
|
|
'favorite-recordings': false,
|
|
seek: false,
|
|
|
|
live: false,
|
|
clips: false,
|
|
recordings: false,
|
|
snapshots: false,
|
|
}),
|
|
},
|
|
{
|
|
config: createCameraConfig({ baseCameraConfig, id: 'another' }),
|
|
capabilties: new Capabilities({
|
|
'favorite-events': true,
|
|
'favorite-recordings': true,
|
|
seek: true,
|
|
|
|
live: true,
|
|
clips: true,
|
|
recordings: true,
|
|
snapshots: true,
|
|
|
|
ptz: {
|
|
left: [PTZMovementType.Continuous],
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
const capabilities = manager.getAggregateCameraCapabilities();
|
|
|
|
expect(capabilities.has('favorite-events')).toBeTruthy();
|
|
expect(capabilities.has('favorite-recordings')).toBeTruthy();
|
|
expect(capabilities.has('seek')).toBeTruthy();
|
|
|
|
expect(capabilities.has('live')).toBeTruthy();
|
|
expect(capabilities.has('clips')).toBeTruthy();
|
|
expect(capabilities.has('recordings')).toBeTruthy();
|
|
expect(capabilities.has('snapshots')).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe('should execute PTZ action', () => {
|
|
it('should handle missing camera', () => {
|
|
const engine = mock<CameraManagerEngine>();
|
|
const manager = createCameraManager(createCardAPI(), engine);
|
|
|
|
manager.executePTZAction('id', 'left', {});
|
|
|
|
// No visible action.
|
|
});
|
|
|
|
it('should succeed with null hass', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
const action = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'action',
|
|
};
|
|
const manager = createCameraManager(api, engine, [
|
|
{
|
|
config: createCameraConfig({
|
|
baseCameraConfig,
|
|
id: 'another',
|
|
ptz: {
|
|
actions_left: action,
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(null);
|
|
manager.executePTZAction('another', 'left');
|
|
|
|
expect(api.getActionsManager().executeActions).toHaveBeenCalledWith({
|
|
actions: action,
|
|
});
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
const action = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'action',
|
|
};
|
|
const manager = createCameraManager(api, engine, [
|
|
{
|
|
config: createCameraConfig({
|
|
baseCameraConfig,
|
|
id: 'another',
|
|
ptz: {
|
|
actions_left: action,
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
manager.executePTZAction('another', 'left');
|
|
|
|
expect(api.getActionsManager().executeActions).toHaveBeenCalledWith({
|
|
actions: action,
|
|
});
|
|
});
|
|
|
|
describe('with rotation', () => {
|
|
it.each([
|
|
// No rotation
|
|
[undefined, 'left', 'left', undefined],
|
|
[undefined, 'right', 'right', undefined],
|
|
[undefined, 'up', 'up', undefined],
|
|
[undefined, 'down', 'down', undefined],
|
|
[0, 'left', 'left', undefined],
|
|
[0, 'right', 'right', undefined],
|
|
[0, 'up', 'up', undefined],
|
|
[0, 'down', 'down', undefined],
|
|
|
|
// 90° rotation (clockwise view rotation means controls rotate counter-clockwise)
|
|
[90, 'left', 'down', undefined],
|
|
[90, 'right', 'up', undefined],
|
|
[90, 'up', 'left', undefined],
|
|
[90, 'down', 'right', undefined],
|
|
|
|
// 180° rotation
|
|
[180, 'left', 'right', undefined],
|
|
[180, 'right', 'left', undefined],
|
|
[180, 'up', 'down', undefined],
|
|
[180, 'down', 'up', undefined],
|
|
|
|
// 270° rotation
|
|
[270, 'left', 'up', undefined],
|
|
[270, 'right', 'down', undefined],
|
|
[270, 'up', 'right', undefined],
|
|
[270, 'down', 'left', undefined],
|
|
|
|
// Non-directional actions should pass through unchanged
|
|
[90, 'zoom_in', 'zoom_in', undefined],
|
|
[90, 'zoom_out', 'zoom_out', undefined],
|
|
[90, 'preset', 'preset', 'test-preset'],
|
|
[180, 'zoom_in', 'zoom_in', undefined],
|
|
[180, 'zoom_out', 'zoom_out', undefined],
|
|
[180, 'preset', 'preset', 'test-preset'],
|
|
[270, 'zoom_in', 'zoom_in', undefined],
|
|
[270, 'zoom_out', 'zoom_out', undefined],
|
|
[270, 'preset', 'preset', 'test-preset'],
|
|
] as const)(
|
|
'rotates %s° %s to %s',
|
|
async (rotation, inputAction, expectedAction, preset) => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
const hass = createHASS();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
|
|
|
|
const leftAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'left-action',
|
|
};
|
|
const rightAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'right-action',
|
|
};
|
|
const upAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'up-action',
|
|
};
|
|
const downAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'down-action',
|
|
};
|
|
const zoomInAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'zoom-in-action',
|
|
};
|
|
const zoomOutAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'zoom-out-action',
|
|
};
|
|
const presetAction = {
|
|
action: 'perform-action' as const,
|
|
perform_action: 'preset-action',
|
|
};
|
|
|
|
const manager = createCameraManager(api, engine, [
|
|
{
|
|
config: createCameraConfig({
|
|
baseCameraConfig,
|
|
id: 'rotated-camera',
|
|
dimensions: rotation !== undefined ? { rotation } : undefined,
|
|
ptz: {
|
|
actions_left: leftAction,
|
|
actions_right: rightAction,
|
|
actions_up: upAction,
|
|
actions_down: downAction,
|
|
actions_zoom_in: zoomInAction,
|
|
actions_zoom_out: zoomOutAction,
|
|
presets: {
|
|
'test-preset': presetAction,
|
|
},
|
|
},
|
|
}),
|
|
},
|
|
]);
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
manager.executePTZAction(
|
|
'rotated-camera',
|
|
inputAction,
|
|
preset ? { preset } : undefined,
|
|
);
|
|
|
|
// Map expected action to the corresponding action object
|
|
const expectedActionMap = {
|
|
left: leftAction,
|
|
right: rightAction,
|
|
up: upAction,
|
|
down: downAction,
|
|
zoom_in: zoomInAction,
|
|
zoom_out: zoomOutAction,
|
|
preset: presetAction,
|
|
};
|
|
|
|
expect(api.getActionsManager().executeActions).toHaveBeenCalledWith({
|
|
actions: expectedActionMap[expectedAction],
|
|
});
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('should determine if queries are fresh', () => {
|
|
beforeAll(() => {
|
|
const start = new Date('2024-03-02T20:35:00');
|
|
vi.useFakeTimers();
|
|
vi.setSystemTime(start);
|
|
});
|
|
|
|
afterAll(() => {
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
it.each([
|
|
['not fresh', new Date('2024-03-02T20:32:00'), false],
|
|
['fresh on lower bound', new Date('2024-03-02T20:34:00'), true],
|
|
['fresh at current time', new Date('2024-03-02T20:35:00'), true],
|
|
['fresh in the future', new Date('2024-03-02T20:40:00'), true],
|
|
[
|
|
'unknown camera',
|
|
new Date('2024-03-02T20:35:00'),
|
|
|
|
// Default assumed to be fresh.
|
|
true,
|
|
[
|
|
{
|
|
...baseEventQuery,
|
|
cameraIDs: new Set(['BAD']),
|
|
},
|
|
],
|
|
],
|
|
])(
|
|
'%s',
|
|
async (
|
|
_name: string,
|
|
resultsTimestamp: Date,
|
|
expectedFresh: boolean,
|
|
queries: EventQuery[] = [baseEventQuery],
|
|
) => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
engine.getQueryResultMaxAge.mockReturnValue(60);
|
|
expect(manager.areMediaQueriesResultsFresh(resultsTimestamp, queries)).toBe(
|
|
expectedFresh,
|
|
);
|
|
},
|
|
);
|
|
|
|
it('should always return false for null queries', () => {
|
|
const manager = createCameraManager(createCardAPI(), mock<CameraManagerEngine>());
|
|
expect(manager.areMediaQueriesResultsFresh(new Date(), null)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('should get media seek time', () => {
|
|
const startTime = new Date('2024-03-02T20:52:00');
|
|
const endTime = new Date('2024-03-02T20:53:00');
|
|
const middleTime = new Date('2024-03-02T20:52:30');
|
|
|
|
describe('invalid requests', () => {
|
|
it.each([
|
|
['null start and end', null, null, middleTime],
|
|
['no start', null, endTime, middleTime],
|
|
['no end', startTime, null, middleTime],
|
|
['target < start', endTime, endTime, startTime],
|
|
['target > end', startTime, startTime, endTime],
|
|
])(
|
|
'%s',
|
|
async (_name: string, start: Date | null, end: Date | null, target: Date) => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
expect(
|
|
await manager.getMediaSeekTime(
|
|
new TestViewMedia({ startTime: start, endTime: end }),
|
|
target,
|
|
),
|
|
).toBeNull();
|
|
},
|
|
);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
engine.getMediaSeekTime.mockResolvedValue(42);
|
|
|
|
const media = new TestViewMedia({
|
|
cameraID: 'id',
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
});
|
|
expect(await manager.getMediaSeekTime(media, middleTime)).toBe(42);
|
|
|
|
expect(engine.getMediaSeekTime).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.anything(),
|
|
media,
|
|
middleTime,
|
|
);
|
|
});
|
|
|
|
it('should handle null return value', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
engine.getMediaSeekTime.mockResolvedValue(null);
|
|
|
|
const media = new TestViewMedia({
|
|
cameraID: 'id',
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
});
|
|
expect(await manager.getMediaSeekTime(media, middleTime)).toBeNull();
|
|
});
|
|
});
|
|
|
|
it('should destroy', async () => {
|
|
const api = createCardAPI();
|
|
const engine = mock<CameraManagerEngine>();
|
|
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
|
|
const manager = createCameraManager(api, engine);
|
|
|
|
await manager.initializeCamerasFromConfig();
|
|
|
|
expect(manager.getStore().getCameraCount()).toBe(1);
|
|
|
|
await manager.destroy();
|
|
|
|
expect(manager.getStore().getCameraCount()).toBe(0);
|
|
});
|
|
});
|