@switchbot/homebridge-switchbot 5.0.0-beta.12 → 5.0.0-beta.121

package/src/utils.test.ts

@@ -1,96 +0,0 @@
-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

@@ -1,197 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import type { SwitchBotPlatformConfig } from './settings.js'
-
-// Create a minimal mock of the SwitchBotPlatform to test verifyConfig
-class MockSwitchBotPlatform {
-  config: SwitchBotPlatformConfig
-  errorLogCalls: string[] = []
-  debugLogCalls: string[] = []
-
-  constructor(config: SwitchBotPlatformConfig) {
-    this.config = config
-  }
-
-  errorLog(message: string) {
-    this.errorLogCalls.push(message)
-  }
-
-  debugLog(message: string) {
-    this.debugLogCalls.push(message)
-  }
-
-  debugWarnLog(message: string) {
-    this.debugLogCalls.push(`WARN: ${message}`)
-  }
-
-  debugErrorLog(message: string) {
-    this.debugLogCalls.push(`ERROR: ${message}`)
-  }
-
-  // Copy the exact verifyConfig method from the actual platform
-  async verifyConfig() {
-    this.debugLog('Verifying Config')
-    this.config = this.config || {}
-    this.config.options = this.config.options || {}
-
-    if (this.config.options) {
-      // Device Config
-      if (this.config.options.devices) {
-        for (const deviceConfig of this.config.options.devices) {
-          if (!deviceConfig.hide_device) {
-            if (!deviceConfig.deviceId) {
-              this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.')
-            }
-            if (!deviceConfig.configDeviceType && (deviceConfig as any).connectionType) {
-              this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.')
-            }
-          }
-        }
-      }
-
-      // IR Device Config
-      if (this.config.options.irdevices) {
-        for (const irDeviceConfig of this.config.options.irdevices) {
-          if (!irDeviceConfig.hide_device) {
-            if (!irDeviceConfig.deviceId) {
-              this.errorLog('The devices config section is missing the *Device ID* in the config. Please check your config.')
-            }
-            if (!irDeviceConfig.deviceId && !irDeviceConfig.configRemoteType) {
-              this.errorLog('The devices config section is missing the *Device Type* in the config. Please check your config.')
-            }
-          }
-        }
-      }
-    }
-
-    if (!this.config.credentials && !this.config.options) {
-      this.debugWarnLog('Missing Credentials')
-    } else if (this.config.credentials && !this.config.credentials.notice) {
-      if (!this.config.credentials?.token) {
-        this.debugErrorLog('Missing token')
-        this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work')
-      }
-      if (this.config.credentials?.token) {
-        if (!this.config.credentials?.secret) {
-          this.debugErrorLog('Missing secret')
-          this.debugWarnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work')
-        }
-      }
-    }
-  }
-}
-
-describe('verifyConfig fix for reboot loop', () => {
-  it('should log error instead of throwing when device config is missing deviceId', async () => {
-    const config: SwitchBotPlatformConfig = {
-      platform: 'SwitchBot',
-      name: 'SwitchBot',
-      credentials: {
-        token: 'test-token',
-        secret: 'test-secret',
-      },
-      options: {
-        devices: [
-          {
-            logging: 'standard',
-          } as any, // Missing deviceId
-        ],
-      },
-    }
-
-    const platform = new MockSwitchBotPlatform(config)
-
-    // 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.'
-    )
-  })
-
-  it('should log error instead of throwing when device config is missing configDeviceType with connectionType', async () => {
-    const config: SwitchBotPlatformConfig = {
-      platform: 'SwitchBot',
-      name: 'SwitchBot',
-      credentials: {
-        token: 'test-token',
-        secret: 'test-secret',
-      },
-      options: {
-        devices: [
-          {
-            deviceId: 'test-device-id',
-            connectionType: 'BLE',
-            // Missing configDeviceType
-          } as any,
-        ],
-      },
-    }
-
-    const platform = new MockSwitchBotPlatform(config)
-
-    // 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.'
-    )
-  })
-
-  it('should not log error when device config has hide_device set to true', async () => {
-    const config: SwitchBotPlatformConfig = {
-      platform: 'SwitchBot',
-      name: 'SwitchBot',
-      credentials: {
-        token: 'test-token',
-        secret: 'test-secret',
-      },
-      options: {
-        devices: [
-          {
-            hide_device: true,
-            // Missing deviceId but hidden
-          } as any,
-        ],
-      },
-    }
-
-    const platform = new MockSwitchBotPlatform(config)
-
-    // Should not throw or log errors because device is hidden
-    await expect(platform.verifyConfig()).resolves.not.toThrow()
-    expect(platform.errorLogCalls).toHaveLength(0)
-  })
-
-  it('should handle valid device config without errors', async () => {
-    const config: SwitchBotPlatformConfig = {
-      platform: 'SwitchBot',
-      name: 'SwitchBot',
-      credentials: {
-        token: 'test-token',
-        secret: 'test-secret',
-      },
-      options: {
-        devices: [
-          {
-            deviceId: 'test-device-id',
-            configDeviceType: 'Bot',
-            logging: 'standard',
-          } as any,
-        ],
-      },
-    }
-
-    const platform = new MockSwitchBotPlatform(config)
-
-    // 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*')
-    )).toHaveLength(0)
-  })
-})