@switchbot/homebridge-switchbot 5.0.0-beta.4 → 5.0.0-beta.40

package/src/test/matter/platform-matter.openapi-mapping.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+describe('platform-matter OpenAPI -> Matter mapping', () => {
+  it('maps light OpenAPI status (on/off, brightness, color, battery) to accessory instance helpers', async () => {
+    const api: any = makeApiStub()
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const deviceId = 'LIGHT-1'
+    const nid = (platform as any).normalizeDeviceId(deviceId)
+
+    const instance = {
+      updateOnOffState: vi.fn(),
+      updateBrightness: vi.fn(),
+      updateHueSaturation: vi.fn(),
+      updateBatteryPercentage: vi.fn(),
+    }
+    ;(platform as any).accessoryInstances.set(nid, instance)
+
+    const status = { power: true, brightness: 80, color: '255:128:64', battery: 92 }
+    await (platform as any).applyStatusToAccessory('uuid-light', { deviceId } as any, status)
+
+    expect(instance.updateOnOffState).toHaveBeenCalled()
+    expect(instance.updateBrightness).toHaveBeenCalled()
+    expect(instance.updateHueSaturation).toHaveBeenCalled()
+    expect(instance.updateBatteryPercentage).toHaveBeenCalled()
+  })
+
+  it('maps MeterPro OpenAPI status (temp, humid, co2, pm25, voc) to accessory instance helpers', async () => {
+    const api: any = makeApiStub()
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const deviceId = 'METERPRO-1'
+    const nid = (platform as any).normalizeDeviceId(deviceId)
+
+    const instance = {
+      updateTemperature: vi.fn(),
+      updateHumidity: vi.fn(),
+      updateCO2: vi.fn(),
+      updatePM25: vi.fn(),
+      updateVOC: vi.fn(),
+    }
+    ;(platform as any).accessoryInstances.set(nid, instance)
+
+    const status = { temp: 21.4, humid: 45, co2: 410, pm25: 12, voc: 85 }
+    await (platform as any).applyStatusToAccessory('uuid-meter', { deviceId } as any, status)
+
+    expect(instance.updateTemperature).toHaveBeenCalled()
+    expect(instance.updateHumidity).toHaveBeenCalled()
+    expect(instance.updateCO2).toHaveBeenCalled()
+    expect(instance.updatePM25).toHaveBeenCalled()
+    expect(instance.updateVOC).toHaveBeenCalled()
+  })
+
+  it('maps lock OpenAPI status to lock helper', async () => {
+    const api: any = makeApiStub()
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const deviceId = 'LOCK-1'
+    const nid = (platform as any).normalizeDeviceId(deviceId)
+
+    const instance = { updateLockState: vi.fn() }
+    ;(platform as any).accessoryInstances.set(nid, instance)
+
+    const status = { lock: true }
+    await (platform as any).applyStatusToAccessory('uuid-lock', { deviceId } as any, status)
+
+    expect(instance.updateLockState).toHaveBeenCalled()
+  })
+
+  it('maps curtain position synonyms to lift position helper', async () => {
+    const api: any = makeApiStub()
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const deviceId = 'CURTAIN-1'
+    const nid = (platform as any).normalizeDeviceId(deviceId)
+
+    const instance = { updateLiftPosition: vi.fn() }
+    ;(platform as any).accessoryInstances.set(nid, instance)
+
+    await (platform as any).applyStatusToAccessory('uuid-cur', { deviceId, deviceType: 'Curtain' } as any, { position: 25 })
+    await (platform as any).applyStatusToAccessory('uuid-cur', { deviceId, deviceType: 'Curtain' } as any, { slidePosition: 75 })
+
+    expect(instance.updateLiftPosition).toHaveBeenCalled()
+  })
+
+  it('maps robot vacuum run state / on to updateRunMode or updateOperationalState', async () => {
+    const api: any = makeApiStub()
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const deviceId = 'RVC-1'
+    const nid = (platform as any).normalizeDeviceId(deviceId)
+
+    const instance: any = { updateRunMode: vi.fn(), updateOperationalState: vi.fn() }
+    ;(platform as any).accessoryInstances.set(nid, instance)
+
+    await (platform as any).applyStatusToAccessory('uuid-rvc', { deviceId, deviceType: 'K10+' } as any, { runState: 'cleaning', power: true })
+
+    const calls = (instance.updateRunMode.mock?.calls?.length || 0) + (instance.updateOperationalState.mock?.calls?.length || 0)
+    expect(calls).toBeGreaterThan(0)
+  })
+})

package/src/test/matter/platform-matter.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { PLATFORM_NAME, PLUGIN_NAME } from '../../settings.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+describe('platform-matter discovered devices', () => {
+  it('uses discovered devices and registers them (platform + robotic)', async () => {
+    const mockRegister = vi.fn()
+    const api: any = makeApiStub({
+      registerPlatformAccessories: mockRegister,
+      clusterNames: { OnOff: 'OnOff', LevelControl: 'LevelControl', ColorControl: 'ColorControl' },
+      deviceTypes: { RoboticVacuumCleaner: 'rvc' },
+    })
+
+    const log: any = makeLogStub()
+
+    const config: any = {}
+
+    const platform = new SwitchBotMatterPlatform(log, config, api)
+
+    // Provide discovered devices
+    ;(platform as any).discoveredDevices = [
+      { deviceId: 'dev1', deviceName: 'Lamp', deviceType: 'Plug' },
+      { deviceId: 'vac1', deviceName: 'Vac', deviceType: 'K10+' },
+    ] as any
+
+    // Stub accessory creation to avoid instantiating full device classes
+    ;(platform as any).createAccessoryFromDevice = async (dev: any) => ({ displayName: dev.deviceName, uuid: api.matter.uuid.generate(dev.deviceId) } as any)
+
+    await (platform as any).registerMatterAccessories()
+
+    // Ensure registerPlatformAccessories was called at least once
+    expect(mockRegister).toHaveBeenCalled()
+
+    // Sum total accessories registered across all calls
+    const totalRegistered = mockRegister.mock.calls.reduce((sum: number, call: any) => sum + ((call[2] && call[2].length) || 0), 0)
+    expect(totalRegistered).toBe(2)
+
+    // Verify PLUGIN_NAME and PLATFORM_NAME were used in the calls
+    for (const call of mockRegister.mock.calls) {
+      expect(call[0]).toBe(PLUGIN_NAME)
+      expect(call[1]).toBe(PLATFORM_NAME)
+    }
+  })
+
+  it('applies per-device config overrides when deviceId matches discovered device', async () => {
+    const mockRegister = vi.fn()
+
+    const api: any = {
+      matter: {
+        uuid: { generate: (s: string) => `uuid-${s}` },
+        registerPlatformAccessories: mockRegister,
+        clusterNames: { OnOff: 'OnOff', LevelControl: 'LevelControl', ColorControl: 'ColorControl' },
+        deviceTypes: { RoboticVacuumCleaner: 'rvc' },
+      },
+      isMatterAvailable: () => true,
+      isMatterEnabled: () => true,
+      on: () => {},
+    }
+
+    const log: any = { info: vi.fn(), warn: vi.fn(), debug: vi.fn(), error: vi.fn() }
+
+    const config: any = {
+      options: {
+        devices: [{ deviceId: 'dev1', configDeviceName: 'Configured Lamp', logging: 'debug' }],
+      },
+    }
+
+    const platform = new SwitchBotMatterPlatform(log, config, api)
+
+    ;(platform as any).discoveredDevices = [{ deviceId: 'dev1', deviceName: 'Lamp', deviceType: 'Plug' }] as any
+
+    const seen: any[] = []
+    ;(platform as any).createAccessoryFromDevice = async (dev: any) => {
+      seen.push(dev)
+      return {
+        displayName: dev.deviceName ?? dev.configDeviceName,
+        uuid: api.matter.uuid.generate(dev.deviceId),
+      } as any
+    }
+
+    await (platform as any).registerMatterAccessories()
+
+    // createAccessoryFromDevice should have been called once with merged config
+    expect(seen.length).toBe(1)
+    expect(seen[0].deviceId).toBe('dev1')
+    // per-device config values should be present on the merged device
+    expect(seen[0].configDeviceName).toBe('Configured Lamp')
+    expect(seen[0].logging).toBe('debug')
+  })
+
+  it('ignores config-only devices by default but includes them when allowConfigOnlyDevices=true', async () => {
+    const mockRegister = vi.fn()
+
+    const api: any = {
+      matter: {
+        uuid: { generate: (s: string) => `uuid-${s}` },
+        registerPlatformAccessories: mockRegister,
+        clusterNames: { OnOff: 'OnOff', LevelControl: 'LevelControl', ColorControl: 'ColorControl' },
+        deviceTypes: { RoboticVacuumCleaner: 'rvc' },
+      },
+      isMatterAvailable: () => true,
+      isMatterEnabled: () => true,
+      on: () => {},
+    }
+
+    const log: any = { info: vi.fn(), warn: vi.fn(), debug: vi.fn(), error: vi.fn() }
+
+    // config-only device (cfg1) and one discovered device (dev1)
+    const cfgOnly = { deviceId: 'cfg1', configDeviceName: 'OnlyInConfig', deviceType: 'Plug' }
+    const configDefault: any = { options: { devices: [cfgOnly] } }
+
+    const platformDefault = new SwitchBotMatterPlatform(log, configDefault, api)
+    ;(platformDefault as any).discoveredDevices = [{ deviceId: 'dev1', deviceName: 'Lamp', deviceType: 'Plug' }] as any
+    const seenDefault: any[] = []
+    ;(platformDefault as any).createAccessoryFromDevice = async (dev: any) => {
+      seenDefault.push(dev)
+      return {
+        displayName: dev.deviceName ?? dev.configDeviceName,
+        uuid: api.matter.uuid.generate(dev.deviceId),
+      } as any
+    }
+    await (platformDefault as any).registerMatterAccessories()
+    // Should only see discovered device (cfg1 ignored)
+    expect(seenDefault.find((d: any) => d.deviceId === 'cfg1')).toBeUndefined()
+
+    // Now opt-in to include config-only devices
+    const configOptIn: any = { options: { devices: [cfgOnly], allowConfigOnlyDevices: true } }
+    const platformOptIn = new SwitchBotMatterPlatform(log, configOptIn, api)
+    ;(platformOptIn as any).discoveredDevices = [{ deviceId: 'dev1', deviceName: 'Lamp', deviceType: 'Plug' }] as any
+    const seenOptIn: any[] = []
+    ;(platformOptIn as any).createAccessoryFromDevice = async (dev: any) => {
+      seenOptIn.push(dev)
+      return {
+        displayName: dev.deviceName ?? dev.configDeviceName,
+        uuid: api.matter.uuid.generate(dev.deviceId),
+      } as any
+    }
+    await (platformOptIn as any).registerMatterAccessories()
+    // Should include the config-only device now
+    expect(seenOptIn.find((d: any) => d.deviceId === 'cfg1')).toBeDefined()
+  })
+})

package/src/test/matter/platform-matter.unregister.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+describe('removeDisabledAccessories and unregister edge cases', () => {
+  it('clears resources and unregisters accessory even with invalid timer and non-MAC deviceId', async () => {
+    // Prepare API stub
+    const unregister = vi.fn()
+    const api: any = makeApiStub({ unregisterPlatformAccessories: unregister })
+    const log: any = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, { enableOnOffLight: false } as any, api)
+
+    // Build a fake serialized accessory matching the generated UUID for OnOff Light
+    const uuid = api.matter.uuid.generate('matter-onoff-light')
+    const accessory: any = { uuid, displayName: 'OnOff Light', context: { deviceId: 'NOT-A-MAC' } }
+
+    // Put invalid timer object into refreshTimers to ensure code handles it
+    const nid = (platform as any).normalizeDeviceId(accessory.context.deviceId)
+    ;(platform as any).refreshTimers.set(nid, null as any)
+    ;(platform as any).accessoryInstances.set(nid, { dummy: true })
+
+    // Insert accessory into matterAccessories so removeDisabledAccessories will see it
+    ;(platform as any).matterAccessories.set(uuid, accessory)
+
+    // Spy on clearDeviceResources
+    const spyClear = vi.spyOn(platform as any, 'clearDeviceResources')
+
+    // Call removeDisabledAccessories directly
+    await (platform as any).removeDisabledAccessories()
+
+    // Expect unregister was called and matterAccessories cleared
+    expect(unregister).toHaveBeenCalled()
+    expect((platform as any).matterAccessories.get(uuid)).toBeUndefined()
+
+    // clearDeviceResources should have been called with the accessory.deviceId
+    expect(spyClear).toHaveBeenCalledWith(accessory.context.deviceId)
+  })
+})

package/src/test/utils.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { createPlatformProxy, detectMatter } from '../utils.js'
+
+describe('detectMatter', () => {
+  it('returns enabled true when api.isMatterEnabled is a function that returns true', () => {
+    const api: any = { isMatterEnabled: () => true }
+    const info = detectMatter(api)
+    expect(info.enabled).toBe(true)
+    expect(info.reason).toMatch(/isMatterEnabled\(\)/)
+  })
+
+  it('returns enabled true when api.isMatterEnabled is a truthy property', () => {
+    const api: any = { isMatterEnabled: true }
+    const info = detectMatter(api)
+    expect(info.enabled).toBe(true)
+    expect(info.reason).toMatch(/property present/)
+  })
+
+  it('uses server fallback when present', () => {
+    const api: any = { server: { isMatterEnabled: () => false } }
+    const info = detectMatter(api)
+    expect(info.enabled).toBe(false)
+    expect(info.reason).toMatch(/server.isMatterEnabled\(\)/)
+  })
+
+  it('returns enabled false with a reason when no API is present', () => {
+    const api: any = {}
+    const info = detectMatter(api)
+    expect(info.enabled).toBe(false)
+    expect(typeof info.reason).toBe('string')
+  })
+})
+
+describe('createPlatformProxy', () => {
+  it('selects HAP platform when Matter is disabled and delegates configureAccessory', () => {
+    class HapStub {
+      public static created = false
+      public configured: any = undefined
+      constructor(public log: any, public config: any, public api: any) {
+        HapStub.created = true
+      }
+
+      configureAccessory(acc: any) {
+        this.configured = acc
+      }
+    }
+
+    class MatterStub {
+      constructor() {
+        throw new Error('should not be constructed')
+      }
+    }
+
+    const ProxyCtor = createPlatformProxy(HapStub as any, MatterStub as any)
+    const log = { info: vi.fn() }
+    const api = { isMatterEnabled: false }
+    const proxy = new (ProxyCtor as any)(log, {}, api)
+
+    // delegate should be instance of HapStub
+    expect(HapStub.created).toBe(true)
+    expect(typeof proxy.delegate.configureAccessory).toBe('function')
+    proxy.configureAccessory('accessory')
+    expect(proxy.delegate.configured).toBe('accessory')
+    // log should mention HAP
+    expect((log.info as any).mock.calls[0][0]).toMatch(/HAP/)
+  })
+
+  it('selects Matter platform when isMatterEnabled is true', () => {
+    class HapStub2 {
+      constructor() {
+        throw new Error('should not be constructed')
+      }
+    }
+
+    class MatterStub2 {
+      public configured: any = undefined
+      constructor(public log: any, public config: any, public api: any) {}
+
+      configureMatterAccessory(acc: any) {
+        this.configured = acc
+      }
+    }
+
+    const ProxyCtor = createPlatformProxy(HapStub2 as any, MatterStub2 as any)
+    const log = { info: vi.fn() }
+    const api = { isMatterEnabled: () => true }
+    const proxy = new (ProxyCtor as any)(log, {}, api)
+
+    // delegate should be instance of MatterStub2
+    expect(typeof proxy.delegate.configureMatterAccessory).toBe('function')
+    ;(proxy as any).configureMatterAccessory('macc')
+    expect(proxy.delegate.configured).toBe('macc')
+    expect((log.info as any).mock.calls[0][0]).toMatch(/Matter/)
+  })
+})

package/src/{verifyconfig.test.ts → test/verifyconfig.test.ts}

@@ -1,5 +1,6 @@
-import { describe, expect, it, vi } from 'vitest'
-import type { SwitchBotPlatformConfig } from './settings.js'
+import type { SwitchBotPlatformConfig } from '../settings.js'
+
+import { describe, expect, it } from 'vitest'
 
 // Create a minimal mock of the SwitchBotPlatform to test verifyConfig
 class MockSwitchBotPlatform {
@@ -102,10 +103,10 @@ describe('verifyConfig fix for reboot loop', () => {
 
     // This should NOT throw an error anymore - it should log instead
     await expect(platform.verifyConfig()).resolves.not.toThrow()
-    
+
     // Verify that the error was logged instead of thrown
     expect(platform.errorLogCalls).toContain(
-      'The devices config section is missing the *Device ID* in the config. Please check your config.'
+      'The devices config section is missing the *Device ID* in the config. Please check your config.',
     )
   })
 
@@ -132,10 +133,10 @@ describe('verifyConfig fix for reboot loop', () => {
 
     // This should NOT throw an error anymore - it should log instead
     await expect(platform.verifyConfig()).resolves.not.toThrow()
-    
+
     // Verify that the error was logged instead of thrown
     expect(platform.errorLogCalls).toContain(
-      'The devices config section is missing the *Device Type* in the config. Please check your config.'
+      'The devices config section is missing the *Device Type* in the config. Please check your config.',
     )
   })
 
@@ -187,11 +188,11 @@ describe('verifyConfig fix for reboot loop', () => {
 
     // Should not throw or log device config errors with valid config
     await expect(platform.verifyConfig()).resolves.not.toThrow()
-    
+
     // Should not have device config errors
-    expect(platform.errorLogCalls.filter(msg => 
-      msg.includes('missing the *Device ID*') || 
-      msg.includes('missing the *Device Type*')
+    expect(platform.errorLogCalls.filter(msg =>
+      msg.includes('missing the *Device ID*')
+      || msg.includes('missing the *Device Type*'),
     )).toHaveLength(0)
   })
-})
+})