@homebridge-plugins/homebridge-august 3.3.0-beta.0 → 3.3.0-beta.2

package/test/platform.matter.test.ts

@@ -0,0 +1,660 @@
+/* Copyright(C) 2021-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * platform.matter.test.ts: homebridge-august Matter platform tests.
+ */
+import type { API, Logging, MatterAccessory, PlatformAccessory } from 'homebridge'
+
+import type { AugustPlatformConfig } from '../src/settings.js'
+
+import { readFileSync } from 'node:fs'
+
+import August from 'august-yale'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { AugustMatterPlatform } from '../src/platform.matter.js'
+
+// Mock the august-yale module
+vi.mock('august-yale', () => {
+  // eslint-disable-next-line prefer-arrow-callback
+  const MockAugust = vi.fn().mockImplementation(function () {
+    return {
+      end: vi.fn(),
+      lock: vi.fn().mockResolvedValue(undefined),
+      unlock: vi.fn().mockResolvedValue(undefined),
+      details: vi.fn(),
+    }
+  })
+
+  const MockConstructor = MockAugust as any
+  MockConstructor.details = vi.fn()
+  MockConstructor.authorize = vi.fn()
+  MockConstructor.validate = vi.fn()
+  MockConstructor.subscribe = vi.fn().mockResolvedValue(() => {}) // returns unsubscribe fn by default
+
+  return {
+    default: MockConstructor,
+  }
+})
+
+// Mock file system
+vi.mock('node:fs', () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}))
+
+describe('augustMatterPlatform', () => {
+  let platform: AugustMatterPlatform
+  let mockApi: API
+  let mockLog: Logging
+  let mockConfig: AugustPlatformConfig
+  let mockMatterApi: any
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockMatterApi = {
+      uuid: { generate: vi.fn((id: string) => `matter-uuid-${id}`) },
+      deviceTypes: { DoorLock: { deviceType: 11 } },
+      types: {
+        DoorLock: {
+          LockState: {
+            NotFullyLocked: 0,
+            Locked: 1,
+            Unlocked: 2,
+          },
+        },
+      },
+      registerPlatformAccessories: vi.fn().mockResolvedValue(undefined),
+      updatePlatformAccessories: vi.fn().mockResolvedValue(undefined),
+      unregisterPlatformAccessories: vi.fn().mockResolvedValue(undefined),
+      updateAccessoryState: vi.fn().mockResolvedValue(undefined),
+      getAccessoryState: vi.fn().mockResolvedValue(undefined),
+    }
+
+    mockApi = {
+      hap: {
+        uuid: { generate: vi.fn(() => 'hap-uuid') },
+      },
+      user: {
+        configPath: vi.fn(() => '/mock/config.json'),
+      },
+      on: vi.fn(),
+      registerPlatformAccessories: vi.fn(),
+      updatePlatformAccessories: vi.fn(),
+      unregisterPlatformAccessories: vi.fn(),
+      publishExternalAccessories: vi.fn(),
+      isMatterAvailable: vi.fn(() => true),
+      isMatterEnabled: vi.fn(() => true),
+      matter: mockMatterApi,
+    } as unknown as API
+
+    mockLog = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+      success: vi.fn(),
+    } as any
+
+    mockConfig = {
+      platform: 'August',
+      name: 'Test August',
+      credentials: {
+        augustId: 'test@example.com',
+        password: 'testpassword',
+        countryCode: 'US',
+        installId: 'test-install-id',
+        isValidated: true,
+      },
+      options: {
+        logging: 'debug',
+      },
+    }
+
+    vi.mocked(readFileSync).mockReturnValue(JSON.stringify({
+      platforms: [mockConfig],
+    }))
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  describe('configureAccessory', () => {
+    it('should stage (not immediately unregister) cached HAP accessories for deferred cleanup', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const hapAccessory = {
+        UUID: 'hap-uuid-1',
+        displayName: 'Front Door',
+      } as unknown as PlatformAccessory
+
+      await platform.configureAccessory(hapAccessory)
+
+      // HAP accessory should NOT be unregistered immediately; deferred until Matter registration succeeds
+      expect(mockApi.unregisterPlatformAccessories).not.toHaveBeenCalled()
+    })
+
+    it('should unregister staged HAP accessory after successful Matter registration', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const device = {
+        lockId: 'lock-abc',
+        LockName: 'Front Door',
+        SerialNumber: 'SN123',
+        skuNumber: 'AUG-SL05',
+        currentFirmwareVersion: '1.2.3',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      // Stage a HAP accessory with UUID matching what matterApi.uuid.generate will return for this lockId
+      const hapAccessory = {
+        UUID: 'matter-uuid-lock-abc',
+        displayName: 'Front Door',
+      } as unknown as PlatformAccessory
+      await platform.configureAccessory(hapAccessory)
+
+      await (platform as any).Lock(device)
+
+      // After Matter registration succeeds, the staged HAP accessory should be unregistered
+      expect(mockApi.unregisterPlatformAccessories).toHaveBeenCalledWith(
+        'homebridge-august',
+        'August',
+        [hapAccessory],
+      )
+    })
+
+    it('should not add HAP accessories to the accessories cache', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const hapAccessory = {
+        UUID: 'hap-uuid-2',
+        displayName: 'Back Door',
+      } as unknown as PlatformAccessory
+
+      await platform.configureAccessory(hapAccessory)
+
+      // accessories array from the HAP base class should remain empty
+      expect(platform.accessories).toHaveLength(0)
+    })
+  })
+
+  describe('configureMatterAccessory', () => {
+    it('should store Matter accessories in the matterAccessories map', () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const matterAccessory = {
+        UUID: 'matter-uuid-lock1',
+        displayName: 'Front Door',
+        deviceType: { deviceType: 11 },
+        serialNumber: 'ABC123',
+        manufacturer: 'August Home Inc.',
+        model: 'AUG-SL05',
+        context: { lockId: 'lock1' },
+      } as unknown as MatterAccessory
+
+      platform.configureMatterAccessory(matterAccessory)
+
+      expect(platform.matterAccessories.has('matter-uuid-lock1')).toBe(true)
+      expect(platform.matterAccessories.get('matter-uuid-lock1')).toBe(matterAccessory)
+    })
+  })
+
+  describe('lock (Matter accessory registration)', () => {
+    it('should register a new Matter DoorLock accessory when Matter API is available', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const device = {
+        lockId: 'lock-abc',
+        LockName: 'Front Door',
+        SerialNumber: 'SN123',
+        skuNumber: 'AUG-SL05',
+        currentFirmwareVersion: '1.2.3',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      // Expose the protected Lock method for testing
+      await (platform as any).Lock(device)
+
+      expect(mockMatterApi.registerPlatformAccessories).toHaveBeenCalledOnce()
+      const [pluginName, platformName, accessories] = mockMatterApi.registerPlatformAccessories.mock.calls[0]
+      expect(pluginName).toBe('homebridge-august')
+      expect(platformName).toBe('August')
+      expect(accessories).toHaveLength(1)
+      expect(accessories[0].deviceType).toBe(mockMatterApi.deviceTypes.DoorLock)
+      expect(accessories[0].manufacturer).toBe('August Home Inc.')
+      expect(accessories[0].serialNumber).toBe('SN123')
+    })
+
+    it('should restore an existing cached Matter accessory', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const uuid = 'matter-uuid-lock-abc'
+      const cachedAccessory: MatterAccessory = {
+        UUID: uuid,
+        displayName: 'Front Door',
+        deviceType: { deviceType: 11 } as any,
+        serialNumber: 'SN123',
+        manufacturer: 'August Home Inc.',
+        model: 'AUG-SL05',
+        context: { lockId: 'lock-abc' },
+      }
+      platform.configureMatterAccessory(cachedAccessory)
+
+      const device = {
+        lockId: 'lock-abc',
+        LockName: 'Front Door',
+        SerialNumber: 'SN123',
+        skuNumber: 'AUG-SL05',
+        currentFirmwareVersion: '1.2.3',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      // re-registers to update handlers
+      expect(mockMatterApi.registerPlatformAccessories).toHaveBeenCalledOnce()
+      // Should have logged the "Restoring" message
+      expect(mockLog.info).toHaveBeenCalledWith(expect.stringContaining('Restoring existing Matter accessory'))
+    })
+
+    it('should unregister stale Matter accessory when device is hidden', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const uuid = 'matter-uuid-hidden-lock'
+      mockMatterApi.uuid.generate.mockReturnValueOnce(uuid)
+
+      const cachedAccessory: MatterAccessory = {
+        UUID: uuid,
+        displayName: 'Hidden Lock',
+        deviceType: { deviceType: 11 } as any,
+        serialNumber: 'SN456',
+        manufacturer: 'August Home Inc.',
+        model: 'AUG-SL05',
+        context: { lockId: 'hidden-lock' },
+      }
+      platform.configureMatterAccessory(cachedAccessory)
+
+      const device = {
+        lockId: 'hidden-lock',
+        LockName: 'Hidden Lock',
+        SerialNumber: 'SN456',
+        hide_device: true, // hidden device
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      // Should unregister the stale accessory
+      expect(mockMatterApi.unregisterPlatformAccessories).toHaveBeenCalledWith(
+        'homebridge-august',
+        'August',
+        [cachedAccessory],
+      )
+      expect(platform.matterAccessories.has(uuid)).toBe(false)
+      expect(mockMatterApi.registerPlatformAccessories).not.toHaveBeenCalled()
+    })
+
+    it('should not register when Matter API is unavailable', async () => {
+      const apiWithoutMatter = {
+        ...mockApi,
+        matter: null as any,
+      }
+      platform = new AugustMatterPlatform(mockLog, mockConfig, apiWithoutMatter as any)
+
+      const device = {
+        lockId: 'lock-xyz',
+        LockName: 'Some Lock',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      expect(mockMatterApi.registerPlatformAccessories).not.toHaveBeenCalled()
+    })
+
+    it('should set initial lockState to 0 (NotFullyLocked) until first poll resolves', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const device = {
+        lockId: 'lock-nullstate',
+        LockName: 'Null State Lock',
+        SerialNumber: 'SN789',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      const registeredAccessory = mockMatterApi.registerPlatformAccessories.mock.calls[0][2][0] as MatterAccessory
+      expect(registeredAccessory.clusters?.doorLock?.lockState).toBe(0)
+    })
+  })
+
+  describe('fetchAndUpdateMatterLockState', () => {
+    // Helper: install a mock connectivity manager whose execute() runs
+    // the supplied fn against a mock August client. This mirrors the
+    // production path (platform.connectivity.execute(label, fn) ->
+    // fn(client)) without spinning up the real ConnectivityManager.
+    function installConnectivityMock(p: AugustMatterPlatform, client: any) {
+      ;(p as any).connectivity = {
+        getState: () => 'healthy',
+        execute: vi.fn(async (_label: string, fn: (c: any) => Promise<any>) => {
+          try {
+            return await fn(client)
+          } catch {
+            // execute() returns undefined on failure rather than
+            // rethrowing (unless throwOnOffline:true). Match that.
+            return undefined
+          }
+        }),
+      }
+    }
+
+    it('should update lockState to 1 (Locked) when lock is locked', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const mockDetailsResult = { LockStatus: { state: { locked: true, unlocked: false } } }
+      installConnectivityMock(platform, { details: vi.fn().mockResolvedValue(mockDetailsResult) })
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi)
+
+      expect(mockMatterApi.updateAccessoryState).toHaveBeenCalledWith('test-uuid', 'doorLock', { lockState: 1 })
+    })
+
+    it('should update lockState to 2 (Unlocked) when lock is unlocked', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const mockDetailsResult = { LockStatus: { state: { locked: false, unlocked: true } } }
+      installConnectivityMock(platform, { details: vi.fn().mockResolvedValue(mockDetailsResult) })
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi)
+
+      expect(mockMatterApi.updateAccessoryState).toHaveBeenCalledWith('test-uuid', 'doorLock', { lockState: 2 })
+    })
+
+    it('should update lockState to 0 (NotFullyLocked) for ambiguous state', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const mockDetailsResult = { LockStatus: { state: { locked: false, unlocked: false } } }
+      installConnectivityMock(platform, { details: vi.fn().mockResolvedValue(mockDetailsResult) })
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi)
+
+      expect(mockMatterApi.updateAccessoryState).toHaveBeenCalledWith('test-uuid', 'doorLock', { lockState: 0 })
+    })
+
+    it('should not throw when August API details call fails', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      installConnectivityMock(platform, { details: vi.fn().mockRejectedValue(new Error('API error')) })
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await expect(
+        platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi),
+      ).resolves.toBeUndefined()
+
+      expect(mockMatterApi.updateAccessoryState).not.toHaveBeenCalled()
+    })
+
+    it('should not call updateAccessoryState when connectivity is not initialized', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+      // connectivity is not set
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await expect(
+        platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi),
+      ).resolves.toBeUndefined()
+
+      expect(mockMatterApi.updateAccessoryState).not.toHaveBeenCalled()
+    })
+
+    it('should not throw when execute returns undefined (offline / failed)', async () => {
+      // The previous "retry with session refresh" test asserted that the
+      // matter path called refreshAugustSession() after a 502. That
+      // explicit retry layer is gone — ConnectivityManager handles
+      // retry/probe/rebuild internally. From the matter path's
+      // perspective, the only observable is: execute() either returned
+      // a result, or it returned undefined.
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+      ;(platform as any).connectivity = {
+        getState: () => 'offline',
+        execute: vi.fn().mockResolvedValue(undefined),
+      }
+
+      const device = { lockId: 'lock-test', LockName: 'Test Lock' } as any
+
+      await expect(
+        platform.fetchAndUpdateMatterLockState(device, 'test-uuid', mockMatterApi),
+      ).resolves.toBeUndefined()
+
+      expect(mockMatterApi.updateAccessoryState).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('pubNub subscription lifecycle (Matter path equivalent of PR #206)', () => {
+    it('should capture unsubscribe function from August.subscribe()', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const mockUnsubscribe = vi.fn()
+      vi.mocked(August.subscribe).mockResolvedValueOnce(mockUnsubscribe)
+
+      const device = {
+        lockId: 'lock-sub',
+        LockName: 'Sub Lock',
+        SerialNumber: 'SN001',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      // The unsubscribe should be stored in the internal map
+      const uuid = mockMatterApi.uuid.generate('lock-sub')
+      const stored = (platform as any).matterPubNubUnsubscribes.get(uuid)
+      expect(stored).toBe(mockUnsubscribe)
+    })
+
+    it('should tear down PubNub subscription when device is hidden (stale accessory removal)', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const uuid = 'matter-uuid-hidden-sub'
+      mockMatterApi.uuid.generate.mockReturnValueOnce(uuid)
+
+      const mockUnsubscribe = vi.fn()
+      ;(platform as any).matterPubNubUnsubscribes.set(uuid, mockUnsubscribe)
+
+      const cachedAccessory: MatterAccessory = {
+        UUID: uuid,
+        displayName: 'Hidden Lock',
+        deviceType: { deviceType: 11 } as any,
+        serialNumber: 'SN002',
+        manufacturer: 'August Home Inc.',
+        model: 'AUG-SL05',
+        context: { lockId: 'hidden-sub' },
+      }
+      platform.configureMatterAccessory(cachedAccessory)
+
+      const device = {
+        lockId: 'hidden-sub',
+        LockName: 'Hidden Lock',
+        hide_device: true,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      expect(mockUnsubscribe).toHaveBeenCalledOnce()
+      expect((platform as any).matterPubNubUnsubscribes.has(uuid)).toBe(false)
+    })
+  })
+
+  describe('polling subscription lifecycle', () => {
+    it('should track the polling subscription so it can be disposed', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const device = {
+        lockId: 'lock-poll-track',
+        LockName: 'Tracked Lock',
+        SerialNumber: 'SN100',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      const uuid = mockMatterApi.uuid.generate('lock-poll-track')
+      const stored = (platform as any).matterPollingSubscriptions.get(uuid)
+      expect(stored).toBeDefined()
+      expect(typeof stored.unsubscribe).toBe('function')
+    })
+
+    it('should dispose previous polling subscription before starting a new one (idempotent)', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const device = {
+        lockId: 'lock-poll-idem',
+        LockName: 'Idempotent Lock',
+        SerialNumber: 'SN101',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      const uuid = mockMatterApi.uuid.generate('lock-poll-idem')
+      const firstSub = (platform as any).matterPollingSubscriptions.get(uuid)
+      const firstUnsubSpy = vi.spyOn(firstSub, 'unsubscribe')
+
+      // Call polling again (simulating re-registration)
+      ;(platform as any).startMatterStatusPolling(device, uuid, mockMatterApi)
+
+      // Previous subscription should have been disposed
+      expect(firstUnsubSpy).toHaveBeenCalledOnce()
+      // A new subscription should be stored
+      const secondSub = (platform as any).matterPollingSubscriptions.get(uuid)
+      expect(secondSub).toBeDefined()
+      expect(secondSub).not.toBe(firstSub)
+    })
+
+    it('should dispose polling subscription when device is hidden', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      const uuid = 'matter-uuid-hidden-poll'
+      mockMatterApi.uuid.generate.mockReturnValueOnce(uuid)
+
+      const fakeSubscription = { unsubscribe: vi.fn() }
+      ;(platform as any).matterPollingSubscriptions.set(uuid, fakeSubscription)
+
+      const device = {
+        lockId: 'hidden-poll',
+        LockName: 'Hidden Poll Lock',
+        hide_device: true,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      expect(fakeSubscription.unsubscribe).toHaveBeenCalledOnce()
+      expect((platform as any).matterPollingSubscriptions.has(uuid)).toBe(false)
+    })
+
+    it('should not start polling when refreshRate is 0', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+      ;(platform as any).platformRefreshRate = 0
+
+      const device = {
+        lockId: 'lock-no-poll',
+        LockName: 'No Poll Lock',
+        SerialNumber: 'SN102',
+        hide_device: false,
+        homeKitEnabled: false,
+      } as any
+
+      await (platform as any).Lock(device)
+
+      const uuid = mockMatterApi.uuid.generate('lock-no-poll')
+      expect((platform as any).matterPollingSubscriptions.has(uuid)).toBe(false)
+    })
+  })
+
+  describe('pendingHapCleanup sweep after discovery', () => {
+    it('should unregister staged HAP accessories that were not handled during discovery', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      // Stage two HAP accessories from a previous session
+      const orphanedHap1 = { UUID: 'hap-orphan-1', displayName: 'Removed Lock 1' } as unknown as PlatformAccessory
+      const orphanedHap2 = { UUID: 'hap-orphan-2', displayName: 'Removed Lock 2' } as unknown as PlatformAccessory
+      await platform.configureAccessory(orphanedHap1)
+      await platform.configureAccessory(orphanedHap2)
+
+      // Stub super.discoverDevices so it's a no-op (doesn't touch pendingHapCleanup)
+      const baseProto = Object.getPrototypeOf(Object.getPrototypeOf(platform))
+      vi.spyOn(baseProto, 'discoverDevices').mockResolvedValue(undefined as never)
+
+      await platform.discoverDevices()
+
+      // Both staged HAP accessories should have been unregistered since neither
+      // had a matching Lock() call during discovery
+      expect(mockApi.unregisterPlatformAccessories).toHaveBeenCalledWith(
+        'homebridge-august',
+        'August',
+        expect.arrayContaining([orphanedHap1, orphanedHap2]),
+      )
+      // Map should be empty after the sweep
+      expect((platform as any).pendingHapCleanup.size).toBe(0)
+    })
+
+    it('should leave handled HAP accessories alone (those already removed by Lock())', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      // Simulate a successful Lock() having already cleaned its entry
+      // (pendingHapCleanup is empty)
+      const baseProto = Object.getPrototypeOf(Object.getPrototypeOf(platform))
+      vi.spyOn(baseProto, 'discoverDevices').mockResolvedValue(undefined as never)
+
+      await platform.discoverDevices()
+
+      // unregisterPlatformAccessories should not be called — nothing to sweep
+      expect(mockApi.unregisterPlatformAccessories).not.toHaveBeenCalled()
+    })
+
+    it('should only sweep the orphans, not the locks that were successfully migrated', async () => {
+      platform = new AugustMatterPlatform(mockLog, mockConfig, mockApi)
+
+      // One lock that will be migrated (has matching active lock in account)
+      // and one orphan that no longer exists in the account
+      const migrated = { UUID: 'hap-migrated', displayName: 'Still Active' } as unknown as PlatformAccessory
+      const orphan = { UUID: 'hap-orphan', displayName: 'Deleted From Account' } as unknown as PlatformAccessory
+      await platform.configureAccessory(migrated)
+      await platform.configureAccessory(orphan)
+
+      // Simulate a successful Lock() call for the 'migrated' UUID by removing
+      // that entry from pendingHapCleanup directly (mimicking what Lock() does).
+      const baseProto = Object.getPrototypeOf(Object.getPrototypeOf(platform))
+      vi.spyOn(baseProto, 'discoverDevices').mockImplementation(async () => {
+        (platform as any).pendingHapCleanup.delete('hap-migrated')
+      })
+
+      await platform.discoverDevices()
+
+      // Only the orphan should have been unregistered in the sweep
+      expect(mockApi.unregisterPlatformAccessories).toHaveBeenCalledOnce()
+      const swept = (mockApi.unregisterPlatformAccessories as any).mock.calls[0][2]
+      expect(swept).toContain(orphan)
+      expect(swept).not.toContain(migrated)
+    })
+  })
+})

package/test/platform.polling.test.ts

@@ -33,7 +33,7 @@ import { readFileSync } from 'node:fs'
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-import { AugustPlatformHAP } from '../src/Platform.HAP.js'
+import { AugustPlatform } from '../src/Platform.HAP.js'
 
 // Same mock conventions as the rest of the suite.
 vi.mock('august-yale', () => {
@@ -57,7 +57,7 @@ vi.mock('node:fs', () => ({
 // execute() runs the supplied fn against a fake "client" passed through
 // from the test. Returns the underlying mock execute fn for assertions.
 function installConnectivity(
-  platform: AugustPlatformHAP,
+  platform: AugustPlatform,
   client: any,
   state: 'healthy' | 'degraded' | 'offline' | 'recovering' = 'healthy',
 ) {
@@ -78,7 +78,7 @@ function installConnectivity(
 // Helper: register N stub LockMechanism objects on the platform. Each
 // has its own lockId and a vi.fn() applyRefresh. Returns the array of
 // stubs in registration order.
-function registerLocks(platform: AugustPlatformHAP, count: number) {
+function registerLocks(platform: AugustPlatform, count: number) {
   const locks: any[] = []
   for (let i = 0; i < count; i++) {
     const lock = {
@@ -94,7 +94,7 @@ function registerLocks(platform: AugustPlatformHAP, count: number) {
 }
 
 describe('augustPlatform.startPolling', () => {
-  let platform: AugustPlatformHAP
+  let platform: AugustPlatform
   let mockApi: API
   let mockLog: Logging
   let mockConfig: AugustPlatformConfig
@@ -137,7 +137,7 @@ describe('augustPlatform.startPolling', () => {
       options: { logging: 'debug' },
     }
 
-    platform = new AugustPlatformHAP(mockLog, mockConfig, mockApi)
+    platform = new AugustPlatform(mockLog, mockConfig, mockApi)
     // Force a deterministic poll interval (1s) so tests can advance
     // time precisely.
     ;(platform as any).platformRefreshRate = 1