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

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>
2026-06-30 17:45:13 -07:00
parent 209c873c58
commit b701366762
354 changed files with 11386 additions and 3020 deletions
@@ -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 () => {
@@ -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(
      {},
@@ -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();
+  });
+});
@@ -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],