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

feat: Align automations with Home Assistant triggers and conditions (#2527)

Browse Source 
Split automations into HA-style `triggers`, ongoing `conditions`, and
`actions`, with compatibility migrations for existing Advanced Camera
Card configs.

## Summary

At a glance (details below):

- **Added** `triggers:` -- a required, HA-shaped block: stock `state` /
`numeric_state` / `template` plus card-specific triggers (`camera`,
`view`, `fullscreen`, ...).
- **Added** the HA-native `if` / `then` / `else` action.
- **Removed** `actions_not` (replaced by `if` / `then` / `else`).
- **Removed** the ambient `advanced_camera_card` template namespace (use
`acc` instead).
- **Changed** the trigger template surface to a top-level `trigger.*`
variable (as in HA); the nested `acc.trigger.*` paths are removed.
- **Changed** `conditions:` to ongoing gates only -- they no longer wake
an automation, and change-only forms (`config`, valueless `camera` /
`view` / `state`) become triggers, not conditions.
- **Changed** action templates to render per step, so a later action
sees state an earlier one changed.
- **Compatibility:** HA-shaped YAML is accepted (singular keys,
single-or-list, `and` / `or` / `not` shorthand, `entity` / `entity_id`).
- **Migration:** existing configs upgrade automatically; anything that
cannot be converted faithfully is recorded under `__UPGRADE_FAILURE__`
for manual fixup.

## Breaking Changes

### 1. Automations now require triggers

Before this PR, `automations[].conditions` served two roles:

- They decided whether the automation should run.
- They also acted as the thing that woke the automation up.

After this PR:

- `triggers` wake the automation.
- `conditions` only gate it at the instant a trigger fires.

Most existing automations are migrated automatically from `conditions:`
to `triggers:`.

### 2. `actions_not` is retired

Legacy `actions_not` is replaced by an HA-style `if` action with `then`
/ `else`.

Faithful conversions are automatic. Cases that cannot be faithfully
converted are recorded under `__UPGRADE_FAILURE__.automations` and must
be migrated manually.

### 3. Template surface aligned with Home Assistant

Two related template changes, both auto-migrated:

- **Top-level `trigger.*`.** Automation actions now receive a top-level
`trigger` template variable, like Home Assistant. Legacy nested paths
such as `acc.trigger.state.to` and
`advanced_camera_card.trigger.camera.to` are migrated automatically when
they appear inside template strings.
- **The ambient `advanced_camera_card` template namespace is removed.**
The long-form ambient namespace (`advanced_camera_card.camera`,
`advanced_camera_card.view`, `advanced_camera_card.config`) is retired
in favour of its shorter `acc` alias -- supported since v7.1.0, and the
only spelling the new trigger surface uses. Existing templates are
migrated automatically by rewriting the `advanced_camera_card.` prefix
to `acc.`.

### 4. Trigger-only condition forms are no longer valid conditions

Some legacy "conditions" were really change detectors. These are now
triggers only:

- `condition: config`
- valueless `camera`
- valueless `view`
- valueless `state` / picture-elements state condition with neither
`state` nor `state_not`

These are automatically promoted in automations and stripped from
overrides/elements where they would no longer be meaningful as ongoing
conditions.

### 5. Template truthiness now follows Home Assistant behavior

Template conditions and template triggers intentionally use different
truthiness rules, matching HA:

- A template condition passes only when the rendered value is `true`
(case-insensitive), matching HA's `condition.py`.
- A template trigger uses HA's broader `result_as_boolean` coercion: a
non-zero number, or `1` / `true` / `yes` / `on` / `enable`
(case-insensitive), counts as true.

### 6. Action templates render when each action executes

Action templates are now rendered per action step, not once for the
whole sequence. This means a later action can see card-local state
changed by an earlier action in the same sequence.

The `trigger` context is fixed for the automation run. HA entity state
updates still depend on the frontend receiving updated HASS state over
the websocket.

## Automatic Migrations

### Automation `conditions:` to `triggers:`

Simple legacy automation:

```yaml
# Before
automations:
  - conditions:
      - condition: fullscreen
        fullscreen: true
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: substream_on
```

```yaml
# After, automatic
automations:
  - triggers:
      - trigger: fullscreen
        fullscreen: true
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: substream_on
```

State conditions become HA-style state triggers:

```yaml
# Before
automations:
  - conditions:
      - condition: state
        entity_id: binary_sensor.front_door
        state: 'on'
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: live
```

```yaml
# After, automatic
automations:
  - triggers:
      - trigger: state
        entity_id: binary_sensor.front_door
        to: 'on'
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: live
```

Multiple conditions become both triggers and ongoing conditions:

```yaml
# Before
automations:
  - conditions:
      - condition: camera
        cameras: [front_door]
      - condition: fullscreen
        fullscreen: true
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: substream_on
```

```yaml
# After, automatic
automations:
  - triggers:
      - trigger: camera
        cameras: [front_door]
      - trigger: fullscreen
        fullscreen: true
    conditions:
      - condition: camera
        cameras: [front_door]
      - condition: fullscreen
        fullscreen: true
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: substream_on
```

The flattened trigger list is an implicit OR. The retained `conditions:`
list is an implicit AND checked when any trigger fires.

### Trigger-only legacy conditions

Legacy `config` conditions become `config` triggers:

```yaml
# Before
automations:
  - conditions:
      - condition: config
        paths: [menu.style]
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: status_bar
```

```yaml
# After, automatic
automations:
  - triggers:
      - trigger: config
        paths: [menu.style]
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: status_bar
```

Trigger-only leaves are removed from retained `conditions:` blocks
because they no longer describe an ongoing state.

### `actions_not` to `if` / `then` / `else`

```yaml
# Before
automations:
  - conditions:
      - condition: state
        entity_id: input_boolean.camera_alerts
        state: 'on'
    actions:
      - action: custom:advanced-camera-card-action
        advanced_camera_card_action: live
    actions_not:
      - action: none
```

```yaml
# After, automatic
automations:
  - triggers:
      - trigger: state
        entity_id: input_boolean.camera_alerts
    actions:
      - if:
          - condition: state
            entity_id: input_boolean.camera_alerts
            state: 'on'
        then:
          - action: custom:advanced-camera-card-action
            advanced_camera_card_action: live
        else:
          - action: none
```

If the legacy automation had no conditions, or only trigger-only
conditions, `actions_not` is dropped because the old `else` branch could
not be reproduced as an ongoing predicate.

### Trigger template paths

```yaml
# Before
message: 'Door is {{ acc.trigger.state.to }} from {{ acc.trigger.state.from }}'
```

```yaml
# After, automatic
message: 'Door is {{ trigger.to_state.state }} from {{ trigger.from_state.state }}'
```

Path rewrites performed automatically:

| Old path                   | New path                   |
| -------------------------- | -------------------------- |
| `acc.trigger.state.entity` | `trigger.entity_id`        |
| `acc.trigger.state.from`   | `trigger.from_state.state` |
| `acc.trigger.state.to`     | `trigger.to_state.state`   |
| `acc.trigger.camera.from`  | `trigger.from_acc.camera`  |
| `acc.trigger.camera.to`    | `trigger.to_acc.camera`    |
| `acc.trigger.view.from`    | `trigger.from_acc.view`    |
| `acc.trigger.view.to`      | `trigger.to_acc.view`      |
| `acc.trigger.config.from`  | `trigger.from_acc.config`  |
| `acc.trigger.config.to`    | `trigger.to_acc.config`    |

The same rewrites are applied for the older
`advanced_camera_card.trigger.*` namespace.

### Ambient template namespace

Any remaining long-form ambient `advanced_camera_card.*` references
(outside the trigger surface) are rewritten to the `acc.*` alias:

```yaml
# Before
title: 'Now viewing {{ advanced_camera_card.camera }}'
```

```yaml
# After, automatic
title: 'Now viewing {{ acc.camera }}'
```

## Manual Migration Cases

### `__UPGRADE_FAILURE__.automations`

If a legacy automation cannot be converted faithfully, the original
automation is recorded under:

```yaml
__UPGRADE_FAILURE__:
  automations:
    - ...
```

These entries require manual migration.

The main known case is legacy `actions_not` with a condition whose
trigger can only fire on a rising edge, such as:

- `condition: template`
- `condition: screen`
- `condition: numeric_state` without an entity-backed state to watch

Those conditions can start the `then` branch, but cannot reliably start
the `else` branch when they stop matching.

### Unsupported HA conditions and triggers

This PR aligns the card with HA where supported, but it is not a full HA
automation engine.

Unsupported HA condition families include:

- `time`
- `zone`
- `sun`
- `location`
- `device`
- `condition: trigger`

Unsupported HA trigger platforms include:

- `event`
- `time`
- `time_pattern`
- `sun`
- `zone`
- `calendar`
- `webhook`
- `tag`
- `device`
- `mqtt`

The card-specific camera `triggers:` feature (which auto-selects and
wakes the card on camera events such as motion) is a separate feature
from automation `triggers:`, despite the shared word.

### Trigger IDs and variables

HA keys such as `id`, `alias`, and `variables` are accepted so pasted HA
YAML validates, but they are ignored by the card. There is no
`trigger.id` support in this PR.

## New Compatibility Features

This PR also makes card config more forgiving for HA-style YAML:

- `trigger`, `condition`, and `action` singular keys are accepted and
normalized to `triggers`, `conditions`, and `actions`.
- Single trigger, condition, and action objects are accepted where lists
are expected.
- `if`, `then`, and `else` accept a single item or a list.
- Composite condition shorthand is accepted:
  - `{ and: [...] }`
  - `{ or: [...] }`
  - `{ not: [...] }`
  - `{ condition: [...] }` as an implicit AND
- State conditions resolve expected state values that name another
entity, matching HA/Lovelace behavior.
- Both `entity` and `entity_id` are accepted on state and numeric
conditions and triggers (a superset of HA's two dialects), so there is
no forced rename.
- `state_not` remains supported as a card/Lovelace-friendly extension.

## Trigger Payloads

Automation action templates receive a top-level `trigger` object.

For stock `state` and `numeric_state` triggers:

```yaml
trigger.platform
trigger.entity_id
trigger.entity
trigger.from_state
trigger.to_state
```

For template triggers:

```yaml
trigger.platform
```

For card-specific triggers:

```yaml
trigger.platform # "acc"
trigger.type
trigger.from_acc
trigger.to_acc
```

The card does not currently expose HA's `id`, `idx`, `for`, `attribute`,
`above`, `below`, or `alias` trigger fields.

BREAKING CHANGE: Automations now follow Home Assistant's `triggers:` /
`conditions:` / `actions:` model. Automations require a `triggers:`
block and `conditions:` no longer wake an automation; `actions_not` is
removed in favour of an `if` / `then` / `else` action; the nested
`acc.trigger.*` template paths and the ambient `advanced_camera_card`
template namespace are removed (use the top-level `trigger.*` surface
and the `acc` alias); trigger-only condition forms (`config`, valueless
`camera` / `view` / `state`) are no longer valid conditions; and
template-condition vs template-trigger truthiness now follow HA.
Existing configs are upgraded automatically where a faithful conversion
exists; anything that cannot be converted is recorded under
`__UPGRADE_FAILURE__` for manual migration.

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Dermot Duffy
2026-06-30 17:45:13 -07:00
committed by dermotduffy
co-authored by Claude Opus 4.8
parent 209c873c58
commit b701366762
354 changed files with 11386 additions and 3020 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/camera-manager/manager.test.ts
+3 -1
View File
@@ -481,7 +481,9 @@ describe('CameraManager', () => {
type: 'new',
};
eventCallback?.(cameraEvent);
expect(api.getTriggersManager().handleCameraEvent).toBeCalledWith(cameraEvent);
expect(api.getCameraTriggersManager().handleCameraEvent).toBeCalledWith(
cameraEvent,
);
});
describe('should fetch entity list when required', () => {
tests/card-controller/actions/actions-manager.test.ts
+224 -9
View File
@@ -17,7 +17,10 @@ import {
import type { CardController } from '../../../src/card-controller/controller';
import { TemplateRenderer } from '../../../src/card-controller/templates';
import { AdvancedCameraCardView } from '../../../src/config/schema/common/const';
import { createGeneralAction, createLogAction } from '../../../src/utils/action';
import {
createInternalCallbackAction,
createLogAction,
} from '../../../src/utils/action';
import { arrayify } from '../../../src/utils/basic';
import { createCardAPI, createConfig, createHASS, createView } from '../../test-utils';
@@ -347,7 +350,12 @@ describe('ActionsManager', () => {
const manager = new ActionsManager(api, templateRenderer);
const config = { entity: 'light.office' };
const triggerData = { view: { from: 'previous-view', to: 'view' } };
const triggerData = {
platform: 'acc',
type: 'view',
from_acc: { view: 'previous-view' },
to_acc: { view: 'view' },
};
vi.spyOn(global.console, 'info').mockReturnValue(undefined);
await manager.executeActions({ actions: action, config, triggerData });
@@ -358,26 +366,233 @@ describe('ActionsManager', () => {
});
});
it('should filter rendered actions through the lock manager', async () => {
const renderedAction = createGeneralAction('reload');
const allowedAction = createLogAction('Allowed');
it('should filter actions through the lock manager before rendering them', async () => {
const rawRan = vi.fn();
const allowedRan = vi.fn();
const rawAction = createInternalCallbackAction(async () => {
rawRan();
});
const allowedAction = createInternalCallbackAction(async () => {
allowedRan();
});
const templateRenderer = mock<TemplateRenderer>();
templateRenderer.renderRecursively.mockReturnValue(renderedAction);
templateRenderer.renderRecursively.mockReturnValue(allowedAction);
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getLockManager().getAllowedActions).mockReturnValue([allowedAction]);
const manager = new ActionsManager(api, templateRenderer);
await manager.executeActions({ actions: rawAction });
// The lock manager sees the raw (unrendered) action; only the action it
// returns is rendered and run.
expect(api.getLockManager().getAllowedActions).toBeCalledWith(rawAction);
expect(allowedRan).toBeCalled();
expect(rawRan).not.toBeCalled();
});
it('should render each action against the state at its turn', async () => {
let camera = 'first';
const templateRenderer = mock<TemplateRenderer>();
// Identity render -- assert on the render *inputs*, not a swapped output.
templateRenderer.renderRecursively.mockImplementation((_hass, data) => data);
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getConditionStateManager().getState).mockImplementation(() => ({
camera,
}));
const manager = new ActionsManager(api, templateRenderer);
await manager.executeActions({
actions: [
// The first action changes the camera...
createInternalCallbackAction(async () => {
camera = 'second';
}),
// ...the second is rendered afterwards.
{ action: 'none' },
],
});
// Each action renders with the state as it is at its turn: the second
// sees the camera the first action set.
expect(templateRenderer.renderRecursively).toHaveBeenNthCalledWith(
1,
expect.anything(),
expect.anything(),
expect.objectContaining({ conditionState: { camera: 'first' } }),
);
expect(templateRenderer.renderRecursively).toHaveBeenNthCalledWith(
2,
expect.anything(),
expect.anything(),
expect.objectContaining({ conditionState: { camera: 'second' } }),
);
});
it('should render against the hass available at each step', async () => {
const ran: string[] = [];
const templateRenderer = mock<TemplateRenderer>();
templateRenderer.renderRecursively.mockImplementation((_hass, data) => data);
const api = createAPI();
// No HASS for the first action's render; HASS thereafter.
vi.mocked(api.getHASSManager().getHASS)
.mockReturnValueOnce(null)
.mockReturnValue(createHASS());
const manager = new ActionsManager(api, templateRenderer);
await manager.executeActions({
actions: [
createInternalCallbackAction(async () => {
ran.push('one');
}),
createInternalCallbackAction(async () => {
ran.push('two');
}),
],
});
// Both actions ran; only the second was rendered -- the first saw no
// HASS, so HASS is read per action rather than captured once.
expect(ran).toEqual(['one', 'two']);
expect(templateRenderer.renderRecursively).toBeCalledTimes(1);
});
it('should abort the remaining actions when one fails to render', async () => {
const ran: string[] = [];
const templateRenderer = mock<TemplateRenderer>();
templateRenderer.renderRecursively
.mockImplementationOnce((_hass, data) => data)
.mockImplementationOnce(() => {
throw new Error('bad template');
});
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
const manager = new ActionsManager(api, templateRenderer);
const warnSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
await manager.executeActions({
actions: [
createInternalCallbackAction(async () => {
ran.push('first');
}),
createInternalCallbackAction(async () => {
ran.push('second');
}),
createInternalCallbackAction(async () => {
ran.push('third');
}),
],
});
// The first action ran; the second's render threw, aborting the rest. The
// error was caught by executeActions().
expect(ran).toEqual(['first']);
expect(warnSpy).toBeCalled();
});
it('should hand an if-action branch to the executor unrendered, with the trigger data', async () => {
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getConditionStateManager().getState).mockReturnValue({
fullscreen: true,
});
const manager = new ActionsManager(api, new TemplateRenderer());
const consoleSpy = vi.spyOn(global.console, 'info').mockReturnValue(undefined);
const thenAction = createLogAction('{{ trigger.entity_id }}');
await manager.executeActions({
actions: {
if: [{ condition: 'fullscreen', fullscreen: true }],
then: [thenAction],
else: [createLogAction('unused else')],
},
triggerData: { platform: 'state', entity_id: 'binary_sensor.door' },
});
// The branch is left raw (template intact) and forwarded with the trigger
// data, so the nested executor renders it per-step when it runs -- not
// frozen against the state at the `if` step.
expect(api.getActionsManager().executeActions).toBeCalledWith({
actions: [thenAction],
config: undefined,
triggerData: { platform: 'state', entity_id: 'binary_sensor.door' },
});
// The log action is handed to the (mocked) nested executor, not run here,
// so it must not actually log.
expect(consoleSpy).not.toBeCalled();
});
it('should render if-action branch actions per-step', async () => {
let camera = 'before';
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
vi.mocked(api.getConditionStateManager().getState).mockImplementation(() => ({
camera,
fullscreen: true,
}));
const manager = new ActionsManager(api, new TemplateRenderer());
// The if-action's nested executor is the same (real) manager.
vi.mocked(api.getActionsManager).mockReturnValue(manager);
const consoleSpy = vi.spyOn(global.console, 'info').mockReturnValue(undefined);
await manager.executeActions({
actions: createLogAction('{{ action }}'),
actions: {
if: [{ condition: 'fullscreen', fullscreen: true }],
then: [
// The first branch action changes the camera...
createInternalCallbackAction(async () => {
camera = 'after';
}),
// ...the second logs `{{ acc.camera }}`, rendered at its own turn.
createLogAction('{{ acc.camera }}'),
],
},
});
expect(api.getLockManager().getAllowedActions).toBeCalledWith(renderedAction);
expect(consoleSpy).toBeCalledWith('Allowed');
// The log rendered against the camera the first branch action set, so it
// logs 'after' -- proving the branch renders per-step. Frozen-at-the-`if`
// rendering would log 'before'.
expect(consoleSpy).toHaveBeenCalledWith('after');
});
it('should drop an action whose templated discriminator cannot be classified', async () => {
const api = createAPI();
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(createHASS());
const manager = new ActionsManager(api, new TemplateRenderer());
const warnSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
await manager.executeActions({
actions: {
action: 'fire-dom-event',
advanced_camera_card_action: '{{ acc.view }}',
},
});
// The discriminator is classified on the raw action (templates render
// only afterwards), so a templated `advanced_camera_card_action` matches
// no action type and is dropped with a warning rather than executed.
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('unknown card action'),
);
});
it('should not execute actions when the lock manager rejects them', async () => {
tests/card-controller/actions/actions/camera-select.test.ts
+6 -6
View File
@@ -123,9 +123,9 @@ describe('should handle camera_select action', () => {
it('with triggered camera', async () => {
const api = createCardAPI();
vi.mocked(api.getViewManager().getView).mockReturnValue(createView());
vi.mocked(api.getTriggersManager().getMostRecentlyTriggeredCameraID).mockReturnValue(
'camera.office',
);
vi.mocked(
api.getCameraTriggersManager().getMostRecentlyTriggeredCameraID,
).mockReturnValue('camera.office');
const action = new CameraSelectAction(
{},
@@ -152,9 +152,9 @@ describe('should handle camera_select action', () => {
it('without camera or triggered camera', async () => {
const api = createCardAPI();
vi.mocked(api.getViewManager().getView).mockReturnValue(createView());
vi.mocked(api.getTriggersManager().getMostRecentlyTriggeredCameraID).mockReturnValue(
'camera.office',
);
vi.mocked(
api.getCameraTriggersManager().getMostRecentlyTriggeredCameraID,
).mockReturnValue('camera.office');
const action = new CameraSelectAction(
{},
tests/card-controller/actions/actions/if.test.ts
+86
View File
@@ -0,0 +1,86 @@
import { describe, expect, it, vi } from 'vitest';
import { IfAction } from '../../../../src/card-controller/actions/actions/if';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { createCardAPI } from '../../../test-utils';
const thenActions = [
{
action: 'fire-dom-event' as const,
advanced_camera_card_action: 'clips' as const,
},
];
const elseActions = [
{
action: 'fire-dom-event' as const,
advanced_camera_card_action: 'clip' as const,
},
];
describe('IfAction', () => {
it('should run the then branch when the conditions hold', async () => {
const api = createCardAPI();
const stateManager = new ConditionStateManager();
stateManager.setState({ fullscreen: true });
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const action = new IfAction(
{},
{
if: [{ condition: 'fullscreen', fullscreen: true }],
then: thenActions,
else: elseActions,
},
);
await action.execute(api);
expect(api.getActionsManager().executeActions).toBeCalledWith({
actions: thenActions,
config: undefined,
triggerData: undefined,
});
});
it('should run the else branch when the conditions do not hold', async () => {
const api = createCardAPI();
const stateManager = new ConditionStateManager();
stateManager.setState({ fullscreen: false });
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const action = new IfAction(
{},
{
if: [{ condition: 'fullscreen', fullscreen: true }],
then: thenActions,
else: elseActions,
},
);
await action.execute(api);
expect(api.getActionsManager().executeActions).toBeCalledWith({
actions: elseActions,
config: undefined,
triggerData: undefined,
});
});
it('should do nothing when the conditions do not hold and there is no else branch', async () => {
const api = createCardAPI();
const stateManager = new ConditionStateManager();
stateManager.setState({ fullscreen: false });
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const action = new IfAction(
{},
{
if: [{ condition: 'fullscreen', fullscreen: true }],
then: thenActions,
},
);
await action.execute(api);
expect(api.getActionsManager().executeActions).not.toBeCalled();
});
});
tests/card-controller/actions/factory.test.ts
+6
View File
@@ -12,6 +12,7 @@ import { DownloadAction } from '../../../src/card-controller/actions/actions/dow
import { EffectAction } from '../../../src/card-controller/actions/actions/effect';
import { ExpandAction } from '../../../src/card-controller/actions/actions/expand';
import { FullscreenAction } from '../../../src/card-controller/actions/actions/fullscreen';
import { IfAction } from '../../../src/card-controller/actions/actions/if';
import { InfoAction } from '../../../src/card-controller/actions/actions/info';
import { InternalCallbackAction } from '../../../src/card-controller/actions/actions/internal-callback';
import { LogAction } from '../../../src/card-controller/actions/actions/log';
@@ -87,6 +88,11 @@ describe('ActionFactory', () => {
});
});
it('should create an if action', () => {
const factory = new ActionFactory();
expect(factory.createAction({}, { if: [], then: [] })).toBeInstanceOf(IfAction);
});
describe('custom actions', () => {
it.each([
[{ advanced_camera_card_action: 'call_answer' as const }, CallAnswerAction],
tests/card-controller/automations-manager.test.ts
+122 -30
View File
@@ -1,8 +1,8 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { ActionsExecutionRequest } from '../../src/card-controller/actions/types.js';
import { AutomationsManager } from '../../src/card-controller/automations-manager.js';
import { ConditionStateManager } from '../../src/conditions/state-manager.js';
import { createCardAPI } from '../test-utils.js';
import { ConditionStateManager } from '../../src/condition-trigger/conditions/state-manager.js';
import { createCardAPI, flushPromises } from '../test-utils.js';
describe('AutomationsManager', () => {
const actions = [
@@ -11,15 +11,11 @@ describe('AutomationsManager', () => {
advanced_camera_card_action: 'clips',
},
];
const conditions = [{ condition: 'fullscreen' as const, fullscreen: true }];
const triggers = [{ trigger: 'fullscreen' as const, fullscreen: true }];
const automation = {
conditions: conditions,
triggers: triggers,
actions: actions,
};
const not_automation = {
conditions: conditions,
actions_not: actions,
};
afterEach(() => {
vi.clearAllMocks();
@@ -78,7 +74,7 @@ describe('AutomationsManager', () => {
});
});
it('should execute actions', () => {
it('should execute actions when triggered', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
@@ -94,8 +90,7 @@ describe('AutomationsManager', () => {
expect(api.getActionsManager().executeActions).toBeCalledTimes(1);
// Automation will not re-fire when condition continues to evaluate the
// same.
// It does not re-trigger while its source stays in the same state.
stateManager.setState({ fullscreen: true });
expect(api.getActionsManager().executeActions).toBeCalledTimes(1);
@@ -106,7 +101,7 @@ describe('AutomationsManager', () => {
expect(api.getActionsManager().executeActions).toBeCalledTimes(2);
});
it('should execute actions_not', () => {
it('should run actions when the ongoing conditions hold', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
@@ -116,13 +111,69 @@ describe('AutomationsManager', () => {
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([not_automation]);
automationsManager.addAutomations([
{
triggers: triggers,
conditions: [{ condition: 'expand' as const, expand: true }],
actions: actions,
},
]);
// The ongoing condition holds when triggered, so `actions` run.
stateManager.setState({ expand: true });
stateManager.setState({ fullscreen: true });
expect(api.getActionsManager().executeActions).toBeCalledWith({
actions: actions,
triggerData: { platform: 'acc', type: 'fullscreen' },
});
});
it('should do nothing when the ongoing conditions do not hold', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
true,
);
const stateManager = new ConditionStateManager();
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([
{
triggers: triggers,
conditions: [{ condition: 'expand' as const, expand: true }],
actions: actions,
},
]);
// The automation is triggered but the ongoing condition does not hold, so
// nothing runs.
stateManager.setState({ fullscreen: true });
expect(api.getActionsManager().executeActions).not.toBeCalled();
});
it('should do nothing when the actions are empty', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
true,
);
const stateManager = new ConditionStateManager();
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([
{
triggers: triggers,
actions: [],
},
]);
stateManager.setState({ fullscreen: true });
expect(api.getActionsManager().executeActions).not.toBeCalled();
stateManager.setState({ fullscreen: false });
expect(api.getActionsManager().executeActions).toBeCalled();
expect(api.getActionsManager().executeActions).not.toBeCalled();
});
it('should prevent automation loops', () => {
@@ -137,29 +188,27 @@ describe('AutomationsManager', () => {
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([
{
conditions: [{ condition: 'fullscreen' as const, fullscreen: true }],
triggers: [{ trigger: 'camera' as const }],
actions: actions,
},
{
conditions: [{ condition: 'fullscreen' as const, fullscreen: false }],
actions_not: actions,
},
]);
// Create a setup where one automation action causes another...
let fullscreen = true;
// Create a setup where the automation's action re-triggers itself: the camera
// trigger responds to every camera change, and the action changes the camera,
// looping until the nested-execution guard trips.
let camera = 'one';
vi.mocked(api.getActionsManager().executeActions).mockImplementation(
async (
// eslint-disable-next-line @typescript-eslint/no-unused-vars
_request: ActionsExecutionRequest,
): Promise<void> => {
fullscreen = !fullscreen;
stateManager.setState({ fullscreen: fullscreen });
camera = camera === 'one' ? 'two' : 'one';
stateManager.setState({ camera: camera });
},
);
stateManager.setState({ fullscreen: fullscreen });
stateManager.setState({ camera: camera });
expect(api.getNotificationManager().setNotification).toBeCalledWith({
heading: {
@@ -172,6 +221,49 @@ describe('AutomationsManager', () => {
expect(api.getActionsManager().executeActions).toBeCalledTimes(10);
});
it('should reset the nested-execution counter after an overflow', async () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
true,
);
const stateManager = new ConditionStateManager();
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([
{
triggers: [{ trigger: 'camera' as const }],
actions: actions,
},
]);
// As in the loop test: the action changes the camera, re-triggering itself
// until the nested-execution guard trips.
let camera = 'one';
vi.mocked(api.getActionsManager().executeActions).mockImplementation(
async (): Promise<void> => {
camera = camera === 'one' ? 'two' : 'one';
stateManager.setState({ camera: camera });
},
);
stateManager.setState({ camera: camera });
expect(api.getActionsManager().executeActions).toBeCalledTimes(10);
// The counter is decremented on the microtasks that resume after each
// awaited execution, so let them drain before the next batch.
await flushPromises();
vi.mocked(api.getActionsManager().executeActions).mockClear();
// A second, independent change overflows afresh and reaches the full limit
// again -- only possible if the counter returned to zero. A leaked counter
// (overflow returning without decrementing) would cut this batch short.
stateManager.setState({ camera: 'three' });
expect(api.getActionsManager().executeActions).toBeCalledTimes(10);
});
it('should delete automations', () => {
const api = createCardAPI();
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
@@ -184,11 +276,11 @@ describe('AutomationsManager', () => {
const automationsManager = new AutomationsManager(api);
automationsManager.addAutomations([
{
conditions: [{ condition: 'expand' as const, expand: true }],
triggers: [{ trigger: 'expand' as const, expand: true }],
actions: actions,
},
{
conditions: [{ condition: 'fullscreen' as const, fullscreen: true }],
triggers: [{ trigger: 'fullscreen' as const, fullscreen: true }],
actions: actions,
tag: 'fullscreen',
},
@@ -210,8 +302,8 @@ describe('AutomationsManager', () => {
// Delete all automations.
automationsManager.deleteAutomations();
stateManager.setState({ fullscreen: false });
stateManager.setState({ fullscreen: true });
stateManager.setState({ expand: false });
stateManager.setState({ expand: true });
expect(api.getActionsManager().executeActions).toBeCalledTimes(2);
});
});
tests/card-controller/call/manager.test.ts
+1 -1
View File
@@ -8,7 +8,7 @@ import { CallManager } from '../../../src/card-controller/call/manager';
import { Ringtone } from '../../../src/card-controller/call/ringtone';
import { CardController } from '../../../src/card-controller/controller';
import { SubstreamViewModifier } from '../../../src/card-controller/view/modifiers/substream';
import { ConditionStateChange } from '../../../src/conditions/types';
import { ConditionStateChange } from '../../../src/condition-trigger/conditions/types';
import { RingtoneConfig } from '../../../src/config/schema/live';
import { AdvancedCameraCardConfig } from '../../../src/config/schema/types';
import { View } from '../../../src/view/view';
tests/card-controller/triggers-manager.test.ts → tests/card-controller/camera-triggers-manager.test.ts
+58 -58
View File
@@ -2,7 +2,7 @@ import { add } from 'date-fns';
import { PartialDeep } from 'type-fest';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { CardController } from '../../src/card-controller/controller';
import { TriggersManager } from '../../src/card-controller/triggers-manager';
import { CameraTriggersManager } from '../../src/card-controller/camera-triggers-manager';
import { AdvancedCameraCardView } from '../../src/config/schema/common/const';
import { TriggersOptions, triggersSchema } from '../../src/config/schema/view';
import {
@@ -85,7 +85,7 @@ const createTriggerAPI = (options?: {
};
// @vitest-environment jsdom
describe('TriggersManager', () => {
describe('CameraTriggersManager', () => {
const start = new Date('2023-10-01T17:14');
beforeEach(() => {
@@ -94,7 +94,7 @@ describe('TriggersManager', () => {
});
it('should not be triggered by default', () => {
const manager = new TriggersManager(createCardAPI());
const manager = new CameraTriggersManager(createCardAPI());
expect(manager.isTriggered()).toBeFalsy();
});
@@ -106,7 +106,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -122,7 +122,7 @@ describe('TriggersManager', () => {
const api = createTriggerAPI();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(null);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -145,7 +145,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -170,7 +170,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -197,7 +197,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -240,7 +240,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -280,7 +280,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -300,7 +300,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -327,7 +327,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -356,7 +356,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -390,7 +390,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -418,7 +418,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -445,7 +445,7 @@ describe('TriggersManager', () => {
it('should handle untrigger call with no state', async () => {
const api = createTriggerAPI();
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -458,7 +458,7 @@ describe('TriggersManager', () => {
it('should not untrigger if other sources are still active', async () => {
const api = createTriggerAPI();
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -501,7 +501,7 @@ describe('TriggersManager', () => {
it('should cancel untrigger timer if a new trigger starts', async () => {
const api = createTriggerAPI();
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -551,7 +551,7 @@ describe('TriggersManager', () => {
]),
);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -604,7 +604,7 @@ describe('TriggersManager', () => {
untrigger_delay_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// 1. Trigger the camera.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -630,7 +630,7 @@ describe('TriggersManager', () => {
untrigger_delay_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Trigger then end to start the untrigger delay timer.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -656,7 +656,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Trigger to start the force untrigger timer.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -680,7 +680,7 @@ describe('TriggersManager', () => {
untrigger_delay_seconds: 0,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -704,7 +704,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 5,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -726,7 +726,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -758,7 +758,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 5,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -785,7 +785,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -816,7 +816,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -842,7 +842,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -861,7 +861,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Continuous source comes on first.
await manager.handleCameraEvent({
@@ -894,7 +894,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -924,7 +924,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -963,7 +963,7 @@ describe('TriggersManager', () => {
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -1007,7 +1007,7 @@ describe('TriggersManager', () => {
default: 'live',
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -1032,7 +1032,7 @@ describe('TriggersManager', () => {
default: 'clips',
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -1051,7 +1051,7 @@ describe('TriggersManager', () => {
// Interaction present.
interaction: true,
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
@@ -1089,7 +1089,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -1126,7 +1126,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -1179,7 +1179,7 @@ describe('TriggersManager', () => {
]),
);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
expect(manager.isTriggered()).toBeFalsy();
expect(manager.getMostRecentlyTriggeredCameraID()).toBeNull();
@@ -1228,7 +1228,7 @@ describe('TriggersManager', () => {
filter_selected_camera: true,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
expect(manager.isTriggered()).toBeFalsy();
const otherCameraSelected = createView({
@@ -1288,7 +1288,7 @@ describe('TriggersManager', () => {
]),
);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const primaryCameraView = createView({
camera: 'camera_primary' as const,
@@ -1315,7 +1315,7 @@ describe('TriggersManager', () => {
actions: { trigger: 'none', untrigger: 'default' },
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Trigger camera_1 normally, then end it -- starts the delay timer.
await manager.handleCameraEvent({
@@ -1372,7 +1372,7 @@ describe('TriggersManager', () => {
]),
);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
expect(result).toBeFalsy();
@@ -1404,7 +1404,7 @@ describe('TriggersManager', () => {
});
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
expect(result).toBeFalsy();
@@ -1436,7 +1436,7 @@ describe('TriggersManager', () => {
});
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
expect(result).toBeTruthy();
@@ -1468,7 +1468,7 @@ describe('TriggersManager', () => {
});
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
expect(result).toBeTruthy();
@@ -1515,7 +1515,7 @@ describe('TriggersManager', () => {
});
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
expect(result).toBeTruthy();
@@ -1555,7 +1555,7 @@ describe('TriggersManager', () => {
});
vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
const result = await manager.handleInitialCameraTriggers();
// A trigger entity was active...
@@ -1580,7 +1580,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({
cameraID: 'camera_1',
id: 'event-1',
@@ -1620,7 +1620,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'end' });
@@ -1642,7 +1642,7 @@ describe('TriggersManager', () => {
untrigger_delay_seconds: 0,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Trigger then end, but don't await the end event so we can check
// triggered IDs while the camera is in the map but no longer triggered.
@@ -1660,7 +1660,7 @@ describe('TriggersManager', () => {
it('should handle newly missing configuration', async () => {
const api = createTriggerAPI();
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// 1. Trigger the camera with valid config.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -1688,7 +1688,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// 1. Initial trigger.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -1717,7 +1717,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// 1. Trigger and force untrigger.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -1747,7 +1747,7 @@ describe('TriggersManager', () => {
},
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Simulate an update for a brand new ID (e.g. from an engine we just switched to).
// Even without a 'new' event, if it's not in our ignore list, it should be processed.
@@ -1768,7 +1768,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Force-ignore e1 on camera_1.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -1794,7 +1794,7 @@ describe('TriggersManager', () => {
untrigger_force_seconds: 10,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Force-ignore e1 and e2 on camera_1.
await manager.handleCameraEvent({ cameraID: 'camera_1', id: 'e1', type: 'new' });
@@ -1825,7 +1825,7 @@ describe('TriggersManager', () => {
untrigger_delay_seconds: 0,
},
});
const manager = new TriggersManager(api);
const manager = new CameraTriggersManager(api);
// Call handleCameraEvent with an unknown camera ID to ensure guard behavior.
const result = await manager.handleCameraEvent({
tests/card-controller/config/config-manager.test.ts
+16 -17
View File
@@ -5,9 +5,9 @@ import { ConfigManager } from '../../../src/card-controller/config/config-manage
import { setRemoteControlEntityFromConfig } from '../../../src/card-controller/config/load-control-entities';
import { setKeyboardShortcutsFromConfig } from '../../../src/card-controller/config/load-keyboard-shortcuts';
import { InitializationAspect } from '../../../src/card-controller/initialization-manager';
import { ConditionStateManager } from '../../../src/conditions/state-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { Automation } from '../../../src/config/schema/automations';
import { AdvancedCameraCardCondition } from '../../../src/config/schema/conditions/types';
import { Trigger } from '../../../src/config/schema/condition-trigger/triggers/types';
import { advancedCameraCardConfigSchema } from '../../../src/config/schema/types';
import { createGeneralAction } from '../../../src/utils/action';
import { createCardAPI, createConfig, flushPromises } from '../../test-utils';
@@ -507,8 +507,8 @@ describe('ConfigManager', () => {
expect(addAutomationsSpy).toHaveBeenCalledWith(
expect.arrayContaining([
expect.objectContaining({
conditions: expect.arrayContaining([
expect.objectContaining({ condition: 'key', key: 'h' }),
triggers: expect.arrayContaining([
expect.objectContaining({ trigger: 'key', key: 'h' }),
]),
actions: expect.arrayContaining([
expect.objectContaining({
@@ -530,9 +530,8 @@ describe('ConfigManager', () => {
const addCalls = addAutomationsSpy.mock.calls;
const hasKeyboardShortcut = addCalls.some((call) =>
call[0].some((automation: Automation) =>
automation.conditions?.some(
(cond: AdvancedCameraCardCondition) =>
cond.condition === 'key' && cond.key === 'h',
automation.triggers.some(
(trig: Trigger) => trig.trigger === 'key' && trig.key === 'h',
),
),
);
@@ -610,7 +609,7 @@ describe('ConfigManager', () => {
);
const automation = {
conditions: [TEST_CONDITIONS.FULLSCREEN_OFF],
triggers: [{ trigger: 'fullscreen' as const, fullscreen: false }],
actions: [createGeneralAction('screenshot')],
};
const config = createConfig({
@@ -672,7 +671,7 @@ describe('ConfigManager', () => {
);
const automation = {
conditions: [TEST_CONDITIONS.FULLSCREEN_ON],
triggers: [{ trigger: 'fullscreen' as const, fullscreen: true }],
actions: [createGeneralAction('screenshot')],
};
const config = createConfig({
@@ -728,9 +727,9 @@ describe('ConfigManager', () => {
expect(addAutomationsSpy).toHaveBeenCalledWith(
expect.arrayContaining([
expect.objectContaining({
conditions: expect.arrayContaining([
triggers: expect.arrayContaining([
expect.objectContaining({
condition: 'config',
trigger: 'config',
paths: expect.arrayContaining(['remote_control.entities.camera']),
}),
]),
@@ -752,10 +751,10 @@ describe('ConfigManager', () => {
const addCalls = addAutomationsSpy.mock.calls;
const hasRemoteControl = addCalls.some((call) =>
call[0].some((automation: Automation) =>
automation.conditions?.some(
(cond: AdvancedCameraCardCondition) =>
cond.condition === 'config' &&
cond.paths?.includes('remote_control.entities.camera'),
automation.triggers.some(
(trig: Trigger) =>
trig.trigger === 'config' &&
trig.paths?.includes('remote_control.entities.camera'),
),
),
);
@@ -771,9 +770,9 @@ describe('ConfigManager', () => {
expect(addAutomationsSpy).toHaveBeenCalledWith(
expect.arrayContaining([
expect.objectContaining({
conditions: expect.arrayContaining([
triggers: expect.arrayContaining([
expect.objectContaining({
condition: 'config',
trigger: 'config',
paths: expect.arrayContaining(['remote_control.entities.camera']),
}),
]),
tests/card-controller/config/load-automations.test.ts
+1 -1
View File
@@ -20,7 +20,7 @@ describe('setAutomationsFromConfig', () => {
advanced_camera_card_action: 'clips',
},
],
conditions: [{ condition: 'fullscreen' as const, fullscreen: true }],
triggers: [{ trigger: 'fullscreen' as const, fullscreen: true }],
},
];
const api = createCardAPI();
tests/card-controller/config/load-control-entities.test.ts
+84 -21
View File
@@ -1,5 +1,8 @@
import { describe, expect, it, vi } from 'vitest';
import { assert, describe, expect, it, vi } from 'vitest';
import { AutomationsManager } from '../../../src/card-controller/automations-manager';
import { setRemoteControlEntityFromConfig } from '../../../src/card-controller/config/load-control-entities';
import { TemplateRenderer } from '../../../src/card-controller/templates/index';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import {
INTERNAL_CALLBACK_ACTION,
InternalCallbackActionConfig,
@@ -48,9 +51,9 @@ describe('setRemoteControlEntityFromConfig', () => {
callback: expect.any(Function),
},
],
conditions: [
triggers: [
{
condition: 'config',
trigger: 'config',
paths: ['cameras', 'remote_control.entities.camera'],
},
],
@@ -64,9 +67,9 @@ describe('setRemoteControlEntityFromConfig', () => {
callback: expect.any(Function),
},
],
conditions: [
triggers: [
{
condition: 'camera',
trigger: 'camera',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -79,9 +82,9 @@ describe('setRemoteControlEntityFromConfig', () => {
callback: expect.any(Function),
},
],
conditions: [
triggers: [
{
condition: 'initialized',
trigger: 'initialized',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -91,13 +94,13 @@ describe('setRemoteControlEntityFromConfig', () => {
{
action: 'fire-dom-event',
advanced_camera_card_action: 'camera_select',
camera: '{{ advanced_camera_card.trigger.state.to }}',
camera: '{{ trigger.to_state.state }}',
},
],
conditions: [
triggers: [
{
condition: 'state',
entity: 'input_select.camera',
trigger: 'state',
entity_id: 'input_select.camera',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -130,9 +133,9 @@ describe('setRemoteControlEntityFromConfig', () => {
callback: expect.any(Function),
},
],
conditions: [
triggers: [
{
condition: 'config',
trigger: 'config',
paths: ['cameras', 'remote_control.entities.camera'],
},
],
@@ -146,9 +149,9 @@ describe('setRemoteControlEntityFromConfig', () => {
callback: expect.any(Function),
},
],
conditions: [
triggers: [
{
condition: 'camera',
trigger: 'camera',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -161,9 +164,9 @@ describe('setRemoteControlEntityFromConfig', () => {
camera: '{{ hass.states["input_select.camera"].state }}',
},
],
conditions: [
triggers: [
{
condition: 'initialized',
trigger: 'initialized',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -173,13 +176,13 @@ describe('setRemoteControlEntityFromConfig', () => {
{
action: 'fire-dom-event',
advanced_camera_card_action: 'camera_select',
camera: '{{ advanced_camera_card.trigger.state.to }}',
camera: '{{ trigger.to_state.state }}',
},
],
conditions: [
triggers: [
{
condition: 'state',
entity: 'input_select.camera',
trigger: 'state',
entity_id: 'input_select.camera',
},
],
tag: setRemoteControlEntityFromConfig,
@@ -618,4 +621,64 @@ describe('setRemoteControlEntityFromConfig', () => {
);
});
});
describe('should render the firing trigger into the camera action', () => {
it('should resolve the new entity state through the trigger template', () => {
const api = createCardAPI();
vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
createConfig({
remote_control: {
entities: {
camera: 'input_select.camera',
camera_priority: 'card',
},
},
}),
);
// Capture the automations the loader registers, then drive them through a
// real AutomationsManager so the state trigger actually fires and its
// `{{ trigger.to_state.state }}` template is rendered end to end (the
// other tests only string-match the literal, so a context mis-wire would
// silently break remote control).
setRemoteControlEntityFromConfig(api);
const automations = vi.mocked(api.getAutomationsManager().addAutomations).mock
.calls[0][0];
vi.mocked(api.getHASSManager().hasHASS).mockReturnValue(true);
vi.mocked(api.getInitializationManager().isInitializedMandatory).mockReturnValue(
true,
);
const stateManager = new ConditionStateManager();
vi.mocked(api.getConditionStateManager).mockReturnValue(stateManager);
new AutomationsManager(api).addAutomations(automations);
stateManager.setState({
hass: createHASS({
'input_select.camera': createStateEntity({ state: 'camera.one' }),
}),
});
const hass = createHASS({
'input_select.camera': createStateEntity({ state: 'camera.two' }),
});
stateManager.setState({ hass });
const captured = vi
.mocked(api.getActionsManager().executeActions)
.mock.calls.at(-1)?.[0];
assert(captured);
const rendered = new TemplateRenderer().renderRecursively(hass, captured.actions, {
triggerData: captured.triggerData,
});
expect(rendered).toEqual([
{
action: 'fire-dom-event',
advanced_camera_card_action: 'camera_select',
camera: 'camera.two',
},
]);
});
});
});
tests/card-controller/config/load-keyboard-shortcuts.test.ts
+6 -6
View File
@@ -78,10 +78,10 @@ describe('setKeyboardShortcutsFromConfig', () => {
ptz_phase: 'start',
},
],
conditions: [
triggers: [
{
alt: undefined,
condition: 'key',
trigger: 'key',
ctrl: undefined,
key: 'z',
meta: undefined,
@@ -100,9 +100,9 @@ describe('setKeyboardShortcutsFromConfig', () => {
ptz_phase: 'stop',
},
],
conditions: [
triggers: [
{
condition: 'key',
trigger: 'key',
key: 'z',
state: 'up',
},
@@ -130,10 +130,10 @@ describe('setKeyboardShortcutsFromConfig', () => {
advanced_camera_card_action: 'ptz_multi',
},
],
conditions: [
triggers: [
{
alt: undefined,
condition: 'key',
trigger: 'key',
ctrl: undefined,
key: 'h',
meta: undefined,
tests/card-controller/config/overrides-manager.test.ts
+1 -1
View File
@@ -1,7 +1,7 @@
import { assert, describe, expect, it, vi } from 'vitest';
import { OverridesManager } from '../../../src/card-controller/config/overrides-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { AdvancedCameraCardConfig } from '../../../src/config/schema/types';
import { ConditionStateManager } from '../../../src/conditions/state-manager';
import { AdvancedCameraCardError } from '../../../src/types';
import { createConfig } from '../../test-utils';
tests/card-controller/controller.test.ts
+7 -7
View File
@@ -3,6 +3,7 @@ import { CameraManager } from '../../src/camera-manager/manager';
import { ActionsManager } from '../../src/card-controller/actions/actions-manager';
import { AutomationsManager } from '../../src/card-controller/automations-manager';
import { CallManager } from '../../src/card-controller/call/manager';
import { CameraTriggersManager } from '../../src/card-controller/camera-triggers-manager';
import { CameraURLManager } from '../../src/card-controller/camera-url-manager';
import {
CardElementManager,
@@ -28,10 +29,9 @@ import { PIPManager } from '../../src/card-controller/pip-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 { ViewItemManager } from '../../src/card-controller/view/item-manager';
import { ViewManager } from '../../src/card-controller/view/view-manager';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { ConditionStateManager } from '../../src/condition-trigger/conditions/state-manager';
import { AdvancedCameraCardEditor } from '../../src/editor';
import { DeviceRegistryManager } from '../../src/ha/registry/device';
import { EntityRegistryManagerLive } from '../../src/ha/registry/entity';
@@ -64,10 +64,10 @@ vi.mock('../../src/card-controller/issues/issue-manager');
vi.mock('../../src/card-controller/query-string-manager');
vi.mock('../../src/card-controller/status-bar-item-manager');
vi.mock('../../src/card-controller/style-manager');
vi.mock('../../src/card-controller/triggers-manager');
vi.mock('../../src/card-controller/camera-triggers-manager');
vi.mock('../../src/card-controller/view/item-manager');
vi.mock('../../src/card-controller/view/view-manager');
vi.mock('../../src/conditions/state-manager');
vi.mock('../../src/condition-trigger/conditions/state-manager');
vi.mock('../../src/ha/registry/device');
vi.mock('../../src/ha/registry/entity');
vi.mock('../../src/ha/resolved-media');
@@ -301,9 +301,9 @@ describe('CardController', () => {
);
});
it('should return getTriggersManager', () => {
expect(createController().getTriggersManager()).toBe(
vi.mocked(TriggersManager).mock.instances[0],
it('should return getCameraTriggersManager', () => {
expect(createController().getCameraTriggersManager()).toBe(
vi.mocked(CameraTriggersManager).mock.instances[0],
);
});
tests/card-controller/default-manager.test.ts
+2 -2
View File
@@ -192,9 +192,9 @@ describe('DefaultManager', () => {
advanced_camera_card_action: 'default',
},
],
conditions: [
triggers: [
{
condition: 'interaction',
trigger: 'interaction',
interaction: false,
},
],
tests/card-controller/folders/ha/media-matcher.test.ts
-12
View File
@@ -172,12 +172,6 @@ describe('MediaMatcher', () => {
is_folder: false,
},
},
advanced_camera_card: {
media: {
title,
is_folder: false,
},
},
},
);
});
@@ -208,12 +202,6 @@ describe('MediaMatcher', () => {
is_folder: false,
},
},
advanced_camera_card: {
media: {
title,
is_folder: false,
},
},
},
);
});
tests/card-controller/fullscreen/webkit/index.test.ts
+1 -1
View File
@@ -1,7 +1,7 @@
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { WebkitFullScreenProvider } from '../../../../src/card-controller/fullscreen/webkit';
import { ConditionStateManager } from '../../../../src/conditions/state-manager';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { MediaPlayerController, WebkitHTMLVideoElement } from '../../../../src/types';
import { createCardAPI, createMediaLoadedInfo } from '../../../test-utils';
tests/card-controller/initialization-manager.test.ts
+1 -1
View File
@@ -5,7 +5,7 @@ import {
InitializationAspect,
InitializationManager,
} from '../../src/card-controller/initialization-manager';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { ConditionStateManager } from '../../src/condition-trigger/conditions/state-manager';
import { sideLoadHomeAssistantElements } from '../../src/ha/side-load-ha-elements.js';
import { loadLanguages } from '../../src/localize/localize';
import { Initializer } from '../../src/utils/initializer/initializer';
tests/card-controller/issues/factory.test.ts
+2 -1
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createIssueManager } from '../../../src/card-controller/issues/factory';
import { IssueManager } from '../../../src/card-controller/issues/issue-manager';
import { ConditionStateManager } from '../../../src/conditions/state-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { createCardAPI } from '../../test-utils';
describe('createIssueManager', () => {
@@ -27,6 +27,7 @@ describe('createIssueManager', () => {
const expectedKeys = [
'config_error',
'config_upgrade',
'config_upgrade_failure',
'connection',
'initialization',
'legacy_resource',
tests/card-controller/issues/issue-manager.test.ts
+1 -1
View File
@@ -12,7 +12,7 @@ import {
IssueDescription,
IssueKey,
} from '../../../src/card-controller/issues/types';
import { ConditionStateManager } from '../../../src/conditions/state-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { InteractionMode } from '../../../src/config/schema/view';
import {
createCardAPI,
tests/card-controller/issues/issues/config-upgrade-failure.test.ts
+59
View File
@@ -0,0 +1,59 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { ConfigUpgradeFailureIssue } from '../../../../src/card-controller/issues/issues/config-upgrade-failure';
import { hasConfigUpgradeFailures } from '../../../../src/config/management';
import { RawAdvancedCameraCardConfig } from '../../../../src/config/types';
import { createCardAPI } from '../../../test-utils';
vi.mock('../../../../src/config/management.js');
const createAPI = (rawConfig?: RawAdvancedCameraCardConfig) => {
const api = createCardAPI();
vi.mocked(api.getConfigManager().getRawConfig).mockReturnValue(rawConfig ?? null);
return api;
};
describe('ConfigUpgradeFailureIssue', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('should have correct key', () => {
const issue = new ConfigUpgradeFailureIssue(createAPI());
expect(issue.key).toBe('config_upgrade_failure');
});
it('should detect failures and return a description', async () => {
vi.mocked(hasConfigUpgradeFailures).mockReturnValue(true);
const rawConfig = { type: 'custom:advanced-camera-card' };
const issue = new ConfigUpgradeFailureIssue(createAPI(rawConfig));
await issue.detectStatic();
expect(issue.hasIssue()).toBe(true);
expect(hasConfigUpgradeFailures).toBeCalledWith(rawConfig);
expect(issue.getIssue()).toEqual(
expect.objectContaining({
icon: 'mdi:update',
severity: 'medium',
notification: expect.objectContaining({
heading: expect.objectContaining({
icon: 'mdi:update',
severity: 'medium',
}),
}),
}),
);
});
it('should report no failures and no description for a clean config', async () => {
vi.mocked(hasConfigUpgradeFailures).mockReturnValue(false);
const issue = new ConfigUpgradeFailureIssue(
createAPI({ type: 'custom:advanced-camera-card' }),
);
await issue.detectStatic();
expect(issue.hasIssue()).toBe(false);
expect(issue.getIssue()).toBeNull();
});
});
tests/card-controller/pip-manager.test.ts
+1 -1
View File
@@ -2,7 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CardController } from '../../src/card-controller/controller';
import { PIPManager } from '../../src/card-controller/pip-manager';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { ConditionStateManager } from '../../src/condition-trigger/conditions/state-manager';
import { MediaPlayerController } from '../../src/types';
import { createCardAPI, createMediaLoadedInfo, flushPromises } from '../test-utils';
tests/card-controller/templates/index.test.ts
+35 -6
View File
@@ -1,6 +1,6 @@
import { describe, expect, it } from 'vitest';
import { TemplateRenderer } from '../../../src/card-controller/templates/index';
import { createHASS } from '../../test-utils';
import { createConfig, createHASS, createStateEntity } from '../../test-utils';
describe('TemplateRenderer', () => {
describe('renderRecursively', () => {
@@ -24,13 +24,13 @@ describe('TemplateRenderer', () => {
expect(result).toBe('View: live');
});
it('should render string templates with full advanced_camera_card context', () => {
it('should render string templates with the acc context', () => {
const renderer = new TemplateRenderer();
const hass = createHASS();
const result = renderer.renderRecursively(
hass,
'{{ advanced_camera_card.camera }} - {{ advanced_camera_card.view }}',
'{{ acc.camera }} - {{ acc.view }}',
{
conditionState: { camera: 'camera.front', view: 'clips' },
},
@@ -90,16 +90,45 @@ describe('TemplateRenderer', () => {
expect(renderer.renderRecursively(hass, 'hello world')).toBe('hello world');
});
it('should render with triggerData context', () => {
it('should render with a top-level stock trigger context', () => {
const renderer = new TemplateRenderer();
const hass = createHASS();
const result = renderer.renderRecursively(hass, '{{ acc.trigger.camera.to }}', {
triggerData: { camera: { from: 'camera.front', to: 'camera.backyard' } },
const result = renderer.renderRecursively(hass, '{{ trigger.to_state.state }}', {
triggerData: {
platform: 'state',
entity_id: 'binary_sensor.door',
to_state: createStateEntity({ state: 'on' }),
},
});
expect(result).toBe('on');
});
it('should render with a top-level card trigger context', () => {
const renderer = new TemplateRenderer();
const hass = createHASS();
const result = renderer.renderRecursively(hass, '{{ trigger.to_acc.camera }}', {
triggerData: {
platform: 'acc',
type: 'camera',
from_acc: { camera: 'camera.front' },
to_acc: { camera: 'camera.backyard' },
},
});
expect(result).toBe('camera.backyard');
});
it('should render with config context', () => {
const renderer = new TemplateRenderer();
const hass = createHASS();
const result = renderer.renderRecursively(hass, '{{ acc.config.view.default }}', {
conditionState: { config: createConfig({ view: { default: 'clips' } }) },
});
expect(result).toBe('clips');
});
it('should render with mediaData context', () => {
const renderer = new TemplateRenderer();
const hass = createHASS();
tests/components-lib/timeline/source.test.ts
+1 -1
View File
@@ -33,7 +33,7 @@ import {
AdvancedCameraCardTimelineItem,
TimelineDataSource,
} from '../../../src/components-lib/timeline/source';
import { ConditionStateManagerReadonlyInterface } from '../../../src/conditions/types';
import { ConditionStateManagerReadonlyInterface } from '../../../src/condition-trigger/conditions/types';
import { QuerySource } from '../../../src/query-source';
import { ViewMediaType } from '../../../src/view/item';
import { QueryNode, UnifiedQuery } from '../../../src/view/unified-query';
tests/condition-trigger/common/media-query-watcher.test.ts
+54
View File
@@ -0,0 +1,54 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { MediaQueryWatcher } from '../../../src/condition-trigger/common/media-query-watcher';
// @vitest-environment jsdom
describe('MediaQueryWatcher', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should report whether the query matches', () => {
vi.spyOn(window, 'matchMedia').mockReturnValue({
matches: true,
} as unknown as MediaQueryList);
expect(new MediaQueryWatcher('(orientation: landscape)').matches()).toBe(true);
});
it('should invoke the callback on a media-query change', () => {
const addEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener,
removeEventListener: vi.fn(),
} as unknown as MediaQueryList);
const onChange = vi.fn();
new MediaQueryWatcher('(orientation: landscape)').subscribe(onChange);
expect(addEventListener).toHaveBeenCalledWith('change', expect.anything());
addEventListener.mock.calls[0][1]();
expect(onChange).toHaveBeenCalledTimes(1);
});
it('should stop listening and ignore changes after teardown', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener,
removeEventListener,
} as unknown as MediaQueryList);
const onChange = vi.fn();
const teardown = new MediaQueryWatcher('(orientation: landscape)').subscribe(
onChange,
);
const handler = addEventListener.mock.calls[0][1];
teardown();
expect(removeEventListener).toHaveBeenCalledWith('change', expect.anything());
handler();
expect(onChange).not.toHaveBeenCalled();
});
});
tests/condition-trigger/common/time-period.test.ts
+98
View File
@@ -0,0 +1,98 @@
import { describe, expect, it } from 'vitest';
import { TemplateRenderer } from '../../../src/card-controller/templates';
import { renderTimePeriodToSeconds } from '../../../src/condition-trigger/common/time-period';
import { createHASS, createStateEntity } from '../../test-utils';
// @vitest-environment jsdom
describe('renderTimePeriodToSeconds', () => {
const createRenderer = (): TemplateRenderer => new TemplateRenderer();
const createStateWithDelay = (delay: string) => ({
hass: createHASS({ 'input_number.delay': createStateEntity({ state: delay }) }),
});
// Without `hass` the value is parsed as-is, matching HA's `cv.time_period`.
it('should accept a number of seconds', () => {
expect(renderTimePeriodToSeconds(createRenderer(), 5)).toBe(5);
expect(renderTimePeriodToSeconds(createRenderer(), 0)).toBe(0);
});
it('should reject a negative period', () => {
expect(renderTimePeriodToSeconds(createRenderer(), -1)).toBeNull();
expect(renderTimePeriodToSeconds(createRenderer(), { seconds: -5 })).toBeNull();
});
it('should parse a bare numeric string as seconds', () => {
expect(renderTimePeriodToSeconds(createRenderer(), '5')).toBe(5);
});
it('should read HH:MM and HH:MM:SS (two parts are hours:minutes, as in HA)', () => {
expect(renderTimePeriodToSeconds(createRenderer(), '01:30')).toBe(5400);
expect(renderTimePeriodToSeconds(createRenderer(), '00:05')).toBe(300);
expect(renderTimePeriodToSeconds(createRenderer(), '00:00:05')).toBe(5);
expect(renderTimePeriodToSeconds(createRenderer(), '1:00:00')).toBe(3600);
});
it('should reject unparseable, empty-part, or over-long strings', () => {
expect(renderTimePeriodToSeconds(createRenderer(), 'not-a-duration')).toBeNull();
expect(renderTimePeriodToSeconds(createRenderer(), '1:ab')).toBeNull();
expect(renderTimePeriodToSeconds(createRenderer(), '1:2:3:4')).toBeNull();
expect(renderTimePeriodToSeconds(createRenderer(), '5:')).toBeNull();
expect(renderTimePeriodToSeconds(createRenderer(), '')).toBeNull();
});
it('should accept a {days, hours, minutes, seconds, milliseconds} dict', () => {
expect(renderTimePeriodToSeconds(createRenderer(), { seconds: 5 })).toBe(5);
expect(renderTimePeriodToSeconds(createRenderer(), { hours: 1, minutes: 30 })).toBe(
5400,
);
expect(renderTimePeriodToSeconds(createRenderer(), { days: 1 })).toBe(86400);
expect(renderTimePeriodToSeconds(createRenderer(), { milliseconds: 500 })).toBe(0.5);
expect(renderTimePeriodToSeconds(createRenderer(), {})).toBe(0);
});
it('should coerce a numeric-string dict field', () => {
expect(renderTimePeriodToSeconds(createRenderer(), { minutes: '2' })).toBe(120);
expect(renderTimePeriodToSeconds(createRenderer(), { minutes: 'nope' })).toBeNull();
});
// With `hass`, templates are rendered against the current state before parsing.
it('should render and parse a template string', () => {
expect(
renderTimePeriodToSeconds(
createRenderer(),
"{{ states('input_number.delay') }}",
createStateWithDelay('5'),
),
).toBe(5);
});
it('should render and parse template fields in a dict', () => {
expect(
renderTimePeriodToSeconds(
createRenderer(),
{ minutes: "{{ states('input_number.delay') }}" },
createStateWithDelay('2'),
),
).toBe(120);
});
it('should return null when a template renders to a non-duration value', () => {
// A string that is not a number.
expect(
renderTimePeriodToSeconds(
createRenderer(),
"{{ states('input_number.delay') }}",
createStateWithDelay('nope'),
),
).toBeNull();
// A value that is neither a number, string nor dict (here, a boolean).
expect(
renderTimePeriodToSeconds(
createRenderer(),
"{{ is_state('input_number.delay', 'x') }}",
createStateWithDelay('5'),
),
).toBeNull();
});
});
tests/condition-trigger/conditions/conditions-manager.test.ts
+297
View File
@@ -0,0 +1,297 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { ConditionsManager } from '../../../src/condition-trigger/conditions/conditions-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { createHASS, createStateEntity } from '../../test-utils';
// Per-condition-type evaluation is covered by tests/conditions/conditions/<type>.test.ts.
// This file covers the manager's own orchestration: building/destroying evaluators,
// listener management, trigger-data merging, and notifying (or not) on changes.
// @vitest-environment jsdom
describe('ConditionsManager', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should not call listeners for HA state changes without a relevant condition', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
},
],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
});
expect(listener).not.toBeCalled();
});
it('should forward the triggering state change to listeners', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({ fullscreen: true });
// The change that prompted the evaluation is passed through verbatim.
expect(listener).toHaveBeenLastCalledWith(expect.anything(), {
old: {},
change: { fullscreen: true },
new: { fullscreen: true },
});
});
it('should re-evaluate and notify when a subscribed condition source changes', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia')
.mockReturnValueOnce({
addEventListener: addEventListener,
removeEventListener: removeEventListener,
} as unknown as MediaQueryList)
.mockReturnValueOnce({
matches: false,
} as unknown as MediaQueryList)
.mockReturnValueOnce({
matches: true,
} as unknown as MediaQueryList);
const manager = new ConditionsManager([
{ condition: 'screen' as const, media_query: 'whatever' },
]);
const listener = vi.fn();
manager.addListener(listener);
// Fire the media-query change; the manager re-evaluates and notifies.
addEventListener.mock.calls[0][1]();
expect(listener).toBeCalledWith({ result: true }, undefined);
// Destroy tears the subscription down.
manager.destroy();
expect(removeEventListener).toBeCalled();
});
describe('should handle listeners correctly', () => {
it('should add listener', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).toBeCalledWith({ result: true }, expect.anything());
expect(listener).toBeCalledTimes(1);
stateManager.setState({ fullscreen: false });
expect(listener).toBeCalledWith({ result: false }, expect.anything());
expect(listener).toBeCalledTimes(2);
// Re-add the same listener (will still only be called once).
manager.addListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).toBeCalledWith({ result: true }, expect.anything());
expect(listener).toBeCalledTimes(3);
});
it('should remove listener', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
manager.removeListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).not.toBeCalled();
});
it('should remove listener on destroy', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
manager.destroy();
stateManager.setState({ fullscreen: true });
expect(listener).not.toBeCalled();
});
it('should not call listeners when the condition result does not change', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'view' as const, views: ['live'] }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(1);
stateManager.setState({ view: 'clip' });
expect(listener).toBeCalledTimes(2);
stateManager.setState({ view: 'clip' });
expect(listener).toBeCalledTimes(2);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(3);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(3);
});
});
describe('enabled', () => {
const ENABLED_TEMPLATE = '{{ is_state("binary_sensor.flag", "on") }}';
it('should ignore a disabled condition', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true, enabled: false }],
stateManager,
);
// The disabled condition is ignored, so with no remaining conditions the
// result is true even though fullscreen does not match.
stateManager.setState({ fullscreen: false });
expect(manager.getEvaluation()).toEqual({ result: true });
});
it('should evaluate an enabled condition normally', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true, enabled: true }],
stateManager,
);
stateManager.setState({ fullscreen: false });
expect(manager.getEvaluation()).toEqual({ result: false });
stateManager.setState({ fullscreen: true });
expect(manager.getEvaluation()).toEqual({ result: true });
});
it('should drop a condition whose enabled template does not render true', () => {
const stateManager = new ConditionStateManager();
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'off' }) }),
});
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
enabled: ENABLED_TEMPLATE,
},
],
stateManager,
);
stateManager.setState({ fullscreen: false });
expect(manager.getEvaluation()).toEqual({ result: true });
});
it('should evaluate a condition whose enabled template renders true', () => {
const stateManager = new ConditionStateManager();
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'on' }) }),
});
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
enabled: ENABLED_TEMPLATE,
},
],
stateManager,
);
stateManager.setState({ fullscreen: false });
expect(manager.getEvaluation()).toEqual({ result: false });
});
it('should keep a condition enabled when its template cannot render without hass', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
enabled: ENABLED_TEMPLATE,
},
],
stateManager,
);
stateManager.setState({ fullscreen: false });
// With no hass the enabled template cannot render, so the gate stays
// enabled and the condition is evaluated (here: fullscreen is false).
expect(manager.getEvaluation()).toEqual({ result: false });
});
it('should re-evaluate the enabled template on each evaluation', () => {
const stateManager = new ConditionStateManager();
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'off' }) }),
fullscreen: false,
});
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
enabled: ENABLED_TEMPLATE,
},
],
stateManager,
);
// Flag off: the condition is disabled and ignored, so the result is true.
expect(manager.getEvaluation()).toEqual({ result: true });
// Flag on: the condition is now active and fullscreen does not match.
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'on' }) }),
});
expect(manager.getEvaluation()).toEqual({ result: false });
});
});
});
tests/condition-trigger/conditions/conditions/and.test.ts
+45
View File
@@ -0,0 +1,45 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('and condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate a simple and condition', () => {
const evaluator = createConditionEvaluator(
{
condition: 'and' as const,
conditions: [
{ condition: 'fullscreen' as const, fullscreen: true },
{ condition: 'expand' as const, expand: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true }).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true, expand: true }).result).toBeTruthy();
expect(evaluator.evaluate({ fullscreen: false, expand: true }).result).toBeFalsy();
});
it('should expose its children external invalidation sources', () => {
// The `screen` child contributes an external source; the `fullscreen` child
// contributes none -- the union must include only the former.
const evaluator = createConditionEvaluator(
{
condition: 'and' as const,
conditions: [
{ condition: 'screen' as const, media_query: 'whatever' },
{ condition: 'fullscreen' as const, fullscreen: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.externalSources).toHaveLength(1);
});
});
tests/conditions/conditions/call.test.ts → tests/condition-trigger/conditions/conditions/call.test.ts
+4 -10
View File
@@ -1,18 +1,12 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { callConditionSchema } from '../../../../src/config/schema/condition-trigger/conditions/custom/call';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('call condition', () => {
it('should default to call true in its bare form', () => {
const evaluator = createConditionEvaluator(
{ condition: 'call' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ call: true }).result).toBeTruthy();
expect(evaluator.evaluate({ call: false }).result).toBeFalsy();
it('should require a value', () => {
expect(() => callConditionSchema.parse({ condition: 'call' })).toThrow();
});
it('should match when call is true', () => {
tests/condition-trigger/conditions/conditions/camera.test.ts
+48
View File
@@ -0,0 +1,48 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('camera condition', () => {
it('should match a named camera', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const, cameras: ['bar'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ camera: 'bar' }).result).toBeTruthy();
expect(evaluator.evaluate({ camera: 'will-not-match' }).result).toBeFalsy();
});
it('should match any of several named cameras', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const, cameras: ['foo', 'bar'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ camera: 'bar' }).result).toBeTruthy();
expect(evaluator.evaluate({ camera: 'foo' }).result).toBeTruthy();
expect(evaluator.evaluate({ camera: 'baz' }).result).toBeFalsy();
});
it('should match a selected camera when cameras is omitted', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ camera: 'bar' }).result).toBeTruthy();
expect(evaluator.evaluate({}).result).toBeFalsy();
});
it('should match no selected camera for an empty list', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const, cameras: [] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeTruthy();
expect(evaluator.evaluate({ camera: 'bar' }).result).toBeFalsy();
});
});
tests/conditions/conditions/display-mode.test.ts → tests/condition-trigger/conditions/conditions/display-mode.test.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
tests/conditions/conditions/expand.test.ts → tests/condition-trigger/conditions/conditions/expand.test.ts
+6 -1
View File
@@ -1,5 +1,6 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { expandConditionSchema } from '../../../../src/config/schema/condition-trigger/conditions/custom/expand';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -14,4 +15,8 @@ describe('expand condition', () => {
expect(evaluator.evaluate({ expand: true }).result).toBeTruthy();
expect(evaluator.evaluate({ expand: false }).result).toBeFalsy();
});
it('should require a value', () => {
expect(() => expandConditionSchema.parse({ condition: 'expand' })).toThrow();
});
});
tests/conditions/conditions/fullscreen.test.ts → tests/condition-trigger/conditions/conditions/fullscreen.test.ts
+6 -1
View File
@@ -1,5 +1,6 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { fullscreenConditionSchema } from '../../../../src/config/schema/condition-trigger/conditions/custom/fullscreen';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -14,4 +15,8 @@ describe('fullscreen condition', () => {
expect(evaluator.evaluate({ fullscreen: true }).result).toBeTruthy();
expect(evaluator.evaluate({ fullscreen: false }).result).toBeFalsy();
});
it('should require a value', () => {
expect(() => fullscreenConditionSchema.parse({ condition: 'fullscreen' })).toThrow();
});
});
tests/conditions/conditions/initialized.test.ts → tests/condition-trigger/conditions/conditions/initialized.test.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
tests/conditions/conditions/interaction.test.ts → tests/condition-trigger/conditions/conditions/interaction.test.ts
+8 -1
View File
@@ -1,5 +1,6 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { interactionConditionSchema } from '../../../../src/config/schema/condition-trigger/conditions/custom/interaction';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -14,4 +15,10 @@ describe('interaction condition', () => {
expect(evaluator.evaluate({ interaction: true }).result).toBeTruthy();
expect(evaluator.evaluate({ interaction: false }).result).toBeFalsy();
});
it('should require a value', () => {
expect(() =>
interactionConditionSchema.parse({ condition: 'interaction' }),
).toThrow();
});
});
tests/condition-trigger/conditions/conditions/is-template-true.test.ts
+19
View File
@@ -0,0 +1,19 @@
import { describe, expect, it } from 'vitest';
import { isTemplateTrue } from '../../../../src/condition-trigger/conditions/conditions/is-template-true';
describe('condition isTemplateTrue', () => {
it('should accept boolean true', () => {
expect(isTemplateTrue(true)).toBe(true);
});
it('should accept the string "true" case-insensitively', () => {
expect(isTemplateTrue('true')).toBe(true);
expect(isTemplateTrue('TRUE')).toBe(true);
});
it('should reject other truthy-looking values for HA symmetry', () => {
for (const value of ['yes', 'on', '1', 'enable', false, 0, null, undefined]) {
expect(isTemplateTrue(value)).toBe(false);
}
});
});
tests/conditions/conditions/key.test.ts → tests/condition-trigger/conditions/conditions/key.test.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
tests/conditions/conditions/media-loaded.test.ts → tests/condition-trigger/conditions/conditions/media-loaded.test.ts
+9 -2
View File
@@ -1,6 +1,7 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createMediaLoadedInfo } from '../../test-utils';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { mediaLoadedConditionSchema } from '../../../../src/config/schema/condition-trigger/conditions/custom/media-loaded';
import { createMediaLoadedInfo } from '../../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -17,4 +18,10 @@ describe('media loaded condition', () => {
).toBeTruthy();
expect(evaluator.evaluate({ mediaLoadedInfo: null }).result).toBeFalsy();
});
it('should require a value', () => {
expect(() =>
mediaLoadedConditionSchema.parse({ condition: 'media_loaded' }),
).toThrow();
});
});
tests/conditions/conditions/microphone.test.ts → tests/condition-trigger/conditions/conditions/microphone.test.ts
+2 -2
View File
@@ -1,6 +1,6 @@
import { describe, expect, it } from 'vitest';
import { MicrophoneState } from '../../../src/card-controller/types';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { MicrophoneState } from '../../../../src/card-controller/types';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
tests/conditions/conditions/not.test.ts → tests/condition-trigger/conditions/conditions/not.test.ts
+7 -22
View File
@@ -1,5 +1,5 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -20,28 +20,20 @@ describe('not condition', () => {
createEvaluatorContext(),
);
// Neither sub-condition is true, so `not` passes — and reports no trigger
// data (nothing is "triggering").
// Neither sub-condition is true, so `not` passes.
expect(evaluator.evaluate({})).toEqual({ result: true });
// Any sub-condition being true means `not` fails.
expect(evaluator.evaluate({ fullscreen: true }).result).toBeFalsy();
expect(evaluator.evaluate({ expand: true }).result).toBeFalsy();
// Both sub-conditions false again — `not` passes.
// Both sub-conditions false again -- `not` passes.
expect(evaluator.evaluate({ fullscreen: false, expand: false }).result).toBeTruthy();
});
it('should forward subscribe and destroy to its children', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener: addEventListener,
removeEventListener: removeEventListener,
} as unknown as MediaQueryList);
// The `screen` child supports subscribe/destroy; the `fullscreen` child does
// not — forwarding must handle both.
it('should expose its children external invalidation sources', () => {
// The `screen` child contributes an external source; the `fullscreen` child
// contributes none -- the union must include only the former.
const evaluator = createConditionEvaluator(
{
condition: 'not' as const,
@@ -53,13 +45,6 @@ describe('not condition', () => {
createEvaluatorContext(),
);
const onChange = vi.fn();
evaluator.subscribe?.(onChange);
expect(addEventListener).toHaveBeenCalledWith('change', expect.anything());
addEventListener.mock.calls[0][1]();
expect(onChange).toHaveBeenCalled();
evaluator.destroy?.();
expect(removeEventListener).toHaveBeenCalled();
expect(evaluator.externalSources).toHaveLength(1);
});
});
tests/condition-trigger/conditions/conditions/numeric-state.test.ts
+227
View File
@@ -0,0 +1,227 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createHASS, createStateEntity } from '../../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('numeric state condition', () => {
it('should match above a threshold', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity_id: 'sensor.foo', above: 10 },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: '9' }) }),
}).result,
).toBeFalsy();
});
it('should match below a threshold', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity_id: 'sensor.foo', below: 10 },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '9' }) }),
}).result,
).toBeTruthy();
});
it('should accept the entity field', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity: 'sensor.foo', above: 10 },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeTruthy();
});
it('should match a list of entities only when all of them match', () => {
const evaluator = createConditionEvaluator(
{
condition: 'numeric_state' as const,
entity_id: ['sensor.a', 'sensor.b'],
above: 10,
},
createEvaluatorContext(),
);
// Both above -> match.
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.a': createStateEntity({ state: '11' }),
'sensor.b': createStateEntity({ state: '12' }),
}),
}).result,
).toBeTruthy();
// One below -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.a': createStateEntity({ state: '11' }),
'sensor.b': createStateEntity({ state: '9' }),
}),
}).result,
).toBeFalsy();
// One absent -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.a': createStateEntity({ state: '11' }),
}),
}).result,
).toBeFalsy();
});
it('should match against an attribute instead of the state', () => {
const evaluator = createConditionEvaluator(
{
condition: 'numeric_state' as const,
entity_id: 'sensor.foo',
attribute: 'battery',
below: 20,
},
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.foo': createStateEntity({ state: 'on', attributes: { battery: 15 } }),
}),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.foo': createStateEntity({ state: 'on', attributes: { battery: 50 } }),
}),
}).result,
).toBeFalsy();
});
it('should compare the rendered value_template instead of the state', () => {
const evaluator = createConditionEvaluator(
{
condition: 'numeric_state' as const,
entity_id: 'sensor.foo',
value_template: '{{ 11 }}',
above: 10,
},
createEvaluatorContext(),
);
// The entity state (0) would fail; the template value (11) passes.
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '0' }) }),
}).result,
).toBeTruthy();
});
it('should not match when the value is not numeric', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity_id: 'sensor.foo', above: 10 },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: 'unavailable' }) }),
}).result,
).toBeFalsy();
});
it('should not match without a condition state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity_id: 'sensor.foo', above: 10 },
createEvaluatorContext(),
);
expect(evaluator.evaluate().result).toBeFalsy();
});
it('should not match when the entity is absent', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity_id: 'sensor.missing', above: 10 },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeFalsy();
});
it('should resolve an entity-id reference as the above/below threshold', () => {
const evaluator = createConditionEvaluator(
{
condition: 'numeric_state' as const,
entity_id: 'sensor.foo',
above: 'input_number.limit',
},
createEvaluatorContext(),
);
// sensor.foo (20) > input_number.limit (10) -> true.
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.foo': createStateEntity({ state: '20' }),
'input_number.limit': createStateEntity({ state: '10' }),
}),
}).result,
).toBeTruthy();
// sensor.foo (5) > input_number.limit (10) -> false.
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.foo': createStateEntity({ state: '5' }),
'input_number.limit': createStateEntity({ state: '10' }),
}),
}).result,
).toBeFalsy();
});
it('should not match when a threshold entity is unresolvable', () => {
const evaluator = createConditionEvaluator(
{
condition: 'numeric_state' as const,
entity_id: 'sensor.foo',
below: 'input_number.limit',
},
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({
'sensor.foo': createStateEntity({ state: '5' }),
'input_number.limit': createStateEntity({ state: 'unavailable' }),
}),
}).result,
).toBeFalsy();
});
});
tests/condition-trigger/conditions/conditions/or.test.ts
+45
View File
@@ -0,0 +1,45 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('or condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate a simple or condition', () => {
const evaluator = createConditionEvaluator(
{
condition: 'or' as const,
conditions: [
{ condition: 'fullscreen' as const, fullscreen: true },
{ condition: 'expand' as const, expand: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true }).result).toBeTruthy();
expect(evaluator.evaluate({ expand: true }).result).toBeTruthy();
expect(evaluator.evaluate({ fullscreen: false, expand: false }).result).toBeFalsy();
});
it('should expose its children external invalidation sources', () => {
// The `screen` child contributes an external source; the `fullscreen` child
// contributes none -- the union must include only the former.
const evaluator = createConditionEvaluator(
{
condition: 'or' as const,
conditions: [
{ condition: 'screen' as const, media_query: 'whatever' },
{ condition: 'fullscreen' as const, fullscreen: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.externalSources).toHaveLength(1);
});
});
tests/condition-trigger/conditions/conditions/screen.test.ts
+42
View File
@@ -0,0 +1,42 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('screen condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate the media query', () => {
vi.spyOn(window, 'matchMedia').mockReturnValue({
matches: true,
} as unknown as MediaQueryList);
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const, media_query: 'whatever' },
createEvaluatorContext(),
);
expect(evaluator.evaluate().result).toBeTruthy();
});
it('should expose the media query as an external invalidation source', () => {
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const, media_query: 'whatever' },
createEvaluatorContext(),
);
expect(evaluator.externalSources).toHaveLength(1);
});
it('should not match or expose a source without a media query', () => {
const matchMedia = vi.spyOn(window, 'matchMedia');
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate().result).toBeFalsy();
expect(evaluator.externalSources).toHaveLength(0);
expect(matchMedia).not.toHaveBeenCalled();
});
});
tests/condition-trigger/conditions/conditions/state.test.ts
+472
View File
@@ -0,0 +1,472 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createHASS, createStateEntity } from '../../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('state condition', () => {
it('should match any transition when neither state nor state_not is set', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity_id: 'binary_sensor.foo' },
createEvaluatorContext(),
);
expect(
evaluator.evaluate(
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
},
{},
),
).toEqual({ result: true });
expect(
evaluator.evaluate(
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
},
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
},
),
).toEqual({ result: true });
});
it('should match a single positive state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity_id: 'binary_sensor.foo', state: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should match multiple positive states', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: ['active', 'on'],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'active' }),
}),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should match a single negative state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity_id: 'binary_sensor.foo', state_not: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeTruthy();
});
it('should match multiple negative states', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state_not: ['active', 'on'],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'active' }),
}),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeTruthy();
});
it('should match an implicit state condition', () => {
const evaluator = createConditionEvaluator(
{ entity_id: 'binary_sensor.foo', state: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should not match when no entity is set', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, state: 'on' },
createEvaluatorContext(),
);
const result = evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
});
expect(result.result).toBeFalsy();
});
it('should accept the entity field', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity: 'binary_sensor.foo', state: 'on' },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should match a list of entities only when all match by default', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: ['binary_sensor.foo', 'binary_sensor.bar'],
state: 'on',
},
createEvaluatorContext(),
);
// Both on -> match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'on' }),
}),
}).result,
).toBeTruthy();
// One off -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'off' }),
}),
}).result,
).toBeFalsy();
// One absent -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
}),
}).result,
).toBeFalsy();
});
it('should match a list of entities when any matches and match is any', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: ['binary_sensor.foo', 'binary_sensor.bar'],
state: 'on',
match: 'any' as const,
},
createEvaluatorContext(),
);
// One on -> match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on' }),
'binary_sensor.bar': createStateEntity({ state: 'off' }),
}),
}).result,
).toBeTruthy();
// None on -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'off' }),
'binary_sensor.bar': createStateEntity({ state: 'off' }),
}),
}).result,
).toBeFalsy();
});
it('should match against an attribute instead of the state', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
attribute: 'device_class',
state: 'door',
},
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
attributes: { device_class: 'door' },
}),
}),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
attributes: { device_class: 'window' },
}),
}),
}).result,
).toBeFalsy();
// Attribute absent on the entity -> no value -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on', attributes: {} }),
}),
}).result,
).toBeFalsy();
});
describe('for', () => {
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-06-05T22:56:56Z'));
});
afterEach(() => {
vi.useRealTimers();
});
it('should not match until the state has been held long enough', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: 'on',
for: '00:00:05',
},
createEvaluatorContext(),
);
// Held 2s (< 5s) -> no match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
last_changed: '2026-06-05T22:56:54Z',
}),
}),
}).result,
).toBeFalsy();
// Held 8s (>= 5s) -> match.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
last_changed: '2026-06-05T22:56:48Z',
}),
}),
}).result,
).toBeTruthy();
});
it('should render a templated "for" before comparing', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: 'on',
for: "{{ states('input_number.delay') }}",
},
createEvaluatorContext(),
);
const evaluateHeldSince = (lastChanged: string): boolean =>
!!evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
last_changed: lastChanged,
}),
'input_number.delay': createStateEntity({ state: '5' }),
}),
}).result;
// `for` renders to 5s: held 2s -> no match, held 8s -> match.
expect(evaluateHeldSince('2026-06-05T22:56:54Z')).toBe(false);
expect(evaluateHeldSince('2026-06-05T22:56:48Z')).toBe(true);
});
it('should not match when last_changed is unavailable', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: 'on',
for: '00:00:05',
},
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'on', last_changed: '' }),
}),
}).result,
).toBeFalsy();
});
it('should not match when for is unparseable', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: 'on',
for: 'not-a-duration',
},
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({
state: 'on',
last_changed: '2026-06-05T22:56:46Z',
}),
}),
}).result,
).toBeFalsy();
});
});
it('should resolve an expected state that names another entity', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity_id: 'binary_sensor.foo',
state: 'input_text.expected',
},
createEvaluatorContext(),
);
// The entity's state matches the resolved state of `input_text.expected`.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'armed' }),
'input_text.expected': createStateEntity({ state: 'armed' }),
}),
}).result,
).toBeTruthy();
// It does not match when the resolved state differs.
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'disarmed' }),
'input_text.expected': createStateEntity({ state: 'armed' }),
}),
}).result,
).toBeFalsy();
});
it('should match a state_not against an empty-string entity state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity_id: 'sensor.foo', state_not: 'on' },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '' }) }),
}).result,
).toBeTruthy();
});
it('should match an empty-string expected state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity_id: 'sensor.foo', state: '' },
createEvaluatorContext(),
);
// An entity state of "" matches the configured empty `state`.
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '' }) }),
}).result,
).toBeTruthy();
// A non-empty entity state does not.
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: 'on' }) }),
}).result,
).toBeFalsy();
});
});
tests/conditions/conditions/template.test.ts → tests/condition-trigger/conditions/conditions/template.test.ts
+11 -2
View File
@@ -1,6 +1,6 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createHASS, createStateEntity } from '../../test-utils';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createHASS, createStateEntity } from '../../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -43,4 +43,13 @@ describe('template condition', () => {
}).result,
).toBeFalsy();
});
it('should accept a template rendering the string "true" for HA symmetry', () => {
const evaluator = createConditionEvaluator(
{ condition: 'template' as const, value_template: '{{ "true" }}' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ hass: createHASS({}) }).result).toBeTruthy();
});
});
tests/condition-trigger/conditions/conditions/test-utils.ts
+6
View File
@@ -0,0 +1,6 @@
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { EvaluatorContext } from '../../../../src/condition-trigger/conditions/conditions/types';
export const createEvaluatorContext = (): EvaluatorContext => ({
templateRenderer: new TemplateRenderer(),
});
tests/condition-trigger/conditions/conditions/triggered.test.ts
+43
View File
@@ -0,0 +1,43 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('triggered condition', () => {
it('should match any triggered camera when no list is given', () => {
const evaluator = createConditionEvaluator(
{ condition: 'triggered' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ triggered: new Set() }).result).toBeFalsy();
expect(evaluator.evaluate({ triggered: new Set(['camera_1']) }).result).toBeTruthy();
});
it('should match when one of the listed cameras is triggered', () => {
const evaluator = createConditionEvaluator(
{ condition: 'triggered' as const, triggered: ['camera_1', 'camera_2'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ triggered: new Set(['camera_1']) }).result).toBeTruthy();
expect(
evaluator.evaluate({ triggered: new Set(['camera_2', 'camera_1', 'camera_3']) })
.result,
).toBeTruthy();
expect(evaluator.evaluate({ triggered: new Set(['camera_3']) }).result).toBeFalsy();
});
it('should match when no camera is triggered for an empty list', () => {
const evaluator = createConditionEvaluator(
{ condition: 'triggered' as const, triggered: [] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeTruthy();
expect(evaluator.evaluate({ triggered: new Set() }).result).toBeTruthy();
expect(evaluator.evaluate({ triggered: new Set(['camera_1']) }).result).toBeFalsy();
});
});
tests/conditions/conditions/user-agent.test.ts → tests/condition-trigger/conditions/conditions/user-agent.test.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
tests/conditions/conditions/user.test.ts → tests/condition-trigger/conditions/conditions/user.test.ts
+13 -2
View File
@@ -1,6 +1,6 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createHASS, createUser } from '../../test-utils';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createHASS, createUser } from '../../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -20,4 +20,15 @@ describe('user condition', () => {
.result,
).toBeFalsy();
});
it('should not match when no users are set', () => {
const evaluator = createConditionEvaluator(
{ condition: 'user' as const },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({ hass: createHASS({}, createUser({ id: 'user_1' })) }).result,
).toBeFalsy();
});
});
tests/conditions/conditions/view.test.ts → tests/condition-trigger/conditions/conditions/view.test.ts
+6 -21
View File
@@ -1,5 +1,5 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConditionEvaluator } from '../../../../src/condition-trigger/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
@@ -15,29 +15,14 @@ describe('view condition', () => {
expect(evaluator.evaluate({ view: 'clips' }).result).toBeFalsy();
});
it('should report trigger data for any view change', () => {
it('should match any of several named views', () => {
const evaluator = createConditionEvaluator(
{ condition: 'view' as const },
{ condition: 'view' as const, views: ['live', 'clips'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ view: 'clips' }, {})).toEqual({
result: true,
triggerData: {
view: {
to: 'clips',
},
},
});
expect(evaluator.evaluate({ view: 'timeline' }, { view: 'clips' })).toEqual({
result: true,
triggerData: {
view: {
from: 'clips',
to: 'timeline',
},
},
});
expect(evaluator.evaluate({ view: 'live' }).result).toBeTruthy();
expect(evaluator.evaluate({ view: 'clips' }).result).toBeTruthy();
expect(evaluator.evaluate({ view: 'timeline' }).result).toBeFalsy();
});
});
tests/condition-trigger/conditions/factory.test.ts
+49
View File
@@ -0,0 +1,49 @@
import { describe, expect, it } from 'vitest';
import { CallConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/call';
import { CameraConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/camera';
import { DisplayModeConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/display-mode';
import { ExpandConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/expand';
import { FullscreenConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/fullscreen';
import { InteractionConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/interaction';
import { KeyConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/key';
import { MediaLoadedConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/media-loaded';
import { MicrophoneConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/microphone';
import { TriggeredConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/triggered';
import { ConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/types';
import { ViewConditionEvaluator } from '../../../src/condition-trigger/conditions/conditions/view';
import { createConditionEvaluatorForTrigger } from '../../../src/condition-trigger/conditions/factory';
import { Trigger } from '../../../src/config/schema/condition-trigger/triggers/types';
type ConditionEvaluatorConstructor = new (...args: never[]) => ConditionEvaluator;
describe('createConditionEvaluatorForTrigger', () => {
it.each<[Trigger, ConditionEvaluatorConstructor]>([
[{ trigger: 'call', call: true }, CallConditionEvaluator],
[{ trigger: 'camera', cameras: ['front'] }, CameraConditionEvaluator],
[{ trigger: 'display_mode', display_mode: 'single' }, DisplayModeConditionEvaluator],
[{ trigger: 'expand', expand: true }, ExpandConditionEvaluator],
[{ trigger: 'fullscreen', fullscreen: true }, FullscreenConditionEvaluator],
[{ trigger: 'interaction', interaction: true }, InteractionConditionEvaluator],
[{ trigger: 'key', key: 'a' }, KeyConditionEvaluator],
[{ trigger: 'media_loaded', media_loaded: true }, MediaLoadedConditionEvaluator],
[{ trigger: 'microphone', muted: true }, MicrophoneConditionEvaluator],
[{ trigger: 'triggered', triggered: ['front'] }, TriggeredConditionEvaluator],
[{ trigger: 'view', views: ['live'] }, ViewConditionEvaluator],
])(
'should reuse the matching condition for a valued %o trigger',
(trigger, expected) => {
expect(createConditionEvaluatorForTrigger(trigger)).toBeInstanceOf(expected);
},
);
it.each<[string, Trigger]>([
['a valueless trigger fires on any change', { trigger: 'fullscreen' }],
['config has no matching condition', { trigger: 'config', paths: ['menu.style'] }],
[
'stock triggers evaluate themselves',
{ trigger: 'state', entity_id: 'binary_sensor.x' },
],
])('should have no condition when %s', (_description, trigger) => {
expect(createConditionEvaluatorForTrigger(trigger)).toBeNull();
});
});
tests/conditions/state-manager-via-event.test.ts → tests/condition-trigger/conditions/state-manager-via-event.test.ts
+2 -2
View File
@@ -1,10 +1,10 @@
import { describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import {
ConditionStateManagerGetEvent,
getConditionStateManagerViaEvent,
} from '../../src/conditions/state-manager-via-event';
} from '../../../src/condition-trigger/conditions/state-manager-via-event';
// @vitest-environment jsdom
describe('getConditionStateManagerViaEvent', () => {
tests/conditions/state-manager.test.ts → tests/condition-trigger/conditions/state-manager.test.ts
+46 -2
View File
@@ -1,6 +1,10 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { createHASS, createStateEntity } from '../test-utils';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import {
ConditionState,
ConditionStateChange,
} from '../../../src/condition-trigger/conditions/types';
import { createHASS, createStateEntity } from '../../test-utils';
describe('ConditionStateManager', () => {
afterEach(() => {
@@ -83,6 +87,46 @@ describe('ConditionStateManager', () => {
});
});
it('should serialize a state change made from within a listener', () => {
const manager = new ConditionStateManager();
const seen: ConditionStateChange[] = [];
let reentrantReturn: boolean | null | undefined = undefined;
let stateDuringDispatch: ConditionState | undefined;
manager.addListener((change) => {
seen.push(change);
// Reentrantly flip the value the originating change just set, capturing
// what is observable mid-dispatch so it can be asserted outside the
// callback (where a failure cannot be swallowed).
if (reentrantReturn === undefined) {
reentrantReturn = manager.setState({ fullscreen: false });
stateDuringDispatch = manager.getState();
}
});
expect(manager.setState({ fullscreen: true })).toBe(true);
// The reentrant change is deferred: it returns null and, crucially, is NOT
// applied while the originating dispatch is still in flight -- fullscreen is
// still true despite the reentrant call to set it false.
expect(reentrantReturn).toBeNull();
expect(stateDuringDispatch).toEqual({ fullscreen: true });
// It is dispatched only after the originating change, seeing that change's
// result as its own `old`: a coherent edge, not a torn state. Only now does
// fullscreen become false.
expect(seen).toEqual([
{ old: {}, change: { fullscreen: true }, new: { fullscreen: true } },
{
old: { fullscreen: true },
change: { fullscreen: false },
new: { fullscreen: false },
},
]);
expect(manager.getState()).toEqual({ fullscreen: false });
});
it('should add listener', () => {
const listener = vi.fn();
const manager = new ConditionStateManager();
tests/condition-trigger/triggers/factory.test.ts
+58
View File
@@ -0,0 +1,58 @@
import { describe, expect, it } from 'vitest';
import { TemplateRenderer } from '../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { createTriggerEvaluator } from '../../../src/condition-trigger/triggers/factory';
import { CallTrigger } from '../../../src/condition-trigger/triggers/triggers/call';
import { CameraTrigger } from '../../../src/condition-trigger/triggers/triggers/camera';
import { ConfigTrigger } from '../../../src/condition-trigger/triggers/triggers/config';
import { DisplayModeTrigger } from '../../../src/condition-trigger/triggers/triggers/display-mode';
import { ExpandTrigger } from '../../../src/condition-trigger/triggers/triggers/expand';
import { FullscreenTrigger } from '../../../src/condition-trigger/triggers/triggers/fullscreen';
import { InitializedTrigger } from '../../../src/condition-trigger/triggers/triggers/initialized';
import { InteractionTrigger } from '../../../src/condition-trigger/triggers/triggers/interaction';
import { KeyTrigger } from '../../../src/condition-trigger/triggers/triggers/key';
import { MediaLoadedTrigger } from '../../../src/condition-trigger/triggers/triggers/media-loaded';
import { MicrophoneTrigger } from '../../../src/condition-trigger/triggers/triggers/microphone';
import { NumericStateTrigger } from '../../../src/condition-trigger/triggers/triggers/numeric-state';
import { ScreenTrigger } from '../../../src/condition-trigger/triggers/triggers/screen';
import { StateTrigger } from '../../../src/condition-trigger/triggers/triggers/state';
import { TemplateTrigger } from '../../../src/condition-trigger/triggers/triggers/template';
import { TriggeredTrigger } from '../../../src/condition-trigger/triggers/triggers/triggered';
import {
TriggerEvaluator,
TriggerEvaluatorContext,
} from '../../../src/condition-trigger/triggers/triggers/types';
import { ViewTrigger } from '../../../src/condition-trigger/triggers/triggers/view';
import { Trigger } from '../../../src/config/schema/condition-trigger/triggers/types';
type TriggerEvaluatorConstructor = new (...args: never[]) => TriggerEvaluator;
// @vitest-environment jsdom
describe('createTriggerEvaluator', () => {
const context = (): TriggerEvaluatorContext => ({
stateManager: new ConditionStateManager(),
templateRenderer: new TemplateRenderer(),
});
it.each<[Trigger, TriggerEvaluatorConstructor]>([
[{ trigger: 'state', entity_id: 'binary_sensor.x' }, StateTrigger],
[{ trigger: 'numeric_state', entity_id: 'sensor.x', above: 5 }, NumericStateTrigger],
[{ trigger: 'template', value_template: '{{ true }}' }, TemplateTrigger],
[{ trigger: 'call', call: true }, CallTrigger],
[{ trigger: 'camera', cameras: ['front'] }, CameraTrigger],
[{ trigger: 'config' }, ConfigTrigger],
[{ trigger: 'display_mode', display_mode: 'single' }, DisplayModeTrigger],
[{ trigger: 'expand', expand: true }, ExpandTrigger],
[{ trigger: 'fullscreen', fullscreen: true }, FullscreenTrigger],
[{ trigger: 'interaction', interaction: true }, InteractionTrigger],
[{ trigger: 'media_loaded', media_loaded: true }, MediaLoadedTrigger],
[{ trigger: 'microphone', muted: true }, MicrophoneTrigger],
[{ trigger: 'triggered' }, TriggeredTrigger],
[{ trigger: 'view', views: ['live'] }, ViewTrigger],
[{ trigger: 'initialized' }, InitializedTrigger],
[{ trigger: 'key', key: 'a' }, KeyTrigger],
[{ trigger: 'screen' }, ScreenTrigger],
])('should create the dedicated evaluator for a %o trigger', (trigger, expected) => {
expect(createTriggerEvaluator(trigger, context())).toBeInstanceOf(expected);
});
});
tests/condition-trigger/triggers/manager.test.ts
+189
View File
@@ -0,0 +1,189 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { ConditionStateManager } from '../../../src/condition-trigger/conditions/state-manager';
import { TriggersManager } from '../../../src/condition-trigger/triggers/manager';
import { Trigger } from '../../../src/config/schema/condition-trigger/triggers/types';
import { createHASS, createStateEntity } from '../../test-utils';
// @vitest-environment jsdom
describe('TriggersManager', () => {
const create = (
triggers: Trigger[],
): {
manager: TriggersManager;
stateManager: ConditionStateManager;
listener: Mock;
} => {
const stateManager = new ConditionStateManager();
const manager = new TriggersManager(triggers, stateManager);
const listener = vi.fn();
return { manager, stateManager, listener };
};
it('should notify a listener when any of its trigger evaluators triggers', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'] },
{ trigger: 'view', views: ['live'] },
]);
manager.addListener(listener);
stateManager.setState({ camera: 'front' });
expect(listener).toHaveBeenCalledTimes(1);
expect(listener).toHaveBeenLastCalledWith(
expect.objectContaining({ platform: 'acc', type: 'camera' }),
);
stateManager.setState({ view: 'live' });
expect(listener).toHaveBeenCalledTimes(2);
expect(listener).toHaveBeenLastCalledWith(
expect.objectContaining({ platform: 'acc', type: 'view' }),
);
});
it('should notify every registered listener', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'] },
]);
const other = vi.fn();
manager.addListener(listener);
manager.addListener(other);
stateManager.setState({ camera: 'front' });
expect(listener).toHaveBeenCalledTimes(1);
expect(other).toHaveBeenCalledTimes(1);
});
it('should register the same listener only once', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'] },
]);
manager.addListener(listener);
manager.addListener(listener);
stateManager.setState({ camera: 'front' });
expect(listener).toHaveBeenCalledTimes(1);
});
it('should not notify a removed listener', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'] },
]);
manager.addListener(listener);
manager.removeListener(listener);
stateManager.setState({ camera: 'front' });
expect(listener).not.toHaveBeenCalled();
});
it('should stop triggering after destroy', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'] },
]);
manager.addListener(listener);
manager.destroy();
stateManager.setState({ camera: 'front' });
expect(listener).not.toHaveBeenCalled();
});
describe('enabled', () => {
const ENABLED_TEMPLATE = '{{ is_state("binary_sensor.flag", "on") }}';
const createWithFlag = (
enabled: string,
state: string | null,
): { stateManager: ConditionStateManager; listener: Mock } => {
const stateManager = new ConditionStateManager();
if (state !== null) {
stateManager.setState({
hass: createHASS({
'binary_sensor.flag': createStateEntity({ state }),
}),
});
}
const manager = new TriggersManager(
[{ trigger: 'camera', cameras: ['front'], enabled }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
return { stateManager, listener };
};
it('should not trigger a disabled trigger', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'], enabled: false },
]);
manager.addListener(listener);
stateManager.setState({ camera: 'front' });
expect(listener).not.toHaveBeenCalled();
});
it('should trigger an explicitly enabled trigger', () => {
const { manager, stateManager, listener } = create([
{ trigger: 'camera', cameras: ['front'], enabled: true },
]);
manager.addListener(listener);
stateManager.setState({ camera: 'front' });
expect(listener).toHaveBeenCalledTimes(1);
});
it('should not trigger a trigger whose enabled template does not render true', () => {
const { stateManager, listener } = createWithFlag(ENABLED_TEMPLATE, 'off');
stateManager.setState({ camera: 'front' });
expect(listener).not.toHaveBeenCalled();
});
it('should trigger a trigger whose enabled template renders true', () => {
const { stateManager, listener } = createWithFlag(ENABLED_TEMPLATE, 'on');
stateManager.setState({ camera: 'front' });
expect(listener).toHaveBeenCalledTimes(1);
});
it('should not trigger a trigger whose enabled template cannot render without hass', () => {
const { stateManager, listener } = createWithFlag(ENABLED_TEMPLATE, null);
stateManager.setState({ camera: 'front' });
// With no hass the enabled template cannot render, so the trigger fails
// closed and does not fire.
expect(listener).not.toHaveBeenCalled();
});
it('should re-evaluate the enabled template on each trigger', () => {
const stateManager = new ConditionStateManager();
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'off' }) }),
});
const manager = new TriggersManager(
[{ trigger: 'camera', cameras: ['front', 'back'], enabled: ENABLED_TEMPLATE }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
// Flag off: the enabled template renders false, so the camera change is
// suppressed and the listener is not notified.
stateManager.setState({ camera: 'front' });
expect(listener).not.toHaveBeenCalled();
// Flag flips on: a subsequent trigger is now allowed through.
stateManager.setState({
hass: createHASS({ 'binary_sensor.flag': createStateEntity({ state: 'on' }) }),
});
stateManager.setState({ camera: 'back' });
expect(listener).toHaveBeenCalledTimes(1);
});
});
});
tests/condition-trigger/triggers/triggers/call.test.ts
+48
View File
@@ -0,0 +1,48 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { CallTrigger } from '../../../../src/condition-trigger/triggers/triggers/call';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('CallTrigger', () => {
const create = (
trigger: TriggerOfType<'call'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new CallTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should treat an absent call state as not-in-call', () => {
const { stateManager, callback } = create({ trigger: 'call' });
// Absent (undefined) is equivalent to false, so this is not a change.
stateManager.setState({ call: false });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ call: true });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger only on changes to the given value', () => {
const { stateManager, callback } = create({ trigger: 'call', call: true });
stateManager.setState({ call: true });
stateManager.setState({ call: false });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { stateManager, callback } = create({ trigger: 'call', call: false });
stateManager.setState({ call: true });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ call: false });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/camera.test.ts
+158
View File
@@ -0,0 +1,158 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { CameraTrigger } from '../../../../src/condition-trigger/triggers/triggers/camera';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createConfig } from '../../../test-utils';
// @vitest-environment jsdom
describe('CameraTrigger', () => {
const create = (
trigger: TriggerOfType<'camera'>,
): {
cameraTrigger: CameraTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const cameraTrigger = new CameraTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { cameraTrigger, stateManager, callback };
};
it('should trigger when the selected camera changes to a listed one', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front', 'back'],
});
cameraTrigger.subscribe(callback);
// An unlisted camera does not trigger.
stateManager.setState({ camera: 'side' });
expect(callback).not.toHaveBeenCalled();
// Crossing to a listed camera triggers, with the before/after trigger data.
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith({
platform: 'acc',
type: 'camera',
from_acc: { camera: 'side' },
to_acc: { camera: 'front' },
});
});
it('should trigger again when the camera changes between two listed cameras', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front', 'back'],
});
cameraTrigger.subscribe(callback);
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenCalledTimes(1);
// Still matching, but the camera moved: triggers again.
stateManager.setState({ camera: 'back' });
expect(callback).toHaveBeenCalledTimes(2);
expect(callback).toHaveBeenLastCalledWith({
platform: 'acc',
type: 'camera',
from_acc: { camera: 'front' },
to_acc: { camera: 'back' },
});
});
it('should not trigger on an unrelated state change while the camera is unchanged', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front'],
});
cameraTrigger.subscribe(callback);
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ fullscreen: true });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger once the camera leaves the listed set', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front'],
});
cameraTrigger.subscribe(callback);
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ camera: 'side' });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on any camera change without a listed set', () => {
const { cameraTrigger, stateManager, callback } = create({ trigger: 'camera' });
cameraTrigger.subscribe(callback);
stateManager.setState({ camera: 'side' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenCalledTimes(2);
// An unrelated change leaves the camera unchanged: no trigger.
stateManager.setState({ fullscreen: true });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only when the camera becomes unselected for an empty list', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: [],
});
cameraTrigger.subscribe(callback);
// Changing between cameras does not trigger.
stateManager.setState({ camera: 'front' });
stateManager.setState({ camera: 'back' });
expect(callback).not.toHaveBeenCalled();
// Becoming unselected triggers.
stateManager.setState({ camera: undefined });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should include camera, view and config in the trigger data', () => {
const config = createConfig();
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front'],
});
cameraTrigger.subscribe(callback);
stateManager.setState({ camera: 'side', view: 'live', config });
stateManager.setState({ camera: 'front' });
expect(callback).toHaveBeenLastCalledWith({
platform: 'acc',
type: 'camera',
from_acc: { camera: 'side', view: 'live', config },
to_acc: { camera: 'front', view: 'live', config },
});
});
it('should stop triggering after destroy', () => {
const { cameraTrigger, stateManager, callback } = create({
trigger: 'camera',
cameras: ['front'],
});
cameraTrigger.subscribe(callback);
cameraTrigger.destroy();
stateManager.setState({ camera: 'front' });
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/config.test.ts
+98
View File
@@ -0,0 +1,98 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { ConfigTrigger } from '../../../../src/condition-trigger/triggers/triggers/config';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createConfig } from '../../../test-utils';
// @vitest-environment jsdom
describe('ConfigTrigger', () => {
const create = (
trigger: TriggerOfType<'config'>,
): {
configTrigger: ConfigTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const configTrigger = new ConfigTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { configTrigger, stateManager, callback };
};
it('should trigger whenever the config changes', () => {
const { configTrigger, stateManager, callback } = create({ trigger: 'config' });
configTrigger.subscribe(callback);
stateManager.setState({ config: createConfig() });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ config: createConfig({ menu: { style: 'outside' } }) });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should not trigger when the config is unchanged', () => {
const { configTrigger, stateManager, callback } = create({ trigger: 'config' });
configTrigger.subscribe(callback);
stateManager.setState({ config: createConfig() });
expect(callback).toHaveBeenCalledTimes(1);
// An unrelated state change leaves the config untouched.
stateManager.setState({ fullscreen: true });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger only when a listed path changes', () => {
const { configTrigger, stateManager, callback } = create({
trigger: 'config',
paths: ['menu.style'],
});
configTrigger.subscribe(callback);
stateManager.setState({
config: createConfig({ menu: { style: 'outside', position: 'top' } }),
});
expect(callback).toHaveBeenCalledTimes(1);
// A config change that leaves `menu.style` untouched does not trigger.
stateManager.setState({
config: createConfig({ menu: { style: 'outside', position: 'bottom' } }),
});
expect(callback).toHaveBeenCalledTimes(1);
// Changing `menu.style` triggers.
stateManager.setState({
config: createConfig({ menu: { style: 'hidden', position: 'bottom' } }),
});
expect(callback).toHaveBeenCalledTimes(2);
});
it('should include camera, view and config in the trigger data', () => {
const config = createConfig();
const config2 = createConfig({ menu: { style: 'outside' } });
const { configTrigger, stateManager, callback } = create({ trigger: 'config' });
configTrigger.subscribe(callback);
stateManager.setState({ config, camera: 'front', view: 'live' });
stateManager.setState({ config: config2 });
expect(callback).toHaveBeenLastCalledWith({
platform: 'acc',
type: 'config',
from_acc: { camera: 'front', view: 'live', config },
to_acc: { camera: 'front', view: 'live', config: config2 },
});
});
it('should stop triggering after destroy', () => {
const { configTrigger, stateManager, callback } = create({ trigger: 'config' });
configTrigger.subscribe(callback);
configTrigger.destroy();
stateManager.setState({ config: createConfig() });
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/display-mode.test.ts
+39
View File
@@ -0,0 +1,39 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { DisplayModeTrigger } from '../../../../src/condition-trigger/triggers/triggers/display-mode';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('DisplayModeTrigger', () => {
const create = (
trigger: TriggerOfType<'display_mode'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new DisplayModeTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger on any change without a value', () => {
const { stateManager, callback } = create({ trigger: 'display_mode' });
stateManager.setState({ displayMode: 'single' });
stateManager.setState({ displayMode: 'grid' });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given value', () => {
const { stateManager, callback } = create({
trigger: 'display_mode',
display_mode: 'grid',
});
stateManager.setState({ displayMode: 'single' });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ displayMode: 'grid' });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/expand.test.ts
+44
View File
@@ -0,0 +1,44 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { ExpandTrigger } from '../../../../src/condition-trigger/triggers/triggers/expand';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('ExpandTrigger', () => {
const create = (
trigger: TriggerOfType<'expand'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new ExpandTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger on any change without a value', () => {
const { stateManager, callback } = create({ trigger: 'expand' });
stateManager.setState({ expand: true });
stateManager.setState({ expand: false });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given value', () => {
const { stateManager, callback } = create({ trigger: 'expand', expand: true });
stateManager.setState({ expand: true });
stateManager.setState({ expand: false });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { stateManager, callback } = create({ trigger: 'expand', expand: false });
stateManager.setState({ expand: true });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ expand: false });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/fullscreen.test.ts
+83
View File
@@ -0,0 +1,83 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { FullscreenTrigger } from '../../../../src/condition-trigger/triggers/triggers/fullscreen';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('FullscreenTrigger', () => {
const create = (
trigger: TriggerOfType<'fullscreen'>,
): {
fullscreenTrigger: FullscreenTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const fullscreenTrigger = new FullscreenTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { fullscreenTrigger, stateManager, callback };
};
it('should trigger on any change without a value', () => {
const { fullscreenTrigger, stateManager, callback } = create({
trigger: 'fullscreen',
});
fullscreenTrigger.subscribe(callback);
stateManager.setState({ fullscreen: true });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith({ platform: 'acc', type: 'fullscreen' });
// The falling edge triggers too.
stateManager.setState({ fullscreen: false });
expect(callback).toHaveBeenCalledTimes(2);
// An unrelated change does not.
stateManager.setState({ expand: true });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given value', () => {
const { fullscreenTrigger, stateManager, callback } = create({
trigger: 'fullscreen',
fullscreen: true,
});
fullscreenTrigger.subscribe(callback);
stateManager.setState({ fullscreen: true });
expect(callback).toHaveBeenCalledTimes(1);
// Leaving fullscreen does not trigger this `true`-filtered trigger.
stateManager.setState({ fullscreen: false });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { fullscreenTrigger, stateManager, callback } = create({
trigger: 'fullscreen',
fullscreen: false,
});
fullscreenTrigger.subscribe(callback);
stateManager.setState({ fullscreen: true });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ fullscreen: false });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should stop triggering after destroy', () => {
const { fullscreenTrigger, stateManager, callback } = create({
trigger: 'fullscreen',
});
fullscreenTrigger.subscribe(callback);
fullscreenTrigger.destroy();
stateManager.setState({ fullscreen: true });
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/interaction.test.ts
+50
View File
@@ -0,0 +1,50 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { InteractionTrigger } from '../../../../src/condition-trigger/triggers/triggers/interaction';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('InteractionTrigger', () => {
const create = (
trigger: TriggerOfType<'interaction'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new InteractionTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger on any change without a value', () => {
const { stateManager, callback } = create({ trigger: 'interaction' });
stateManager.setState({ interaction: true });
stateManager.setState({ interaction: false });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given value', () => {
const { stateManager, callback } = create({
trigger: 'interaction',
interaction: true,
});
stateManager.setState({ interaction: true });
stateManager.setState({ interaction: false });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { stateManager, callback } = create({
trigger: 'interaction',
interaction: false,
});
stateManager.setState({ interaction: true });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ interaction: false });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/is-template-true.test.ts
+29
View File
@@ -0,0 +1,29 @@
import { describe, expect, it } from 'vitest';
import { isTemplateTrue } from '../../../../src/condition-trigger/triggers/triggers/is-template-true';
describe('trigger isTemplateTrue', () => {
it('should pass booleans through', () => {
expect(isTemplateTrue(true)).toBe(true);
expect(isTemplateTrue(false)).toBe(false);
});
it('should treat a non-zero number as true', () => {
expect(isTemplateTrue(1)).toBe(true);
expect(isTemplateTrue(0)).toBe(false);
});
it('should accept HA truthy strings case-insensitively', () => {
for (const value of ['1', 'true', 'YES', 'On', 'enable']) {
expect(isTemplateTrue(value)).toBe(true);
}
});
it('should reject falsey strings and other types', () => {
for (const value of ['0', 'false', 'no', 'off', 'disable', 'whatever']) {
expect(isTemplateTrue(value)).toBe(false);
}
expect(isTemplateTrue(null)).toBe(false);
expect(isTemplateTrue(undefined)).toBe(false);
expect(isTemplateTrue({})).toBe(false);
});
});
tests/condition-trigger/triggers/triggers/media-loaded.test.ts
+57
View File
@@ -0,0 +1,57 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { MediaLoadedTrigger } from '../../../../src/condition-trigger/triggers/triggers/media-loaded';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createMediaLoadedInfo } from '../../../test-utils';
// @vitest-environment jsdom
describe('MediaLoadedTrigger', () => {
const create = (
trigger: TriggerOfType<'media_loaded'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new MediaLoadedTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger when media presence changes without a value', () => {
const { stateManager, callback } = create({ trigger: 'media_loaded' });
stateManager.setState({ mediaLoadedInfo: createMediaLoadedInfo() });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ mediaLoadedInfo: null });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given value', () => {
const { stateManager, callback } = create({
trigger: 'media_loaded',
media_loaded: true,
});
stateManager.setState({ mediaLoadedInfo: createMediaLoadedInfo() });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ mediaLoadedInfo: null });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { stateManager, callback } = create({
trigger: 'media_loaded',
media_loaded: false,
});
stateManager.setState({ mediaLoadedInfo: createMediaLoadedInfo() });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ mediaLoadedInfo: null });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/microphone.test.ts
+54
View File
@@ -0,0 +1,54 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { MicrophoneState } from '../../../../src/card-controller/types';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { MicrophoneTrigger } from '../../../../src/condition-trigger/triggers/triggers/microphone';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('MicrophoneTrigger', () => {
const createMicrophoneState = (state: Partial<MicrophoneState>): MicrophoneState => ({
connected: false,
muted: false,
forbidden: false,
...state,
});
const create = (
trigger: TriggerOfType<'microphone'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new MicrophoneTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger on any mute change without a value', () => {
const { stateManager, callback } = create({ trigger: 'microphone' });
stateManager.setState({ microphone: createMicrophoneState({ muted: true }) });
stateManager.setState({ microphone: createMicrophoneState({ muted: false }) });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger only on changes to the given mute value', () => {
const { stateManager, callback } = create({ trigger: 'microphone', muted: true });
stateManager.setState({ microphone: createMicrophoneState({ muted: true }) });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ microphone: createMicrophoneState({ muted: false }) });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on the falling edge to a false value', () => {
const { stateManager, callback } = create({ trigger: 'microphone', muted: false });
stateManager.setState({ microphone: createMicrophoneState({ muted: true }) });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ microphone: createMicrophoneState({ muted: false }) });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/numeric-state.test.ts
+455
View File
@@ -0,0 +1,455 @@
import { HassEntities, HassEntity } from 'home-assistant-js-websocket';
import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { NumericStateTrigger } from '../../../../src/condition-trigger/triggers/triggers/numeric-state';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createHASS, createStateEntity } from '../../../test-utils';
const SENSOR = 'sensor.temperature';
const SENSOR_TWO = 'sensor.humidity';
const THRESHOLD = 'input_number.limit';
// @vitest-environment jsdom
describe('NumericStateTrigger', () => {
const create = (
config: TriggerOfType<'numeric_state'>,
): {
trigger: NumericStateTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const trigger = new NumericStateTrigger(config, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { trigger, stateManager, callback };
};
const setHass = (
manager: ConditionStateManager,
states: Record<string, Partial<HassEntity>>,
): void => {
const entities: HassEntities = {};
for (const [id, partial] of Object.entries(states)) {
entities[id] = createStateEntity(partial);
}
manager.setState({ hass: createHASS(entities) });
};
it('should trigger on the crossing into range', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
// Below the threshold: arms but does not trigger.
setHass(stateManager, { [SENSOR]: { state: '10' } });
expect(callback).not.toHaveBeenCalled();
// Crosses above the threshold: triggers once.
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith(
expect.objectContaining({
platform: 'numeric_state',
entity_id: SENSOR,
entity: SENSOR,
}),
);
});
it('should not re-trigger while the value stays in range', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
// Still in range: not a fresh crossing, so no re-trigger.
setHass(stateManager, { [SENSOR]: { state: '26' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger again after leaving and re-entering the range', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
// Leave the range (re-arms), then cross back in.
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should respect a range with both above and below', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
below: 30,
});
trigger.subscribe(callback);
// Below the range: arms.
setHass(stateManager, { [SENSOR]: { state: '10' } });
// Into the range: triggers.
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
// Out the top of the range: re-arms, no trigger.
setHass(stateManager, { [SENSOR]: { state: '35' } });
expect(callback).toHaveBeenCalledTimes(1);
// Back into the range: triggers again.
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should resolve an entity-id reference as the threshold', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: THRESHOLD,
});
trigger.subscribe(callback);
// 10 > 20 is false: arms.
setHass(stateManager, { [SENSOR]: { state: '10' }, [THRESHOLD]: { state: '20' } });
// 25 > 20 is true: triggers.
setHass(stateManager, { [SENSOR]: { state: '25' }, [THRESHOLD]: { state: '20' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should match against an attribute', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
attribute: 'battery',
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: 'on', attributes: { battery: 10 } } });
setHass(stateManager, { [SENSOR]: { state: 'on', attributes: { battery: 25 } } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should match the rendered value_template', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
value_template: `{{ states('${SENSOR}') | float * 10 }}`,
above: 20,
});
trigger.subscribe(callback);
// Template value 1 * 10 = 10: arms.
setHass(stateManager, { [SENSOR]: { state: '1' } });
// Template value 3 * 10 = 30: crosses in and triggers.
setHass(stateManager, { [SENSOR]: { state: '3' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should fan out independently over a list of entities', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: [SENSOR, SENSOR_TWO],
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, {
[SENSOR]: { state: '10' },
[SENSOR_TWO]: { state: '10' },
});
// Only SENSOR crosses in.
setHass(stateManager, { [SENSOR]: { state: '25' }, [SENSOR_TWO]: { state: '10' } });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenLastCalledWith(
expect.objectContaining({ entity_id: SENSOR }),
);
// Now SENSOR_TWO crosses in.
setHass(stateManager, { [SENSOR]: { state: '25' }, [SENSOR_TWO]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(2);
expect(callback).toHaveBeenLastCalledWith(
expect.objectContaining({ entity_id: SENSOR_TWO }),
);
});
it('should not trigger for an entity that did not change', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
// An unrelated entity changes; SENSOR is unchanged so must not trigger.
setHass(stateManager, {
[SENSOR]: { state: '10' },
[SENSOR_TWO]: { state: '25' },
});
expect(callback).not.toHaveBeenCalled();
});
it('should arm an entity already outside the range at subscribe', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
// Already below the threshold before subscribe: armed at subscribe.
setHass(stateManager, { [SENSOR]: { state: '10' } });
trigger.subscribe(callback);
// The first crossing in triggers.
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger for an entity already in range at subscribe', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
// Already in range before subscribe: not armed.
setHass(stateManager, { [SENSOR]: { state: '25' } });
trigger.subscribe(callback);
// A further in-range change is not a crossing.
setHass(stateManager, { [SENSOR]: { state: '26' } });
expect(callback).not.toHaveBeenCalled();
});
it('should not trigger for an entity unreadable at subscribe until it crosses in afresh', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
// No value at subscribe: not armed (an unreadable entity is not a crossing
// source until it has been outside the range).
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).not.toHaveBeenCalled();
// After it has been outside, the next crossing in triggers.
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should provide the full from_state/to_state objects', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledWith(
expect.objectContaining({
from_state: expect.objectContaining({ state: '10' }),
to_state: expect.objectContaining({ state: '25' }),
}),
);
});
it('should trigger without a from_state when an armed entity is removed and reappears in range', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
// Arm the entity below the range, then remove it (still armed).
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, {});
// It reappears already in range: triggers, but there is no prior state.
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenLastCalledWith({
platform: 'numeric_state',
entity_id: SENSOR,
entity: SENSOR,
to_state: expect.objectContaining({ state: '25' }),
});
});
it('should accept the entity alias', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity: SENSOR,
above: 20,
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).toHaveBeenCalledTimes(1);
});
describe('for', () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.useRealTimers();
});
it('should trigger only after the value is held in range for the duration', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(4999);
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should cancel the pending trigger when the value leaves the range', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(3000);
// Leaves the range before the hold elapses: cancelled.
setHass(stateManager, { [SENSOR]: { state: '10' } });
vi.advanceTimersByTime(5000);
expect(callback).not.toHaveBeenCalled();
});
it('should keep the hold across an in-range change', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(3000);
// Still in range: the fixed-deadline hold keeps running, not reset.
setHass(stateManager, { [SENSOR]: { state: '26' } });
vi.advanceTimersByTime(2000);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should clear a pending for: timer on destroy', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
trigger.destroy();
vi.advanceTimersByTime(5000);
expect(callback).not.toHaveBeenCalled();
});
it('should reset the for: timer on a fresh crossing', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(3000);
// Leave and cross back in: the hold restarts from zero.
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(4000);
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger when for is unparseable', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
for: 'not-a-duration',
});
trigger.subscribe(callback);
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
vi.advanceTimersByTime(100000);
expect(callback).not.toHaveBeenCalled();
});
});
it('should stop triggering after destroy', () => {
const { trigger, stateManager, callback } = create({
trigger: 'numeric_state',
entity_id: SENSOR,
above: 20,
});
trigger.subscribe(callback);
trigger.destroy();
setHass(stateManager, { [SENSOR]: { state: '10' } });
setHass(stateManager, { [SENSOR]: { state: '25' } });
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/screen.test.ts
+112
View File
@@ -0,0 +1,112 @@
import { afterEach, describe, expect, it, Mock, vi } from 'vitest';
import { ScreenTrigger } from '../../../../src/condition-trigger/triggers/triggers/screen';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('ScreenTrigger', () => {
let matches = false;
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
const mockMatchMedia = (): void => {
vi.spyOn(window, 'matchMedia').mockImplementation(
() =>
({
get matches(): boolean {
return matches;
},
addEventListener,
removeEventListener,
}) as unknown as MediaQueryList,
);
};
const subscribe = (
trigger: TriggerOfType<'screen'>,
): { screenTrigger: ScreenTrigger; callback: Mock } => {
const callback = vi.fn();
const screenTrigger = new ScreenTrigger(trigger);
screenTrigger.subscribe(callback);
return { screenTrigger, callback };
};
const fireMediaQueryChange = (): void => addEventListener.mock.calls[0][1]();
afterEach(() => {
vi.restoreAllMocks();
matches = false;
addEventListener.mockClear();
removeEventListener.mockClear();
});
it('should trigger on the rising edge of the media query match', () => {
mockMatchMedia();
const { callback } = subscribe({
trigger: 'screen',
media_query: '(orientation: landscape)',
});
matches = true;
fireMediaQueryChange();
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith({ platform: 'acc', type: 'screen' });
});
it('should not trigger again while the query stays matching', () => {
mockMatchMedia();
const { callback } = subscribe({
trigger: 'screen',
media_query: '(orientation: landscape)',
});
matches = true;
fireMediaQueryChange();
fireMediaQueryChange();
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger on the falling edge of the match', () => {
mockMatchMedia();
const { callback } = subscribe({
trigger: 'screen',
media_query: '(orientation: landscape)',
});
matches = true;
fireMediaQueryChange();
matches = false;
fireMediaQueryChange();
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger when already matching at subscribe', () => {
matches = true;
mockMatchMedia();
const { callback } = subscribe({
trigger: 'screen',
media_query: '(orientation: landscape)',
});
fireMediaQueryChange();
expect(callback).not.toHaveBeenCalled();
});
it('should stop listening after destroy', () => {
mockMatchMedia();
const { screenTrigger } = subscribe({
trigger: 'screen',
media_query: '(orientation: landscape)',
});
screenTrigger.destroy();
expect(removeEventListener).toHaveBeenCalledWith('change', expect.anything());
});
it('should never trigger without a media query', () => {
mockMatchMedia();
const { callback } = subscribe({ trigger: 'screen' });
expect(addEventListener).not.toHaveBeenCalled();
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/state.test.ts
+487
View File
@@ -0,0 +1,487 @@
import { HassEntities, HassEntity } from 'home-assistant-js-websocket';
import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { StateTrigger } from '../../../../src/condition-trigger/triggers/triggers/state';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createHASS, createStateEntity } from '../../../test-utils';
const ENTITY = 'binary_sensor.door';
const ENTITY_TWO = 'binary_sensor.window';
// @vitest-environment jsdom
describe('StateTrigger', () => {
const create = (
config: TriggerOfType<'state'>,
): {
trigger: StateTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const trigger = new StateTrigger(config, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { trigger, stateManager, callback };
};
const setHass = (
manager: ConditionStateManager,
states: Record<string, Partial<HassEntity>>,
): void => {
const entities: HassEntities = {};
for (const [id, partial] of Object.entries(states)) {
entities[id] = createStateEntity(partial);
}
manager.setState({ hass: createHASS(entities) });
};
it('should trigger on a transition to a matching state', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
expect(callback).not.toHaveBeenCalled();
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith(
expect.objectContaining({ platform: 'state', entity_id: ENTITY, entity: ENTITY }),
);
});
it('should not trigger on a transition to a non-matching state', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'unavailable' } });
expect(callback).not.toHaveBeenCalled();
});
it('should require the from state to match', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
from: 'off',
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'unknown' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
// From 'unknown', not 'off'.
expect(callback).not.toHaveBeenCalled();
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should match not_to', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
not_to: 'unavailable',
});
trigger.subscribe(callback);
// Triggers (initial -> off, not unavailable).
setHass(stateManager, { [ENTITY]: { state: 'off' } });
expect(callback).toHaveBeenCalledTimes(1);
// To unavailable -> excluded.
setHass(stateManager, { [ENTITY]: { state: 'unavailable' } });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should exclude transitions from a not_from state', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
not_from: 'unavailable',
});
trigger.subscribe(callback);
// From undefined (not 'unavailable') -> triggers.
setHass(stateManager, { [ENTITY]: { state: 'unavailable' } });
expect(callback).toHaveBeenCalledTimes(1);
// From 'unavailable' -> excluded.
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(1);
// From 'on' -> triggers.
setHass(stateManager, { [ENTITY]: { state: 'off' } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should match a list of to-states', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: ['armed_home', 'armed_away'],
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'disarmed' } });
setHass(stateManager, { [ENTITY]: { state: 'armed_home' } });
expect(callback).toHaveBeenCalledTimes(1);
setHass(stateManager, { [ENTITY]: { state: 'armed_away' } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should fan out independently over a list of entities', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: [ENTITY, ENTITY_TWO],
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, {
[ENTITY]: { state: 'off' },
[ENTITY_TWO]: { state: 'off' },
});
setHass(stateManager, { [ENTITY]: { state: 'on' }, [ENTITY_TWO]: { state: 'off' } });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenLastCalledWith(
expect.objectContaining({ entity_id: ENTITY }),
);
setHass(stateManager, { [ENTITY]: { state: 'on' }, [ENTITY_TWO]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(2);
expect(callback).toHaveBeenLastCalledWith(
expect.objectContaining({ entity_id: ENTITY_TWO }),
);
});
it('should not trigger for a watched entity that did not change', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
// An unrelated entity changes; ENTITY is unchanged so must not trigger.
setHass(stateManager, {
[ENTITY]: { state: 'off' },
[ENTITY_TWO]: { state: 'on' },
});
expect(callback).not.toHaveBeenCalled();
});
it('should provide the full from_state/to_state objects', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledWith(
expect.objectContaining({
from_state: expect.objectContaining({ state: 'off' }),
to_state: expect.objectContaining({ state: 'on' }),
}),
);
});
it('should accept the entity alias', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(1);
});
describe('attribute-only changes', () => {
it('should trigger on an attribute-only change when no from/to is set', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
});
trigger.subscribe(callback);
// Initial change.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 1 } } });
expect(callback).toHaveBeenCalledTimes(1);
// Attribute-only change still triggers.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 2 } } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should not trigger on an attribute-only change when a to is set', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
// Off -> on.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 1 } } });
expect(callback).toHaveBeenCalledTimes(1);
// Attribute-only -> suppressed.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 2 } } });
expect(callback).toHaveBeenCalledTimes(1);
});
});
it('should treat a null to as matching any state change but not attributes', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: null,
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
expect(callback).toHaveBeenCalledTimes(1);
// Any state change.
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(2);
// Attribute-only suppressed (key present).
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 1 } } });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should match against an attribute', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
attribute: 'device_class',
to: 'door',
});
trigger.subscribe(callback);
setHass(stateManager, {
[ENTITY]: { state: 'on', attributes: { device_class: 'window' } },
});
expect(callback).not.toHaveBeenCalled();
setHass(stateManager, {
[ENTITY]: { state: 'on', attributes: { device_class: 'door' } },
});
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger when the watched attribute is unchanged', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
attribute: 'device_class',
to: 'door',
});
trigger.subscribe(callback);
setHass(stateManager, {
[ENTITY]: { state: 'on', attributes: { device_class: 'window' } },
});
// The state changes but the watched attribute does not -> ignored.
setHass(stateManager, {
[ENTITY]: { state: 'off', attributes: { device_class: 'window' } },
});
expect(callback).not.toHaveBeenCalled();
});
it('should treat an absent watched attribute as no value', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
attribute: 'device_class',
to: 'door',
});
trigger.subscribe(callback);
// The entity has no `device_class` attribute, so there is no value to match.
setHass(stateManager, { [ENTITY]: { state: 'on' } });
setHass(stateManager, { [ENTITY]: { state: 'off' } });
expect(callback).not.toHaveBeenCalled();
});
it('should trigger without a to_state when the entity is removed', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).toHaveBeenCalledTimes(1);
// Remove the entity from hass entirely.
stateManager.setState({ hass: createHASS({}) });
expect(callback).toHaveBeenCalledTimes(2);
expect(callback).toHaveBeenLastCalledWith({
platform: 'state',
entity_id: ENTITY,
entity: ENTITY,
from_state: expect.objectContaining({ state: 'on' }),
});
});
describe('for', () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.useRealTimers();
});
it('should trigger only after the state has been held for the duration', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
vi.advanceTimersByTime(4999);
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should cancel the pending trigger when the state leaves the match', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
vi.advanceTimersByTime(3000);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
vi.advanceTimersByTime(5000);
expect(callback).not.toHaveBeenCalled();
});
it('should clear a pending for: timer on destroy', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
// Arms the for: timer.
setHass(stateManager, { [ENTITY]: { state: 'on' } });
trigger.destroy();
vi.advanceTimersByTime(5000);
expect(callback).not.toHaveBeenCalled();
});
it('should reset the for: timer on a fresh matching transition', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: ['on', 'off'],
for: '00:00:05',
});
trigger.subscribe(callback);
// Arms (to includes 'off').
setHass(stateManager, { [ENTITY]: { state: 'off' } });
vi.advanceTimersByTime(3000);
// Re-arms (resets the 5s).
setHass(stateManager, { [ENTITY]: { state: 'on' } });
vi.advanceTimersByTime(4000);
// Would have triggered at 5s without the reset.
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not cancel the for: hold on an attribute-only change', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
for: '00:00:05',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
// Arms.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 1 } } });
vi.advanceTimersByTime(3000);
// The state stays 'on'; only an attribute moves -- the hold must continue.
setHass(stateManager, { [ENTITY]: { state: 'on', attributes: { a: 2 } } });
// 5s total since arming.
vi.advanceTimersByTime(2000);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should not trigger when for is unparseable', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
for: 'not-a-duration',
});
trigger.subscribe(callback);
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
vi.advanceTimersByTime(100000);
expect(callback).not.toHaveBeenCalled();
});
});
it('should stop triggering after destroy', () => {
const { trigger, stateManager, callback } = create({
trigger: 'state',
entity_id: ENTITY,
to: 'on',
});
trigger.subscribe(callback);
trigger.destroy();
setHass(stateManager, { [ENTITY]: { state: 'off' } });
setHass(stateManager, { [ENTITY]: { state: 'on' } });
expect(callback).not.toHaveBeenCalled();
});
});
tests/condition-trigger/triggers/triggers/template.test.ts
+193
View File
@@ -0,0 +1,193 @@
import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { TemplateTrigger } from '../../../../src/condition-trigger/triggers/triggers/template';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { createHASS, createStateEntity } from '../../../test-utils';
const ENTITY_ONE = 'sensor.foo';
const ENTITY_TWO = 'sensor.bar';
const ENTITY_ONE_ON_TEMPLATE = `{{ is_state("${ENTITY_ONE}", "on") }}`;
// @vitest-environment jsdom
describe('TemplateTrigger', () => {
const create = (
config: TriggerOfType<'template'>,
): {
trigger: TemplateTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const trigger = new TemplateTrigger(config, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { trigger, stateManager, callback };
};
const setSensor = (manager: ConditionStateManager, state: string): void => {
manager.setState({
hass: createHASS({ [ENTITY_ONE]: createStateEntity({ state }) }),
});
};
it('should trigger on the rising edge to true', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
});
trigger.subscribe(callback);
setSensor(stateManager, 'off');
expect(callback).not.toHaveBeenCalled();
setSensor(stateManager, 'on');
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenCalledWith({ platform: 'template' });
});
it('should not trigger when the template is already true at subscribe', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
});
setSensor(stateManager, 'on');
trigger.subscribe(callback);
// A later change that keeps the template true must not trigger.
stateManager.setState({
hass: createHASS({
[ENTITY_ONE]: createStateEntity({ state: 'on' }),
[ENTITY_TWO]: createStateEntity({ state: 'x' }),
}),
});
expect(callback).not.toHaveBeenCalled();
});
it('should not re-trigger while the template remains true', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({
hass: createHASS({
[ENTITY_ONE]: createStateEntity({ state: 'on' }),
[ENTITY_TWO]: createStateEntity({ state: 'y' }),
}),
});
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger again after returning to false then true', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
setSensor(stateManager, 'off');
setSensor(stateManager, 'on');
expect(callback).toHaveBeenCalledTimes(2);
});
it('should trigger immediately when "for" is zero', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
for: 0,
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
expect(callback).toHaveBeenCalledTimes(1);
});
describe('for', () => {
beforeEach(() => {
vi.useFakeTimers();
});
afterEach(() => {
vi.useRealTimers();
});
it('should trigger only after the template has held true for the duration', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
for: '00:00:05',
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
vi.advanceTimersByTime(4999);
expect(callback).not.toHaveBeenCalled();
vi.advanceTimersByTime(1);
expect(callback).toHaveBeenCalledTimes(1);
});
it('should cancel the pending trigger when the template goes false before the duration', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
for: '00:00:05',
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
vi.advanceTimersByTime(3000);
setSensor(stateManager, 'off');
vi.advanceTimersByTime(5000);
expect(callback).not.toHaveBeenCalled();
});
it('should not trigger when "for" is unparseable', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
for: 'not-a-duration',
});
trigger.subscribe(callback);
setSensor(stateManager, 'on');
vi.advanceTimersByTime(100000);
expect(callback).not.toHaveBeenCalled();
});
});
it('should stop triggering after destroy', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
value_template: ENTITY_ONE_ON_TEMPLATE,
});
trigger.subscribe(callback);
trigger.destroy();
setSensor(stateManager, 'on');
expect(callback).not.toHaveBeenCalled();
});
it('should trigger on a string-truthy template value for HA symmetry', () => {
const { trigger, stateManager, callback } = create({
trigger: 'template',
// Renders the string "on"/"off", not a boolean; HA treats "on" as true.
value_template: `{{ "on" if is_state("${ENTITY_ONE}", "on") else "off" }}`,
});
trigger.subscribe(callback);
setSensor(stateManager, 'off');
expect(callback).not.toHaveBeenCalled();
setSensor(stateManager, 'on');
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/triggered.test.ts
+41
View File
@@ -0,0 +1,41 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { TriggeredTrigger } from '../../../../src/condition-trigger/triggers/triggers/triggered';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
// @vitest-environment jsdom
describe('TriggeredTrigger', () => {
const create = (
trigger: TriggerOfType<'triggered'>,
): { stateManager: ConditionStateManager; callback: Mock } => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
new TriggeredTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
}).subscribe(callback);
return { stateManager, callback };
};
it('should trigger on any change to the triggered set without a value', () => {
const { stateManager, callback } = create({ trigger: 'triggered' });
stateManager.setState({ triggered: new Set(['front']) });
stateManager.setState({ triggered: new Set(['front', 'back']) });
stateManager.setState({ triggered: new Set() });
expect(callback).toHaveBeenCalledTimes(3);
});
it('should trigger only when a listed camera is among the triggered set', () => {
const { stateManager, callback } = create({
trigger: 'triggered',
triggered: ['front'],
});
stateManager.setState({ triggered: new Set(['back']) });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ triggered: new Set(['front']) });
expect(callback).toHaveBeenCalledTimes(1);
});
});
tests/condition-trigger/triggers/triggers/view.test.ts
+95
View File
@@ -0,0 +1,95 @@
import { describe, expect, it, Mock, vi } from 'vitest';
import { TemplateRenderer } from '../../../../src/card-controller/templates';
import { ConditionStateManager } from '../../../../src/condition-trigger/conditions/state-manager';
import { TriggerOfType } from '../../../../src/condition-trigger/triggers/triggers/types';
import { ViewTrigger } from '../../../../src/condition-trigger/triggers/triggers/view';
// @vitest-environment jsdom
describe('ViewTrigger', () => {
const create = (
trigger: TriggerOfType<'view'>,
): {
viewTrigger: ViewTrigger;
stateManager: ConditionStateManager;
callback: Mock;
} => {
const stateManager = new ConditionStateManager();
const callback = vi.fn();
const viewTrigger = new ViewTrigger(trigger, {
stateManager,
templateRenderer: new TemplateRenderer(),
});
return { viewTrigger, stateManager, callback };
};
it('should trigger when the selected view changes to a listed one', () => {
const { viewTrigger, stateManager, callback } = create({
trigger: 'view',
views: ['live'],
});
viewTrigger.subscribe(callback);
stateManager.setState({ view: 'clip' });
expect(callback).not.toHaveBeenCalled();
stateManager.setState({ view: 'live' });
expect(callback).toHaveBeenCalledTimes(1);
expect(callback).toHaveBeenLastCalledWith({
platform: 'acc',
type: 'view',
from_acc: { view: 'clip' },
to_acc: { view: 'live' },
});
});
it('should trigger again when the view changes between two listed views', () => {
const { viewTrigger, stateManager, callback } = create({
trigger: 'view',
views: ['live', 'clips'],
});
viewTrigger.subscribe(callback);
stateManager.setState({ view: 'live' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ view: 'clips' });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should not trigger once the view leaves the listed set', () => {
const { viewTrigger, stateManager, callback } = create({
trigger: 'view',
views: ['live'],
});
viewTrigger.subscribe(callback);
stateManager.setState({ view: 'live' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ view: 'clips' });
expect(callback).toHaveBeenCalledTimes(1);
});
it('should trigger on any view change without a listed set', () => {
const { viewTrigger, stateManager, callback } = create({ trigger: 'view' });
viewTrigger.subscribe(callback);
stateManager.setState({ view: 'clips' });
expect(callback).toHaveBeenCalledTimes(1);
stateManager.setState({ view: 'live' });
expect(callback).toHaveBeenCalledTimes(2);
});
it('should stop triggering after destroy', () => {
const { viewTrigger, stateManager, callback } = create({
trigger: 'view',
views: ['live'],
});
viewTrigger.subscribe(callback);
viewTrigger.destroy();
stateManager.setState({ view: 'live' });
expect(callback).not.toHaveBeenCalled();
});
});
tests/conditions/conditions-manager.test.ts
-208
View File
@@ -1,208 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { ConditionsManager } from '../../src/conditions/conditions-manager';
import { ConditionStateManager } from '../../src/conditions/state-manager';
import { createHASS, createStateEntity } from '../test-utils';
// Per-condition-type evaluation is covered by tests/conditions/conditions/<type>.test.ts.
// This file covers the manager's own orchestration: building/destroying evaluators,
// listener management, trigger-data merging, and notifying (or not) on changes.
// @vitest-environment jsdom
describe('ConditionsManager', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should not call listeners for HA state changes without a relevant condition', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[
{
condition: 'fullscreen' as const,
fullscreen: true,
},
],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
});
expect(listener).not.toBeCalled();
});
it('should notify on each change and merge trigger data across multiple conditions', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[
{ condition: 'state' as const, entity: 'switch.one' },
{ condition: 'state' as const, entity: 'switch.two' },
],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({
hass: createHASS({
'switch.one': createStateEntity({ state: 'on' }),
'switch.two': createStateEntity({ state: 'off' }),
}),
});
expect(listener).toHaveBeenLastCalledWith({
result: true,
triggerData: {
// Only the last matching condition's data is retained.
state: {
entity: 'switch.two',
to: 'off',
},
},
});
// The result stays true but the trigger data changes, so listeners are
// still notified.
stateManager.setState({
hass: createHASS({
'switch.one': createStateEntity({ state: 'off' }),
'switch.two': createStateEntity({ state: 'on' }),
}),
});
expect(listener).toHaveBeenLastCalledWith({
result: true,
triggerData: {
state: {
entity: 'switch.two',
from: 'off',
to: 'on',
},
},
});
expect(listener).toBeCalledTimes(2);
});
it('should re-evaluate and notify when a subscribed condition source changes', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia')
.mockReturnValueOnce({
addEventListener: addEventListener,
removeEventListener: removeEventListener,
} as unknown as MediaQueryList)
.mockReturnValueOnce({
matches: false,
} as unknown as MediaQueryList)
.mockReturnValueOnce({
matches: true,
} as unknown as MediaQueryList);
const manager = new ConditionsManager([
{ condition: 'screen' as const, media_query: 'whatever' },
]);
const listener = vi.fn();
manager.addListener(listener);
// Fire the media-query change; the manager re-evaluates and notifies.
addEventListener.mock.calls[0][1]();
expect(listener).toBeCalledWith({ result: true, triggerData: {} });
// Destroy tears the subscription down via the evaluator.
manager.destroy();
expect(removeEventListener).toBeCalled();
});
describe('should handle listeners correctly', () => {
it('should add listener', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).toBeCalledWith({ result: true, triggerData: {} });
expect(listener).toBeCalledTimes(1);
stateManager.setState({ fullscreen: false });
expect(listener).toBeCalledWith({ result: false });
expect(listener).toBeCalledTimes(2);
// Re-add the same listener (will still only be called once).
manager.addListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).toBeCalledWith({ result: true, triggerData: {} });
expect(listener).toBeCalledTimes(3);
});
it('should remove listener', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
manager.removeListener(listener);
stateManager.setState({ fullscreen: true });
expect(listener).not.toBeCalled();
});
it('should remove listener on destroy', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'fullscreen' as const, fullscreen: true }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
manager.destroy();
stateManager.setState({ fullscreen: true });
expect(listener).not.toBeCalled();
});
it('should not call listeners when the condition result does not change', () => {
const stateManager = new ConditionStateManager();
const manager = new ConditionsManager(
[{ condition: 'view' as const, views: ['live'] }],
stateManager,
);
const listener = vi.fn();
manager.addListener(listener);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(1);
stateManager.setState({ view: 'clip' });
expect(listener).toBeCalledTimes(2);
stateManager.setState({ view: 'clip' });
expect(listener).toBeCalledTimes(2);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(3);
stateManager.setState({ view: 'live' });
expect(listener).toBeCalledTimes(3);
});
});
});
tests/conditions/conditions/and.test.ts
-87
View File
@@ -1,87 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('and condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate a simple and condition', () => {
const evaluator = createConditionEvaluator(
{
condition: 'and' as const,
conditions: [
{ condition: 'fullscreen' as const, fullscreen: true },
{ condition: 'expand' as const, expand: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true }).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true, expand: true }).result).toBeTruthy();
expect(evaluator.evaluate({ fullscreen: false, expand: true }).result).toBeFalsy();
});
it('should report combined trigger data for an and condition', () => {
// Not a terribly realistic example, but chosen so that trigger data for
// both camera and view should be returned.
const evaluator = createConditionEvaluator(
{
condition: 'and' as const,
conditions: [{ condition: 'camera' as const }, { condition: 'view' as const }],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ camera: 'camera-1' }, {}).result).toBeFalsy();
expect(
evaluator.evaluate(
{ camera: 'camera-2', view: 'clip' },
{ camera: 'camera-1', view: 'live' },
),
).toEqual({
result: true,
triggerData: {
camera: { from: 'camera-1', to: 'camera-2' },
view: { from: 'live', to: 'clip' },
},
});
});
it('should forward subscribe and destroy to its children', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener: addEventListener,
removeEventListener: removeEventListener,
} as unknown as MediaQueryList);
// The `screen` child supports subscribe/destroy; the `fullscreen` child does
// not — forwarding must handle both.
const evaluator = createConditionEvaluator(
{
condition: 'and' as const,
conditions: [
{ condition: 'screen' as const, media_query: 'whatever' },
{ condition: 'fullscreen' as const, fullscreen: true },
],
},
createEvaluatorContext(),
);
const onChange = vi.fn();
evaluator.subscribe?.(onChange);
expect(addEventListener).toHaveBeenCalledWith('change', expect.anything());
addEventListener.mock.calls[0][1]();
expect(onChange).toHaveBeenCalled();
evaluator.destroy?.();
expect(removeEventListener).toHaveBeenCalled();
});
});
tests/conditions/conditions/camera.test.ts
-43
View File
@@ -1,43 +0,0 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('camera condition', () => {
it('should match a named camera', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const, cameras: ['bar'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ camera: 'bar' }).result).toBeTruthy();
expect(evaluator.evaluate({ camera: 'will-not-match' }).result).toBeFalsy();
});
it('should report trigger data for any camera change', () => {
const evaluator = createConditionEvaluator(
{ condition: 'camera' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ camera: 'bar' }, {})).toEqual({
result: true,
triggerData: {
camera: {
to: 'bar',
},
},
});
expect(evaluator.evaluate({ camera: 'foo' }, { camera: 'bar' })).toEqual({
result: true,
triggerData: {
camera: {
from: 'bar',
to: 'foo',
},
},
});
});
});
tests/conditions/conditions/config.test.ts
-106
View File
@@ -1,106 +0,0 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createConfig } from '../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('config condition', () => {
const config_1 = createConfig({
// Default is:
//
// view: {
// default: live,
// },
});
const config_2 = createConfig({
view: {
default: 'clips',
},
});
const config_3 = createConfig({
view: {
default: 'clips',
default_cycle_camera: true,
},
});
const config_4 = createConfig({
view: {
default: 'clips',
default_cycle_camera: true,
dim: true,
},
});
it('should report trigger data for any config change', () => {
const evaluator = createConditionEvaluator(
{ condition: 'config' as const },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ config: config_1 }, {})).toEqual({
result: true,
triggerData: {
config: {
to: config_1,
},
},
});
expect(evaluator.evaluate({ config: config_2 }, { config: config_1 })).toEqual({
result: true,
triggerData: {
config: {
from: config_1,
to: config_2,
},
},
});
});
it('should not match when the config is unchanged', () => {
const evaluator = createConditionEvaluator(
{ condition: 'config' as const },
createEvaluatorContext(),
);
expect(
evaluator.evaluate({ config: config_1 }, { config: config_1 }).result,
).toBeFalsy();
});
it('should match a specific config change', () => {
const evaluator = createConditionEvaluator(
{ condition: 'config' as const, paths: ['view.default'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({ config: config_1 }, {}).result).toBeTruthy();
expect(
evaluator.evaluate({ config: config_2 }, { config: config_1 }).result,
).toBeTruthy();
expect(
evaluator.evaluate({ config: config_3 }, { config: config_2 }).result,
).toBeFalsy();
});
it('should match multiple specific config changes', () => {
const evaluator = createConditionEvaluator(
{
condition: 'config' as const,
paths: ['view.default', 'view.default_cycle_camera'],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({ config: config_1 }, {}).result).toBeTruthy();
expect(
evaluator.evaluate({ config: config_2 }, { config: config_1 }).result,
).toBeTruthy();
expect(
evaluator.evaluate({ config: config_3 }, { config: config_2 }).result,
).toBeTruthy();
expect(
evaluator.evaluate({ config: config_4 }, { config: config_3 }).result,
).toBeFalsy();
});
});
tests/conditions/conditions/numeric-state.test.ts
-45
View File
@@ -1,45 +0,0 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createHASS, createStateEntity } from '../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('numeric state condition', () => {
it('should match above a threshold', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity: 'sensor.foo', above: 10 },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: '9' }) }),
}).result,
).toBeFalsy();
});
it('should match below a threshold', () => {
const evaluator = createConditionEvaluator(
{ condition: 'numeric_state' as const, entity: 'sensor.foo', below: 10 },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '11' }) }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'sensor.foo': createStateEntity({ state: '9' }) }),
}).result,
).toBeTruthy();
});
});
tests/conditions/conditions/or.test.ts
-92
View File
@@ -1,92 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('or condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate a simple or condition', () => {
const evaluator = createConditionEvaluator(
{
condition: 'or' as const,
conditions: [
{ condition: 'fullscreen' as const, fullscreen: true },
{ condition: 'expand' as const, expand: true },
],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ fullscreen: true }).result).toBeTruthy();
expect(evaluator.evaluate({ expand: true }).result).toBeTruthy();
expect(evaluator.evaluate({ fullscreen: false, expand: false }).result).toBeFalsy();
});
it('should report trigger data for the first matching sub-condition', () => {
// Not a terribly realistic example, but chosen so that trigger data for
// both camera and view could be returned.
const evaluator = createConditionEvaluator(
{
condition: 'or' as const,
conditions: [{ condition: 'camera' as const }, { condition: 'view' as const }],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ camera: 'camera-1' }, {})).toEqual({
result: true,
triggerData: { camera: { to: 'camera-1' } },
});
expect(evaluator.evaluate({ view: 'live' }, {})).toEqual({
result: true,
triggerData: { view: { to: 'live' } },
});
// When both change, the camera sub-condition matches first, so only its
// trigger data is returned.
expect(
evaluator.evaluate({ camera: 'camera-2', view: 'clip' }, { camera: 'camera-1' }),
).toEqual({
result: true,
triggerData: { camera: { from: 'camera-1', to: 'camera-2' } },
});
});
it('should forward subscribe and destroy to its children', () => {
const addEventListener = vi.fn();
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener: addEventListener,
removeEventListener: removeEventListener,
} as unknown as MediaQueryList);
// The `screen` child supports subscribe/destroy; the `fullscreen` child does
// not — forwarding must handle both.
const evaluator = createConditionEvaluator(
{
condition: 'or' as const,
conditions: [
{ condition: 'screen' as const, media_query: 'whatever' },
{ condition: 'fullscreen' as const, fullscreen: true },
],
},
createEvaluatorContext(),
);
const onChange = vi.fn();
evaluator.subscribe?.(onChange);
expect(addEventListener).toHaveBeenCalledWith('change', expect.anything());
addEventListener.mock.calls[0][1]();
expect(onChange).toHaveBeenCalled();
evaluator.destroy?.();
expect(removeEventListener).toHaveBeenCalled();
});
});
tests/conditions/conditions/screen.test.ts
-61
View File
@@ -1,61 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('screen condition', () => {
afterEach(() => {
vi.restoreAllMocks();
});
it('should evaluate the media query', () => {
vi.spyOn(window, 'matchMedia').mockReturnValue({
matches: true,
} as unknown as MediaQueryList);
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const, media_query: 'whatever' },
createEvaluatorContext(),
);
expect(evaluator.evaluate().result).toBeTruthy();
});
it('should register and invoke a media-query listener on subscribe', () => {
const addEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener: addEventListener,
removeEventListener: vi.fn(),
} as unknown as MediaQueryList);
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const, media_query: 'whatever' },
createEvaluatorContext(),
);
const onChange = vi.fn();
evaluator.subscribe?.(onChange);
expect(addEventListener).toHaveBeenCalledWith('change', expect.anything());
// Invoke the registered handler and confirm it triggers the callback.
addEventListener.mock.calls[0][1]();
expect(onChange).toHaveBeenCalled();
});
it('should remove the media-query listener on destroy', () => {
const removeEventListener = vi.fn();
vi.spyOn(window, 'matchMedia').mockReturnValue({
addEventListener: vi.fn(),
removeEventListener: removeEventListener,
} as unknown as MediaQueryList);
const evaluator = createConditionEvaluator(
{ condition: 'screen' as const, media_query: 'whatever' },
createEvaluatorContext(),
);
evaluator.subscribe?.(vi.fn());
evaluator.destroy?.();
expect(removeEventListener).toHaveBeenCalledWith('change', expect.anything());
});
});
tests/conditions/conditions/state.test.ts
-168
View File
@@ -1,168 +0,0 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createHASS, createStateEntity } from '../../test-utils';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('state condition', () => {
it('should report trigger data for any change when neither state nor state_not is set', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity: 'binary_sensor.foo' },
createEvaluatorContext(),
);
expect(
evaluator.evaluate(
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
},
{},
),
).toEqual({
result: true,
triggerData: {
state: {
entity: 'binary_sensor.foo',
to: 'on',
},
},
});
expect(
evaluator.evaluate(
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
},
{
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'on' }) }),
},
),
).toEqual({
result: true,
triggerData: {
state: {
entity: 'binary_sensor.foo',
from: 'on',
to: 'off',
},
},
});
});
it('should match a single positive state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity: 'binary_sensor.foo', state: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should match multiple positive states', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity: 'binary_sensor.foo',
state: ['active', 'on'],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'active' }),
}),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
it('should match a single negative state', () => {
const evaluator = createConditionEvaluator(
{ condition: 'state' as const, entity: 'binary_sensor.foo', state_not: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeTruthy();
});
it('should match multiple negative states', () => {
const evaluator = createConditionEvaluator(
{
condition: 'state' as const,
entity: 'binary_sensor.foo',
state_not: ['active', 'on'],
},
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({
'binary_sensor.foo': createStateEntity({ state: 'active' }),
}),
}).result,
).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeTruthy();
});
it('should match an implicit state condition', () => {
const evaluator = createConditionEvaluator(
{ entity: 'binary_sensor.foo', state: 'on' },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity() }),
}).result,
).toBeTruthy();
expect(
evaluator.evaluate({
hass: createHASS({ 'binary_sensor.foo': createStateEntity({ state: 'off' }) }),
}).result,
).toBeFalsy();
});
});
tests/conditions/conditions/test-utils.ts
-6
View File
@@ -1,6 +0,0 @@
import { TemplateRenderer } from '../../../src/card-controller/templates';
import { EvaluatorContext } from '../../../src/conditions/conditions/types';
export const createEvaluatorContext = (): EvaluatorContext => ({
templateRenderer: new TemplateRenderer(),
});
tests/conditions/conditions/triggered.test.ts
-21
View File
@@ -1,21 +0,0 @@
import { describe, expect, it } from 'vitest';
import { createConditionEvaluator } from '../../../src/conditions/factory';
import { createEvaluatorContext } from './test-utils';
// @vitest-environment jsdom
describe('triggered condition', () => {
it('should match a triggered condition', () => {
const evaluator = createConditionEvaluator(
{ condition: 'triggered' as const, triggered: ['camera_1', 'camera_2'] },
createEvaluatorContext(),
);
expect(evaluator.evaluate({}).result).toBeFalsy();
expect(evaluator.evaluate({ triggered: new Set(['camera_1']) }).result).toBeTruthy();
expect(
evaluator.evaluate({ triggered: new Set(['camera_2', 'camera_1', 'camera_3']) })
.result,
).toBeTruthy();
expect(evaluator.evaluate({ triggered: new Set(['camera_3']) }).result).toBeFalsy();
});
});
tests/config/management.test.ts
+1333 -184
View File
File diff suppressed because it is too large Load Diff
tests/config/schema/condition-trigger/conditions/custom/user-agent.test.ts
+32
View File
@@ -0,0 +1,32 @@
import { describe, expect, it } from 'vitest';
import { userAgentConditionSchema } from '../../../../../../src/config/schema/condition-trigger/conditions/custom/user-agent';
describe('userAgentConditionSchema', () => {
it('should reject a user_agent condition with no fields', () => {
expect(() => userAgentConditionSchema.parse({ condition: 'user_agent' })).toThrow();
});
it('should accept a user_agent condition constrained by user_agent', () => {
expect(
userAgentConditionSchema.parse({ condition: 'user_agent', user_agent: 'Foo' }),
).toEqual({ condition: 'user_agent', user_agent: 'Foo' });
});
it('should accept a user_agent condition constrained by user_agent_re', () => {
expect(
userAgentConditionSchema.parse({ condition: 'user_agent', user_agent_re: 'Foo' }),
).toEqual({ condition: 'user_agent', user_agent_re: 'Foo' });
});
it('should accept a user_agent condition constrained by casting', () => {
expect(
userAgentConditionSchema.parse({ condition: 'user_agent', casting: true }),
).toEqual({ condition: 'user_agent', casting: true });
});
it('should accept a user_agent condition constrained by companion', () => {
expect(
userAgentConditionSchema.parse({ condition: 'user_agent', companion: true }),
).toEqual({ condition: 'user_agent', companion: true });
});
});
tests/config/schema/condition-trigger/conditions/stock/entity-base.test.ts
+8
View File
@@ -0,0 +1,8 @@
import { describe, expect, it } from 'vitest';
import { entityConditionBaseSchema } from '../../../../../../src/config/schema/condition-trigger/conditions/stock/entity-base';
describe('entityConditionBaseSchema', () => {
it('should reject when neither entity nor entity_id are provided', () => {
expect(() => entityConditionBaseSchema.parse({})).toThrow();
});
});
tests/config/schema/condition-trigger/conditions/stock/numeric-state.test.ts
+13
View File
@@ -0,0 +1,13 @@
import { describe, expect, it } from 'vitest';
import { numericStateConditionSchema } from '../../../../../../src/config/schema/condition-trigger/conditions/stock/numeric-state';
describe('numericStateConditionSchema', () => {
it('should reject when neither above nor below is provided', () => {
expect(() =>
numericStateConditionSchema.parse({
condition: 'numeric_state',
entity_id: 'sensor.temperature',
}),
).toThrow();
});
});
tests/config/schema/condition-trigger/conditions/stock/state.test.ts
+33
View File
@@ -0,0 +1,33 @@
import { describe, expect, it } from 'vitest';
import { stateConditionSchema } from '../../../../../../src/config/schema/condition-trigger/conditions/stock/state';
describe('stateConditionSchema', () => {
it('should reject a state condition without state or state_not', () => {
expect(() =>
stateConditionSchema.parse({
condition: 'state',
entity_id: 'binary_sensor.door',
}),
).toThrow();
});
it('should accept a state condition with state', () => {
expect(
stateConditionSchema.parse({
condition: 'state',
entity_id: 'binary_sensor.door',
state: 'on',
}),
).toEqual({ condition: 'state', entity_id: 'binary_sensor.door', state: 'on' });
});
it('should accept a state condition with state_not', () => {
expect(
stateConditionSchema.parse({
condition: 'state',
entity_id: 'binary_sensor.door',
state_not: 'on',
}),
).toEqual({ condition: 'state', entity_id: 'binary_sensor.door', state_not: 'on' });
});
});
tests/config/schema/condition-trigger/parity.test.ts
+70
View File
@@ -0,0 +1,70 @@
import { describe, expect, it } from 'vitest';
import { z } from 'zod';
import { conditionUnion } from '../../../../src/config/schema/condition-trigger/conditions/types';
import { triggerSchema } from '../../../../src/config/schema/condition-trigger/triggers/types';
// Reads the discriminator literal (`condition`/`trigger`) from every member of
// a union, unwrapping the optional discriminator the state condition uses.
const getTypes = (
options: readonly z.ZodType[],
key: 'condition' | 'trigger',
): Set<string> => {
const result = new Set<string>();
for (const option of options) {
if (!(option instanceof z.ZodObject)) {
continue;
}
const field = option.shape[key];
const literal = field instanceof z.ZodOptional ? field.unwrap() : field;
if (literal instanceof z.ZodLiteral) {
result.add(String(literal.value));
}
}
return result;
};
// HA conditions have `or`/`and`/`not` composites; HA triggers do not (a flat
// trigger list is an implicit OR). So triggers = conditions minus the
// composites.
const COMPOSITES = ['or', 'and', 'not'];
// `config` only ever detects a change, so it is a trigger but not a condition.
const TRIGGER_ONLY = ['config'];
// `user`/`user_agent` are static per session, so they are conditions but not
// triggers.
const CONDITION_ONLY = ['user', 'user_agent'];
// Verify the same (except composite) types are defined in both condition and
// trigger schemas.
describe('condition/trigger schema parity', () => {
it('should keep condition and trigger leaf types in sync', () => {
// Apart from the documented exceptions below, conditions and triggers stay
// paired: adding a leaf type to one without the other (or without recording
// it as an exception) is a bug (the fields may still differ).
const conditionTypes = getTypes(conditionUnion.options, 'condition');
const triggerTypes = getTypes(triggerSchema.options, 'trigger');
// Triggers have no composites (as per HA standard).
expect(COMPOSITES.some((c) => triggerTypes.has(c))).toBe(false);
// Conditions have composites.
expect(COMPOSITES.every((c) => conditionTypes.has(c))).toBe(true);
// TRIGGER_ONLY are ... trigger-only.
expect(TRIGGER_ONLY.every((c) => triggerTypes.has(c))).toBe(true);
expect(TRIGGER_ONLY.some((c) => conditionTypes.has(c))).toBe(false);
// CONDITION_ONLY are ... condition-only.
expect(CONDITION_ONLY.every((c) => conditionTypes.has(c))).toBe(true);
expect(CONDITION_ONLY.some((c) => triggerTypes.has(c))).toBe(false);
// Otherwise the leaf type sets are identical.
const conditionLeaves = [...conditionTypes].filter(
(t) => !COMPOSITES.includes(t) && !CONDITION_ONLY.includes(t),
);
const triggerLeaves = [...triggerTypes].filter((t) => !TRIGGER_ONLY.includes(t));
expect(triggerLeaves.sort()).toEqual(conditionLeaves.sort());
});
});
tests/config/schema/condition-trigger/triggers/stock/entity-base.test.ts
+8
View File
@@ -0,0 +1,8 @@
import { describe, expect, it } from 'vitest';
import { entityTriggerBaseSchema } from '../../../../../../src/config/schema/condition-trigger/triggers/stock/entity-base';
describe('entityTriggerBaseSchema', () => {
it('should reject when neither entity nor entity_id are provided', () => {
expect(() => entityTriggerBaseSchema.parse({})).toThrow();
});
});
tests/config/schema/condition-trigger/triggers/stock/numeric-state.test.ts
+70
View File
@@ -0,0 +1,70 @@
import { describe, expect, it } from 'vitest';
import { numericStateTriggerSchema } from '../../../../../../src/config/schema/condition-trigger/triggers/stock/numeric-state';
describe('numericStateTriggerSchema', () => {
it('should reject a numeric_state trigger with neither above nor below', () => {
expect(() =>
numericStateTriggerSchema.parse({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
}),
).toThrow();
});
it('should reject a literal above greater than below (an impossible band)', () => {
expect(() =>
numericStateTriggerSchema.parse({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 20,
below: 10,
}),
).toThrow();
});
it('should accept a literal above not greater than below', () => {
expect(
numericStateTriggerSchema.parse({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 10,
below: 20,
}),
).toEqual({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 10,
below: 20,
});
});
it('should accept an entity-reference threshold', () => {
expect(
numericStateTriggerSchema.parse({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 'input_number.high',
below: 10,
}),
).toEqual({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 'input_number.high',
below: 10,
});
});
it('should accept a single threshold', () => {
expect(
numericStateTriggerSchema.parse({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 25,
}),
).toEqual({
trigger: 'numeric_state',
entity_id: 'sensor.temperature',
above: 25,
});
});
});
tests/config/schema/condition-trigger/triggers/stock/state.test.ts
+28
View File
@@ -0,0 +1,28 @@
import { describe, expect, it } from 'vitest';
import { stateTriggerSchema } from '../../../../../../src/config/schema/condition-trigger/triggers/stock/state';
// Covers the card's own refinements (zod pass-through is trusted): HA makes
// `from`/`not_from` and `to`/`not_to` mutually exclusive.
describe('stateTriggerSchema', () => {
it('should reject from together with not_from', () => {
expect(() =>
stateTriggerSchema.parse({
trigger: 'state',
entity_id: 'binary_sensor.door',
from: 'off',
not_from: 'unavailable',
}),
).toThrow();
});
it('should reject to together with not_to', () => {
expect(() =>
stateTriggerSchema.parse({
trigger: 'state',
entity_id: 'binary_sensor.door',
to: 'on',
not_to: 'unavailable',
}),
).toThrow();
});
});
tests/config/types.test.ts
+209 -36
View File
@@ -1,8 +1,12 @@
import { describe, expect, it } from 'vitest';
import { advancedCameraCardCustomActionsBaseSchema } from '../../src/config/schema/actions/custom/base';
import { statusBarActionConfigSchema } from '../../src/config/schema/actions/types';
import {
actionConfigSchema,
statusBarActionConfigSchema,
} from '../../src/config/schema/actions/types';
import { automationsSchema } from '../../src/config/schema/automations';
import { cameraConfigSchema } from '../../src/config/schema/cameras';
import { advancedCameraCardConditionSchema } from '../../src/config/schema/conditions/types';
import { conditionSchema } from '../../src/config/schema/condition-trigger/conditions/types';
import { dimensionsConfigSchema } from '../../src/config/schema/dimensions';
import { customSchema } from '../../src/config/schema/elements/stock/custom';
import { conditionalSchema } from '../../src/config/schema/elements/types';
@@ -692,7 +696,7 @@ describe('config defaults', () => {
conditions: [
{
condition: 'state',
entity: 'light.office_main_lights',
entity_id: 'light.office_main_lights',
state: 'on',
state_not: 'off',
},
@@ -889,7 +893,6 @@ describe('config defaults', () => {
{ condition: 'and', conditions: [{ condition: 'initialized' }] },
{ condition: 'call', call: true },
{ condition: 'camera', cameras: ['camera.office'] },
{ condition: 'config', paths: ['menu.style'] },
{ condition: 'display_mode', display_mode: 'single' },
{ condition: 'expand', expand: true },
{ condition: 'fullscreen', fullscreen: true },
@@ -909,7 +912,7 @@ describe('config defaults', () => {
{ condition: 'not', conditions: [{ condition: 'initialized' }] },
{
condition: 'numeric_state',
entity: 'sensor.office_temperature',
entity_id: 'sensor.office_temperature',
above: 10,
below: 20,
},
@@ -917,7 +920,7 @@ describe('config defaults', () => {
{ condition: 'screen', media_query: '(orientation: landscape)' },
{
condition: 'state',
entity: 'climate.office',
entity_id: 'climate.office',
state: 'heat',
state_not: 'off',
},
@@ -1323,7 +1326,7 @@ it('should transform dimensions.aspect_ratio', () => {
describe('should refine user_agent_re conditions', () => {
it('should successfully parse valid user_agent_re condition', () => {
expect(
advancedCameraCardConditionSchema.parse({
conditionSchema.parse({
condition: 'user_agent',
user_agent_re: 'Chrome/',
}),
@@ -1335,7 +1338,7 @@ describe('should refine user_agent_re conditions', () => {
it('should reject invalid user_agent_re conditions', () => {
expect(() =>
advancedCameraCardConditionSchema.parse({
conditionSchema.parse({
condition: 'user_agent',
user_agent_re: '[',
}),
@@ -1343,6 +1346,76 @@ describe('should refine user_agent_re conditions', () => {
});
});
describe('conditions should accept Home Assistant composite shorthand', () => {
it('should expand and/or/not operator shorthand', () => {
for (const op of ['and', 'or', 'not'] as const) {
expect(
conditionSchema.parse({
[op]: [{ condition: 'fullscreen', fullscreen: true }],
}),
).toMatchObject({
condition: op,
conditions: [{ condition: 'fullscreen', fullscreen: true }],
});
}
});
it('should expand a condition list to an implicit and', () => {
expect(
conditionSchema.parse({
condition: [
{ condition: 'fullscreen', fullscreen: true },
{ condition: 'expand', expand: true },
],
}),
).toMatchObject({
condition: 'and',
conditions: [
{ condition: 'fullscreen', fullscreen: true },
{ condition: 'expand', expand: true },
],
});
});
it('should normalise a single shorthand condition to a list', () => {
expect(
conditionSchema.parse({ or: { condition: 'fullscreen', fullscreen: true } }),
).toMatchObject({
condition: 'or',
conditions: [{ condition: 'fullscreen', fullscreen: true }],
});
});
it('should expand nested shorthand and preserve base fields', () => {
expect(
conditionSchema.parse({
or: [{ and: [{ condition: 'fullscreen', fullscreen: true }] }],
enabled: false,
}),
).toMatchObject({
condition: 'or',
enabled: false,
conditions: [
{
condition: 'and',
conditions: [{ condition: 'fullscreen', fullscreen: true }],
},
],
});
});
it('should leave a canonical condition untouched', () => {
expect(
conditionSchema.parse({ condition: 'fullscreen', fullscreen: true }),
).toMatchObject({ condition: 'fullscreen', fullscreen: true });
});
it('should reject ambiguous or non-record shorthand', () => {
expect(conditionSchema.safeParse({ and: [], or: [] }).success).toBe(false);
expect(conditionSchema.safeParse('nope').success).toBe(false);
});
});
it('should transform action', () => {
expect(
advancedCameraCardCustomActionsBaseSchema.parse({
@@ -1582,7 +1655,7 @@ describe('should lazy evaluate schemas', () => {
conditions: [
{
condition: 'state',
entity: 'light.office_main_lights',
entity_id: 'light.office_main_lights',
state: 'on',
state_not: 'off',
},
@@ -1603,7 +1676,7 @@ describe('should lazy evaluate schemas', () => {
conditions: [
{
condition: 'state',
entity: 'light.office_main_lights',
entity_id: 'light.office_main_lights',
state: 'on',
state_not: 'off',
},
@@ -1643,6 +1716,90 @@ describe('should lazy evaluate schemas', () => {
};
expect(statusBarActionConfigSchema.parse(input)).toEqual(input);
});
it('should recursively validate if action then/else sequences', () => {
const input = {
if: [
{
condition: 'state',
entity_id: 'light.office_main_lights',
state: 'on',
},
],
then: [
{
action: 'fire-dom-event',
advanced_camera_card_action: 'live_substream_on',
},
],
else: [
{
action: 'fire-dom-event',
advanced_camera_card_action: 'live_substream_off',
},
],
};
expect(actionConfigSchema.parse(input)).toEqual(input);
// The then/else sequences are validated as actions (not accepted verbatim).
expect(
actionConfigSchema.safeParse({ ...input, then: [{ action: 'not-an-action' }] })
.success,
).toBeFalsy();
});
it('should normalise single if/then/else items to lists', () => {
const result = actionConfigSchema.parse({
if: { condition: 'state', entity_id: 'light.office', state: 'on' },
then: {
action: 'fire-dom-event',
advanced_camera_card_action: 'live_substream_on',
},
else: {
action: 'fire-dom-event',
advanced_camera_card_action: 'live_substream_off',
},
});
expect(result).toMatchObject({
if: [{ condition: 'state', entity_id: 'light.office', state: 'on' }],
then: [
{ action: 'fire-dom-event', advanced_camera_card_action: 'live_substream_on' },
],
else: [
{ action: 'fire-dom-event', advanced_camera_card_action: 'live_substream_off' },
],
});
});
});
describe('should apply specific custom action schemas, not the generic catch-all', () => {
it('should default a log action level to info', () => {
// The generic `customActionSchema` (a loose `fire-dom-event` matcher) must
// not shadow `logActionConfigSchema`, or the `level` default is lost and the
// action crashes at runtime.
expect(
actionConfigSchema.parse({
action: 'fire-dom-event',
advanced_camera_card_action: 'log',
message: 'hello',
}),
).toMatchObject({ advanced_camera_card_action: 'log', level: 'info' });
});
it('should default a log action level nested in an if branch', () => {
const result = actionConfigSchema.parse({
if: { condition: 'state', entity_id: 'light.office', state: 'on' },
then: {
action: 'fire-dom-event',
advanced_camera_card_action: 'log',
message: 'hello',
},
});
expect(result).toMatchObject({
then: [{ advanced_camera_card_action: 'log', level: 'info' }],
});
});
});
describe('should handle custom advanced camera card elements', () => {
@@ -1717,40 +1874,56 @@ it('media viewer should not support microphone based conditions', () => {
).toThrowError();
});
describe('automations should require at least one action', () => {
it('should handle no action', () => {
describe('automations should require actions', () => {
it('should reject a missing actions key', () => {
expect(() =>
createConfig({
cameras: [{}],
automations: [{ conditions: [] }],
automations: [{ triggers: [{ trigger: 'initialized' }], conditions: [] }],
}),
).toThrowError(/Automations must include at least one action/);
).toThrowError();
});
});
it('should handle empty actions', () => {
expect(() =>
createConfig({
cameras: [{}],
automations: [{ conditions: [], actions: [], actions_not: [] }],
}),
).toThrowError(/Automations must include at least one action/);
describe('automations should accept Home Assistant input shorthands', () => {
it('should normalise singular keys and single items to lists', () => {
const result = automationsSchema.parse([
{
trigger: { trigger: 'state', entity_id: 'binary_sensor.door', to: 'on' },
condition: { condition: 'state', entity_id: 'input_boolean.x', state: 'on' },
action: {
action: 'fire-dom-event',
advanced_camera_card_action: 'live_substream_on',
},
},
]);
expect(result).toMatchObject([
{
triggers: [{ trigger: 'state', entity_id: 'binary_sensor.door', to: 'on' }],
conditions: [{ condition: 'state', entity_id: 'input_boolean.x', state: 'on' }],
actions: [
{ action: 'fire-dom-event', advanced_camera_card_action: 'live_substream_on' },
],
},
]);
});
it('should handle at least one action', () => {
expect(() =>
createConfig({
cameras: [{}],
automations: [
{
conditions: [],
actions: [
{
action: 'fire-dom-event',
},
],
},
it('should keep the plural key when both singular and plural are given', () => {
const result = automationsSchema.parse([
{
triggers: [{ trigger: 'initialized' }],
trigger: { trigger: 'state', entity_id: 'x', to: 'on' },
actions: [
{ action: 'fire-dom-event', advanced_camera_card_action: 'live_substream_on' },
],
}),
).not.toThrowError();
},
]);
expect(result[0].triggers).toEqual([{ trigger: 'initialized' }]);
});
it('should reject a non-object automation', () => {
expect(automationsSchema.safeParse(['not-an-object']).success).toBe(false);
});
});
tests/templates/index.test.ts
+12 -21
View File
@@ -1,7 +1,8 @@
import { renderTemplate } from 'ha-nunjucks';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { TemplateRenderer } from '../../src/card-controller/templates';
import { ConditionsTriggerData, ConditionState } from '../../src/conditions/types';
import { ConditionState } from '../../src/condition-trigger/conditions/types';
import { TriggerData } from '../../src/condition-trigger/triggers/types';
import { createHASS } from '../test-utils';
// ha-nunjucks attempts to make websocket calls initially so mock it out.
@@ -46,11 +47,11 @@ describe('TemplateRenderer', () => {
camera: 'camera',
view: 'live',
};
const triggerData: ConditionsTriggerData = {
camera: {
to: 'camera',
from: 'previous-camera',
},
const triggerData: TriggerData = {
platform: 'acc',
type: 'camera',
from_acc: { camera: 'previous-camera' },
to_acc: { camera: 'camera' },
};
const renderer = new TemplateRenderer();
@@ -71,22 +72,12 @@ describe('TemplateRenderer', () => {
acc: {
camera: 'camera',
view: 'live',
trigger: {
camera: {
to: 'camera',
from: 'previous-camera',
},
},
},
advanced_camera_card: {
camera: 'camera',
view: 'live',
trigger: {
camera: {
to: 'camera',
from: 'previous-camera',
},
},
trigger: {
platform: 'acc',
type: 'camera',
from_acc: { camera: 'previous-camera' },
to_acc: { camera: 'camera' },
},
});
});
tests/test-utils.ts
+4 -4
View File
@@ -24,6 +24,7 @@ import {
import { ActionsManager } from '../src/card-controller/actions/actions-manager';
import { AutomationsManager } from '../src/card-controller/automations-manager';
import { CallManager } from '../src/card-controller/call/manager';
import { CameraTriggersManager } from '../src/card-controller/camera-triggers-manager';
import { CameraURLManager } from '../src/card-controller/camera-url-manager';
import {
CardElementManager,
@@ -37,8 +38,8 @@ import { ExpandManager } from '../src/card-controller/expand-manager';
import { FoldersManager } from '../src/card-controller/folders/manager';
import { FolderQuery } from '../src/card-controller/folders/types';
import { FullscreenManager } from '../src/card-controller/fullscreen/fullscreen-manager';
import { HASSManager } from '../src/card-controller/hass/hass-manager';
import { EventWatcherSubscriptionInterface } from '../src/card-controller/hass/event-watcher';
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';
@@ -54,11 +55,10 @@ import { PIPManager } from '../src/card-controller/pip-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 { ViewItemManager } from '../src/card-controller/view/item-manager';
import { ViewManager } from '../src/card-controller/view/view-manager';
import { SubmenuInteraction, SubmenuItem } from '../src/components/submenu/types';
import { ConditionStateManager } from '../src/conditions/state-manager';
import { ConditionStateManager } from '../src/condition-trigger/conditions/state-manager';
import { CameraConfig, cameraConfigSchema } from '../src/config/schema/cameras';
import { FolderConfig } from '../src/config/schema/folders';
import {
@@ -725,7 +725,7 @@ export const createCardAPI = (): CardController => {
api.getQueryStringManager.mockReturnValue(mock<QueryStringManager>());
api.getStatusBarItemManager.mockReturnValue(mock<StatusBarItemManager>());
api.getStyleManager.mockReturnValue(mock<StyleManager>());
api.getTriggersManager.mockReturnValue(mock<TriggersManager>());
api.getCameraTriggersManager.mockReturnValue(mock<CameraTriggersManager>());
api.getViewItemManager.mockReturnValue(mock<ViewItemManager>());
api.getViewManager.mockReturnValue(mock<ViewManager>());
tests/utils/action.test.ts
+30
View File
@@ -25,7 +25,9 @@ import {
createSubstreamOnAction,
createViewAction,
getActionConfigGivenAction,
getActionName,
hasAction,
isIfAction,
stopEventFromActivatingCardWideActions,
} from '../../src/utils/action.js';
@@ -563,6 +565,34 @@ describe('hasAction', () => {
it('should return false with an array of actions none real', () => {
expect(hasAction([noneAction, noneAction, noneAction])).toBeFalsy();
});
it('should return true for an if action', () => {
expect(hasAction({ if: [], then: [] })).toBeTruthy();
});
});
describe('isIfAction', () => {
it('should return true for an if action', () => {
expect(isIfAction({ if: [], then: [] })).toBeTruthy();
});
it('should return false for a stock action', () => {
expect(isIfAction({ action: 'none' })).toBeFalsy();
});
});
describe('getActionName', () => {
it('should name an if action', () => {
expect(getActionName({ if: [], then: [] })).toBe('if');
});
it('should name a custom action', () => {
expect(getActionName(createViewAction('clips'))).toBe('clips');
});
it('should name a stock action', () => {
expect(getActionName({ action: 'more-info' })).toBe('more-info');
});
});
// @vitest-environment jsdom
tests/utils/keyed-subscription-manager.test.ts → tests/utils/concurrency/keyed-subscription-manager.test.ts
+1 -1
View File
@@ -1,5 +1,5 @@
import { describe, expect, it, vi } from 'vitest';
import { KeyedSubscriptionManager } from '../../src/utils/keyed-subscription-manager';
import { KeyedSubscriptionManager } from '../../../src/utils/concurrency/keyed-subscription-manager';
interface TestRequest {
key: string;
tests/utils/concurrency/serial-runner.test.ts
+65
View File
@@ -0,0 +1,65 @@
import { describe, expect, it } from 'vitest';
import { SerialRunner } from '../../../src/utils/concurrency/serial-runner';
describe('SerialRunner', () => {
it('should run work immediately and return its result', () => {
const runner = new SerialRunner();
expect(runner.run(() => 42)).toBe(42);
});
it('should defer work run from within work and return null for it', () => {
const runner = new SerialRunner();
const order: string[] = [];
let deferredResult: number | null = -1;
const result = runner.run(() => {
order.push('outer-start');
deferredResult = runner.run(() => {
order.push('inner');
return 2;
});
order.push('outer-end');
return 1;
});
expect(result).toBe(1);
// The re-entrant call returns null: its work had not run when it returned.
expect(deferredResult).toBeNull();
// The deferred work runs only after the outer work completes, never nested.
expect(order).toEqual(['outer-start', 'outer-end', 'inner']);
});
it('should drain multiple re-entrant runs in the order enqueued', () => {
const runner = new SerialRunner();
const order: string[] = [];
runner.run(() => {
order.push('outer');
runner.run(() => order.push('a'));
runner.run(() => order.push('b'));
});
expect(order).toEqual(['outer', 'a', 'b']);
});
it('should drain work enqueued while draining, preserving order', () => {
const runner = new SerialRunner();
const order: string[] = [];
runner.run(() => {
order.push('outer');
runner.run(() => {
order.push('a');
// Enqueued during the drain of 'a', after 'b' is already queued.
runner.run(() => order.push('c'));
});
runner.run(() => order.push('b'));
});
expect(order).toEqual(['outer', 'a', 'b', 'c']);
});
});
tests/view/unified-query-runner.test.ts
+1 -1
View File
@@ -2,7 +2,7 @@ import { assert, describe, expect, it } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { CameraManager } from '../../src/camera-manager/manager';
import { FoldersManager } from '../../src/card-controller/folders/manager';
import { ConditionStateManagerReadonlyInterface } from '../../src/conditions/types';
import { ConditionStateManagerReadonlyInterface } from '../../src/condition-trigger/conditions/types';
import { QuerySource } from '../../src/query-source';
import { ViewMedia } from '../../src/view/item';
import { UnifiedQuery } from '../../src/view/unified-query';