homebridge-securitysystem 0.0.1-matter

package/src/tests/conditions.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { ConditionContext } from '../interfaces/condition-context-interface.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import { NotArmedCondition } from '../conditions/not-armed-condition.js';
+import { ArmingInProgressCondition } from '../conditions/arming-in-progress-condition.js';
+import { AlreadyTriggeredCondition } from '../conditions/already-triggered-condition.js';
+import { DoubleKnockCondition } from '../conditions/double-knock-condition.js';
+import { ArmingLockCondition } from '../conditions/arming-lock-condition.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeState(overrides: Partial<SystemState> = {}): SystemState {
+  return {
+    currentState: SecurityState.HOME,
+    targetState: SecurityState.HOME,
+    defaultState: SecurityState.OFF,
+    availableTargetStates: [SecurityState.HOME, SecurityState.AWAY, SecurityState.NIGHT, SecurityState.OFF],
+    isArming: false,
+    isTripping: false,
+    isKnocked: false,
+    serverAuthenticationAttempts: 0,
+    pausedCurrentState: null,
+    armingLocks: { global: false, home: false, away: false, night: false },
+    modeAwayExtended: false,
+    ...overrides,
+  };
+}
+
+function makeOptions(overrides: Partial<SecuritySystemOptions> = {}): SecuritySystemOptions {
+  return {
+    overrideOff: false,
+    doubleKnock: false,
+    doubleKnockSeconds: 90,
+    doubleKnockModes: [],
+    homeDoubleKnockSeconds: null,
+    awayDoubleKnockSeconds: null,
+    nightDoubleKnockSeconds: null,
+    armingLockSwitch: false,
+    armingLockSwitches: false,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+function makeLog() {
+  return { info: vi.fn(), warn: vi.fn(), debug: vi.fn(), error: vi.fn(), success: vi.fn() };
+}
+
+function makeCtx(state: SystemState, options: SecuritySystemOptions, value: boolean, origin = OriginType.REGULAR_SWITCH): ConditionContext {
+  return { state, options, value, origin, log: makeLog() as unknown as ConditionContext['log'] };
+}
+
+// ── ArmingLockCondition ───────────────────────────────────────────────────────
+
+describe('ArmingLockCondition', () => {
+  const cond = new ArmingLockCondition();
+
+  it('blocks when the global lock is active and arming to an armed mode', () => {
+    const state = makeState({ armingLocks: { global: true, home: false, away: false, night: false } });
+    expect(cond.evaluate(makeCtx(state, makeOptions({ armingLockSwitch: true }), true))).toBe(true);
+    expect(cond.failureReason).toBe('arming is blocked by the global arming lock switch');
+  });
+
+  it('blocks when the matching mode lock is active', () => {
+    const state = makeState({ targetState: SecurityState.AWAY, armingLocks: { global: false, home: false, away: true, night: false } });
+    expect(cond.evaluate(makeCtx(state, makeOptions({ armingLockSwitches: true }), true))).toBe(true);
+  });
+
+  it('does not block when the lock feature is disabled', () => {
+    const state = makeState({ armingLocks: { global: true, home: false, away: false, night: false } });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), true))).toBe(false);
+  });
+
+  it('does not block disarming', () => {
+    const state = makeState({ targetState: SecurityState.OFF, armingLocks: { global: true, home: false, away: false, night: false } });
+    expect(cond.evaluate(makeCtx(state, makeOptions({ armingLockSwitch: true }), true))).toBe(false);
+  });
+
+  it('allows when no lock is active', () => {
+    const state = makeState();
+    expect(cond.evaluate(makeCtx(state, makeOptions({ armingLockSwitch: true }), true))).toBe(false);
+  });
+});
+
+// ── NotArmedCondition ─────────────────────────────────────────────────────────
+
+describe('NotArmedCondition', () => {
+  const cond = new NotArmedCondition();
+
+  it('blocks when disarmed and override_off is false', () => {
+    const state = makeState({ currentState: SecurityState.OFF });
+    const opts = makeOptions({ overrideOff: false });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(true);
+  });
+
+  it('allows when disarmed but override_off is true', () => {
+    const state = makeState({ currentState: SecurityState.OFF });
+    const opts = makeOptions({ overrideOff: true });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(false);
+  });
+
+  it('allows when disarmed but origin is OVERRIDE_SWITCH', () => {
+    const state = makeState({ currentState: SecurityState.OFF });
+    const opts = makeOptions({ overrideOff: false });
+    expect(cond.evaluate(makeCtx(state, opts, true, OriginType.OVERRIDE_SWITCH))).toBe(false);
+  });
+
+  it('allows when system is armed', () => {
+    const state = makeState({ currentState: SecurityState.HOME });
+    const opts = makeOptions({ overrideOff: false });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(false);
+  });
+
+  it('does not block on value=false', () => {
+    const state = makeState({ currentState: SecurityState.OFF });
+    const opts = makeOptions({ overrideOff: false });
+    expect(cond.evaluate(makeCtx(state, opts, false))).toBe(false);
+  });
+});
+
+// ── ArmingInProgressCondition ─────────────────────────────────────────────────
+
+describe('ArmingInProgressCondition', () => {
+  const cond = new ArmingInProgressCondition();
+
+  it('blocks when isArming is true and value is true', () => {
+    const state = makeState({ isArming: true });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), true))).toBe(true);
+  });
+
+  it('allows when not arming', () => {
+    const state = makeState({ isArming: false });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), true))).toBe(false);
+  });
+
+  it('does not block on value=false', () => {
+    const state = makeState({ isArming: true });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), false))).toBe(false);
+  });
+});
+
+// ── AlreadyTriggeredCondition ─────────────────────────────────────────────────
+
+describe('AlreadyTriggeredCondition', () => {
+  const cond = new AlreadyTriggeredCondition();
+
+  it('blocks when currently triggered and value is true', () => {
+    const state = makeState({ currentState: SecurityState.TRIGGERED });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), true))).toBe(true);
+  });
+
+  it('allows when not triggered', () => {
+    const state = makeState({ currentState: SecurityState.HOME });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), true))).toBe(false);
+  });
+
+  it('does not block on value=false (cancel)', () => {
+    const state = makeState({ currentState: SecurityState.TRIGGERED });
+    expect(cond.evaluate(makeCtx(state, makeOptions(), false))).toBe(false);
+  });
+});
+
+// ── DoubleKnockCondition ──────────────────────────────────────────────────────
+
+describe('DoubleKnockCondition', () => {
+  it('allows through when doubleKnock option is disabled', () => {
+    const onFirstKnock = vi.fn();
+    const cond = new DoubleKnockCondition(onFirstKnock, vi.fn());
+    const state = makeState({ isKnocked: false });
+    const opts = makeOptions({ doubleKnock: false, doubleKnockModes: ['home'] });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(false);
+    expect(onFirstKnock).not.toHaveBeenCalled();
+  });
+
+  it('allows override switch to bypass double-knock', () => {
+    const onFirstKnock = vi.fn();
+    const cond = new DoubleKnockCondition(onFirstKnock, vi.fn());
+    const state = makeState({ isKnocked: false, currentState: SecurityState.HOME });
+    const opts = makeOptions({ doubleKnock: true, doubleKnockModes: ['home'], doubleKnockSeconds: 90 });
+    expect(cond.evaluate(makeCtx(state, opts, true, OriginType.OVERRIDE_SWITCH))).toBe(false);
+    expect(onFirstKnock).not.toHaveBeenCalled();
+  });
+
+  it('blocks first knock and calls onFirstKnock', () => {
+    const onFirstKnock = vi.fn();
+    const cond = new DoubleKnockCondition(onFirstKnock, vi.fn());
+    const state = makeState({ isKnocked: false, currentState: SecurityState.HOME });
+    const opts = makeOptions({ doubleKnock: true, doubleKnockModes: ['home'], doubleKnockSeconds: 90 });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(true);
+    expect(state.isKnocked).toBe(true);
+    expect(onFirstKnock).toHaveBeenCalledWith(90, expect.any(Function));
+  });
+
+  it('allows second knock through and clears isKnocked', () => {
+    const cond = new DoubleKnockCondition(vi.fn(), vi.fn());
+    const state = makeState({ isKnocked: true, currentState: SecurityState.HOME });
+    const opts = makeOptions({ doubleKnock: true, doubleKnockModes: ['home'], doubleKnockSeconds: 90 });
+    expect(cond.evaluate(makeCtx(state, opts, true))).toBe(false);
+    expect(state.isKnocked).toBe(false);
+  });
+
+  it('uses mode-specific knock window when configured', () => {
+    const onFirstKnock = vi.fn();
+    const cond = new DoubleKnockCondition(onFirstKnock, vi.fn());
+    const state = makeState({ isKnocked: false, currentState: SecurityState.AWAY });
+    const opts = makeOptions({ doubleKnock: true, doubleKnockModes: ['away'], doubleKnockSeconds: 90, awayDoubleKnockSeconds: 30 });
+    cond.evaluate(makeCtx(state, opts, true));
+    expect(onFirstKnock).toHaveBeenCalledWith(30, expect.any(Function));
+  });
+});