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

package/src/test/homebridge-ui/server.test.ts

@@ -0,0 +1,486 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import { describe, expect, it } from 'vitest'
+
+/**
+ * Test suite for the homebridge-ui server handler logic
+ *
+ * These tests validate the cached accessory file reading logic that powers
+ * the getCachedAccessories and getCachedMatterAccessories handlers.
+ *
+ * Note: These are integration tests that test the file system logic rather than
+ * the UI server infrastructure itself, since HomebridgePluginUiServer is designed
+ * to run as a standalone process with IPC communication.
+ */
+
+// Helper to create isolated test environment
+function createTestEnvironment() {
+  const testId = Math.random().toString(36).substring(7)
+  const testDir = join(tmpdir(), `switchbot-ui-test-${testId}`)
+  const accessoriesDir = join(testDir, 'accessories')
+
+  // Create test directories
+  if (!existsSync(testDir)) {
+    mkdirSync(testDir, { recursive: true })
+  }
+  if (!existsSync(accessoriesDir)) {
+    mkdirSync(accessoriesDir, { recursive: true })
+  }
+
+  return { testDir, accessoriesDir }
+}
+
+// Cleanup helper
+function cleanup(testDir: string) {
+  try {
+    if (existsSync(testDir)) {
+      const removeRecursive = (dir: string) => {
+        if (!existsSync(dir)) {
+          return
+        }
+        const files = readdirSync(dir)
+        for (const file of files) {
+          const filePath = join(dir, file)
+          try {
+            const stat = statSync(filePath)
+            if (stat.isDirectory()) {
+              removeRecursive(filePath)
+            } else {
+              unlinkSync(filePath)
+            }
+          } catch {
+            // ignore
+          }
+        }
+        try {
+          rmdirSync(dir)
+        } catch {
+          // ignore
+        }
+      }
+      removeRecursive(testDir)
+    }
+  } catch {
+    // ignore
+  }
+}
+
+/**
+ * Re-implementation of the getCachedAccessories handler logic for testing
+ * This mirrors the actual implementation in server.ts
+ */
+function getCachedAccessories(homebridgeStoragePath: string): any[] {
+  try {
+    const pluginNames = ['@switchbot/homebridge-switchbot', 'homebridge-switchbot']
+    const devicesToReturn = []
+
+    const accFile = `${homebridgeStoragePath}/accessories/cachedAccessories`
+
+    if (existsSync(accFile)) {
+      const cachedAccessories: any[] = JSON.parse(readFileSync(accFile, 'utf8'))
+
+      cachedAccessories.forEach((entry: any) => {
+        const pluginName = entry.plugin || entry?.accessory?.plugin || entry?.accessory?.pluginName
+        const acc = entry.accessory ?? entry
+        if (pluginNames.includes(pluginName)) {
+          devicesToReturn.push(acc as never)
+        }
+      })
+    }
+    return devicesToReturn
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Re-implementation of the getCachedMatterAccessories handler logic for testing
+ * This mirrors the actual implementation in server.ts
+ */
+function getCachedMatterAccessories(homebridgeStoragePath: string): any[] {
+  try {
+    const pluginNames = ['@switchbot/homebridge-switchbot', 'homebridge-switchbot']
+    const devicesToReturn: any[] = []
+
+    const accFile = `${homebridgeStoragePath}/accessories/cachedAccessories`
+    const matterFile = `${homebridgeStoragePath}/accessories/cachedMatterAccessories`
+
+    const readAndCollect = (filePath: string) => {
+      if (!existsSync(filePath)) {
+        return
+      }
+      try {
+        const parsed: any[] = JSON.parse(readFileSync(filePath, 'utf8'))
+        parsed.forEach((entry: any) => {
+          const pluginName = entry.plugin || entry?.accessory?.plugin || entry?.accessory?.pluginName
+          const acc = entry.accessory ?? entry
+          if (pluginNames.includes(pluginName)) {
+            devicesToReturn.push(acc as never)
+          }
+        })
+      } catch {
+        // ignore parse errors for a single file
+      }
+    }
+
+    readAndCollect(accFile)
+    readAndCollect(matterFile)
+
+    return devicesToReturn
+  } catch {
+    return []
+  }
+}
+
+describe('homebridge-ui server handler logic', () => {
+  describe('getCachedAccessories', () => {
+    it('should return empty array when no cached accessories file exists', () => {
+      const { testDir } = createTestEnvironment()
+      try {
+        const result = getCachedAccessories(testDir)
+        expect(result).toEqual([])
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should return accessories with scoped plugin name', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: {
+              displayName: 'Test Bot',
+              UUID: 'test-uuid-1',
+              services: [],
+            },
+          },
+          {
+            plugin: 'homebridge-other-plugin',
+            accessory: {
+              displayName: 'Other Device',
+              UUID: 'test-uuid-2',
+              services: [],
+            },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Test Bot')
+        expect(result[0].UUID).toBe('test-uuid-1')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should return accessories with unscoped plugin name', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: 'homebridge-switchbot',
+            accessory: {
+              displayName: 'Test Curtain',
+              UUID: 'test-uuid-3',
+              services: [],
+            },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Test Curtain')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should handle entries with plugin name in accessory.plugin', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            accessory: {
+              plugin: '@switchbot/homebridge-switchbot',
+              displayName: 'Test Contact Sensor',
+              UUID: 'test-uuid-4',
+              services: [],
+            },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Test Contact Sensor')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should handle entries with plugin name in accessory.pluginName', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            accessory: {
+              pluginName: '@switchbot/homebridge-switchbot',
+              displayName: 'Test Motion Sensor',
+              UUID: 'test-uuid-5',
+              services: [],
+            },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Test Motion Sensor')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should filter out accessories from other plugins', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: { displayName: 'SwitchBot Device 1', UUID: 'uuid-1', services: [] },
+          },
+          {
+            plugin: 'homebridge-other',
+            accessory: { displayName: 'Other Device', UUID: 'uuid-2', services: [] },
+          },
+          {
+            plugin: 'homebridge-switchbot',
+            accessory: { displayName: 'SwitchBot Device 2', UUID: 'uuid-3', services: [] },
+          },
+          {
+            plugin: 'homebridge-another',
+            accessory: { displayName: 'Another Device', UUID: 'uuid-4', services: [] },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toHaveLength(2)
+        expect(result[0].displayName).toBe('SwitchBot Device 1')
+        expect(result[1].displayName).toBe('SwitchBot Device 2')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should return empty array on malformed JSON', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, '{ invalid json }', 'utf8')
+
+        const result = getCachedAccessories(testDir)
+
+        expect(result).toEqual([])
+      } finally {
+        cleanup(testDir)
+      }
+    })
+  })
+
+  describe('getCachedMatterAccessories', () => {
+    it('should return empty array when no cached files exist', () => {
+      const { testDir } = createTestEnvironment()
+      try {
+        const result = getCachedMatterAccessories(testDir)
+        expect(result).toEqual([])
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should read from cachedAccessories file', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: {
+              displayName: 'HAP Device',
+              UUID: 'hap-uuid-1',
+              services: [],
+            },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('HAP Device')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should read from cachedMatterAccessories file', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const matterAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: {
+              displayName: 'Matter Device',
+              UUID: 'matter-uuid-1',
+              services: [],
+            },
+          },
+        ]
+
+        const matterFile = join(accessoriesDir, 'cachedMatterAccessories')
+        writeFileSync(matterFile, JSON.stringify(matterAccessories), 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Matter Device')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should combine accessories from both files', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: { displayName: 'HAP Device', UUID: 'hap-uuid', services: [] },
+          },
+        ]
+        const matterAccessories = [
+          {
+            plugin: 'homebridge-switchbot',
+            accessory: { displayName: 'Matter Device', UUID: 'matter-uuid', services: [] },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        const matterFile = join(accessoriesDir, 'cachedMatterAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+        writeFileSync(matterFile, JSON.stringify(matterAccessories), 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        expect(result).toHaveLength(2)
+        expect(result[0].displayName).toBe('HAP Device')
+        expect(result[1].displayName).toBe('Matter Device')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should filter out accessories from other plugins across both files', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const cachedAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: { displayName: 'SwitchBot HAP 1', UUID: 'hap-1', services: [] },
+          },
+          {
+            plugin: 'homebridge-other',
+            accessory: { displayName: 'Other HAP', UUID: 'hap-2', services: [] },
+          },
+        ]
+        const matterAccessories = [
+          {
+            plugin: 'homebridge-switchbot',
+            accessory: { displayName: 'SwitchBot Matter 1', UUID: 'matter-1', services: [] },
+          },
+          {
+            plugin: 'homebridge-another',
+            accessory: { displayName: 'Another Matter', UUID: 'matter-2', services: [] },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        const matterFile = join(accessoriesDir, 'cachedMatterAccessories')
+        writeFileSync(accFile, JSON.stringify(cachedAccessories), 'utf8')
+        writeFileSync(matterFile, JSON.stringify(matterAccessories), 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        expect(result).toHaveLength(2)
+        expect(result[0].displayName).toBe('SwitchBot HAP 1')
+        expect(result[1].displayName).toBe('SwitchBot Matter 1')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should handle malformed JSON in one file gracefully', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const matterAccessories = [
+          {
+            plugin: '@switchbot/homebridge-switchbot',
+            accessory: { displayName: 'Valid Matter', UUID: 'valid', services: [] },
+          },
+        ]
+
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        const matterFile = join(accessoriesDir, 'cachedMatterAccessories')
+        writeFileSync(accFile, '{ invalid json }', 'utf8')
+        writeFileSync(matterFile, JSON.stringify(matterAccessories), 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        // Should still return the valid Matter accessory
+        expect(result).toHaveLength(1)
+        expect(result[0].displayName).toBe('Valid Matter')
+      } finally {
+        cleanup(testDir)
+      }
+    })
+
+    it('should return empty array if both files have malformed JSON', () => {
+      const { testDir, accessoriesDir } = createTestEnvironment()
+      try {
+        const accFile = join(accessoriesDir, 'cachedAccessories')
+        const matterFile = join(accessoriesDir, 'cachedMatterAccessories')
+        writeFileSync(accFile, '{ bad json', 'utf8')
+        writeFileSync(matterFile, 'also bad }', 'utf8')
+
+        const result = getCachedMatterAccessories(testDir)
+
+        expect(result).toEqual([])
+      } finally {
+        cleanup(testDir)
+      }
+    })
+  })
+})

package/src/test/index.test.ts

@@ -0,0 +1,24 @@
+import type { API } from 'homebridge'
+
+import { describe, expect, it, vi } from 'vitest'
+
+import registerPlatform from '../index.js'
+import { PLATFORM_NAME, PLUGIN_NAME } from '../settings.js'
+
+describe('index.ts', () => {
+  it('should register the platform with homebridge', () => {
+    const api = {
+      registerPlatform: vi.fn(),
+    } as unknown as API
+
+    registerPlatform(api)
+
+    // The platform registration now uses a runtime proxy/delegate constructor so
+    // assert the call happened and the third argument is a constructor function.
+    expect(api.registerPlatform).toHaveBeenCalled()
+    const callArgs = (api.registerPlatform as any).mock.calls[0]
+    expect(callArgs[0]).toBe(PLUGIN_NAME)
+    expect(callArgs[1]).toBe(PLATFORM_NAME)
+    expect(typeof callArgs[2]).toBe('function')
+  })
+})

package/src/test/matter/devices-matter/baseMatterAccessory.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { BaseMatterAccessory } from '../../../devices-matter/BaseMatterAccessory.js'
+
+// Minimal concrete subclass for testing
+class TestAccessory extends BaseMatterAccessory {
+  constructor(api: any, log: any, opts?: any) {
+    super(api, log, {
+      uuid: opts?.uuid ?? api.matter.uuid.generate('test'),
+      displayName: opts?.displayName ?? 'Test',
+      deviceType: opts?.deviceType ?? ('OnOffLight' as any),
+      serialNumber: opts?.serialNumber ?? 'TEST-1',
+      manufacturer: opts?.manufacturer ?? 'TestCo',
+      model: opts?.model ?? 'T-1',
+      firmwareRevision: opts?.firmwareRevision ?? '1.0',
+      hardwareRevision: opts?.hardwareRevision ?? '1.0',
+      context: opts?.context ?? {},
+      clusters: opts?.clusters,
+      handlers: opts?.handlers,
+    })
+  }
+}
+
+describe('baseMatterAccessory helpers', () => {
+  it('sendOnCommand uses OpenAPI helper and updates state', async () => {
+    const update = vi.fn()
+    const sendOpenAPI = vi.fn(async () => ({ response: {}, statusCode: 200 }))
+    const api: any = { matter: { clusterNames: { OnOff: 'onOff', LevelControl: 'level', ColorControl: 'color' }, uuid: { generate: () => 'uuid-1' }, updateAccessoryState: update } }
+    const log: any = { info: vi.fn(), debug: vi.fn(), error: vi.fn(), warn: vi.fn() }
+
+    const ctx = { deviceId: 'DEV-1', sendOpenAPI, connectionType: 'OpenAPI' }
+    const acc = new TestAccessory(api, log, { context: ctx })
+
+    await acc.sendOnCommand()
+
+    expect(sendOpenAPI).toHaveBeenCalledWith('turnOn', 'default')
+    expect(update).toHaveBeenCalledWith(acc.uuid, 'onOff', { onOff: true })
+  })
+
+  it('sendOnCommand uses BLE helper when connectionType is BLE', async () => {
+    const update = vi.fn()
+    const sendBLE = vi.fn(async () => true)
+    const api: any = { matter: { clusterNames: { OnOff: 'onOff', LevelControl: 'level', ColorControl: 'color' }, uuid: { generate: () => 'uuid-2' }, updateAccessoryState: update } }
+    const log: any = { info: vi.fn(), debug: vi.fn(), error: vi.fn(), warn: vi.fn() }
+
+    const ctx = { deviceId: 'DEV-2', sendBLE, connectionType: 'BLE' }
+    const acc = new TestAccessory(api, log, { context: ctx })
+
+    await acc.sendOnCommand()
+
+    expect(sendBLE).toHaveBeenCalledWith('turnOn')
+    expect(update).toHaveBeenCalledWith(acc.uuid, 'onOff', { onOff: true })
+  })
+
+  it('sendSetBrightness sends percent and updates LevelControl', async () => {
+    const update = vi.fn()
+    const sendOpenAPI = vi.fn(async () => ({ response: {}, statusCode: 200 }))
+    const api: any = { matter: { clusterNames: { OnOff: 'onOff', LevelControl: 'level', ColorControl: 'color' }, uuid: { generate: () => 'uuid-3' }, updateAccessoryState: update } }
+    const log: any = { info: vi.fn(), debug: vi.fn(), error: vi.fn(), warn: vi.fn() }
+
+    const ctx = { deviceId: 'DEV-3', sendOpenAPI, connectionType: 'OpenAPI' }
+    const acc = new TestAccessory(api, log, { context: ctx })
+
+    await acc.sendSetBrightness(50)
+
+    expect(sendOpenAPI).toHaveBeenCalledWith('setBrightness', '50')
+    const expectedLevel = Math.round((50 / 100) * 254)
+    expect(update).toHaveBeenCalledWith(acc.uuid, 'level', { currentLevel: expectedLevel })
+  })
+
+  it('sendSetColor sends RGB and updates ColorControl', async () => {
+    const update = vi.fn()
+    const sendOpenAPI = vi.fn(async () => ({ response: {}, statusCode: 200 }))
+    const api: any = { matter: { clusterNames: { OnOff: 'onOff', LevelControl: 'level', ColorControl: 'color' }, uuid: { generate: () => 'uuid-4' }, updateAccessoryState: update } }
+    const log: any = { info: vi.fn(), debug: vi.fn(), error: vi.fn(), warn: vi.fn() }
+
+    const ctx = { deviceId: 'DEV-4', sendOpenAPI, connectionType: 'OpenAPI' }
+    const acc = new TestAccessory(api, log, { context: ctx })
+
+    await acc.sendSetColor(255, 128, 0)
+
+    expect(sendOpenAPI).toHaveBeenCalledWith('setColor', '255:128:0')
+    expect(update).toHaveBeenCalled()
+    // Ensure we updated ColorControl cluster with numeric attributes
+    const calledWith = (update.mock.calls[0] || update.mock.calls[1])
+    expect(calledWith[1] === 'color' || calledWith[1] === api.matter.clusterNames.ColorControl).toBeTruthy()
+  })
+})

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

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+describe('additional platform-matter mapping tests', () => {
+  it('parses OpenAPI color strings and triggers an update', async () => {
+    const updateAccessoryState = vi.fn()
+    const api: any = makeApiStub({ updateAccessoryState })
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    // Some OpenAPI statuses provide color as comma/colon separated or hex
+    await (platform as any).applyStatusToAccessory('uuid-col', { deviceId: 'DEV-COL' } as any, { color: '255:128:64' })
+    await (platform as any).applyStatusToAccessory('uuid-col', { deviceId: 'DEV-COL' } as any, { color: '255,128,64' })
+    await (platform as any).applyStatusToAccessory('uuid-col', { deviceId: 'DEV-COL' } as any, { color: '#FF8040' })
+
+    expect(updateAccessoryState).toHaveBeenCalled()
+  })
+
+  it('maps MeterPro CO2 values to Matter updates', async () => {
+    const updateAccessoryState = vi.fn()
+    const api: any = makeApiStub({ updateAccessoryState })
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    await (platform as any).applyStatusToAccessory('uuid-co2', { deviceId: 'DEV-METERPRO' } as any, { co2: 420 })
+
+    expect(updateAccessoryState).toHaveBeenCalled()
+  })
+
+  it('handles curtain position synonyms (position / slidePosition)', async () => {
+    const updateAccessoryState = vi.fn()
+    const api: any = makeApiStub({ updateAccessoryState })
+    const log = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    // Provide status with position and slidePosition synonyms
+    await (platform as any).applyStatusToAccessory('uuid-cur', { deviceId: 'DEV-CUR', deviceType: 'Curtain' } as any, { position: 30 })
+    await (platform as any).applyStatusToAccessory('uuid-cur', { deviceId: 'DEV-CUR', deviceType: 'Curtain' } as any, { slidePosition: 70 })
+
+    expect(updateAccessoryState).toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+describe('platform-matter BLE advertisement parser', () => {
+  it('parses extended serviceData fields correctly', () => {
+    const updateAccessoryState = vi.fn()
+    const api: any = makeApiStub({ updateAccessoryState })
+
+    const log: any = makeLogStub()
+    const platform = new SwitchBotMatterPlatform(log as any, {} as any, api)
+
+    const dev: any = { deviceId: 'DEV-TEST' }
+    const sd = {
+      temp: 22.3,
+      humid: 45,
+      pm25: 12,
+      pm10: 34,
+      voc: 120,
+      co2: 420,
+      motion: 1,
+      open: 0,
+      leak: 0,
+      position: 30,
+      fanSpeed: 75,
+      battery: 88,
+      rgb: '255:128:64',
+    }
+
+    const parsed = (platform as any).parseAdvertisementForDevice(dev, sd)
+    expect(parsed).toBeTruthy()
+    expect(parsed.temperature).toBeCloseTo(22.3)
+    expect(parsed.humidity).toBe(45)
+    expect(parsed.pm25).toBe(12)
+    expect(parsed.pm10).toBe(34)
+    expect(parsed.voc).toBe(120)
+    expect(parsed.co2).toBe(420)
+    expect(parsed.motion).toBeTruthy()
+    expect(parsed.contact).toBeDefined()
+    expect(parsed.leak).toBeFalsy()
+    expect(parsed.position).toBe(30)
+    expect(parsed.fanSpeed).toBe(75)
+    expect(parsed.battery).toBe(88)
+    expect(parsed.color).toEqual({ r: 255, g: 128, b: 64 })
+  })
+})