homebridge-securitysystem 0.0.1-matter

package/src/tests/state-handler.test.ts

@@ -0,0 +1,371 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import type { ServiceRegistry } from '../interfaces/service-registry-interface.js';
+import type { StorageService } from '../services/storage-service.js';
+import { EventType } from '../types/event-type.js';
+
+// ── Minimal mocks ─────────────────────────────────────────────────────────────
+
+function makeMockChar(initialValue: unknown = false) {
+  const char = { value: initialValue, updateValue: vi.fn(), setProps: vi.fn() };
+  char.updateValue.mockImplementation((v: unknown) => {
+    char.value = v;
+  });
+  return char;
+}
+
+function makeMockService(charValue: unknown = false) {
+  const char = makeMockChar(charValue);
+  return {
+    getCharacteristic: vi.fn().mockReturnValue(char),
+    setCharacteristic: vi.fn().mockReturnThis(),
+    updateCharacteristic: vi.fn(),
+    addCharacteristic: vi.fn(),
+    addOptionalCharacteristic: vi.fn(),
+  };
+}
+
+function makeServices(): ServiceRegistry {
+  const s = {} as Record<string, ReturnType<typeof makeMockService>>;
+  const keys = [
+    'mainService', 'accessoryInfoService', 'tripSwitchService', 'tripHomeSwitchService',
+    'tripAwaySwitchService', 'tripNightSwitchService', 'tripOverrideSwitchService',
+    'armingLockSwitchService', 'armingLockHomeSwitchService', 'armingLockAwaySwitchService',
+    'armingLockNightSwitchService', 'modeHomeSwitchService', 'modeAwaySwitchService',
+    'modeNightSwitchService', 'modeOffSwitchService', 'modeAwayExtendedSwitchService',
+    'modePauseSwitchService', 'armingMotionSensorService',
+    'trippedMotionSensorService', 'triggeredResetMotionSensorService',
+  ];
+  for (const k of keys) {
+    s[k] = makeMockService();
+  }
+  return s as unknown as ServiceRegistry;
+}
+
+function makeState(overrides: Partial<SystemState> = {}): SystemState {
+  return {
+    currentState: SecurityState.OFF,
+    targetState: SecurityState.OFF,
+    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 {
+    armSeconds: 0,
+    triggerSeconds: 0,
+    resetMinutes: 10,
+    testMode: false,
+    proxyMode: false,
+    saveState: false,
+    armingLockSwitch: false,
+    armingLockSwitches: false,
+    disabledModes: [],
+    homeArmSeconds: null,
+    awayArmSeconds: null,
+    nightArmSeconds: null,
+    homeTriggerSeconds: null,
+    awayTriggerSeconds: null,
+    nightTriggerSeconds: null,
+    trippedMotionSensor: false,
+    trippedMotionSensorSeconds: 5,
+    resetOffFlow: false,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+function makeMockLog() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+function makeStorage() {
+  return { save: vi.fn(), load: vi.fn(), init: vi.fn() } as unknown as StorageService;
+}
+
+function makeTimers() {
+  return {
+    setArmTimer: vi.fn(), clearArmTimer: vi.fn(),
+    setTriggerTimer: vi.fn(), clearTriggerTimer: vi.fn(), isTriggerRunning: vi.fn().mockReturnValue(false),
+    setPauseTimer: vi.fn(), clearPauseTimer: vi.fn(),
+    setDoubleKnockTimer: vi.fn(), clearDoubleKnockTimer: vi.fn(),
+    setResetTimer: vi.fn(), clearResetTimer: vi.fn(),
+    setTrippedInterval: vi.fn(), clearTrippedInterval: vi.fn(),
+    clearAll: vi.fn(),
+  } as any;
+}
+
+function makeMockSensor() {
+  return {
+    resetArmingMotionSensor: vi.fn(),
+    setTrippedMotionSensor: vi.fn(),
+    resetTrippedMotionSensor: vi.fn(),
+    pulseResetMotionSensor: vi.fn(),
+    updateArmingMotionSensor: vi.fn(),
+  };
+}
+
+// ── StateHandler tests ────────────────────────────────────────────────────────
+
+describe('StateHandler.getArmingSeconds', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+
+  let stateHandler: InstanceType<typeof StateHandler>;
+  let state: SystemState;
+
+  beforeEach(async () => {
+    const { EventBusService } = await import('../services/event-bus-service.js');
+
+    state = makeState();
+    const services = makeServices();
+    const options = makeOptions();
+    const log = makeMockLog();
+    const bus = new EventBusService();
+
+    const sensor = makeMockSensor() as any;
+    stateHandler = new StateHandler(services, state, options, {} as any, log as any, bus, makeStorage(), makeTimers(), sensor);
+  });
+
+  it('returns 0 when current state is TRIGGERED', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    expect(stateHandler.getArmingSeconds(SecurityState.HOME)).toBe(0);
+  });
+
+  it('returns 0 when target state is OFF (disarm)', () => {
+    state.currentState = SecurityState.HOME;
+    expect(stateHandler.getArmingSeconds(SecurityState.OFF)).toBe(0);
+  });
+
+  it('returns global armSeconds when no mode-specific value', () => {
+    state.currentState = SecurityState.HOME;
+    expect(stateHandler.getArmingSeconds(SecurityState.AWAY)).toBe(0);
+  });
+});
+
+// ── StateHandler.updateTargetState ───────────────────────────────────────────
+
+describe('StateHandler.updateTargetState', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  it('returns success (no-op) when currentState already matches the requested mode', async () => {
+    const state = makeState({ currentState: SecurityState.HOME, targetState: SecurityState.HOME });
+    const log = makeMockLog();
+    const bus = new EventBusService();
+    const sensor = makeMockSensor() as any;
+    const timers = makeTimers();
+    const handler = new StateHandler(makeServices(), state, makeOptions(), {} as any, log as any, bus, makeStorage(), timers, sensor);
+
+    const result = handler.updateTargetState(SecurityState.HOME, OriginType.INTERNAL, 0);
+    expect(result.success).toBe(true);
+    expect(timers.clearArmTimer).not.toHaveBeenCalled();
+  });
+
+  it('cancels arm timer and applies state immediately on same-target re-call while arming', async () => {
+    const state = makeState({ currentState: SecurityState.OFF, targetState: SecurityState.HOME, isArming: true });
+    const log = makeMockLog();
+    const bus = new EventBusService();
+    const sensor = makeMockSensor() as any;
+    const timers = makeTimers();
+    const handler = new StateHandler(makeServices(), state, makeOptions(), {} as any, log as any, bus, makeStorage(), timers, sensor);
+
+    const result = handler.updateTargetState(SecurityState.HOME, OriginType.EXTERNAL, 0);
+    expect(result.success).toBe(true);
+    expect(timers.clearArmTimer).toHaveBeenCalled();
+    expect(state.isArming).toBe(false);
+    expect(state.currentState).toBe(SecurityState.HOME);
+  });
+
+  it('applies state immediately on same-target re-call when not arming', async () => {
+    const state = makeState({ currentState: SecurityState.OFF, targetState: SecurityState.HOME, isArming: false });
+    const log = makeMockLog();
+    const bus = new EventBusService();
+    const sensor = makeMockSensor() as any;
+    const timers = makeTimers();
+    const handler = new StateHandler(makeServices(), state, makeOptions(), {} as any, log as any, bus, makeStorage(), timers, sensor);
+
+    const result = handler.updateTargetState(SecurityState.HOME, OriginType.EXTERNAL, 0);
+    expect(result.success).toBe(true);
+    expect(timers.clearArmTimer).not.toHaveBeenCalled();
+    expect(state.currentState).toBe(SecurityState.HOME);
+  });
+
+  it('transitions to a new armed mode', async () => {
+    const state = makeState({ currentState: SecurityState.OFF, targetState: SecurityState.OFF });
+    const log = makeMockLog();
+    const bus = new EventBusService();
+    const sensor = makeMockSensor() as any;
+    const handler = new StateHandler(makeServices(), state, makeOptions(), {} as any, log as any, bus, makeStorage(), makeTimers(), sensor);
+
+    const result = handler.updateTargetState(SecurityState.HOME, OriginType.REGULAR_SWITCH, 0);
+    expect(result.success).toBe(true);
+    expect(state.targetState).toBe(SecurityState.HOME);
+  });
+});
+
+// ── Regression: RESET_TRIP_SWITCHES on TRIGGERED ───────────────────────────────
+// Issue 905: Trip Switch was being reset to OFF when the alarm triggered,
+// hiding the active sensor from the user.
+
+describe('StateHandler.setCurrentState - RESET_TRIP_SWITCHES', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  it('does not emit RESET_TRIP_SWITCHES when entering TRIGGERED', () => {
+    const state = makeState({ currentState: SecurityState.NIGHT });
+    const bus = new EventBusService();
+    const spy = vi.fn();
+    bus.on(EventType.RESET_TRIP_SWITCHES, spy);
+
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, bus, makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+
+    handler.setCurrentState(SecurityState.TRIGGERED, OriginType.EXTERNAL);
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('still emits RESET_TRIP_SWITCHES when entering a non-TRIGGERED state', () => {
+    const state = makeState({ currentState: SecurityState.TRIGGERED });
+    const bus = new EventBusService();
+    const spy = vi.fn();
+    bus.on(EventType.RESET_TRIP_SWITCHES, spy);
+
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, bus, makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+
+    handler.setCurrentState(SecurityState.NIGHT, OriginType.EXTERNAL);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ── Regression: isTripping reset on target state change ───────────────────────
+// Issue 905: isTripping was not being reset when the user changed the target
+// mode, causing stale trip state after OFF disarm + re-arm.
+
+describe('StateHandler.updateTargetState - isTripping reset', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  it('resets isTripping to false when target state changes to a different mode', () => {
+    const state = makeState({ currentState: SecurityState.HOME, isTripping: true });
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, new EventBusService(), makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+
+    handler.updateTargetState(SecurityState.AWAY, OriginType.INTERNAL, 0);
+
+    expect(state.isTripping).toBe(false);
+  });
+
+  it('resets isTripping to false when disarming from TRIGGERED to OFF', () => {
+    const state = makeState({
+      currentState: SecurityState.TRIGGERED,
+      targetState: SecurityState.NIGHT,
+      isTripping: true,
+    });
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, new EventBusService(), makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+
+    handler.updateTargetState(SecurityState.OFF, OriginType.INTERNAL, 0);
+
+    expect(state.isTripping).toBe(false);
+  });
+});
+
+// ── Arming locks read from SystemState (switches are Matter-only) ─────────────
+
+describe('StateHandler.isArmingLocked', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  function makeHandler(state: SystemState) {
+    return new StateHandler(
+      makeServices(), state, makeOptions({ armingLockSwitch: true }), {} as any,
+      makeMockLog() as any, new EventBusService(), makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+  }
+
+  it('blocks when the global arming lock is active', () => {
+    const state = makeState({ armingLocks: { global: true, home: false, away: false, night: false } });
+    expect(makeHandler(state).isArmingLocked(SecurityState.HOME)).toBe(true);
+  });
+
+  it('blocks when the matching mode lock is active', () => {
+    const state = makeState({ armingLocks: { global: false, home: false, away: true, night: false } });
+    expect(makeHandler(state).isArmingLocked(SecurityState.AWAY)).toBe(true);
+    expect(makeHandler(state).isArmingLocked(SecurityState.HOME)).toBe(false);
+  });
+
+  it('never blocks disarming', () => {
+    const state = makeState({ armingLocks: { global: true, home: false, away: false, night: false } });
+    expect(makeHandler(state).isArmingLocked(SecurityState.OFF)).toBe(false);
+  });
+});
+
+// ── Away-extended flag is cleared on any target change ───────────────────────
+
+describe('StateHandler.updateTargetState - modeAwayExtended reset', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  it('clears modeAwayExtended when the target changes', () => {
+    const state = makeState({ currentState: SecurityState.OFF, modeAwayExtended: true });
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, new EventBusService(), makeStorage(),
+      makeTimers(), makeMockSensor() as any,
+    );
+
+    handler.updateTargetState(SecurityState.HOME, OriginType.INTERNAL, 0);
+
+    expect(state.modeAwayExtended).toBe(false);
+  });
+});
+
+// ── Tripped sensor reset on TRIGGERED ────────────────────────────────────────
+
+describe('StateHandler.setCurrentState - tripped sensor reset', async () => {
+  const { StateHandler } = await import('../handlers/state-handler.js');
+  const { EventBusService } = await import('../services/event-bus-service.js');
+
+  it('resets tripped motion sensor when entering TRIGGERED', () => {
+    const state = makeState({ currentState: SecurityState.NIGHT });
+    const bus = new EventBusService();
+    const sensor = makeMockSensor() as any;
+
+    const handler = new StateHandler(
+      makeServices(), state, makeOptions(), {} as any,
+      makeMockLog() as any, bus, makeStorage(),
+      makeTimers(), sensor,
+    );
+
+    handler.setCurrentState(SecurityState.TRIGGERED, OriginType.EXTERNAL);
+
+    expect(sensor.resetTrippedMotionSensor).toHaveBeenCalled();
+  });
+});

package/src/tests/switch-handler.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SecurityState } from '../types/security-state-type.js';
+import { OriginType } from '../types/origin-type.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import { SwitchHandler } from '../handlers/switch-handler.js';
+
+// ── Minimal mocks ─────────────────────────────────────────────────────────────
+
+function makeState(overrides: Partial<SystemState> = {}): SystemState {
+  return {
+    currentState: SecurityState.OFF,
+    targetState: SecurityState.OFF,
+    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 {
+    armSeconds: 0,
+    triggerSeconds: 0,
+    resetMinutes: 10,
+    testMode: false,
+    proxyMode: false,
+    saveState: false,
+    overrideOff: false,
+    doubleKnock: false,
+    doubleKnockSeconds: 90,
+    doubleKnockModes: [],
+    homeTriggerSeconds: null,
+    awayTriggerSeconds: null,
+    nightTriggerSeconds: null,
+    homeDoubleKnockSeconds: null,
+    awayDoubleKnockSeconds: null,
+    nightDoubleKnockSeconds: null,
+    modeAwayExtendedSwitchTriggerSeconds: null,
+    armingLockSwitch: false,
+    armingLockSwitches: false,
+    disabledModes: [],
+    homeArmSeconds: null,
+    awayArmSeconds: null,
+    nightArmSeconds: null,
+    trippedMotionSensor: false,
+    trippedMotionSensorSeconds: 5,
+    resetOffFlow: false,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+function makeMockLog() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+function makeMockStateHandler() {
+  return {
+    updateTargetState: vi.fn().mockReturnValue({ success: true }),
+    getArmingSeconds: vi.fn().mockReturnValue(0),
+  };
+}
+
+function makeMockTimers() {
+  return {
+    setArmTimer: vi.fn(), clearArmTimer: vi.fn(),
+    setTriggerTimer: vi.fn(), clearTriggerTimer: vi.fn(), isTriggerRunning: vi.fn().mockReturnValue(false),
+    setPauseTimer: vi.fn(), clearPauseTimer: vi.fn(),
+    setDoubleKnockTimer: vi.fn(), clearDoubleKnockTimer: vi.fn(),
+    setResetTimer: vi.fn(), clearResetTimer: vi.fn(),
+    setTrippedInterval: vi.fn(), clearTrippedInterval: vi.fn(),
+    clearAll: vi.fn(),
+  } as any;
+}
+
+function makeHandler(state: SystemState, options = makeOptions()) {
+  const stateHandler = makeMockStateHandler();
+  const log = makeMockLog();
+  const timers = makeMockTimers();
+  const handler = new SwitchHandler(state, options, log as any, timers, stateHandler as any);
+  return { handler, stateHandler, log, timers };
+}
+
+// ── SwitchHandler tests ───────────────────────────────────────────────────────
+
+describe('SwitchHandler', () => {
+  it('setModeSwitch arms via updateTargetState with the arming delay', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+    stateHandler.getArmingSeconds.mockReturnValue(42);
+
+    const result = handler.setModeSwitch(SecurityState.HOME, true);
+
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.HOME, OriginType.INTERNAL, 42);
+    expect(result.success).toBe(true);
+  });
+
+  it('setModeSwitch reports how updateTargetState refused the change', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+    stateHandler.updateTargetState.mockReturnValue({ success: false, reason: 'arming is blocked by an arming lock switch' });
+
+    const result = handler.setModeSwitch(SecurityState.HOME, true);
+
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('arming is blocked by an arming lock switch');
+  });
+
+  it('setModeSwitch rejects turning a mode switch off', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+
+    const result = handler.setModeSwitch(SecurityState.HOME, false);
+
+    expect(result.success).toBe(false);
+    expect(stateHandler.updateTargetState).not.toHaveBeenCalled();
+  });
+
+  it('setModeOffSwitch disarms and propagates refusals', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+
+    handler.setModeOffSwitch(true);
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.OFF, OriginType.INTERNAL, 0);
+
+    stateHandler.updateTargetState.mockReturnValue({ success: false, reason: 'target mode is disabled' });
+    const refused = handler.setModeOffSwitch(true);
+    expect(refused).toEqual({ success: false, reason: 'target mode is disabled' });
+
+    const rejected = handler.setModeOffSwitch(false);
+    expect(rejected.success).toBe(false);
+    // Only the two successful ON commands reach updateTargetState.
+    expect(stateHandler.updateTargetState).toHaveBeenCalledTimes(2);
+  });
+
+  it('setModeAwayExtendedSwitch arms away and records the extended flag', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+
+    const result = handler.setModeAwayExtendedSwitch(true);
+
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.AWAY, OriginType.INTERNAL, 0);
+    expect(state.modeAwayExtended).toBe(true);
+    expect(result.success).toBe(true);
+  });
+
+  it('setModeAwayExtendedSwitch does not set the extended flag when arming was refused', () => {
+    const state = makeState();
+    const { handler, stateHandler } = makeHandler(state);
+    stateHandler.updateTargetState.mockReturnValue({ success: false, reason: 'arming is blocked by an arming lock switch' });
+
+    const result = handler.setModeAwayExtendedSwitch(true);
+
+    expect(result.success).toBe(false);
+    expect(state.modeAwayExtended).toBe(false);
+  });
+
+  it('setModeAwayExtendedSwitch rejects turning off', () => {
+    const state = makeState();
+    const { handler } = makeHandler(state);
+
+    expect(handler.setModeAwayExtendedSwitch(false).success).toBe(false);
+  });
+
+  it('setModePauseSwitch rejects while triggered', () => {
+    const state = makeState({ currentState: SecurityState.TRIGGERED });
+    const { handler, timers } = makeHandler(state);
+
+    const result = handler.setModePauseSwitch(true);
+
+    expect(result.success).toBe(false);
+    expect(timers.setPauseTimer).not.toHaveBeenCalled();
+  });
+
+  it('setModePauseSwitch rejects while disarmed', () => {
+    const state = makeState({ currentState: SecurityState.OFF });
+    const { handler, timers } = makeHandler(state);
+
+    const result = handler.setModePauseSwitch(true);
+
+    expect(result.success).toBe(false);
+    expect(timers.setPauseTimer).not.toHaveBeenCalled();
+  });
+
+  it('setModePauseSwitch pauses and schedules the resume timer', () => {
+    const state = makeState({ currentState: SecurityState.HOME });
+    const { handler, stateHandler, timers } = makeHandler(state, makeOptions({ pauseMinutes: 5 }));
+
+    const result = handler.setModePauseSwitch(true);
+
+    expect(state.pausedCurrentState).toBe(SecurityState.HOME);
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.OFF, OriginType.INTERNAL, 0);
+    expect(timers.setPauseTimer).toHaveBeenCalledWith(5 * 60 * 1000, expect.any(Function));
+    expect(result.success).toBe(true);
+  });
+
+  it('setModePauseSwitch cancel resumes the paused mode', () => {
+    const state = makeState({ currentState: SecurityState.OFF, pausedCurrentState: SecurityState.AWAY });
+    const { handler, stateHandler, timers } = makeHandler(state);
+
+    const result = handler.setModePauseSwitch(false);
+
+    expect(timers.clearPauseTimer).toHaveBeenCalled();
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.AWAY, OriginType.INTERNAL, 0);
+    expect(result.success).toBe(true);
+  });
+
+  it('updateArmingLock stores the lock on state and returns success', () => {
+    const state = makeState();
+    const { handler } = makeHandler(state);
+
+    expect(handler.updateArmingLock('global', true).success).toBe(true);
+    expect(state.armingLocks.global).toBe(true);
+
+    expect(handler.updateArmingLock('away', false).success).toBe(true);
+    expect(state.armingLocks.away).toBe(false);
+  });
+
+  it('updateArmingLock rejects unknown modes', () => {
+    const state = makeState();
+    const { handler } = makeHandler(state);
+
+    const result = handler.updateArmingLock('garage', true);
+
+    expect(result.success).toBe(false);
+    expect(result.reason).toBe('unknown arming lock mode: garage');
+  });
+});