flan/advanced-camera-card
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use custom websocket to avoid needing admin privileges.

Browse Source
This commit is contained in:
Dermot Duffy
2024-08-24 20:00:00 -07:00
parent 5a1d08f3ea
commit 429dd90972
47 changed files with 1219 additions and 874 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/camera-manager/browse-media/camera.test.ts
+14 -2
View File
@@ -5,6 +5,7 @@ import { CameraManagerEngine } from '../../../src/camera-manager/engine';
import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
import { Entity } from '../../../src/utils/ha/entity-registry/types';
import { createCameraConfig, createHASS } from '../../test-utils';
import { StateWatcherSubscriptionInterface } from '../../../src/card-controller/hass/state-watcher';
describe('BrowseMediaCamera', () => {
describe('should initialize', () => {
@@ -15,7 +16,12 @@ describe('BrowseMediaCamera', () => {
);
expect(
async () => await camera.initialize(createHASS(), mock<EntityRegistryManager>()),
async () =>
await camera.initialize({
hass: createHASS(),
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
entityRegistryManager: mock<EntityRegistryManager>(),
}),
).rejects.toThrowError(/Could not find camera entity/);
});
@@ -30,7 +36,13 @@ describe('BrowseMediaCamera', () => {
const entity = mock<Entity>();
entityRegistryManager.getEntity.mockResolvedValue(entity);
expect(await camera.initialize(createHASS(), entityRegistryManager)).toBe(camera);
expect(
await camera.initialize({
hass: createHASS(),
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
entityRegistryManager: entityRegistryManager,
}),
).toBe(camera);
expect(camera.getEntity()).toBe(entity);
});
});
tests/camera-manager/camera.test.ts
+47 -77
View File
@@ -2,51 +2,69 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { Camera } from '../../src/camera-manager/camera.js';
import { GenericCameraManagerEngine } from '../../src/camera-manager/generic/engine-generic.js';
import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
import {
callHASubscribeMessageHandler,
callStateWatcherCallback,
createCameraConfig,
createCapabilities,
createHASS,
createStateEntity,
} from '../test-utils.js';
describe('Camera', () => {
it('should get config', async () => {
const config = createCameraConfig();
const camera = new Camera(config, new GenericCameraManagerEngine());
const camera = new Camera(
config,
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
);
expect(camera.getConfig()).toBe(config);
});
describe('should get capabilities', async () => {
it('when populated', async () => {
const capabilities = createCapabilities();
const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine(), {
capabilities: capabilities,
});
const camera = new Camera(
createCameraConfig(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
{
capabilities: capabilities,
},
);
expect(camera.getCapabilities()).toBe(capabilities);
});
it('when unpopulated', async () => {
const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
const camera = new Camera(
createCameraConfig(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
);
expect(camera.getCapabilities()).toBeNull();
});
});
it('should get engine', async () => {
const engine = new GenericCameraManagerEngine();
const engine = new GenericCameraManagerEngine(
mock<StateWatcherSubscriptionInterface>(),
);
const camera = new Camera(createCameraConfig(), engine);
expect(camera.getEngine()).toBe(engine);
});
it('should set and get id', async () => {
const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
const camera = new Camera(
createCameraConfig(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
);
camera.setID('foo');
expect(camera.getID()).toBe('foo');
expect(camera.getConfig().id).toBe('foo');
});
it('should throw without id', async () => {
const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
const camera = new Camera(
createCameraConfig(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
);
expect(() => camera.getID()).toThrowError(
'Could not determine camera id for the following ' +
"camera, may need to set 'id' parameter manually",
@@ -60,39 +78,19 @@ describe('Camera', () => {
entities: ['camera.foo'],
},
}),
new GenericCameraManagerEngine(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
);
const hass = createHASS();
const unsubcribeCallback = vi.fn();
vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubcribeCallback);
const stateWatcher = mock<StateWatcherSubscriptionInterface>();
await camera.initialize({
stateWatcher: stateWatcher,
});
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(hass.connection.subscribeMessage).toBeCalledWith(
expect.anything(),
expect.objectContaining({
type: 'subscribe_trigger',
trigger: {
entity_id: ['camera.foo'],
platform: 'state',
from: null,
to: null,
},
}),
);
expect(unsubcribeCallback).not.toBeCalled();
expect(stateWatcher.subscribe).toBeCalledWith(expect.any(Function), ['camera.foo']);
await camera.destroy();
expect(unsubcribeCallback).toBeCalled();
});
it('should not subscribe without trigger entities', async () => {
const camera = new Camera(createCameraConfig(), new GenericCameraManagerEngine());
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(hass.connection.subscribeMessage).not.toBeCalled();
expect(stateWatcher.unsubscribe).toBeCalled();
});
describe('should handle trigger state changes', () => {
@@ -100,28 +98,6 @@ describe('Camera', () => {
vi.restoreAllMocks();
});
it('when malformed', async () => {
vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
const eventCallback = vi.fn();
const camera = new Camera(
createCameraConfig({
triggers: {
entities: ['camera.foo'],
},
}),
new GenericCameraManagerEngine(),
{ eventCallback: eventCallback },
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
callHASubscribeMessageHandler(hass, 'MALFORMED_DATA');
expect(eventCallback).not.toBeCalled();
});
it.each([
['off' as const, 'on' as const, 'new' as const],
['on' as const, 'off' as const, 'end' as const],
@@ -138,28 +114,22 @@ describe('Camera', () => {
entities: ['binary_sensor.foo'],
},
}),
new GenericCameraManagerEngine(),
new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
{ eventCallback: eventCallback },
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
callHASubscribeMessageHandler(hass, {
variables: {
trigger: {
from_state: {
entity_id: 'binary_sensor.foo',
state: stateFrom,
},
to_state: {
entity_id: 'binary_sensor.foo',
state: stateTo,
},
},
},
const stateWatcher = mock<StateWatcherSubscriptionInterface>();
await camera.initialize({
stateWatcher: stateWatcher,
});
const diff = {
entityID: 'sensor.force_update',
oldState: createStateEntity({ state: stateFrom }),
newState: createStateEntity({ state: stateTo }),
};
callStateWatcherCallback(stateWatcher, diff);
expect(eventCallback).toBeCalledWith({
cameraID: 'camera_1',
type: eventType,
tests/camera-manager/engine-factory.test.ts
+20 -11
View File
@@ -1,9 +1,11 @@
import { describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CameraManagerEngineFactory } from '../../src/camera-manager/engine-factory.js';
import { FrigateCameraManagerEngine } from '../../src/camera-manager/frigate/engine-frigate';
import { GenericCameraManagerEngine } from '../../src/camera-manager/generic/engine-generic';
import { MotionEyeCameraManagerEngine } from '../../src/camera-manager/motioneye/engine-motioneye';
import { Engine } from '../../src/camera-manager/types.js';
import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
import { CardWideConfig } from '../../src/config/types.js';
import { EntityRegistryManager } from '../../src/utils/ha/entity-registry';
import { EntityCache } from '../../src/utils/ha/entity-registry/cache';
@@ -20,12 +22,10 @@ vi.mock('../../src/utils/ha/entity-registry/cache');
const createFactory = (options?: {
entityRegistryManager?: EntityRegistryManager;
resolvedMediaCache?: ResolvedMediaCache;
cardWideConfig?: CardWideConfig;
}): CameraManagerEngineFactory => {
return new CameraManagerEngineFactory(
options?.entityRegistryManager ?? new EntityRegistryManager(new EntityCache()),
options?.resolvedMediaCache ?? new ResolvedMediaCache(),
);
};
@@ -181,18 +181,27 @@ describe('getEngineForCamera()', () => {
describe('createEngine()', () => {
it('should create generic engine', async () => {
expect(await createFactory().createEngine(Engine.Generic)).toBeInstanceOf(
GenericCameraManagerEngine,
);
expect(
await createFactory().createEngine(Engine.Generic, {
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
resolvedMediaCache: mock<ResolvedMediaCache>(),
}),
).toBeInstanceOf(GenericCameraManagerEngine);
});
it('should create frigate engine', async () => {
expect(await createFactory().createEngine(Engine.Frigate)).toBeInstanceOf(
FrigateCameraManagerEngine,
);
expect(
await createFactory().createEngine(Engine.Frigate, {
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
resolvedMediaCache: mock<ResolvedMediaCache>(),
}),
).toBeInstanceOf(FrigateCameraManagerEngine);
});
it('should create motioneye engine', async () => {
expect(await createFactory().createEngine(Engine.MotionEye)).toBeInstanceOf(
MotionEyeCameraManagerEngine,
);
expect(
await createFactory().createEngine(Engine.MotionEye, {
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
resolvedMediaCache: mock<ResolvedMediaCache>(),
}),
).toBeInstanceOf(MotionEyeCameraManagerEngine);
});
});
tests/camera-manager/frigate/camera.test.ts
+268 -217
View File
@@ -2,40 +2,25 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CameraManagerEngine } from '../../../src/camera-manager/engine';
import { FrigateCamera } from '../../../src/camera-manager/frigate/camera';
import { FrigateEventWatcher } from '../../../src/camera-manager/frigate/event-watcher';
import { getPTZInfo } from '../../../src/camera-manager/frigate/requests';
import {
FrigateEventChange,
FrigateEventChangeTriggerResponse,
FrigateEventChangeType,
} from '../../../src/camera-manager/frigate/types';
import { FrigateEventChange } from '../../../src/camera-manager/frigate/types';
import { StateWatcher } from '../../../src/card-controller/hass/state-watcher';
import { CameraTriggerEventType } from '../../../src/config/types';
import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
import { Entity } from '../../../src/utils/ha/entity-registry/types';
import {
callHASubscribeMessageHandler,
createCameraConfig,
createHASS,
createRegistryEntity,
} from '../../test-utils';
import { createCameraConfig, createHASS, createRegistryEntity } from '../../test-utils';
vi.mock('../../../src/camera-manager/frigate/requests');
const createFrigateEventChangeTrigger = (
type: FrigateEventChangeType,
before: FrigateEventChange,
after: FrigateEventChange,
): FrigateEventChangeTriggerResponse => {
return {
variables: {
trigger: {
payload_json: {
before: before,
after: after,
type: type,
},
},
},
};
const callEventWatcherCallback = (
eventWatcher: FrigateEventWatcher,
event: FrigateEventChange,
n = 0,
): void => {
const mock = vi.mocked(eventWatcher.subscribe).mock;
expect(mock.calls.length).greaterThan(n);
mock.calls[n][1].callback(event);
};
describe('FrigateCamera', () => {
@@ -51,7 +36,12 @@ describe('FrigateCamera', () => {
const camera = new FrigateCamera(config, mock<CameraManagerEngine>());
const beforeConfig = { ...config };
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(beforeConfig).toEqual(camera.getConfig());
});
@@ -67,7 +57,13 @@ describe('FrigateCamera', () => {
entityRegistryManager.getEntity.mockRejectedValue(null);
expect(
async () => await camera.initialize(createHASS(), entityRegistryManager),
async () =>
await camera.initialize({
hass: createHASS(),
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
).rejects.toThrowError(/Could not find camera entity/);
});
@@ -85,9 +81,13 @@ describe('FrigateCamera', () => {
});
entityRegistryManager.getEntity.mockResolvedValue(entity);
await camera.initialize(createHASS(), entityRegistryManager);
expect(camera.getConfig().frigate.camera_name).toBe('fnt_dr');
await camera.initialize({
hass: createHASS(),
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getConfig().frigate.camera_name).toBe('fnt_dr');
});
it('with a camera_entity without camera_name match', async () => {
@@ -104,9 +104,13 @@ describe('FrigateCamera', () => {
});
entityRegistryManager.getEntity.mockResolvedValue(entity);
await camera.initialize(createHASS(), entityRegistryManager);
expect(camera.getConfig().frigate.camera_name).toBeUndefined();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getConfig().frigate.camera_name).toBeUndefined();
});
it('with a camera_entity without platform match', async () => {
@@ -123,9 +127,13 @@ describe('FrigateCamera', () => {
});
entityRegistryManager.getEntity.mockResolvedValue(entity);
await camera.initialize(createHASS(), entityRegistryManager);
expect(camera.getConfig().frigate.camera_name).toBeUndefined();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getConfig().frigate.camera_name).toBeUndefined();
});
});
});
@@ -141,9 +149,13 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
expect(camera.getCapabilities()?.has('favorite-events')).toBeTruthy();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
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();
@@ -163,9 +175,13 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
expect(camera.getCapabilities()?.has('favorite-events')).toBeFalsy();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
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();
@@ -188,9 +204,14 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
vi.mocked(getPTZInfo).mockRejectedValue(new Error());
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
expect(camera.getCapabilities()?.has('ptz')).toBeFalsy();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getCapabilities()?.has('ptz')).toBeFalsy();
expect(camera.getCapabilities()?.hasPTZCapability()).toBeFalsy();
expect(consoleSpy).toBeCalled();
});
@@ -211,9 +232,14 @@ describe('FrigateCamera', () => {
name: 'front_door',
presets: ['preset01'],
});
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
left: ['continuous'],
right: ['continuous'],
@@ -242,9 +268,14 @@ describe('FrigateCamera', () => {
name: 'front_door',
presets: ['preset01'],
});
await camera.initialize(createHASS(), mock<EntityRegistryManager>());
expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
await camera.initialize({
hass: createHASS(),
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
}),
expect(camera.getCapabilities()?.has('ptz')).toBeTruthy();
expect(camera.getCapabilities()?.getPTZCapabilities()).toEqual({
left: [],
right: [],
@@ -272,17 +303,19 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(hass.connection.subscribeMessage).toBeCalledWith(expect.anything(), {
type: 'subscribe_trigger',
trigger: {
platform: 'mqtt',
topic: `CLIENT_ID/events`,
payload: 'CAMERA',
value_template: '{{ value_json.after.camera }}',
},
});
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
}),
expect(eventWatcher.subscribe).toBeCalledWith(
hass,
expect.objectContaining({
instanceID: 'CLIENT_ID',
}),
);
});
it('should not subscribe with no trigger events', async () => {
@@ -300,9 +333,14 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(hass.connection.subscribeMessage).not.toBeCalled();
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
}),
expect(eventWatcher.subscribe).not.toBeCalled();
});
it('should not subscribe with no camera name', async () => {
@@ -316,9 +354,14 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(hass.connection.subscribeMessage).not.toBeCalled();
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
}),
expect(eventWatcher.subscribe).not.toBeCalled();
});
it('should unsubscribe on destroy', async () => {
@@ -332,79 +375,20 @@ describe('FrigateCamera', () => {
const unsubscribeCallback = vi.fn();
vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubscribeCallback);
await camera.initialize(hass, mock<EntityRegistryManager>());
expect(unsubscribeCallback).not.toBeCalled();
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
}),
expect(eventWatcher.unsubscribe).not.toBeCalled();
await camera.destroy();
expect(unsubscribeCallback).toBeCalled();
expect(eventWatcher.unsubscribe).toBeCalled();
});
describe('should call handler correctly', () => {
it('with malformed Frigate event', async () => {
const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
const camera = new FrigateCamera(
createCameraConfig({
frigate: { camera_name: 'front_door' },
}),
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
callHASubscribeMessageHandler(hass, 'GARBAGE');
expect(consoleSpy).toBeCalledWith(
'Ignoring unparseable Frigate event',
'GARBAGE',
);
});
it('with wrong camera', async () => {
const eventCallback = vi.fn();
const camera = new FrigateCamera(
createCameraConfig({
id: 'CAMERA_1',
frigate: {
camera_name: 'camera.front_door',
},
}),
mock<CameraManagerEngine>(),
{
eventCallback: eventCallback,
},
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
callHASubscribeMessageHandler(
hass,
createFrigateEventChangeTrigger(
'new',
{
camera: 'camera.back_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
{
camera: 'camera.back_door',
snapshot: null,
has_clip: false,
has_snapshot: true,
label: 'person',
current_zones: [],
},
),
);
expect(eventCallback).not.toBeCalled();
});
describe('should handle event type correctly', () => {
it.each([
[
@@ -487,30 +471,33 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
});
callHASubscribeMessageHandler(
hass,
createFrigateEventChangeTrigger(
'new',
{
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
{
camera: 'camera.front_door',
snapshot: null,
has_clip: hasClip,
has_snapshot: hasSnapshot,
label: 'person',
current_zones: [],
},
),
);
callEventWatcherCallback(eventWatcher, {
type: 'new',
before: {
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
after: {
camera: 'camera.front_door',
snapshot: null,
has_clip: hasClip,
has_snapshot: hasSnapshot,
label: 'person',
current_zones: [],
},
});
if (call) {
expect(eventCallback).toBeCalledWith({
@@ -549,30 +536,33 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
});
callHASubscribeMessageHandler(
hass,
createFrigateEventChangeTrigger(
'new',
{
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
{
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: true,
label: 'person',
current_zones: zones,
},
),
);
callEventWatcherCallback(eventWatcher, {
type: 'new',
before: {
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
after: {
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: true,
label: 'person',
current_zones: zones,
},
});
expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
});
@@ -599,32 +589,35 @@ describe('FrigateCamera', () => {
);
const hass = createHASS();
await camera.initialize(hass, mock<EntityRegistryManager>());
const eventWatcher = mock<FrigateEventWatcher>();
await camera.initialize({
hass: hass,
entityRegistryManager: mock<EntityRegistryManager>(),
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: eventWatcher,
});
callHASubscribeMessageHandler(
hass,
createFrigateEventChangeTrigger(
'new',
{
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
// Even new events appear to have the event label in the
// 'before' dictionary.
label: label,
current_zones: [],
},
{
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: true,
label: label,
current_zones: [],
},
),
);
callEventWatcherCallback(eventWatcher, {
type: 'new',
before: {
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
// Even new events appear to have the event label in the
// 'before' dictionary.
label: label,
current_zones: [],
},
after: {
camera: 'camera.front_door',
snapshot: null,
has_clip: false,
has_snapshot: true,
label: label,
current_zones: [],
},
});
expect(eventCallback).toHaveBeenCalledTimes(call ? 1 : 0);
});
@@ -668,8 +661,14 @@ describe('FrigateCamera', () => {
}),
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual([]);
});
@@ -694,8 +693,14 @@ describe('FrigateCamera', () => {
}),
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
});
@@ -719,8 +724,14 @@ describe('FrigateCamera', () => {
}),
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
});
@@ -743,7 +754,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual([]);
});
@@ -767,7 +783,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual([]);
});
@@ -789,7 +810,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual([]);
});
@@ -814,7 +840,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
});
@@ -837,7 +868,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual([]);
});
@@ -866,7 +902,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
});
@@ -896,7 +937,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
expect(camera.getConfig().triggers.entities).toEqual(['binary_sensor.foo']);
});
@@ -922,7 +968,12 @@ describe('FrigateCamera', () => {
mock<CameraManagerEngine>(),
);
const hass = createHASS();
await camera.initialize(hass, entityRegistryManager);
await camera.initialize({
hass: hass,
entityRegistryManager: entityRegistryManager,
stateWatcher: mock<StateWatcher>(),
frigateEventWatcher: mock<FrigateEventWatcher>(),
});
const filterFunc = entityRegistryManager.getMatchingEntities.mock.calls[0][1];
tests/camera-manager/frigate/event-watcher.test.ts
+201
View File
@@ -0,0 +1,201 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { FrigateEventWatcher } from '../../../src/camera-manager/frigate/event-watcher';
import { createHASS } from '../../test-utils';
import { HomeAssistant } from '@dermotduffy/custom-card-helpers';
import { FrigateEventChange } from '../../../src/camera-manager/frigate/types';
const createEventChange = (): FrigateEventChange => {
return {
type: 'new',
before: {
camera: 'front_door',
snapshot: null,
has_clip: false,
has_snapshot: false,
label: 'person',
current_zones: [],
},
after: {
camera: 'front_door',
snapshot: null,
has_clip: true,
has_snapshot: true,
label: 'person',
current_zones: [],
},
};
};
const callHASubscribeMessageCallback = (
hass: HomeAssistant,
data: unknown,
n = 0,
): void => {
const mock = vi.mocked(hass.connection.subscribeMessage).mock;
expect(mock.calls.length).greaterThan(n);
mock.calls[n][0](data);
};
describe('FrigateEventWatcher', () => {
it('should subscribe to a given topic once', async () => {
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
await stateWatcher.subscribe(hass, {
instanceID: 'frigate',
callback: vi.fn(),
});
await stateWatcher.subscribe(hass, {
instanceID: 'frigate',
callback: vi.fn(),
});
expect(hass.connection.subscribeMessage).toBeCalledTimes(1);
});
it('should only subscribe from a given topic once', async () => {
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const unsubscribeCallback = vi.fn();
vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubscribeCallback);
const request_1 = {
instanceID: 'frigate',
callback: vi.fn(),
};
const request_2 = { ...request_1 };
await stateWatcher.subscribe(hass, request_1);
await stateWatcher.subscribe(hass, request_2);
await stateWatcher.unsubscribe(request_1);
expect(unsubscribeCallback).not.toBeCalled();
await stateWatcher.unsubscribe(request_2);
expect(unsubscribeCallback).toBeCalledTimes(1);
});
describe('should call handler', () => {
afterEach(() => {
vi.resetAllMocks();
});
it('with invalid JSON', async () => {
const spy = vi.spyOn(global.console, 'warn').mockImplementation(() => true);
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const callback = vi.fn();
const request = {
instanceID: 'frigate',
callback: callback,
};
await stateWatcher.subscribe(hass, request);
callHASubscribeMessageCallback(hass, 'NOT_JSON');
expect(callback).not.toBeCalled();
expect(spy).toBeCalledWith(
'Received non-JSON payload as Frigate event',
'NOT_JSON',
);
});
it('with malformed event', async () => {
const spy = vi.spyOn(global.console, 'warn').mockImplementation(() => true);
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const callback = vi.fn();
const request = {
instanceID: 'frigate',
callback: callback,
};
await stateWatcher.subscribe(hass, request);
const data = JSON.stringify({});
callHASubscribeMessageCallback(hass, data);
expect(callback).not.toBeCalled();
expect(spy).toBeCalledWith(
'Received malformed Frigate event from Home Assistant',
data,
);
});
it('without a matcher', async () => {
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const callback = vi.fn();
const request = {
instanceID: 'frigate',
callback: callback,
};
await stateWatcher.subscribe(hass, request);
const eventChange = createEventChange();
callHASubscribeMessageCallback(hass, JSON.stringify(eventChange));
expect(callback).toBeCalledWith(eventChange);
});
it('with a non-matching instance_id', async () => {
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const callback_1 = vi.fn();
const request_1 = {
instanceID: 'frigate_1',
callback: callback_1,
};
const callback_2 = vi.fn();
const request_2 = {
instanceID: 'frigate_2',
callback: callback_2,
};
await stateWatcher.subscribe(hass, request_1);
await stateWatcher.subscribe(hass, request_2);
const eventChange = createEventChange();
callHASubscribeMessageCallback(hass, JSON.stringify(eventChange), 1);
expect(callback_1).not.toBeCalledWith(eventChange);
expect(callback_2).toBeCalledWith(eventChange);
});
it('with a matcher', async () => {
const stateWatcher = new FrigateEventWatcher();
const hass = createHASS();
const matching_callback = vi.fn();
const matching_request = {
instanceID: 'frigate',
callback: matching_callback,
matcher: (event: FrigateEventChange) => event.after.camera === 'front_door',
};
const non_matching_callback = vi.fn();
const non_matching_request = {
instanceID: 'frigate',
callback: non_matching_callback,
matcher: (event: FrigateEventChange) => event.after.camera === 'back_door',
};
await stateWatcher.subscribe(hass, matching_request);
await stateWatcher.subscribe(hass, non_matching_request);
const eventChange = createEventChange();
callHASubscribeMessageCallback(hass, JSON.stringify(eventChange));
expect(non_matching_callback).not.toBeCalledWith(eventChange);
expect(matching_callback).toBeCalledWith(eventChange);
});
});
});
tests/camera-manager/generic/engine-generic.test.ts
+3 -7
View File
@@ -2,8 +2,8 @@ import { describe, expect, it } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { GenericCameraManagerEngine } from '../../../src/camera-manager/generic/engine-generic';
import { Engine, QueryResultsType, QueryType } from '../../../src/camera-manager/types';
import { StateWatcherSubscriptionInterface } from '../../../src/card-controller/hass/state-watcher';
import { CameraConfig, RawFrigateCardConfig } from '../../../src/config/types';
import { EntityRegistryManager } from '../../../src/utils/ha/entity-registry';
import {
TestViewMedia,
createCameraConfig,
@@ -13,7 +13,7 @@ import {
} from '../../test-utils';
const createEngine = (): GenericCameraManagerEngine => {
return new GenericCameraManagerEngine();
return new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>());
};
const createGenericCameraConfig = (config?: RawFrigateCardConfig): CameraConfig => {
@@ -27,11 +27,7 @@ describe('GenericCameraManagerEngine', () => {
it('should initialize camera', async () => {
const config = createGenericCameraConfig();
const camera = await createEngine().createCamera(
createHASS(),
mock<EntityRegistryManager>(),
config,
);
const camera = await createEngine().createCamera(createHASS(), config);
expect(camera.getConfig()).toEqual(config);
expect(camera.getCapabilities()).toBeTruthy();
tests/camera-manager/manager.test.ts
+6 -8
View File
@@ -29,7 +29,6 @@ import {
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';
import { ViewMedia } from '../../src/view/media';
import {
TestViewMedia,
@@ -240,11 +239,7 @@ describe('CameraManager', async () => {
camera.engineType === undefined ? Engine.Generic : camera.engineType;
if (engineType) {
vi.mocked(mockEngine.createCamera).mockImplementationOnce(
async (
_hass: HomeAssistant,
_entityRegistryManager: EntityRegistryManager,
cameraConfig: CameraConfig,
): Promise<Camera> =>
async (_hass: HomeAssistant, cameraConfig: CameraConfig): Promise<Camera> =>
createCamera(
cameraConfig,
mockEngine,
@@ -313,6 +308,7 @@ describe('CameraManager', async () => {
'Could not determine camera id for the following camera, ' +
"may need to set 'id' parameter manually",
),
'Camera initialization failed',
);
});
@@ -338,6 +334,7 @@ describe('CameraManager', async () => {
'Duplicate Frigate camera id for the following camera, ' +
"use the 'id' parameter to uniquely identify cameras",
),
'Camera initialization failed',
);
});
@@ -356,6 +353,7 @@ describe('CameraManager', async () => {
expect(await manager.initializeCamerasFromConfig()).toBeFalsy();
expect(api.getMessageManager().setErrorIfHigherPriority).toBeCalledWith(
new Error('Could not determine suitable engine for camera'),
'Camera initialization failed',
);
});
@@ -371,13 +369,13 @@ describe('CameraManager', async () => {
factory,
);
expect(await manager.initializeCamerasFromConfig()).toBeTruthy();
const triggerCallback = factory.createEngine.mock.calls[0][1];
const eventCallback = factory.createEngine.mock.calls[0][1].eventCallback;
const cameraEvent: CameraEvent = {
cameraID: 'camera',
type: 'new',
};
triggerCallback?.(cameraEvent);
eventCallback?.(cameraEvent);
expect(api.getTriggersManager().handleCameraEvent).toBeCalledWith(cameraEvent);
});
tests/camera-manager/store.test.ts
+10 -6
View File
@@ -8,6 +8,7 @@ import { Engine } from '../../src/camera-manager/types.js';
import { EntityRegistryManager } from '../../src/utils/ha/entity-registry/index.js';
import { ResolvedMediaCache } from '../../src/utils/ha/resolved-media.js';
import { TestViewMedia, createCameraConfig } from '../test-utils.js';
import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
describe('CameraManagerStore', async () => {
const configVisible = createCameraConfig({
@@ -18,13 +19,16 @@ describe('CameraManagerStore', async () => {
hide: true,
});
const engineFactory = new CameraManagerEngineFactory(
mock<EntityRegistryManager>(),
mock<ResolvedMediaCache>(),
);
const engineFactory = new CameraManagerEngineFactory(mock<EntityRegistryManager>());
const engineGeneric = await engineFactory.createEngine(Engine.Generic);
const engineFrigate = await engineFactory.createEngine(Engine.Frigate);
const engineGeneric = await engineFactory.createEngine(Engine.Generic, {
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
resolvedMediaCache: mock<ResolvedMediaCache>(),
});
const engineFrigate = await engineFactory.createEngine(Engine.Frigate, {
stateWatcher: mock<StateWatcherSubscriptionInterface>(),
resolvedMediaCache: mock<ResolvedMediaCache>(),
});
const setupStore = (): CameraManagerStore => {
const store = new CameraManagerStore();
tests/card-controller/card-element-manager.test.ts
+70 -1
View File
@@ -1,7 +1,14 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CardElementManager } from '../../src/card-controller/card-element-manager';
import { createCardAPI, createLitElement } from '../test-utils';
import { StateWatcher } from '../../src/card-controller/hass/state-watcher';
import {
callStateWatcherCallback,
createCardAPI,
createConfig,
createLitElement,
createStateEntity,
} from '../test-utils';
// @vitest-environment jsdom
describe('CardElementManager', () => {
@@ -191,4 +198,66 @@ describe('CardElementManager', () => {
expect(api.getActionsManager().uninitialize).toBeCalled();
expect(api.getInitializationManager().uninitialize).toBeCalledWith('cameras');
});
describe('should update card when', () => {
it('render entity changes', () => {
const api = createCardAPI();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
render_entities: ['sensor.force_update'],
},
}),
);
const stateWatcher = mock<StateWatcher>();
vi.mocked(api.getHASSManager().getStateWatcher).mockReturnValue(stateWatcher);
const element = createLitElement();
const manager = new CardElementManager(
api,
element,
() => undefined,
() => undefined,
);
manager.elementConnected();
const diff = {
entityID: 'sensor.force_update',
newState: createStateEntity({ state: 'off' }),
};
callStateWatcherCallback(stateWatcher, diff);
expect(element.requestUpdate).toBeCalled();
});
it('media player entity changes', () => {
const api = createCardAPI();
vi.mocked(api.getMediaPlayerManager().getMediaPlayers).mockReturnValue([
'media_player.foo',
]);
const stateWatcher = mock<StateWatcher>();
vi.mocked(api.getHASSManager().getStateWatcher).mockReturnValue(stateWatcher);
const element = createLitElement();
const manager = new CardElementManager(
api,
element,
() => undefined,
() => undefined,
);
manager.elementConnected();
const diff = {
entityID: 'sensor.force_update',
newState: createStateEntity({ state: 'off' }),
};
callStateWatcherCallback(stateWatcher, diff);
expect(element.requestUpdate).toBeCalled();
});
});
});
tests/card-controller/controller.test.ts
+3 -3
View File
@@ -14,7 +14,7 @@ import { DefaultManager } from '../../src/card-controller/default-manager';
import { DownloadManager } from '../../src/card-controller/download-manager';
import { ExpandManager } from '../../src/card-controller/expand-manager';
import { FullscreenManager } from '../../src/card-controller/fullscreen-manager';
import { HASSManager } from '../../src/card-controller/hass-manager';
import { HASSManager } from '../../src/card-controller/hass/hass-manager';
import { InitializationManager } from '../../src/card-controller/initialization-manager';
import { InteractionManager } from '../../src/card-controller/interaction-manager';
import { KeyboardStateManager } from '../../src/card-controller/keyboard-state-manager';
@@ -23,13 +23,13 @@ import { MediaPlayerManager } from '../../src/card-controller/media-player-manag
import { MessageManager } from '../../src/card-controller/message-manager';
import { MicrophoneManager } from '../../src/card-controller/microphone-manager';
import { QueryStringManager } from '../../src/card-controller/query-string-manager';
import { StatusBarItemManager } from '../../src/card-controller/status-bar-item-manager';
import { StyleManager } from '../../src/card-controller/style-manager';
import { TriggersManager } from '../../src/card-controller/triggers-manager';
import { ViewManager } from '../../src/card-controller/view/view-manager';
import { FrigateCardEditor } from '../../src/editor';
import { EntityRegistryManager } from '../../src/utils/ha/entity-registry';
import { ResolvedMediaCache } from '../../src/utils/ha/resolved-media';
import { StatusBarItemManager } from '../../src/card-controller/status-bar-item-manager';
vi.mock('../../src/camera-manager/manager');
vi.mock('../../src/card-controller/actions/actions-manager');
@@ -42,7 +42,7 @@ vi.mock('../../src/card-controller/default-manager');
vi.mock('../../src/card-controller/download-manager');
vi.mock('../../src/card-controller/expand-manager');
vi.mock('../../src/card-controller/fullscreen-manager');
vi.mock('../../src/card-controller/hass-manager');
vi.mock('../../src/card-controller/hass/hass-manager');
vi.mock('../../src/card-controller/initialization-manager');
vi.mock('../../src/card-controller/interaction-manager');
vi.mock('../../src/card-controller/keyboard-state-manager');
tests/card-controller/default-manager.test.ts
+44 -58
View File
@@ -1,12 +1,24 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CardController } from '../../src/card-controller/controller';
import { DefaultManager } from '../../src/card-controller/default-manager';
import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher';
import {
callHASubscribeMessageHandler,
callStateWatcherCallback,
createCardAPI,
createConfig,
createHASS,
createStateEntity,
} from '../test-utils';
const createCardAPIWithStateWatcher = (): CardController => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().getStateWatcher).mockReturnValue(
mock<StateWatcherSubscriptionInterface>(),
);
return api;
};
// @vitest-environment jsdom
describe('DefaultManager', () => {
afterEach(() => {
@@ -15,7 +27,7 @@ describe('DefaultManager', () => {
describe('time based', () => {
it('should set default view when allowed', async () => {
const api = createCardAPI();
const api = createCardAPIWithStateWatcher();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
@@ -75,7 +87,7 @@ describe('DefaultManager', () => {
});
it('should restart timer when reconfigured', async () => {
const api = createCardAPI();
const api = createCardAPIWithStateWatcher();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
@@ -88,8 +100,6 @@ describe('DefaultManager', () => {
vi.mocked(api.getInteractionManager().hasInteraction).mockReturnValue(false);
const hass = createHASS();
const unsubcribeCallback = vi.fn();
vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubcribeCallback);
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
vi.useFakeTimers();
@@ -99,71 +109,47 @@ describe('DefaultManager', () => {
await manager.initialize();
expect(api.getViewManager().setViewDefault).not.toBeCalled();
await manager.initialize();
expect(api.getViewManager().setViewDefault).not.toBeCalled();
vi.runOnlyPendingTimers();
expect(api.getViewManager().setViewDefault).toBeCalled();
});
});
describe('state based', () => {
it('should set default view when state changed', async () => {
const api = createCardAPI();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
default_reset: {
every_seconds: 10,
},
},
}),
);
vi.mocked(api.getInteractionManager().hasInteraction).mockReturnValue(false);
const hass = createHASS();
const unsubcribeCallback = vi.fn();
vi.mocked(hass.connection.subscribeMessage).mockResolvedValue(unsubcribeCallback);
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new DefaultManager(api);
await manager.initialize();
callHASubscribeMessageHandler(hass, {
variables: {
trigger: {
from_state: {
entity_id: 'binary_sensor.foo',
state: 'off',
},
to_state: {
entity_id: 'binary_sensor.foo',
state: 'on',
},
it('should set default view when state changed', async () => {
const api = createCardAPIWithStateWatcher();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
default_reset: {
entities: ['binary_sensor.foo'],
every_seconds: 10,
},
},
});
}),
);
vi.mocked(api.getInteractionManager().hasInteraction).mockReturnValue(false);
await manager.initialize();
expect(unsubcribeCallback).toBeCalledTimes(1);
const hass = createHASS();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
expect(api.getViewManager().setViewDefault).toBeCalledTimes(1);
const manager = new DefaultManager(api);
await manager.initialize();
callStateWatcherCallback(api.getHASSManager().getStateWatcher(), {
entityID: 'binary_sensor.foo',
oldState: createStateEntity({ state: 'off' }),
newState: createStateEntity({ state: 'on' }),
});
it('should not monitor state without config', async () => {
const api = createCardAPI();
const hass = createHASS();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new DefaultManager(api);
await manager.initialize();
const mock = vi.mocked(hass.connection.subscribeMessage).mock;
expect(mock.calls.length).toBe(0);
});
expect(api.getViewManager().setViewDefault).toBeCalled();
});
describe('interaction based', () => {
it('should not register automation on initialization', async () => {
const api = createCardAPI();
const api = createCardAPIWithStateWatcher();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
@@ -182,7 +168,7 @@ describe('DefaultManager', () => {
});
it('should register automation on initialization', async () => {
const api = createCardAPI();
const api = createCardAPIWithStateWatcher();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
@@ -216,10 +202,10 @@ describe('DefaultManager', () => {
]);
});
it('should remove automation on uninitalize', async () => {
const api = createCardAPI();
it('should remove automation on uninitalize', () => {
const api = createCardAPIWithStateWatcher();
const manager = new DefaultManager(api);
await manager.uninitialize();
manager.uninitialize();
expect(api.getAutomationsManager().deleteAutomations).toBeCalledWith(manager);
});
tests/card-controller/hass-manager.test.ts → tests/card-controller/hass/hass-manager.test.ts
+17 -56
View File
@@ -1,6 +1,6 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { CardController } from '../../src/card-controller/controller';
import { HASSManager } from '../../src/card-controller/hass-manager';
import { HASSManager } from '../../../src/card-controller/hass/hass-manager';
import { StateWatcher } from '../../../src/card-controller/hass/state-watcher';
import {
createCameraConfig,
createCameraManager,
@@ -11,13 +11,7 @@ import {
createStore,
createUser,
createView,
} from '../test-utils';
const createAPIWithoutMediaPlayers = (): CardController => {
const api = createCardAPI();
vi.mocked(api.getMediaPlayerManager().getMediaPlayers).mockReturnValue([]);
return api;
};
} from '../../test-utils';
describe('HASSManager', () => {
beforeEach(() => {
@@ -29,8 +23,13 @@ describe('HASSManager', () => {
expect(manager.getHASS()).toBeNull();
});
it('should get state watcher', () => {
const manager = new HASSManager(createCardAPI());
expect(manager.getStateWatcher()).toEqual(expect.any(StateWatcher));
});
it('should set light or dark mode upon setting hass', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
manager.setHASS(createHASS());
@@ -40,7 +39,7 @@ describe('HASSManager', () => {
describe('should set condition manager state', () => {
it('positively', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
vi.mocked(api.getConditionsManager().hasHAStateConditions).mockReturnValue(true);
@@ -59,7 +58,7 @@ describe('HASSManager', () => {
});
it('negatively', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
vi.mocked(api.getConditionsManager().hasHAStateConditions).mockReturnValue(false);
@@ -71,7 +70,7 @@ describe('HASSManager', () => {
describe('should handle connection state change when', () => {
it('initially disconnected', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
const disconnectedHASS = createHASS();
@@ -90,7 +89,7 @@ describe('HASSManager', () => {
});
it('disconnected', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
manager.setHASS(createHASS());
@@ -110,7 +109,7 @@ describe('HASSManager', () => {
});
it('reconnected', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
const disconnectedHASS = createHASS();
@@ -124,7 +123,7 @@ describe('HASSManager', () => {
});
it('hass is null', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
const manager = new HASSManager(api);
const connectedHASS = createHASS();
connectedHASS.connected = true;
@@ -148,7 +147,7 @@ describe('HASSManager', () => {
describe('should not set default view when', () => {
it('selected camera is unknown', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
vi.mocked(api.getCameraManager).mockReturnValue(createCameraManager());
vi.mocked(api.getCameraManager().getStore).mockReturnValue(
createStore([
@@ -179,7 +178,7 @@ describe('HASSManager', () => {
});
it('when there is card interaction', () => {
const api = createAPIWithoutMediaPlayers();
const api = createCardAPI();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
@@ -201,42 +200,4 @@ describe('HASSManager', () => {
expect(api.getViewManager().setViewDefault).not.toBeCalled();
});
});
describe('should update card when', () => {
it('render entity changes', () => {
const api = createAPIWithoutMediaPlayers();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
view: {
render_entities: ['sensor.force_update'],
},
}),
);
const manager = new HASSManager(api);
const hass = createHASS({
'sensor.force_update': createStateEntity(),
});
manager.setHASS(hass);
expect(api.getCardElementManager().update).toBeCalled();
});
it('media player entity changes', () => {
const api = createCardAPI();
vi.mocked(api.getMediaPlayerManager().getMediaPlayers).mockReturnValue([
'media_player.foo',
]);
const manager = new HASSManager(api);
const hass = createHASS({
'media_player.foo': createStateEntity(),
});
manager.setHASS(hass);
expect(api.getCardElementManager().update).toBeCalled();
});
});
});
tests/card-controller/hass/state-watcher.test.ts
+101
View File
@@ -0,0 +1,101 @@
import { describe, expect, it, vi } from 'vitest';
import { StateWatcher } from '../../../src/card-controller/hass/state-watcher';
import { createHASS, createStateEntity } from '../../test-utils';
describe('StateWatcher', () => {
it('should not subscribe with no entities', () => {
const stateWatcher = new StateWatcher();
const callback = vi.fn();
expect(stateWatcher.subscribe(callback, [])).toBeFalsy();
});
it('should call back with state change', () => {
const stateWatcher = new StateWatcher();
const callback = vi.fn();
expect(stateWatcher.subscribe(callback, ['binary_sensor.foo'])).toBeTruthy();
expect(stateWatcher.subscribe(callback, ['binary_sensor.bar'])).toBeTruthy();
stateWatcher.setHASS(
null,
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'off' }),
}),
);
expect(callback).not.toBeCalled();
stateWatcher.setHASS(
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'off' }),
}),
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'on' }),
}),
);
expect(callback).toBeCalledTimes(1);
expect(callback).toBeCalledWith(
expect.objectContaining({
entityID: 'binary_sensor.bar',
oldState: createStateEntity({ state: 'off' }),
newState: createStateEntity({ state: 'on' }),
}),
);
});
it('should not call back without state change', () => {
const stateWatcher = new StateWatcher();
const callback = vi.fn();
expect(stateWatcher.subscribe(callback, ['binary_sensor.foo'])).toBeTruthy();
stateWatcher.setHASS(
null,
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
);
expect(callback).not.toBeCalled();
stateWatcher.setHASS(
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
);
expect(callback).not.toBeCalled();
});
it('should not call back when unsubscribed', () => {
const stateWatcher = new StateWatcher();
const callback = vi.fn();
expect(stateWatcher.subscribe(callback, ['binary_sensor.foo'])).toBeTruthy();
expect(stateWatcher.unsubscribe(callback));
stateWatcher.setHASS(
null,
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
);
expect(callback).not.toBeCalled();
stateWatcher.setHASS(
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
createHASS({
'binary_sensor.foo': createStateEntity({ state: 'off' }),
}),
);
expect(callback).not.toBeCalled();
});
});
tests/card-controller/message-manager.test.ts
+16
View File
@@ -144,6 +144,22 @@ describe('MessageManager', () => {
expect(consoleSpy).toBeCalled();
});
it('should set error with prefix', () => {
const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
const api = createCardAPI();
const manager = new MessageManager(api);
manager.setErrorIfHigherPriority(new Error('generic error message'), 'PREFIX');
expect(manager.hasMessage()).toBeTruthy();
expect(manager.getMessage()).toEqual({
message: 'PREFIX: generic error message',
type: 'error',
});
expect(consoleSpy).toBeCalled();
});
it('should not set unknown error type', () => {
const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
tests/test-utils.ts
+14 -12
View File
@@ -1,8 +1,4 @@
import {
CurrentUser,
HASSDomEvent,
HomeAssistant,
} from '@dermotduffy/custom-card-helpers';
import { CurrentUser, HASSDomEvent } from '@dermotduffy/custom-card-helpers';
import { HassEntities, HassEntity } from 'home-assistant-js-websocket';
import { LitElement } from 'lit';
import { expect, vi } from 'vitest';
@@ -29,7 +25,8 @@ import { DefaultManager } from '../src/card-controller/default-manager';
import { DownloadManager } from '../src/card-controller/download-manager';
import { ExpandManager } from '../src/card-controller/expand-manager';
import { FullscreenManager } from '../src/card-controller/fullscreen-manager';
import { HASSManager } from '../src/card-controller/hass-manager';
import { HASSManager } from '../src/card-controller/hass/hass-manager';
import { StateWatcherSubscriptionInterface } from '../src/card-controller/hass/state-watcher';
import { InitializationManager } from '../src/card-controller/initialization-manager';
import { InteractionManager } from '../src/card-controller/interaction-manager';
import { KeyboardStateManager } from '../src/card-controller/keyboard-state-manager';
@@ -57,6 +54,7 @@ import {
performanceConfigSchema,
} from '../src/config/types';
import { CapabilitiesRaw, ExtendedHomeAssistant, MediaLoadedInfo } from '../src/types';
import { HassStateDifference } from '../src/utils/ha';
import { EntityRegistryManager } from '../src/utils/ha/entity-registry';
import { Entity } from '../src/utils/ha/entity-registry/types';
import { ViewMedia, ViewMediaType } from '../src/view/media';
@@ -213,7 +211,11 @@ export const createStore = (
const eventCallback = cameraProps.eventCallback ?? vi.fn();
const camera = new Camera(
cameraProps.config ?? createCameraConfig(),
cameraProps.engine ?? new GenericCameraManagerEngine(eventCallback),
cameraProps.engine ??
new GenericCameraManagerEngine(
mock<StateWatcherSubscriptionInterface>(),
eventCallback,
),
{
capabilities:
cameraProps.capabilities === undefined
@@ -464,14 +466,14 @@ export const createCardAPI = (): CardController => {
return api;
};
export const callHASubscribeMessageHandler = (
hass: HomeAssistant,
ev: unknown,
export const callStateWatcherCallback = (
stateWatcher: StateWatcherSubscriptionInterface,
diff: HassStateDifference,
n = 0,
): void => {
const mock = vi.mocked(hass.connection.subscribeMessage).mock;
const mock = vi.mocked(stateWatcher.subscribe).mock;
expect(mock.calls.length).greaterThan(n);
mock.calls[n][0](ev);
mock.calls[n][0](diff);
};
/**
tests/utils/basic.test.ts
+16 -11
View File
@@ -103,36 +103,40 @@ describe('contentsChanged', () => {
describe('errorToConsole', () => {
const spy = vi.spyOn(global.console, 'warn').mockImplementation(() => true);
afterAll(() => {
vi.restoreAllMocks();
});
it('should log given error', () => {
const error = new Error();
const error = new Error('ERROR');
errorToConsole(error);
expect(spy).toHaveBeenCalledWith(error);
expect(spy).toHaveBeenCalledWith('ERROR');
});
it('should log with context given frigate card error', () => {
const data = { foo: 2 };
const error = new FrigateCardError('foo', { foo: 2 });
const error = new FrigateCardError('ERROR', { foo: 2 });
errorToConsole(error);
expect(spy).toHaveBeenCalledWith(error, data);
});
it('should log with custom function', () => {
const func = vi.fn();
const error = new Error();
const error = new Error('ERROR');
errorToConsole(error, func);
expect(func).toHaveBeenCalledWith(error);
expect(func).toHaveBeenCalledWith('ERROR');
});
});
describe('isHoverableDevice', () => {
afterAll(() => {
vi.restoreAllMocks();
});
it('should return hoverable', () => {
const spy = vi
.spyOn(window, 'matchMedia')
.mockReturnValue(<MediaQueryList>{ matches: true });
vi.spyOn(window, 'matchMedia').mockReturnValue(<MediaQueryList>{ matches: true });
expect(isHoverableDevice()).toBeTruthy();
});
it('should return not hoverable', () => {
const spy = vi
.spyOn(window, 'matchMedia')
.mockReturnValue(<MediaQueryList>{ matches: false });
vi.spyOn(window, 'matchMedia').mockReturnValue(<MediaQueryList>{ matches: false });
expect(isHoverableDevice()).toBeFalsy();
});
});
@@ -225,6 +229,7 @@ describe('sleep', () => {
it('should sleep', async () => {
const spy = vi
.spyOn(global, 'setTimeout')
// eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
.mockImplementation((func: () => unknown, _time?: number): any => {
func();
});
tests/utils/ha/index.test.ts
+1 -105
View File
@@ -1,10 +1,8 @@
import { HomeAssistant } from '@dermotduffy/custom-card-helpers';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { describe, expect, it } from 'vitest';
import {
getEntityIcon,
hasHAConnectionStateChanged,
parseStateChangeTrigger,
subscribeToTrigger,
} from '../../../src/utils/ha/index.js';
import { createHASS, createStateEntity } from '../../test-utils.js';
@@ -69,105 +67,3 @@ describe('getEntityIcon', () => {
expect(getEntityIcon(createHASS(), 'camera.test')).toBe('mdi:video');
});
});
describe('should subscribe to trigger', () => {
it('mqtt', async () => {
const hass = createHASS();
const callback = vi.fn();
await subscribeToTrigger(hass, callback, {
platform: 'mqtt',
topic: 'topic',
payload: 'payload',
valueTemplate: 'value_template',
});
expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
type: 'subscribe_trigger',
trigger: {
platform: 'mqtt',
topic: 'topic',
payload: 'payload',
value_template: 'value_template',
},
});
});
it('state and attributes', async () => {
const hass = createHASS();
const callback = vi.fn();
await subscribeToTrigger(hass, callback, {
platform: 'state',
entityID: 'camera.foo',
});
expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
type: 'subscribe_trigger',
trigger: {
platform: 'state',
entity_id: 'camera.foo',
},
});
});
it('state only', async () => {
const hass = createHASS();
const callback = vi.fn();
await subscribeToTrigger(hass, callback, {
platform: 'state',
entityID: 'camera.foo',
stateOnly: true,
});
expect(hass.connection.subscribeMessage).toBeCalledWith(callback, {
type: 'subscribe_trigger',
trigger: {
platform: 'state',
entity_id: 'camera.foo',
from: null,
to: null,
},
});
});
});
describe('should parse state change response', () => {
beforeEach(() => {
vi.restoreAllMocks();
});
it('malformed response', async () => {
const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
expect(parseStateChangeTrigger('INVALID')).toBeNull();
expect(consoleSpy).toBeCalledWith('Ignoring unparseable HA state change', 'INVALID');
});
it('valid response', async () => {
const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
const stateChange = {
from_state: {
entity_id: 'camera.foo',
state: 'off',
},
to_state: {
entity_id: 'camera.foo',
state: 'on',
},
};
expect(
parseStateChangeTrigger({
variables: {
trigger: stateChange,
},
}),
).toEqual(stateChange);
expect(consoleSpy).not.toBeCalled();
});
});