@switchbot/homebridge-switchbot 5.2.2-beta.0 → 5.2.2

package/test/client/node-switchbot-commands.spec.ts

@@ -0,0 +1,85 @@
+import { SwitchBot } from 'node-switchbot'
+import { describe, expect, it, vi } from 'vitest'
+
+import { hsToRgb, toKelvin, toRgb } from '../../src/deviceCommandMapper'
+import { SwitchBotClient } from '../../src/switchbotClient'
+
+const logger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} }
+
+// Drive real node-switchbot devices (OpenAPI only) through the plugin client and record what
+// reaches the OpenAPI. Commands used to be looked up by device type string, and most real types
+// ("Plug Mini (US)", "Strip Light", "Lock Pro", ...) had no entry, so they failed as unsupported.
+async function send(deviceType: string, ...bodies: any[]) {
+  const switchbot = new SwitchBot({ enableBLE: false, token: 'token', secret: 'secret', enableRetry: false })
+  const api = switchbot.getAPIClient()!
+  vi.spyOn(api, 'getDevices').mockResolvedValue({
+    deviceList: [{ deviceId: 'DEV', deviceName: 'Test', deviceType, enableCloudService: true, hubDeviceId: 'HUB' }],
+    infraredRemoteList: [],
+  } as any)
+  const sendCommand = vi.spyOn(api, 'sendCommand').mockResolvedValue({ statusCode: 100, message: 'success', body: {} } as any)
+  const client = new SwitchBotClient({ logger, writeDebounceMs: 0 } as any)
+  ;(client as any).client = switchbot
+  for (const body of bodies) {
+    await client.setDeviceState('DEV', body)
+  }
+  return sendCommand.mock.calls.map(([, command, parameter]) => [command, parameter])
+}
+
+describe('commands reach node-switchbot devices', () => {
+  it.each(['Plug Mini (US)', 'Plug Mini (JP)', 'Plug', 'Relay Switch 1', 'Strip Light', 'Color Bulb', 'Ceiling Light'])('%s turns on and off', async (type) => {
+    expect(await send(type, { command: 'turnOn' }, { command: 'turnOff' })).toEqual([['turnOn', undefined], ['turnOff', undefined]])
+  })
+
+  it('lock Pro locks and unlocks', async () => {
+    const calls = await send('Smart Lock Pro', { command: 'lock' }, { command: 'unlock' })
+    expect(calls.map(([command]) => command)).toEqual(['lock', 'unlock'])
+  })
+
+  // Brightness arrives as a string; color as "hue,saturation"; color temperature in mireds.
+  it('color Bulb converts brightness, color and color temperature', async () => {
+    const calls = await send(
+      'Color Bulb',
+      { command: 'setBrightness', parameter: '40' },
+      { command: 'setColor', parameter: '120,100' },
+      { command: 'setColorTemperature', parameter: '250' },
+    )
+    expect(calls).toEqual([
+      ['setBrightness', 40],
+      ['setColor', '0:255:0'],
+      ['setColorTemperature', 4000],
+    ])
+  })
+
+  it('curtain and Blind Tilt set their position', async () => {
+    expect(await send('Curtain3', { command: 'setPosition', parameter: '30' })).toEqual([['setPosition', '0,ff,30']])
+    expect(await send('Blind Tilt', { command: 'setPosition', parameter: '50' })).toEqual([['setPosition', 'down;100']])
+  })
+
+  it('a vacuum starts and docks', async () => {
+    expect(await send('K10+', { command: 'start' }, { command: 'dock' })).toEqual([['start', undefined], ['dock', undefined]])
+  })
+
+  it('an unsupported command is rejected', async () => {
+    await expect(send('Meter', { command: 'turnOn' })).rejects.toThrow('Unsupported command')
+  })
+})
+
+describe('parameter conversion', () => {
+  it('converts mireds to kelvin and passes kelvin through', () => {
+    expect(toKelvin(140)).toBe(6500)
+    expect(toKelvin(500)).toBe(2700)
+    expect(toKelvin(4000)).toBe(4000)
+  })
+
+  it('converts hue and saturation to RGB', () => {
+    expect(hsToRgb(0, 100)).toEqual([255, 0, 0])
+    expect(hsToRgb(240, 100)).toEqual([0, 0, 255])
+    expect(hsToRgb(0, 0)).toEqual([255, 255, 255])
+  })
+
+  it('accepts hex and r:g:b colors', () => {
+    expect(toRgb('#FF8000')).toEqual([255, 128, 0])
+    expect(toRgb('10:20:30')).toEqual([10, 20, 30])
+    expect(() => toRgb('nope')).toThrow('Unrecognised color')
+  })
+})

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

@@ -32,4 +32,21 @@ describe('switchBotClient debounce', () => {
     expect(doSetDeviceState).toHaveBeenCalledWith('device-1', { command: 'turnOn' })
     expect(doSetDeviceState).toHaveBeenCalledWith('device-2', { command: 'turnOff' })
   })
+
+  // HomeKit writes On and Brightness together when a light is turned on at a level. Debouncing by
+  // device alone kept only the last body, so turnOn was dropped while both callers saw success.
+  it('keeps different operations on the same device', async () => {
+    const client = new SwitchBotClient({ logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} } } as any)
+    const doSetDeviceState = vi.spyOn(client as any, '_doSetDeviceState').mockResolvedValue({ status: 'success' })
+
+    await Promise.all([
+      client.setDeviceState('bulb', { command: 'turnOn' }),
+      client.setDeviceState('bulb', { command: 'setBrightness', parameter: 40 }),
+      client.setDeviceState('bulb', { command: 'setBrightness', parameter: 50 }),
+    ])
+
+    expect(doSetDeviceState).toHaveBeenCalledTimes(2)
+    expect(doSetDeviceState).toHaveBeenCalledWith('bulb', { command: 'turnOn' })
+    expect(doSetDeviceState).toHaveBeenCalledWith('bulb', { command: 'setBrightness', parameter: 50 })
+  })
 })

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

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { SwitchBotClient } from '../../src/switchbotClient'
+
+function client(devices: any[] = []) {
+  const c = new SwitchBotClient({ logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} } } as any)
+  const discover = vi.fn(async () => {
+    await new Promise(resolve => setTimeout(resolve, 10))
+    return devices
+  })
+  ;(c as any).client = { discover, devices: { get: () => undefined, list: () => devices } }
+  return { c, discover }
+}
+
+// A configured device that is offline or out of range is not in the device list. Every lookup
+// forced a full discovery (BLE scan plus an OpenAPI getDevices call), and concurrent lookups each
+// started their own.
+describe('switchBotClient rediscovery for a missing device', () => {
+  it('shares one discovery between concurrent lookups', async () => {
+    const { c, discover } = client([{ id: 'present' }])
+    await Promise.all([c.getDevice('missing-1'), c.getDevice('missing-2'), c.getDevice('missing-3')])
+    expect(discover).toHaveBeenCalledOnce()
+  })
+
+  it('does not rediscover again within the cache period', async () => {
+    const { c, discover } = client([{ id: 'present' }])
+    await c.getDevice('missing')
+    await c.getDevice('missing')
+    await c.getDevice('missing')
+    expect(discover).toHaveBeenCalledOnce()
+  })
+
+  it('still finds a device that appears after a rediscovery', async () => {
+    const devices: any[] = []
+    const { c, discover } = client(devices)
+    devices.push({ id: 'late' })
+    await expect(c.getDevice('late')).resolves.toEqual({ id: 'late' })
+    expect(discover).toHaveBeenCalledOnce()
+  })
+})

package/test/device/genericDevice-blepoll.spec.ts

@@ -45,3 +45,45 @@ describe('genericDevice BLE polling config', () => {
     expect((device as any)._blePollIntervalMs).toBe(600000)
   })
 })
+
+// "BLE polling" called getState() for every device every 10 minutes, even with BLE disabled or for
+// a cloud-only device. getState() then reads status over the OpenAPI, outside the plugin's daily
+// API budget and on top of the normal refresh, which can use up the 10,000 calls a day.
+describe('genericDevice BLE polling only polls over BLE', () => {
+  function device(cfg: Record<string, unknown>, hasBLE: boolean | undefined) {
+    const nodeDevice = hasBLE === undefined ? undefined : { hasBLE: () => hasBLE }
+    const client = { devices: { get: () => nodeDevice }, getDevice: vi.fn(async () => nodeDevice) }
+    const d = new GenericDevice({ id: 'dev', type: 'Unknown', log: mockLogger, blePollIntervalMs: 60_000 }, { log: mockLogger, _client: client, ...cfg } as any)
+    const getState = vi.spyOn(d, 'getState').mockResolvedValue({})
+    return { d, getState }
+  }
+
+  it('does not start when BLE is disabled', () => {
+    const { d } = device({ enableBLE: false }, true)
+    expect((d as any)._blePollTimer).toBeNull()
+  })
+
+  it('skips devices without a BLE connection', async () => {
+    vi.useFakeTimers()
+    try {
+      const { d, getState } = device({}, false)
+      await vi.advanceTimersByTimeAsync(60_000)
+      expect(getState).not.toHaveBeenCalled()
+      await d.destroy()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('polls devices that have BLE', async () => {
+    vi.useFakeTimers()
+    try {
+      const { d, getState } = device({}, true)
+      await vi.advanceTimersByTimeAsync(60_000)
+      expect(getState).toHaveBeenCalledOnce()
+      await d.destroy()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})

package/test/platform/hap-cache-restart.spec.ts

@@ -0,0 +1,112 @@
+import { mkdtempSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import * as hap from '@homebridge/hap-nodejs'
+import { Characteristic, Service, uuid } from '@homebridge/hap-nodejs'
+import { describe, expect, it, vi } from 'vitest'
+
+// Homebridge exports only the PlatformAccessory type. This test needs the real class, because its
+// serialize/deserialize are what write and read the accessory cache.
+// eslint-disable-next-line antfu/no-import-dist, antfu/no-import-node-modules-by-path
+import { PlatformAccessory } from '../../node_modules/homebridge/dist/platformAccessory.js'
+import { repairCachedAccessories } from '../../src/cacheRepair.js'
+import { createDevice } from '../../src/deviceFactory.js'
+import { PLATFORM_NAME, PLUGIN_NAME } from '../../src/settings.js'
+import { SwitchBotHAPPlatform } from '../../src/SwitchBotHAPPlatform.js'
+import { normalizeTypeForMatter } from '../../src/utils.js'
+
+const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+const INFO = Service.AccessoryInformation.UUID
+
+async function startOnce(cache: any[] | undefined, devices: { id: string, type: string, name: string }[], mutate?: (json: any) => void) {
+  // Homebridge sets these when it registers an accessory; serialize() requires them.
+  const register = (accs: any[]) => accs.forEach((a) => {
+    a._associatedPlugin = PLUGIN_NAME
+    a._associatedPlatform = PLATFORM_NAME
+  })
+  const api = { hap: { Service, Characteristic, uuid }, platformAccessory: PlatformAccessory, registerPlatformAccessories: vi.fn((_p, _q, accs) => register(accs)), updatePlatformAccessories: vi.fn() }
+  const platform = Object.create(SwitchBotHAPPlatform.prototype) as any
+  platform.api = api
+  platform.log = log
+  platform.config = { devices: devices.map(d => ({ deviceId: d.id, configDeviceType: d.type })) }
+  platform.hapPushTargets = new Map()
+  platform.accessories = new Map()
+  for (const json of cache ?? []) {
+    mutate?.(json)
+    const acc: any = PlatformAccessory.deserialize(json) // the call that throws in #1424
+    platform.accessories.set(acc.UUID, acc)
+  }
+  const list = []
+  for (const d of devices) {
+    const type = normalizeTypeForMatter(d.type)
+    const _client = { getDeviceStatus: vi.fn(async () => ({})), setDeviceState: vi.fn(async () => ({ success: true })), getDevice: vi.fn(async () => undefined) }
+    const created = await createDevice({ id: d.id, type, deviceType: d.type, name: d.name, log } as any, { log, devices: platform.config.devices, _client } as any, false)
+    list.push({ created, d, type })
+  }
+  log.warn.mockClear()
+  await platform.registerHAPAccessories(list)
+  expect(log.warn).not.toHaveBeenCalled()
+  return [...platform.accessories.values()].map((a: any) => PlatformAccessory.serialize(a))
+}
+
+describe('hAP accessory cache across restarts (#1424)', () => {
+  const devices = [
+    { id: 'EA552551B763', type: 'Curtain3', name: 'Curtain3-1' },
+    { id: 'D83BDA1173CA', type: 'Plug', name: 'Plug-1' },
+  ]
+  const hasInfo = (cache: any[]) => cache.every(a => a.services.some((s: any) => s.UUID === INFO))
+
+  it('survives restarts', async () => {
+    let cache = await startOnce(undefined, devices)
+    expect(cache).toHaveLength(2)
+    for (let i = 0; i < 3; i++) cache = await startOnce(cache, devices)
+    expect(hasInfo(cache)).toBe(true)
+  })
+
+  // HAP restores a service whose class name was not stored as a plain `Service`. The plugin
+  // used to match services by class name, removed AccessoryInformation, and the next start crashed.
+  it('survives restarts with a cache whose services have no constructorName', async () => {
+    let cache = await startOnce(undefined, devices)
+    for (let i = 0; i < 3; i++) {
+      cache = await startOnce(cache, devices, json => json.services.forEach((s: any) => delete s.constructorName))
+    }
+    expect(hasInfo(cache)).toBe(true)
+  })
+
+  it('repairs a cache that is already missing AccessoryInformation, so the bridge can start', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'switchbot-cache-'))
+    const good = await startOnce(undefined, devices)
+    const broken = good.map(a => ({ ...a, services: a.services.filter((s: any) => s.UUID !== INFO) }))
+    const otherPlugin = { ...broken[0], plugin: 'homebridge-other', UUID: uuid.generate('other') }
+    const file = join(dir, 'cachedAccessories.0EF8A6716C95')
+    writeFileSync(file, JSON.stringify([...broken, otherPlugin]))
+    expect(() => PlatformAccessory.deserialize(broken[0])).toThrow('getCharacteristic')
+
+    const messages: string[] = []
+    const api: any = { hap, user: { cachedAccessoryPath: () => dir } }
+    const results = repairCachedAccessories(api, m => messages.push(m))
+
+    expect(results).toEqual([{ file, repaired: ['Curtain3-1', 'Plug-1'] }])
+    expect(messages[0]).toContain('Repaired 2 cached accessories')
+    expect(readdirSync(dir)).toContain('cachedAccessories.0EF8A6716C95.switchbot-repair.bak')
+    const repaired = JSON.parse(readFileSync(file, 'utf8'))
+    expect(repaired[2]).toEqual(otherPlugin) // other plugins' entries are left alone
+    let cache = await startOnce(repaired.slice(0, 2), devices)
+    cache = await startOnce(cache, devices)
+    expect(hasInfo(cache)).toBe(true)
+    // A second run finds nothing to do and does not rewrite the file.
+    expect(repairCachedAccessories(api)).toEqual([])
+  })
+
+  it('ignores missing directories, backups and unreadable files', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'switchbot-cache-'))
+    writeFileSync(join(dir, '.cachedAccessories.bak'), JSON.stringify([{ plugin: PLUGIN_NAME, services: [] }]))
+    writeFileSync(join(dir, 'cachedAccessories'), '{not json')
+    const messages: string[] = []
+    expect(repairCachedAccessories({ hap, user: { cachedAccessoryPath: () => dir } } as any, m => messages.push(m))).toEqual([])
+    expect(messages).toHaveLength(1)
+    expect(repairCachedAccessories({ hap, user: { cachedAccessoryPath: () => join(dir, 'missing') } } as any)).toEqual([])
+    expect(repairCachedAccessories({} as any)).toEqual([])
+  })
+})

package/test/utils/utils.spec.ts

@@ -29,6 +29,32 @@ describe('utils', () => {
     expect(result).not.toBe(input)
   })
 
+  // The config from #1424: credentials and options in the v4 layout, read by a v5 plugin that
+  // only looked at openApiToken/openApiSecret/enableBLE, so the OpenAPI was never configured.
+  it('normalizeConfig reads v4 credentials and options when the v5 keys are missing', () => {
+    const devices = [{ deviceId: 'EA552551B763', configDeviceType: 'Curtain3' }]
+    const result = normalizeConfig({
+      platform: 'SwitchBot',
+      credentials: { token: 'TOKEN', secret: 'SECRET', notice: 'Keep your Token & Secret a secret!' },
+      options: { BLE: false, discoverBLE: false, refreshRate: 180, logging: 'standard', devices },
+    } as any)
+    expect(result).toMatchObject({ openApiToken: 'TOKEN', openApiSecret: 'SECRET', enableBLE: false, openApiRefreshRate: 180, devices })
+  })
+
+  it('normalizeConfig prefers the v5 keys over v4 ones', () => {
+    const devices = [{ deviceId: 'A' }]
+    const result = normalizeConfig({
+      openApiToken: 'NEW',
+      openApiSecret: 'NEWSECRET',
+      enableBLE: true,
+      openApiRefreshRate: 600,
+      devices,
+      credentials: { token: 'OLD', secret: 'OLDSECRET' },
+      options: { BLE: false, refreshRate: 60, devices: [{ deviceId: 'B' }] },
+    } as any)
+    expect(result).toMatchObject({ openApiToken: 'NEW', openApiSecret: 'NEWSECRET', enableBLE: true, openApiRefreshRate: 600, devices })
+  })
+
   it('createPlatformProxy instantiates MatterPlatform if available and enabled', () => {
     const HAP = vi.fn()
     const Matter = vi.fn()

package/.github/npm-version-script-esm.js

@@ -1,100 +0,0 @@
-#!/bin/env node
-
-/**
- * This scripts queries the npm registry to pull out the latest version for a given tag.
- */
-
-import assert from 'node:assert'
-import child_process from 'node:child_process'
-import fs from 'node:fs'
-import process from 'node:process'
-
-const BRANCH_VERSION_PATTERN = /^([A-Z]+)-(\d+\.\d+\.\d+)$/i
-
-// Load the contents of the package.json file
-const packageJSON = JSON.parse(fs.readFileSync('package.json', 'utf8'))
-
-const refArgument = process.argv[2]
-const tagArgument = process.argv[3] || 'latest'
-
-if (!refArgument) {
-  console.error('ref argument is missing')
-  console.error('Usage: npm-version-script-esm.js <ref> [tag]')
-  process.exit(1)
-}
-
-/**
- * Queries the NPM registry for the latest version for the provided base version and tag.
- * If the tag is latest, then the base version is returned if it exists. For other tags, the latest
- * version found for that base version and tag is returned.
- * @param baseVersion The base version to query for, e.g. 2.0.0
- * @param tag The tag to query for, e.g. beta or latest
- * @returns {string} Returns the version, or '' if not found
- */
-function getTagVersionFromNpm(baseVersion, tag) {
-  try {
-    return JSON.parse(child_process.execSync(`npm info ${packageJSON.name} versions --json`).toString('utf8').trim())
-      .filter(v => tag === 'latest' ? v === baseVersion : v.startsWith(`${baseVersion}-${tag}.`)) // find all published versions for this base version and tag
-      .reduce((_, current) => current, '') // choose the last as they're sorted in ascending order, or '' if there are none
-  } catch (e) {
-    console.error(`Failed to query the npm registry for the latest version for tag: ${tag}`, e)
-    // throw e;
-    return ''
-  }
-}
-
-function desiredTargetVersion(ref) {
-  // ref is a GitHub action ref string
-  if (ref.startsWith('refs/pull/')) {
-    throw new Error('The version script was executed inside a PR!')
-  }
-
-  assert(ref.startsWith('refs/heads/'))
-  const branchName = ref.slice('refs/heads/'.length)
-
-  const results = branchName.match(BRANCH_VERSION_PATTERN)
-  if (results !== null) {
-    if (results[1] !== tagArgument) {
-      console.warn(`The base branch name (${results[1]}) differs from the tag name ${tagArgument}`)
-    }
-
-    return results[2]
-  }
-
-  throw new Error(`Malformed branch name for ref: ${ref}. Can't derive the base version. Use a branch name like: beta-x.x.x or alpha-x.x.x`)
-}
-
-// derive the base version from the branch ref
-const baseVersion = desiredTargetVersion(refArgument)
-
-// query the npm registry for the latest version of the provided tag name
-const latestReleasedVersion = getTagVersionFromNpm(baseVersion, tagArgument) // e.g. 0.7.0-beta.12
-
-let publishTag
-
-if (latestReleasedVersion) {
-  console.warn(`Latest published version for ${baseVersion} with tag ${tagArgument} is ${latestReleasedVersion}`)
-  publishTag = latestReleasedVersion // set this released beta or alpha to be incremented
-} else {
-  console.warn(`No published versions for ${baseVersion} with tag ${tagArgument}`)
-  publishTag = baseVersion // start off with a new beta or alpha version
-}
-
-if (packageJSON.version !== publishTag) {
-  // report the change for CI
-  console.warn(`Changing version in package.json from ${packageJSON.version} to ${publishTag}`)
-
-  // save the package.json
-  // JSON.stringify does not end with a newline, but npm writes both of these
-  // files with one. Leaving it off makes the file fail an eol-last lint rule,
-  // which breaks any repo whose prepublishOnly lints the whole tree.
-  packageJSON.version = publishTag
-  fs.writeFileSync('package.json', `${JSON.stringify(packageJSON, null, 2)}\n`)
-
-  // perform the same change to the package-lock.json
-  const packageLockJSON = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'))
-  packageLockJSON.version = publishTag
-  fs.writeFileSync('package-lock.json', `${JSON.stringify(packageLockJSON, null, 2)}\n`)
-} else {
-  console.warn(`Leaving version in package.json at ${packageJSON.version}`)
-}