@switchbot/homebridge-switchbot 5.0.0-beta.99 → 5.0.0

package/test/accessory-restore.spec.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { SwitchBotHAPPlatform, SwitchBotMatterPlatform } from '../src/platform'
-
-const log = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} }
-
-describe('accessory restore', () => {
-  it('reuses restored HAP accessory by context.deviceId and avoids re-register', async () => {
-    const registered: any[] = []
-    const hap = { uuid: { generate: (s: string) => `uuid-${s}` }, Service: {}, Characteristic: {} }
-
-    function PlatformAccessory(name: string, uuid: string) {
-      this.displayName = name
-      this.UUID = uuid
-      this.context = {}
-      this.getService = () => undefined
-      this.addService = () => undefined
-    }
-
-    const api: any = {
-      hap,
-      platformAccessory: PlatformAccessory as any,
-      registerPlatformAccessories: (_p: string, _n: string, accs: any[]) => registered.push(...accs),
-      on: (_ev: string, cb: Function) => {},
-    }
-
-    const platform = new SwitchBotHAPPlatform(log as any, { devices: [{ id: 'dev1', type: 'light', name: 'NewName' }] }, api)
-
-    // Simulate restored accessory with different uuid but correct deviceId in context
-    const restored = new (api.platformAccessory)('OldName', 'old-uuid')
-    restored.context = { deviceId: 'dev1', type: 'light' }
-    platform.configureAccessory(restored)
-
-    // Load devices should reuse restored accessory by context.deviceId
-    await (platform as any).loadDevices()
-
-    // No new registration for this device because restored accessory was reused
-    expect(registered.length).toBe(0)
-    // The restored accessory should remain in the platform's accessory map
-    const keys = Array.from((platform as any).accessories.keys())
-    expect(keys).toContain('old-uuid')
-    const acc = (platform as any).accessories.get('old-uuid')
-    expect(acc.context.deviceId).toBe('dev1')
-  })
-
-  it('reuses restored Matter accessory by context.deviceId when registering', async () => {
-    const captured: any[] = []
-    const matter = { uuid: { generate: (s: string) => `uuid-${s}` }, clusterNames: {} }
-    const api: any = {
-      matter,
-      isMatterAvailable: () => true,
-      isMatterEnabled: () => true,
-      on: (_ev: string, cb: Function) => {},
-    }
-
-    const platform = new SwitchBotMatterPlatform(log as any, { devices: [{ id: 'm1', type: 'light', name: 'M1' }] }, api)
-
-    // Simulate restored Matter accessory with a different uuid but matching deviceId
-    const restored = { uuid: 'restored-uuid', displayName: 'OldM', context: { deviceId: 'm1', type: 'light' } }
-    ;(platform as any).accessories.set(restored.uuid, restored)
-
-    // stub matter.registerPlatformAccessories to capture what is registered
-    api.matter.registerPlatformAccessories = async (_p: string, _n: string, accs: any[]) => captured.push(...accs)
-
-    // call registerMatterAccessories
-    await (platform as any).registerMatterAccessories()
-
-    // The restored accessory should still be present and associated with deviceId
-    const keys = Array.from((platform as any).accessories.keys())
-    expect(keys).toContain(restored.uuid)
-    const acc = (platform as any).accessories.get(restored.uuid)
-    expect(acc.context.deviceId).toBe('m1')
-  })
-})

package/test/device-mapping.spec.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { createDevice } from '../src/deviceFactory'
-
-const DEVICE_TYPES = [
-  'bot',
-  'curtain',
-  'fan',
-  'light',
-  'lightstrip',
-  'motion',
-  'contact',
-  'vacuum',
-  'lock',
-  'humidifier',
-  'temperature',
-]
-
-describe('device mapping', () => {
-  it('maps known device types to device descriptors (HAP)', async () => {
-    for (const t of DEVICE_TYPES) {
-      const created = await createDevice({ id: `dev-${t}`, type: t, name: `Name-${t}` }, {}, false)
-      expect(created).toHaveProperty('instance')
-      expect(created).toHaveProperty('createAccessory')
-      const acc = created.createAccessory?.(undefined)
-      expect(acc).toBeDefined()
-      // descriptor should include services for HAP devices
-      if (created.protocol === 'hap') {
-        expect(acc).toHaveProperty('services')
-      }
-    }
-  })
-
-  it('returns matter protocol when requested', async () => {
-    const created = await createDevice({ id: 'm1', type: 'light', name: 'M1' }, { preferMatter: true, enableMatter: true }, true)
-    expect(created.protocol).toBe('matter')
-  })
-})

package/test/deviceFactory.spec.ts

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { createDevice } from '../src/deviceFactory'
-
-describe('deviceFactory', () => {
-  it('creates HAP device descriptor for light', async () => {
-    const created = await createDevice({ id: 'dev1', type: 'light', name: 'L1' }, {}, false)
-    expect(created).toHaveProperty('instance')
-    expect(created).toHaveProperty('createAccessory')
-    expect(created.protocol).toBe('hap')
-    const acc = created.createAccessory?.(undefined)
-    expect(acc).toHaveProperty('services')
-  })
-
-  it('creates Matter descriptor when useMatter=true', async () => {
-    const created = await createDevice({ id: 'dev2', type: 'light', name: 'L2' }, { preferMatter: true, enableMatter: true }, true)
-    expect(created.protocol).toBe('matter')
-  })
-})

package/test/fan-swing.spec.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { FanDevice } from '../src/devices/genericDevice'
-
-describe('Fan swing commands', () => {
-  it('sends setSwing on boolean swing', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new FanDevice({ id: 'fan1', type: 'fan', name: 'F' }, { _client: mockClient } as any)
-    await d.init()
-    const res = await d.setState({ swing: true })
-    expect(mockClient.setDeviceState).toHaveBeenCalled()
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'setSwing', parameter: 'on', commandType: 'command' })
-  })
-
-  it('sends setSwing with angle', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new FanDevice({ id: 'fan2', type: 'fan', name: 'F2' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ swingAngle: 45 })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'setSwing', parameter: '45', commandType: 'command' })
-  })
-
-  it('sends setSwing with mode', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new FanDevice({ id: 'fan3', type: 'fan', name: 'F3' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ swingMode: 'vertical' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'setSwing', parameter: 'vertical', commandType: 'command' })
-  })
-})

package/test/lock-users.spec.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { LockDevice } from '../src/devices/genericDevice'
-
-describe('Lock user management', () => {
-  it('sets lock pin via pin field', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new LockDevice({ id: 'lock1', type: 'lock', name: 'L1' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ pin: '1234' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'setLockPin', parameter: '1234', commandType: 'command' })
-  })
-
-  it('adds a user code with addUser action', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new LockDevice({ id: 'lock2', type: 'lock', name: 'L2' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ action: 'addUser', user: 'user1', pin: '9999' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'addUserCode', parameter: 'user1:9999', commandType: 'command' })
-  })
-
-  it('removes a user code with removeUser action', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new LockDevice({ id: 'lock3', type: 'lock', name: 'L3' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ action: 'removeUser', user: 'user1' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'removeUserCode', parameter: 'user1', commandType: 'command' })
-  })
-
-  it('lists users with listUsers action', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new LockDevice({ id: 'lock4', type: 'lock', name: 'L4' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ action: 'listUsers' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'listUsers', parameter: 'default', commandType: 'command' })
-  })
-
-  it('unlocks with pin using unlockWithPin action', async () => {
-    const mockClient = { setDeviceState: vi.fn(async (id: string, body: any) => ({ id, body })) }
-    const d = new LockDevice({ id: 'lock5', type: 'lock', name: 'L5' }, { _client: mockClient } as any)
-    await d.init()
-    await d.setState({ action: 'unlockWithPin', pin: '5555' })
-    expect((mockClient.setDeviceState as any).mock.calls[0][1]).toEqual({ command: 'unlockWithPin', parameter: '5555', commandType: 'command' })
-  })
-})

package/test/matter-childbridge.spec.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import SwitchBotPlatform from '../src/platform'
-import { createPlatformProxy } from '../src/utils'
-
-// This is a lightweight integration-style unit test that verifies the
-// platform will attempt Matter registration when MatterPlatform is
-// provided by the proxy and will still restore cached accessories.
-
-describe('platform integration (Matter)', () => {
-  it('creates Matter descriptors when useMatter=true and restores accessories', async () => {
-    // Create a fake MatterPlatform class that records register calls
-    class FakeMatterPlatform {
-      public registered: any[] = []
-      constructor(public log: any, public cfg: any, public api: any) {}
-      async registerMatterAccessories(accessories: any[]) {
-        this.registered.push(...accessories)
-        return
-      }
-      // simulate configureAccessory hook for restored matter accessories
-      configureMatterAccessory(accessory: any) {
-        // no-op
-      }
-      // lightweight loadDevices implementation that uses an injected discover hook if present
-      async loadDevices() {
-        const devices = (this.cfg?.devices) || (this as any)._discoverDevices ? await (this as any)._discoverDevices() : []
-        // Simulate preparing descriptors and immediately registering them
-        const serialized = devices.map((d: any) => ({ id: d.id ?? d.deviceId ?? d, protocol: 'matter', name: d.name }))
-        if (serialized.length > 0) await this.registerMatterAccessories(serialized)
-      }
-    }
-
-    // Create proxy that would choose the fake matter platform when preferred
-    const Proxy = createPlatformProxy(function HAP() {}, FakeMatterPlatform)
-    const platform = new (Proxy as any)(console, { preferMatter: true, enableMatter: true }, {})
-
-    // Make a small device descriptor to load
-    const device = { id: 'dev-m-1', type: 'light', name: 'MatterLight' }
-    // Simulate platform method that loads devices (use same method name used in code)
-    if (typeof platform.loadDevices === 'function') {
-      // Add an internal method to return our single device for creation
-      platform._discoverDevices = async () => [device]
-      // Call loadDevices which should call the MatterPlatform.registerMatterAccessories
-      await platform.loadDevices()
-
-      // Verify FakeMatterPlatform received the accessory
-      expect(platform).toBeInstanceOf(FakeMatterPlatform)
-      expect((platform as any).registered.length).toBeGreaterThanOrEqual(1)
-      const registered = (platform as any).registered[0]
-      expect(registered).toHaveProperty('protocol', 'matter')
-      expect(registered).toHaveProperty('id', device.id)
-    } else {
-      throw new Error('platform.loadDevices not implemented')
-    }
-  })
-})

package/test/matter-descriptors.spec.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { FanDevice, LightDevice, CurtainDevice, LockDevice } from '../src/devices/genericDevice'
-
-describe('Matter descriptors and translations (per-device)', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('Fan: maps oscillation and swing to setDeviceState commands', async () => {
-    const calls: any[] = []
-    const fakeClient: any = { setDeviceState: async (id: string, body: any) => { calls.push({ id, body }); return { ok: true } } }
-    const d = new FanDevice({ id: 'f1', type: 'fan' } as any, { _client: fakeClient } as any)
-
-    // Oscillate
-    await d.setState({ oscillate: true })
-    expect(calls.pop()?.body.command).toBe('setOscillation')
-
-    // Swing boolean
-    await d.setState({ swing: true })
-    expect(calls.pop()?.body.command).toBe('setSwing')
-
-    // Swing angle
-    await d.setState({ swingAngle: 45 })
-    const last = calls.pop()
-    expect(last.body.command).toBe('setSwing')
-    expect(last.body.parameter).toBe('45')
-  })
-
-  it('Light: color/CT mapping and setState commands', async () => {
-    const calls: any[] = []
-    const fakeClient: any = { setDeviceState: async (id: string, body: any) => { calls.push(body); return { ok: true } } }
-    const d = new LightDevice({ id: 'l1', type: 'light' } as any, { _client: fakeClient } as any)
-
-    // color temperature (mired)
-    await d.setState({ colorTemperature: 300 })
-    expect(calls.pop()?.command).toBe('setColorTemperature')
-
-    // hue + saturation
-    await d.setState({ hue: 120, saturation: 50 })
-    const c = calls.pop()
-    expect(c.command).toBe('setColor')
-    expect(c.parameter).toBe('120,50')
-
-    // hex color string
-    await d.setState({ color: '#ff0000' })
-    expect(calls.pop()?.command).toBe('setColor')
-  })
-
-  it('Curtain: position mapping and Matter attribute writes', async () => {
-    const calls: any[] = []
-    const fakeClient: any = { setDeviceState: async (id: string, body: any) => { calls.push(body); return { ok: true } } }
-    const d = new CurtainDevice({ id: 'c1', type: 'curtain' } as any, { _client: fakeClient } as any)
-
-    // Setting position via HAP-style setState
-    await d.setState({ position: 25 })
-    expect(calls.pop()?.command).toBe('setPosition')
-
-    // Matter descriptor write: call targetPosition write handler
-    const matter = d.createMatterAccessory({})
-    const cluster = matter.clusters.find((c: any) => c.type === 'Shade')
-    // targetPosition attribute exists and has a write function
-    expect(cluster.attributes.targetPosition.write).toBeTypeOf('function')
-    await cluster.attributes.targetPosition.write(80)
-    expect(calls.pop()?.command).toBe('setPosition')
-  })
-
-  it('Lock: user management actions map to correct commands', async () => {
-    const calls: any[] = []
-    const fakeClient: any = { setDeviceState: async (id: string, body: any) => { calls.push(body); return { ok: true } } }
-    const d = new LockDevice({ id: 'lock1', type: 'lock' } as any, { _client: fakeClient } as any)
-
-    // addUser via setState
-    await d.setState({ action: 'addUser', user: 'u1', pin: '1234' })
-    let last = calls.pop()
-    expect(last.command).toBe('addUserCode')
-    expect(last.parameter).toBe('u1:1234')
-
-    // removeUser
-    await d.setState({ action: 'removeUser', user: 'u1' })
-    last = calls.pop()
-    expect(last.command).toBe('removeUserCode')
-
-    // unlockWithPin
-    await d.setState({ action: 'unlockWithPin', pin: '0000' })
-    last = calls.pop()
-    expect(last.command).toBe('unlockWithPin')
-
-    // Matter descriptor write for addUser
-    const matter = d.createMatterAccessory({})
-    const mgmt = matter.clusters.find((c: any) => c.type === 'DoorLockUserManagement')
-    expect(mgmt.attributes.addUser.write).toBeTypeOf('function')
-    await mgmt.attributes.addUser.write({ user: 'u2', pin: '4321' })
-    last = calls.pop()
-    expect(last.command).toBe('addUserCode')
-    expect(last.parameter).toBe('u2:4321')
-  })
-})

package/test/matter-device-state.spec.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { LightDevice, FanDevice, CurtainDevice, LockDevice, HumidifierMatterDevice } from '../src/devices/genericDevice'
-import { makeFakeApiWithMatter } from './helpers/matter-harness'
-
-const api = makeFakeApiWithMatter()
-
-describe('Matter device state translations', () => {
-  it('Light: reads and writes map to setState/getState', async () => {
-    const device = new LightDevice({ id: 'l-1', type: 'light', name: 'L1' }, {})
-    let lastSet: any = null
-    device.getState = async () => ({ on: true, brightness: 75, hue: 120, saturation: 50, colorTemperature: 350 })
-    device.setState = async (c: any) => { lastSet = c; return { success: true } }
-
-    const desc = device.createMatterAccessory(api)
-    const levelCluster = desc.clusters.find((c: any) => c.clusterId === 0x0008 || c.type === 'LevelControl')
-    expect(levelCluster).toBeDefined()
-    const levelAttr = levelCluster.attributes.currentLevel || levelCluster.attributes["0x0000"] || Object.values(levelCluster.attributes)[0]
-    const read = await levelAttr.read()
-    expect(read).toBe(75)
-
-    // write should call setState with brightness
-    await levelAttr.write(30)
-    expect(lastSet).toMatchObject({ brightness: 30 })
-  })
-
-  it('Fan: reads speed and writes speed/oscillation', async () => {
-    const device = new FanDevice({ id: 'f-1', type: 'fan', name: 'F1' }, {})
-    let last: any = null
-    device.getState = async () => ({ on: false, speed: 45, oscillating: true, swingMode: 'auto' })
-    device.setState = async (c: any) => { last = c; return { success: true } }
-
-    const desc = device.createMatterAccessory(api)
-    const fanCluster = desc.clusters.find((c: any) => c.clusterId === 0x0202 || c.type === 'FanControl')
-    expect(fanCluster).toBeDefined()
-    const speedAttr = fanCluster.attributes.rotationSpeed || Object.values(fanCluster.attributes)[0]
-    const speed = await speedAttr.read()
-    expect(speed).toBe(45)
-
-    await speedAttr.write(80)
-    expect(last).toMatchObject({ speed: 80 })
-
-    // oscillation write
-    const osc = fanCluster.attributes.oscillation
-    await osc.write(true)
-    expect(last).toMatchObject({ oscillate: true })
-  })
-
-  it('Curtain: reads and writes position', async () => {
-    const device = new CurtainDevice({ id: 'c-1', type: 'curtain', name: 'C1' }, {})
-    let last: any = null
-    device.getState = async () => ({ position: 42 })
-    device.setState = async (c: any) => { last = c; return { success: true } }
-
-    const desc = device.createMatterAccessory(api)
-    const shade = desc.clusters.find((c: any) => c.clusterId === 0x0102 || c.type === 'Shade')
-    expect(shade).toBeDefined()
-    const current = shade.attributes.currentPosition || shade.attributes["0x0000"]
-    const v = await current.read()
-    expect(v).toBe(42)
-
-    const target = shade.attributes.targetPosition || shade.attributes["0x0001"]
-    await target.write(10)
-    expect(last).toMatchObject({ position: 10 })
-  })
-
-  it('Lock: reads and writes locked state', async () => {
-    const device = new LockDevice({ id: 'k-1', type: 'lock', name: 'K1' }, {})
-    let last: any = null
-    device.getState = async () => ({ locked: true })
-    device.setState = async (c: any) => { last = c; return { success: true } }
-
-    const desc = device.createMatterAccessory(api)
-    const lock = desc.clusters.find((c: any) => c.clusterId === 0x0101 || c.type === 'DoorLock')
-    expect(lock).toBeDefined()
-    const lockAttr = lock.attributes.lockState || lock.attributes["0x0000"]
-    const v = await lockAttr.read()
-    expect(v).toBe(true)
-
-    await lockAttr.write(false)
-    expect(last).toMatchObject({ locked: false })
-  })
-
-  it('Humidifier: reads humidity and toggles on/off', async () => {
-    const device = new HumidifierMatterDevice({ id: 'h-1', type: 'humidifier', name: 'H1' }, {})
-    let last: any = null
-    device.getState = async () => ({ humidity: 55, on: false })
-    device.setState = async (c: any) => { last = c; return { success: true } }
-
-    const desc = device.createMatterAccessory(api)
-    const rh = desc.clusters.find((c: any) => c.clusterId === 0x0405 || c.type === 'RelativeHumiditySensor')
-    expect(rh).toBeDefined()
-    const humAttr = rh.attributes.currentRelativeHumidity || rh.attributes["0x0000"]
-    const hv = await humAttr.read()
-    expect(hv).toBe(55)
-
-    const onCluster = desc.clusters.find((c: any) => c.clusterId === 0x0006 || c.type === 'OnOff')
-    const onAttr = onCluster.attributes.onOff || onCluster.attributes["0x0000"]
-    await onAttr.write(true)
-    expect(last).toMatchObject({ on: true })
-  })
-})

package/test/matter-integration.spec.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { createPlatformProxy } from '../src/utils'
-import { makeFakeApiWithMatter, makeFakeApiWithoutMatter, makeFakeMatterApi } from './helpers/matter-harness'
-import SwitchBotHAPPlatform, { SwitchBotMatterPlatform } from '../src/platform'
-
-// Expanded Matter integration harness tests
-
-describe('Matter integration harness', () => {
-  it('registers Matter accessories when Matter API available', async () => {
-    // Instantiate the real Matter platform directly to test its registration path
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, { devices: [{ id: 'm-1', type: 'light', name: 'L1' }], enableMatter: true, preferMatter: true } as any, api as any)
-
-    // Call register path directly
-    if (typeof (platform as any).registerMatterAccessories === 'function') {
-      await (platform as any).registerMatterAccessories()
-    } else if (typeof (platform as any).loadDevices === 'function') {
-      await (platform as any).loadDevices()
-    }
-
-    const regs = matterApi.getRegistered()
-    expect(regs.length).toBeGreaterThanOrEqual(1)
-    // The platform registers serialized accessories; ensure deviceId is present in context
-    expect(regs[0]).toHaveProperty('context')
-    expect(regs[0].context).toHaveProperty('deviceId', 'm-1')
-  })
-
-  it('falls back to HAP when Matter API unavailable', async () => {
-    // Directly instantiate the HAP platform to exercise HAP fallback
-    const api = makeFakeApiWithoutMatter()
-    const platform = new SwitchBotHAPPlatform(console as any, { devices: [{ id: 'h-1', type: 'light', name: 'H1' }], enableMatter: true, preferMatter: true } as any, api as any)
-
-    // call loadDevices for HAP flow
-    if (typeof (platform as any).loadDevices === 'function') await (platform as any).loadDevices()
-
-    // Platform should have an accessories map populated
-    const accMap = (platform as any).accessories
-    expect(accMap).toBeDefined()
-    const keys = Array.from(accMap.keys())
-    expect(keys.length).toBeGreaterThanOrEqual(1)
-  })
-
-  it('reuses restored Matter accessories instead of registering duplicates', async () => {
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, { devices: [{ id: 'r-1', type: 'light', name: 'R1' }], enableMatter: true, preferMatter: true } as any, api as any)
-
-    // Simulate a restored accessory present before registration
-    const restored = { uuid: matterApi.uuid.generate('r-1'), displayName: 'Restored R1', context: { deviceId: 'r-1' } }
-    if (typeof (platform as any).configureMatterAccessory === 'function') {
-      await (platform as any).configureMatterAccessory(restored)
-    } else if (typeof (platform as any).configureAccessory === 'function') {
-      await (platform as any).configureAccessory(restored)
-    }
-
-    // Now call register path
-    if (typeof (platform as any).registerMatterAccessories === 'function') await (platform as any).registerMatterAccessories()
-    else if (typeof (platform as any).loadDevices === 'function') {
-      await (platform as any).loadDevices()
-      if (typeof (platform as any).registerMatterAccessories === 'function') await (platform as any).registerMatterAccessories()
-    }
-
-    const accs = (platform as any).accessories
-    const found = Array.from(accs.values()).some((a: any) => a && (a.uuid === restored.uuid || a.UUID === restored.uuid))
-    expect(found).toBeTruthy()
-  })
-})

package/test/platform.integration.spec.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { SwitchBotHAPPlatform } from '../src/platform'
-
-// Minimal mock logger
-const log = {
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  debug: () => {},
-}
-
-describe('platform integration (HAP)', () => {
-  it('registers HAP accessories using Homebridge API', async () => {
-    const registered: any[] = []
-
-    // Minimal hap stub
-    const hap = {
-      uuid: { generate: (s: string) => `uuid-${s}` },
-      Service: { Switch: 'Switch', Lightbulb: 'Lightbulb' },
-      Characteristic: { On: 'On', Brightness: 'Brightness' },
-    }
-
-    // Simple platformAccessory constructor
-    function PlatformAccessory(name: string, uuid: string) {
-      this.displayName = name
-      this.UUID = uuid
-      this.services = []
-      this.getService = (type: any) => this.services.find((s: any) => s.type === type)
-      this.addService = (type: any) => {
-        const s: any = { type, characteristics: {} }
-        this.services.push(s)
-        return s
-      }
-    }
-
-    const api: any = {
-      hap,
-      platformAccessory: PlatformAccessory as any,
-      registerPlatformAccessories: (_p: string, _n: string, accs: any[]) => registered.push(...accs),
-      on: (_ev: string, cb: Function) => { /* do not auto-run */ },
-    }
-
-    const config: any = { devices: [{ id: 'dev1', type: 'light', name: 'L1' }] }
-
-    const platform = new SwitchBotHAPPlatform(log as any, config, api)
-
-    // call loadDevices directly to control flow
-    await (platform as any).loadDevices()
-
-    // Expect accessory created and registered
-    expect(registered.length).toBeGreaterThanOrEqual(1)
-    const keys = Array.from((platform as any).accessories.keys())
-    expect(keys.some((k: string) => k.includes('dev1'))).toBeTruthy()
-  })
-})