homebridge-securitysystem 0.0.1-matter

package/src/tests/mqtt-service.test.ts

@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventType } from '../types/event-type.js';
+import { OriginType } from '../types/origin-type.js';
+import { SecurityState } from '../types/security-state-type.js';
+import { EventBusService } from '../services/event-bus-service.js';
+import type { SystemState } from '../interfaces/system-state-interface.js';
+import type { SecuritySystemOptions } from '../interfaces/options-interface.js';
+import { MqttService } from '../services/mqtt-service.js';
+
+// ── Mocks ─────────────────────────────────────────────────────────────────────
+
+const mockClient = {
+  on: vi.fn().mockReturnThis(),
+  publish: vi.fn(),
+  connected: true,
+  end: vi.fn(),
+};
+
+vi.mock('mqtt', () => ({
+  connect: vi.fn(() => mockClient),
+}));
+
+import { connect } from 'mqtt';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeLog() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+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 {
+    mqttBroker: null,
+    mqttUsername: null,
+    mqttPassword: null,
+    mqttTopic: 'security-system/state',
+    mqttClientId: null,
+    proxyMode: false,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+
+describe('MqttService', () => {
+  let log: ReturnType<typeof makeLog>;
+  let state: SystemState;
+  let bus: EventBusService;
+
+  beforeEach(() => {
+    log = makeLog();
+    state = makeState();
+    bus = new EventBusService();
+    vi.clearAllMocks();
+    mockClient.connected = true;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('does nothing when broker is not configured', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: null }), state);
+    service.attachToBus(bus);
+
+    expect(connect).not.toHaveBeenCalled();
+    expect(log.debug).toHaveBeenCalledWith('MQTT broker not configured.');
+  });
+
+  it('connects when broker is configured', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost:1883' }), state);
+    service.attachToBus(bus);
+
+    expect(connect).toHaveBeenCalledWith('mqtt://localhost:1883', {});
+    expect(mockClient.on).toHaveBeenCalledWith('connect', expect.any(Function));
+    expect(mockClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+    expect(mockClient.on).toHaveBeenCalledWith('close', expect.any(Function));
+  });
+
+  it('passes connection options when provided', () => {
+    const options = makeOptions({
+      mqttBroker: 'mqtt://broker:1883',
+      mqttUsername: 'user',
+      mqttPassword: 'pass',
+      mqttClientId: 'my-client',
+    });
+
+    new MqttService(log as never, options, state).attachToBus(bus);
+
+    expect(connect).toHaveBeenCalledWith('mqtt://broker:1883', {
+      clientId: 'my-client',
+      username: 'user',
+      password: 'pass',
+    });
+  });
+
+  it('publishes status on TARGET_CHANGED event', () => {
+    state.isArming = true;
+    state.currentState = SecurityState.HOME;
+    state.targetState = SecurityState.AWAY;
+
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.TARGET_CHANGED, { state: SecurityState.AWAY, origin: OriginType.INTERNAL });
+
+    expect(mockClient.publish).toHaveBeenCalledWith(
+      'security-system/state',
+      JSON.stringify({
+        arming: true,
+        current_mode: 'home',
+        target_mode: 'away',
+        tripped: false,
+      }),
+      { qos: 0, retain: true },
+      expect.any(Function),
+    );
+  });
+
+  it('publishes status on CURRENT_CHANGED event', () => {
+    state.currentState = SecurityState.TRIGGERED;
+    state.isTripping = true;
+
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.CURRENT_CHANGED, { state: SecurityState.TRIGGERED, origin: OriginType.INTERNAL });
+
+    expect(mockClient.publish).toHaveBeenCalledTimes(1);
+  });
+
+  it('publishes status on ARMING event', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.ARMING, { state: SecurityState.HOME });
+
+    expect(mockClient.publish).toHaveBeenCalledTimes(1);
+  });
+
+  it('publishes status on WARNING event', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.WARNING, { origin: OriginType.INTERNAL, triggerSeconds: 30 });
+
+    expect(mockClient.publish).toHaveBeenCalledTimes(1);
+  });
+
+  it('bypasses publish when proxyMode is on and origin is EXTERNAL', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost', proxyMode: true }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.TARGET_CHANGED, { state: SecurityState.HOME, origin: OriginType.EXTERNAL });
+
+    expect(mockClient.publish).not.toHaveBeenCalled();
+    expect(log.debug).toHaveBeenCalledWith('MQTT publish bypassed (proxy mode).');
+  });
+
+  it('does not bypass publish when proxyMode is on but origin is INTERNAL', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost', proxyMode: true }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.TARGET_CHANGED, { state: SecurityState.HOME, origin: OriginType.INTERNAL });
+
+    expect(mockClient.publish).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not publish when client is not connected', () => {
+    mockClient.connected = false;
+
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.TARGET_CHANGED, { state: SecurityState.HOME, origin: OriginType.INTERNAL });
+
+    expect(mockClient.publish).not.toHaveBeenCalled();
+  });
+
+  it('disconnect ends the client', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+    service.disconnect();
+
+    expect(mockClient.end).toHaveBeenCalledWith(true);
+  });
+
+  it('uses custom topic when configured', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost', mqttTopic: 'alarm/status' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.CURRENT_CHANGED, { state: SecurityState.OFF, origin: OriginType.INTERNAL });
+
+    expect(mockClient.publish).toHaveBeenCalledWith(
+      'alarm/status',
+      expect.any(String),
+      expect.any(Object),
+      expect.any(Function),
+    );
+  });
+
+  it('logs error on publish failure', () => {
+    const service = new MqttService(log as never, makeOptions({ mqttBroker: 'mqtt://localhost' }), state);
+    service.attachToBus(bus);
+
+    bus.emit(EventType.CURRENT_CHANGED, { state: SecurityState.OFF, origin: OriginType.INTERNAL });
+
+    const publishCallback = mockClient.publish.mock.calls[0][3];
+    publishCallback(new Error('connection lost'));
+
+    expect(log.error).toHaveBeenCalledWith('MQTT publish failed (security-system/state)');
+    expect(log.error).toHaveBeenCalledWith('Error: connection lost');
+  });
+});

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

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { EventBusService } from '../services/event-bus-service.js';
+import { EventType } from '../types/event-type.js';
+import type { EventBusService as EventBusType } from '../services/event-bus-service.js';
+import type { SensorStateChangedPayload } from '../types/event-type.js';
+import { SensorHandler } from '../handlers/sensor-handler.js';
+import { SENSOR_PULSE_MS } from '../constants/homekit-constant.js';
+
+function makeLog() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+function recordedEvents(bus: EventBusType): SensorStateChangedPayload[] {
+  const events: SensorStateChangedPayload[] = [];
+  bus.on(EventType.SENSOR_STATE_CHANGED, payload => events.push(payload));
+  return events;
+}
+
+describe('SensorHandler', () => {
+  let bus: EventBusType;
+  let handler: SensorHandler;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    bus = new EventBusService();
+    handler = new SensorHandler(makeLog() as never, bus);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('updateArmingMotionSensor records the value and emits', () => {
+    const events = recordedEvents(bus);
+
+    handler.updateArmingMotionSensor(true);
+
+    expect(handler.getMotionState('arming')).toBe(true);
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({ sensor: 'arming', value: true });
+  });
+
+  it('resetArmingMotionSensor only emits when the sensor is on', () => {
+    const events = recordedEvents(bus);
+
+    handler.resetArmingMotionSensor();
+    expect(events).toHaveLength(0);
+
+    handler.updateArmingMotionSensor(true);
+    handler.resetArmingMotionSensor();
+
+    expect(handler.getMotionState('arming')).toBe(false);
+    expect(events).toEqual([
+      { sensor: 'arming', value: true },
+      { sensor: 'arming', value: false },
+    ]);
+  });
+
+  it('setTrippedMotionSensor records the value and emits', () => {
+    const events = recordedEvents(bus);
+
+    handler.setTrippedMotionSensor(true);
+
+    expect(handler.getMotionState('tripped')).toBe(true);
+    expect(events[0]).toEqual({ sensor: 'tripped', value: true });
+  });
+
+  it('pulseTrippedMotionSensor turns the sensor on then resets it after the pulse', () => {
+    const events = recordedEvents(bus);
+
+    handler.pulseTrippedMotionSensor();
+    expect(handler.getMotionState('tripped')).toBe(true);
+
+    vi.advanceTimersByTime(SENSOR_PULSE_MS);
+
+    expect(handler.getMotionState('tripped')).toBe(false);
+    expect(events).toEqual([
+      { sensor: 'tripped', value: true },
+      { sensor: 'tripped', value: false },
+    ]);
+  });
+
+  it('pulseResetMotionSensor turns the sensor on then resets it after the pulse', () => {
+    const events = recordedEvents(bus);
+
+    handler.pulseResetMotionSensor();
+    expect(handler.getMotionState('reset')).toBe(true);
+
+    vi.advanceTimersByTime(SENSOR_PULSE_MS);
+
+    expect(handler.getMotionState('reset')).toBe(false);
+    expect(events).toEqual([
+      { sensor: 'reset', value: true },
+      { sensor: 'reset', value: false },
+    ]);
+  });
+
+  it('resetTrippedMotionSensor only emits when the sensor is on', () => {
+    const events = recordedEvents(bus);
+
+    handler.resetTrippedMotionSensor();
+    expect(events).toHaveLength(0);
+
+    handler.setTrippedMotionSensor(true);
+    handler.resetTrippedMotionSensor();
+
+    expect(handler.getMotionState('tripped')).toBe(false);
+    expect(events).toHaveLength(2);
+  });
+
+  it('getMotionState starts at false for every sensor', () => {
+    expect(handler.getMotionState('arming')).toBe(false);
+    expect(handler.getMotionState('tripped')).toBe(false);
+    expect(handler.getMotionState('reset')).toBe(false);
+  });
+});

package/src/tests/server-service.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi, afterEach } 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 { ServiceResult } from '../types/service-result-type.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeLog() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+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 {
+    serverPort: 8080,
+    serverApiKey: null,
+    ...overrides,
+  } as unknown as SecuritySystemOptions;
+}
+
+function makeStateHandler(result: ServiceResult = { success: true }) {
+  return {
+    updateTargetState: vi.fn().mockReturnValue(result),
+    isTripping: vi.fn().mockReturnValue(false),
+    setCurrentState: vi.fn(),
+  };
+}
+
+function makeTripHandler(result: ServiceResult = { success: true }) {
+  return {
+    updateTripSwitch: vi.fn().mockReturnValue(result),
+    triggerIfModeSet: vi.fn().mockReturnValue(result),
+    checkTripConditions: vi.fn().mockReturnValue(result),
+  };
+}
+
+function makeSwitchHandler(result: ServiceResult = { success: true }) {
+  return {
+    updateArmingLock: vi.fn().mockReturnValue(result),
+  };
+}
+
+async function makeService(
+  stateHandlerResult?: ServiceResult,
+  tripHandlerResult?: ServiceResult,
+  switchHandlerResult?: ServiceResult,
+  stateOverrides?: Partial<SystemState>,
+  optionsOverrides?: Partial<SecuritySystemOptions>,
+) {
+  const { ServerService } = await import('../services/server-service.js');
+  const log = makeLog();
+  const state = makeState(stateOverrides);
+  const options = makeOptions(optionsOverrides);
+  const stateHandler = makeStateHandler(stateHandlerResult);
+  const tripHandler = makeTripHandler(tripHandlerResult);
+  const switchHandler = makeSwitchHandler(switchHandlerResult);
+
+  const service = new ServerService(log as any, options, state, stateHandler as any, tripHandler as any, switchHandler as any);
+
+  return { service, stateHandler, tripHandler, switchHandler, state };
+}
+
+function json(body: unknown, path: string, method = 'PUT') {
+  return new Request(`http://localhost${path}`, {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+// ── PUT /mode/update ──────────────────────────────────────────────────────────
+
+describe('PUT /mode/update', () => {
+  it('returns 204 and calls updateTargetState with no delay', async () => {
+    const { service, stateHandler } = await makeService();
+    const res = await service.app.request(json({ mode: 'home' }, '/mode/update'));
+    expect(res.status).toBe(204);
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.HOME, OriginType.EXTERNAL, 0);
+  });
+
+  it('returns 204 and passes delay to updateTargetState', async () => {
+    const { service, stateHandler } = await makeService();
+    const res = await service.app.request(json({ mode: 'away', delay: 10 }, '/mode/update'));
+    expect(res.status).toBe(204);
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.AWAY, OriginType.EXTERNAL, 10);
+  });
+
+  it('returns 204 for off mode without delay', async () => {
+    const { service, stateHandler } = await makeService();
+    const res = await service.app.request(json({ mode: 'off' }, '/mode/update'));
+    expect(res.status).toBe(204);
+    expect(stateHandler.updateTargetState).toHaveBeenCalledWith(SecurityState.OFF, OriginType.EXTERNAL, 0);
+  });
+
+  it('returns 409 when stateHandler rejects the mode change', async () => {
+    const { service } = await makeService({ success: false, reason: 'target mode is already set' });
+    const res = await service.app.request(json({ mode: 'night' }, '/mode/update'));
+    expect(res.status).toBe(409);
+    const body = await res.json();
+    expect(body.reason).toBe('target mode is already set');
+  });
+
+  it('rejects "triggered" — returns 400 (Zod validation failure)', async () => {
+    const { service } = await makeService();
+    const res = await service.app.request(json({ mode: 'triggered' }, '/mode/update'));
+    expect(res.status).toBe(400);
+  });
+});
+
+// ── POST /mode/trip ───────────────────────────────────────────────────────────
+
+describe('POST /mode/trip', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns 204 and calls updateTripSwitch when mode and delay are omitted', async () => {
+    const { service, tripHandler } = await makeService();
+    const res = await service.app.request(json({}, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.updateTripSwitch).toHaveBeenCalledWith(true, OriginType.EXTERNAL, false);
+    expect(tripHandler.triggerIfModeSet).not.toHaveBeenCalled();
+  });
+
+  it('returns 204 and calls updateTripSwitch when mode is null', async () => {
+    const { service, tripHandler } = await makeService();
+    const res = await service.app.request(json({ mode: null }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.updateTripSwitch).toHaveBeenCalledWith(true, OriginType.EXTERNAL, false);
+  });
+
+  it('returns 204 and calls triggerIfModeSet when mode is specified', async () => {
+    const { service, tripHandler } = await makeService();
+    const res = await service.app.request(json({ mode: 'away' }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.triggerIfModeSet).toHaveBeenCalledWith(SecurityState.AWAY, true);
+    expect(tripHandler.updateTripSwitch).not.toHaveBeenCalled();
+  });
+
+  it('returns 409 when trip handler rejects without delay', async () => {
+    const { service } = await makeService(undefined, { success: false, reason: 'not armed' });
+    const res = await service.app.request(json({}, '/mode/trip', 'POST'));
+    expect(res.status).toBe(409);
+    const body = await res.json();
+    expect(body.reason).toBe('not armed');
+  });
+
+  it('returns 409 when mode does not match (triggerIfModeSet rejects)', async () => {
+    const { service } = await makeService(undefined, { success: false, reason: 'mode not set' });
+    const res = await service.app.request(json({ mode: 'home' }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(409);
+    const body = await res.json();
+    expect(body.reason).toBe('mode not set');
+  });
+
+  it('returns 204 immediately and calls updateTripSwitch after delay when mode is omitted', async () => {
+    vi.useFakeTimers();
+    const { service, tripHandler } = await makeService();
+
+    const res = await service.app.request(json({ delay: 5 }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.checkTripConditions).toHaveBeenCalledWith(true, OriginType.EXTERNAL);
+    expect(tripHandler.updateTripSwitch).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(tripHandler.updateTripSwitch).toHaveBeenCalledWith(true, OriginType.EXTERNAL, false);
+  });
+
+  it('returns 204 immediately and calls triggerIfModeSet after delay when mode is specified', async () => {
+    vi.useFakeTimers();
+    const { service, tripHandler } = await makeService();
+
+    const res = await service.app.request(json({ mode: 'night', delay: 3 }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.triggerIfModeSet).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(tripHandler.triggerIfModeSet).toHaveBeenCalledWith(SecurityState.NIGHT, true);
+  });
+
+  it('returns 409 on pre-check failure even when delay is specified', async () => {
+    const { service, tripHandler } = await makeService(
+      undefined,
+      { success: false, reason: 'arming in progress' },
+    );
+    const res = await service.app.request(json({ delay: 10 }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(409);
+    expect(tripHandler.updateTripSwitch).not.toHaveBeenCalled();
+  });
+
+  it('treats delay: null the same as no delay', async () => {
+    const { service, tripHandler } = await makeService();
+    const res = await service.app.request(json({ delay: null }, '/mode/trip', 'POST'));
+    expect(res.status).toBe(204);
+    expect(tripHandler.updateTripSwitch).toHaveBeenCalledWith(true, OriginType.EXTERNAL, false);
+  });
+});
+
+// ── PUT /switches/arming-lock ─────────────────────────────────────────────────
+
+describe('PUT /switches/arming-lock', () => {
+  it('returns 204 and calls updateArmingLock', async () => {
+    const { service, switchHandler } = await makeService();
+    const res = await service.app.request(json({ mode: 'home', value: true }, '/switches/arming-lock'));
+    expect(res.status).toBe(204);
+    expect(switchHandler.updateArmingLock).toHaveBeenCalledWith('home', true);
+  });
+
+  it('returns 409 when switchHandler rejects', async () => {
+    const { service } = await makeService(
+      undefined,
+      undefined,
+      { success: false, reason: 'unknown arming lock mode: invalid' },
+    );
+    const res = await service.app.request(json({ mode: 'global', value: false }, '/switches/arming-lock'));
+    expect(res.status).toBe(409);
+    const body = await res.json();
+    expect(body.reason).toBe('unknown arming lock mode: invalid');
+  });
+});