@switchbot/homebridge-switchbot 5.0.0-beta.136 → 5.0.0-beta.138

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

@@ -1,117 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { CurtainDevice, FanDevice, HumidifierMatterDevice, LightDevice, LockDevice } 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' }, { log: console })
-    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 = await 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' }, { log: console })
-    let lastFan: any = null
-    device.getState = async () => ({ on: false, speed: 45, oscillating: true, swingMode: 'auto' })
-    device.setState = async (c: any) => {
-      lastFan = c
-      return { success: true }
-    }
-
-    const desc = await 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(lastFan).toMatchObject({ speed: 80 })
-
-    // oscillation write
-    const osc = fanCluster.attributes.oscillation
-    await osc.write(true)
-    expect(lastFan).toMatchObject({ oscillate: true })
-  })
-
-  it('curtain: reads and writes position', async () => {
-    const device = new CurtainDevice({ id: 'c-1', type: 'curtain', name: 'C1' }, { log: console })
-    let lastCurtain: any = null
-    device.getState = async () => ({ position: 42 })
-    device.setState = async (c: any) => {
-      lastCurtain = c
-      return { success: true }
-    }
-
-    const desc = await device.createMatterAccessory(api)
-    const shade = desc.clusters.find((c: any) => c.clusterId === 0x0102 || c.type === 'WindowCovering')
-    expect(shade).toBeDefined()
-    const current = shade.attributes.currentPositionLiftPercent100ths
-    const v = await current.read()
-    expect(Math.round(v / 100)).toBe(42)
-
-    const target = shade.attributes.targetPositionLiftPercent100ths
-    await target.write(4200)
-    expect(lastCurtain).toMatchObject({ position: 42 })
-  })
-
-  it('lock: reads and writes locked state', async () => {
-    const device = new LockDevice({ id: 'k-1', type: 'lock', name: 'K1' }, { log: console })
-    let lastLock: any = null
-    device.getState = async () => ({ locked: true })
-    device.setState = async (c: any) => {
-      lastLock = c
-      return { success: true }
-    }
-
-    const desc = await 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(lastLock).toMatchObject({ locked: false })
-  })
-
-  it('humidifier: reads humidity and toggles on/off', async () => {
-    const device = new HumidifierMatterDevice({ id: 'h-1', type: 'humidifier', name: 'H1' }, { log: console })
-    let lastHum: any = null
-    device.getState = async () => ({ humidity: 55, on: false })
-    device.setState = async (c: any) => {
-      lastHum = c
-      return { success: true }
-    }
-
-    const desc = await 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(lastHum).toMatchObject({ on: true })
-  })
-})

package/test/matter-integration.spec.ts

@@ -1,183 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import SwitchBotHAPPlatform, { SwitchBotMatterPlatform } from '../src/platform'
-import { makeFakeApiWithMatter, makeFakeApiWithoutMatter, makeFakeMatterApi } from './helpers/matter-harness'
-
-// Expanded Matter integration harness tests
-
-describe('matter integration harness', () => {
-  it('registers blind tilt Matter accessory with correct window covering tilt attributes', async () => {
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, {
-      devices: [{ id: 'blindtilt-1', type: 'blindtilt', name: 'Blind Tilt 1' }],
-      enableMatter: true,
-      preferMatter: true,
-      log: console,
-    } as any, api as any)
-
-    await (platform as any).registerMatterAccessories()
-
-    const regs = matterApi.getRegistered()
-    expect(regs.length).toBeGreaterThanOrEqual(1)
-    const clusters = regs[0]?.clusters
-    // Debug: log the actual clusters structure
-    // eslint-disable-next-line no-console
-    console.log('DEBUG clusters (blindtilt):', JSON.stringify(clusters, null, 2))
-    // Support both array and object cluster representations
-    let wc = clusters?.windowCovering
-    if (!wc && Array.isArray(clusters)) {
-      wc = clusters.find((c: any) => c?.type === 'WindowCovering' || c?.clusterId === 0x0102)
-    }
-    expect(wc).toBeDefined()
-    expect(wc).toHaveProperty('currentPositionTiltPercent100ths')
-    expect(wc).toHaveProperty('targetPositionTiltPercent100ths')
-    expect(wc).toHaveProperty('operationalStatus')
-    expect(wc).toHaveProperty('endProductType')
-    expect(wc).toHaveProperty('configStatus')
-  })
-  it('normalizes Color Bulb and Motion Sensor to Matter-supported categories', async () => {
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, {
-      devices: [
-        { id: 'cb-1', type: 'Color Bulb', name: 'Color Bulb 1' },
-        { id: 'ms-1', type: 'Motion Sensor', name: 'Motion Sensor 1' },
-      ],
-      enableMatter: true,
-      preferMatter: true,
-      log: console,
-    } as any, api as any)
-
-    await (platform as any).registerMatterAccessories()
-
-    const regs = matterApi.getRegistered()
-    expect(regs.length).toBeGreaterThanOrEqual(2)
-    const ids = regs.map((r: any) => r?.context?.deviceId)
-    expect(ids).toContain('cb-1')
-    expect(ids).toContain('ms-1')
-  })
-
-  it('registers curtain Matter accessory with correct window covering attributes', async () => {
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, {
-      devices: [{ id: 'curtain-1', type: 'curtain', name: 'Curtain 1' }],
-      enableMatter: true,
-      preferMatter: true,
-      log: console,
-    } as any, api as any)
-
-    await (platform as any).registerMatterAccessories()
-
-    const regs = matterApi.getRegistered()
-    expect(regs.length).toBeGreaterThanOrEqual(1)
-    const clusters = regs[0]?.clusters
-    // Debug: log the actual clusters structure
-    // eslint-disable-next-line no-console
-    console.log('DEBUG clusters (curtain):', JSON.stringify(clusters, null, 2))
-    // Support both array and object cluster representations
-    let wc = clusters?.windowCovering
-    if (!wc && Array.isArray(clusters)) {
-      wc = clusters.find((c: any) => c?.type === 'WindowCovering' || c?.clusterId === 0x0102)
-    }
-    expect(wc).toBeDefined()
-    expect(wc).toHaveProperty('currentPositionLiftPercent100ths')
-    expect(wc).toHaveProperty('targetPositionLiftPercent100ths')
-    expect(wc).toHaveProperty('operationalStatus')
-    expect(wc).toHaveProperty('endProductType')
-    expect(wc).toHaveProperty('configStatus')
-  })
-
-  it('registers RGBIC Neon Wire Rope Light as lightstrip with conformant ColorControl defaults', async () => {
-    const matterApi = makeFakeMatterApi()
-    const api = makeFakeApiWithMatter(matterApi)
-
-    const platform = new SwitchBotMatterPlatform(console as any, {
-      devices: [{ id: 'neon-1', type: 'RGBIC Neon Wire Rope Light', name: 'Family Room Neon Wire Rope Light' }],
-      enableMatter: true,
-      preferMatter: true,
-      log: console,
-    } as any, api as any)
-
-    await (platform as any).registerMatterAccessories()
-
-    const regs = matterApi.getRegistered()
-    expect(regs.length).toBeGreaterThanOrEqual(1)
-    const neon = regs.find((r: any) => r?.context?.deviceId === 'neon-1')
-    expect(neon).toBeDefined()
-    expect(neon?.context?.type).toBe('lightstrip')
-    expect(neon?.clusters?.colorControl).toBeDefined()
-    expect(neon?.clusters?.colorControl?.colorMode).toBe(0)
-  })
-
-  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, log: console } 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, log: console } 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 = [...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, log: console } 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 = [...accs.values()].some((a: any) => a && (a.uuid === restored.uuid || a.UUID === restored.uuid))
-    expect(found).toBeTruthy()
-  })
-})

package/test/platform.integration.spec.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } 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(this: any, 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: () => { /* do not auto-run */ },
-    }
-
-    // Inject logger into config
-    const config: any = { devices: [{ id: 'dev1', type: 'light', name: 'L1' }], log }
-
-    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 = [...(platform as any).accessories.keys()]
-    expect(keys.some((k: string) => k.includes('dev1'))).toBeTruthy()
-  })
-})

package/test/switchbot-client-debounce.spec.ts

@@ -1,127 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { SwitchBotClient } from '../src/switchbotClient'
-
-describe('switchBotClient debounce/coalesce', () => {
-  let origFetch: any
-
-  beforeEach(() => {
-    origFetch = (globalThis as any).fetch
-    vi.useFakeTimers()
-  })
-
-  afterEach(() => {
-    (globalThis as any).fetch = origFetch
-    vi.restoreAllMocks()
-    vi.useRealTimers()
-  })
-
-  it('coalesces rapid writes for the same device (last write wins)', async () => {
-    const respBody = { status: 'ok' }
-    const fetchMock = vi.fn(async () => ({ json: async () => respBody }))
-    ;(globalThis as any).fetch = fetchMock
-
-    // Set a short debounce in config to keep the test fast
-    const c = new SwitchBotClient({ openApiToken: 't', writeDebounceMs: 10, log: console, logger: console } as any)
-    await c.init()
-
-    const body1 = { command: 'one' }
-    const body2 = { command: 'two' }
-
-    const p1 = c.setDeviceState('d-debounce', body1)
-    const p2 = c.setDeviceState('d-debounce', body2)
-
-    // Fast-forward timers past debounce window
-    vi.advanceTimersByTime(20)
-    // Allow pending microtasks to resolve
-    await Promise.resolve()
-    await Promise.resolve()
-
-    const [r1, r2] = await Promise.all([p1, p2])
-    expect(r1).toEqual(respBody)
-    expect(r2).toEqual(respBody)
-
-    // Only one network call should have been made
-    expect(fetchMock).toHaveBeenCalledTimes(1)
-    let calledBody = {}
-    const calls = fetchMock.mock.calls as any
-    if (calls.length > 0 && Array.isArray(calls[0]) && calls[0].length > 1 && calls[0][1]?.body) {
-      calledBody = JSON.parse(calls[0][1].body)
-    }
-    expect(calledBody).toEqual(body2)
-  })
-
-  it('does not coalesce writes for different devices', async () => {
-    const respBody = { status: 'ok' }
-    const fetchMock = vi.fn(async () => ({ json: async () => respBody }))
-    ;(globalThis as any).fetch = fetchMock
-
-    const c = new SwitchBotClient({ openApiToken: 't', writeDebounceMs: 10, log: console, logger: console } as any)
-    await c.init()
-
-    const p1 = c.setDeviceState('d-A', { command: 'a' })
-    const p2 = c.setDeviceState('d-B', { command: 'b' })
-
-    vi.advanceTimersByTime(20)
-    await Promise.resolve()
-    await Promise.resolve()
-
-    const [r1, r2] = await Promise.all([p1, p2])
-    expect(r1).toEqual(respBody)
-    expect(r2).toEqual(respBody)
-    expect(fetchMock).toHaveBeenCalledTimes(2)
-  })
-
-  it('coalesces multiple rapid writes (three) and resolves all promises with last response', async () => {
-    const respBody = { status: 'ok' }
-    const fetchMock = vi.fn(async () => ({ json: async () => respBody }))
-    ;(globalThis as any).fetch = fetchMock
-
-    const c = new SwitchBotClient({ openApiToken: 't', writeDebounceMs: 10, log: console, logger: console } as any)
-    await c.init()
-
-    const p1 = c.setDeviceState('d-debounce', { command: 'one' })
-    const p2 = c.setDeviceState('d-debounce', { command: 'two' })
-    const p3 = c.setDeviceState('d-debounce', { command: 'three' })
-
-    vi.advanceTimersByTime(20)
-    await Promise.resolve()
-    await Promise.resolve()
-
-    const [r1, r2, r3] = await Promise.all([p1, p2, p3])
-    expect(r1).toEqual(respBody)
-    expect(r2).toEqual(respBody)
-    expect(r3).toEqual(respBody)
-    expect(fetchMock).toHaveBeenCalledTimes(1)
-    let calledBody = {}
-    const calls = fetchMock.mock.calls as any
-    if (calls.length > 0 && Array.isArray(calls[0]) && calls[0].length > 1 && calls[0][1]?.body) {
-      calledBody = JSON.parse(calls[0][1].body)
-    }
-    expect(calledBody).toEqual({ command: 'three' })
-  })
-
-  it('separate writes outside debounce window produce multiple network calls', async () => {
-    const respBody = { status: 'ok' }
-    const fetchMock = vi.fn(async () => ({ json: async () => respBody }))
-    ;(globalThis as any).fetch = fetchMock
-
-    const c = new SwitchBotClient({ openApiToken: 't', writeDebounceMs: 10, log: console, logger: console } as any)
-    await c.init()
-
-    const p1 = c.setDeviceState('d-debounce', { command: 'one' })
-    vi.advanceTimersByTime(20)
-    await Promise.resolve()
-    await Promise.resolve()
-
-    const p2 = c.setDeviceState('d-debounce', { command: 'two' })
-    vi.advanceTimersByTime(20)
-    await Promise.resolve()
-    await Promise.resolve()
-
-    const [r1, r2] = await Promise.all([p1, p2])
-    expect(r1).toEqual(respBody)
-    expect(r2).toEqual(respBody)
-    expect(fetchMock).toHaveBeenCalledTimes(2)
-  })
-})

package/test/switchbot-client-openapi.spec.ts

@@ -1,63 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { SwitchBotClient } from '../src/switchbotClient'
-
-describe('switchBotClient OpenAPI fallback', () => {
-  let origFetch: any
-
-  beforeEach(() => {
-    origFetch = (globalThis as any).fetch
-  })
-
-  afterEach(() => {
-    (globalThis as any).fetch = origFetch
-    vi.restoreAllMocks()
-  })
-
-  it('throws when no client and no token', async () => {
-    const c = new SwitchBotClient({ log: console, logger: console } as any)
-    await c.init()
-    await expect(c.getDevice('nope')).rejects.toThrow('No SwitchBot client available')
-  })
-
-  it('uses OpenAPI when token provided for getDevice', async () => {
-    const fakeResp = { body: { device: { id: 'd1', state: 'ok' } } }
-    const fetchMock = vi.fn(async () => ({ json: async () => fakeResp }))
-    ;(globalThis as any).fetch = fetchMock
-
-    const c = new SwitchBotClient({ openApiToken: 'token-123', log: console, logger: console } as any)
-    await c.init()
-    const res = await c.getDevice('d1')
-    expect(res).toEqual(fakeResp)
-    expect(fetchMock).toHaveBeenCalledWith('https://api.switch-bot.com/v1.0/devices/d1', { headers: { Authorization: 'token-123' } })
-  })
-
-  it('posts commands to OpenAPI for setDeviceState', async () => {
-    const respBody = { status: 'ok' }
-    const fetchMock = vi.fn(async () => ({ json: async () => respBody }))
-    ;(globalThis as any).fetch = fetchMock
-
-    const c = new SwitchBotClient({ openApiToken: 't', log: console, logger: console } as any)
-    await c.init()
-    const body = { command: 'turnOn', parameter: 'default', commandType: 'command' }
-    const out = await c.setDeviceState('d2', body)
-    expect(out).toEqual(respBody)
-    expect(fetchMock).toHaveBeenCalledWith('https://api.switch-bot.com/v1.0/devices/d2/commands', expect.objectContaining({ method: 'POST' }))
-    let calledBody = {}
-    const calls = fetchMock.mock.calls as any
-    if (calls.length > 0 && calls[0][1]?.body) {
-      calledBody = JSON.parse(calls[0][1].body)
-    }
-    expect(calledBody).toEqual(body)
-  })
-
-  it('propagates fetch errors', async () => {
-    const fetchMock = vi.fn(async () => {
-      throw new Error('network')
-    })
-    ;(globalThis as any).fetch = fetchMock
-    const c = new SwitchBotClient({ openApiToken: 't', log: console, logger: console } as any)
-    await c.init()
-    await expect(c.getDevice('x')).rejects.toThrow('network')
-  })
-})

package/test/switchbotClient.spec.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { SwitchBotClient } from '../src/switchbotClient'
-
-describe('switchBotClient', () => {
-  it('init does not throw and getDevice throws when no token/client', async () => {
-    const c = new SwitchBotClient({ log: console, logger: console })
-    await c.init()
-    await expect(c.getDevice('nope')).rejects.toThrow()
-  })
-})

package/test/utils.spec.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createPlatformProxy } from '../src/utils'
-
-describe('createPlatformProxy', () => {
-  it('returns Matter platform when preferMatter, enabled, and Matter API is available', () => {
-    class HAP {}
-    class Matter {}
-    const ProxyCtor: any = createPlatformProxy(HAP, Matter)
-    const api = {
-      isMatterAvailable: () => true,
-      isMatterEnabled: () => true,
-    }
-    const impl = new (ProxyCtor as any)(console, { preferMatter: true, enableMatter: true }, api)
-    expect(impl).toBeInstanceOf(Matter)
-  })
-
-  it('returns HAP platform when preferMatter is false', () => {
-    class HAP {}
-    class Matter {}
-    const ProxyCtor: any = createPlatformProxy(HAP, Matter)
-    const impl = new (ProxyCtor as any)(console, { preferMatter: false, enableMatter: true }, undefined)
-    expect(impl).toBeInstanceOf(HAP)
-  })
-
-  it('returns HAP platform when Matter API is unavailable', () => {
-    class HAP {}
-    class Matter {}
-    const ProxyCtor: any = createPlatformProxy(HAP, Matter)
-    const api = {
-      isMatterAvailable: () => false,
-      isMatterEnabled: () => false,
-    }
-    const impl = new (ProxyCtor as any)(console, { preferMatter: true, enableMatter: true }, api)
-    expect(impl).toBeInstanceOf(HAP)
-  })
-})