homebridge-tuya-plus 3.14.0-dev.5 → 3.14.0-dev.52

package/test/TuyaDevice.test.js

@@ -0,0 +1,266 @@
+'use strict';
+
+// The LAN backend opens real TCP sockets; stub it so attachLan() can be tested
+// without touching the network. Cloud backend stays real (it's inert with
+// connect:false).
+jest.mock('../lib/TuyaAccessory', () => jest.fn().mockImplementation(function(props) {
+    this.context = {...props};
+    this.connected = false;
+    this.state = {};
+    this.update = jest.fn().mockReturnValue(true);
+    this.on = jest.fn();
+    this._connect = jest.fn();
+}));
+
+const EventEmitter = require('events');
+const TuyaDevice = require('../lib/TuyaDevice');
+const TuyaCloudDevice = require('../lib/TuyaCloudDevice');
+
+const log = {info: () => {}, warn: () => {}, error: () => {}, debug: () => {}};
+
+// A minimal stand-in for either backend (TuyaAccessory / TuyaCloudDevice): an
+// EventEmitter exposing the surface TuyaDevice routes through.
+function fakeBackend(extra = {}) {
+    const b = new EventEmitter();
+    b.connected = false;
+    b.state = {};
+    b.update = jest.fn().mockReturnValue(true);
+    b.codeByDpId = {};
+    b.dpIdByCode = {};
+    b._connect = jest.fn();
+    return Object.assign(b, extra);
+}
+
+function makeDevice(props = {}) {
+    return new TuyaDevice({id: 'dev1', key: 'k', name: 'Lamp', type: 'switch', log, connect: false, ...props});
+}
+
+// Attach fake backends to a device and wire their events (white-box, so the merge
+// / fallback logic can be exercised without any real network).
+function withBackends(dev, {lan, cloud} = {}) {
+    if (cloud) { dev.cloud = cloud; dev._wire(cloud, 'cloud'); }
+    if (lan) { dev.lan = lan; dev._wire(lan, 'lan'); }
+    return dev;
+}
+
+describe('TuyaDevice — connectivity', () => {
+    test('connected reflects either backend', () => {
+        const dev = makeDevice();
+        const lan = fakeBackend();
+        const cloud = fakeBackend();
+        withBackends(dev, {lan, cloud});
+
+        expect(dev.connected).toBe(false);
+        lan.connected = true;
+        expect(dev.connected).toBe(true);
+        lan.connected = false;
+        cloud.connected = true;
+        expect(dev.connected).toBe(true);
+    });
+
+    test("'connect' is emitted once, on the first backend to connect", () => {
+        const dev = makeDevice();
+        const lan = fakeBackend();
+        const cloud = fakeBackend();
+        withBackends(dev, {lan, cloud});
+
+        let connects = 0;
+        dev.on('connect', () => connects++);
+        lan.emit('connect');
+        cloud.emit('connect');
+        expect(connects).toBe(1);
+    });
+});
+
+describe('TuyaDevice — pure LAN (no cloud) preserves legacy behaviour', () => {
+    test('update returns the synchronous boolean from the LAN backend', () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true});
+        withBackends(dev, {lan});
+
+        lan.update.mockReturnValue(true);
+        expect(dev.update({'1': false})).toBe(true);
+        expect(lan.update).toHaveBeenCalledWith({'1': false});
+
+        lan.update.mockReturnValue(false);
+        expect(dev.update({'1': true})).toBe(false);
+    });
+
+    test('update is false when there is no transport at all', () => {
+        const dev = makeDevice();
+        expect(dev.update({'1': true})).toBe(false);
+    });
+});
+
+describe('TuyaDevice — state merge & registration', () => {
+    test('first change drives registration and exposes the merged state', () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true, state: {'1': true, '2': 50}});
+        withBackends(dev, {lan});
+
+        const seen = [];
+        dev.on('change', (changes, state) => seen.push({changes, state}));
+        lan.emit('change');
+
+        expect(seen).toHaveLength(1);
+        expect(seen[0].state).toEqual({'1': true, '2': 50});
+    });
+
+    test('LAN wins over the cloud while connected; cloud-only DPs are kept; LAN is mirrored to codes', () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true, state: {'1': true}});
+        const cloud = fakeBackend({
+            connected: true,
+            state: {'switch_led': false, '1': false, 'battery_percentage': 80},
+            codeByDpId: {'1': 'switch_led'},
+            dpIdByCode: {'switch_led': '1'}
+        });
+        withBackends(dev, {lan, cloud});
+
+        lan.emit('change');
+        expect(dev.state['1']).toBe(true);                 // LAN value wins
+        expect(dev.state['switch_led']).toBe(true);        // …mirrored to its code
+        expect(dev.state['battery_percentage']).toBe(80);  // cloud-only DP retained
+    });
+
+    test('when the LAN drops, the cloud takes over and the change is emitted', () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true, state: {'1': true}});
+        const cloud = fakeBackend({connected: true, state: {'1': false}});
+        withBackends(dev, {lan, cloud});
+
+        lan.emit('change');
+        expect(dev.state['1']).toBe(true);
+
+        lan.connected = false; // LAN lost
+        const seen = [];
+        dev.on('change', changes => seen.push(changes));
+        cloud.emit('change');
+
+        expect(dev.state['1']).toBe(false);
+        expect(seen[0]).toEqual({'1': false});
+    });
+});
+
+describe('TuyaDevice — writes with fallback', () => {
+    test('LAN is used first when both backends are up', async () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true});
+        const cloud = fakeBackend({connected: true, update: jest.fn().mockResolvedValue(true)});
+        withBackends(dev, {lan, cloud});
+
+        await expect(dev.update({'1': true})).resolves.toBe(true);
+        expect(lan.update).toHaveBeenCalledWith({'1': true});
+        expect(cloud.update).not.toHaveBeenCalled();
+    });
+
+    test('a failed LAN write falls back to the cloud', async () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true, update: jest.fn().mockReturnValue(false)});
+        const cloud = fakeBackend({connected: true, update: jest.fn().mockResolvedValue(true)});
+        withBackends(dev, {lan, cloud});
+
+        await expect(dev.update({'1': true})).resolves.toBe(true);
+        expect(cloud.update).toHaveBeenCalledWith({'1': true});
+    });
+
+    test('with the LAN down, writes go straight to the cloud (raw keys; the cloud translates)', async () => {
+        const dev = makeDevice();
+        const cloud = fakeBackend({connected: true, update: jest.fn().mockResolvedValue(true)});
+        withBackends(dev, {cloud});
+
+        await expect(dev.update({'switch_led': true})).resolves.toBe(true);
+        expect(cloud.update).toHaveBeenCalledWith({'switch_led': true});
+    });
+
+    test('a code-style write is translated to numeric ids for the LAN', async () => {
+        const dev = makeDevice();
+        const lan = fakeBackend({connected: true, update: jest.fn().mockReturnValue(true)});
+        const cloud = fakeBackend({connected: true, dpIdByCode: {'switch_led': '1'}, codeByDpId: {'1': 'switch_led'}});
+        withBackends(dev, {lan, cloud});
+
+        await dev.update({'switch_led': true});
+        expect(lan.update).toHaveBeenCalledWith({'1': true});
+    });
+
+    test('update resolves false when nothing is reachable', async () => {
+        const dev = makeDevice();
+        const cloud = fakeBackend({connected: false, update: jest.fn()});
+        withBackends(dev, {cloud});
+        await expect(dev.update({'1': true})).resolves.toBe(false);
+    });
+});
+
+describe('TuyaDevice — registration source guard', () => {
+    test('a LAN-primary device defers cloud-driven registration until it has the map or the LAN grace elapses', () => {
+        const dev = makeDevice();                  // has a key → LAN-primary
+        dev.cloud = fakeBackend({codeByDpId: {}});  // cloud, but no numeric map yet
+
+        expect(dev._mayRegisterFrom('lan')).toBe(true);
+        expect(dev._mayRegisterFrom('cloud')).toBe(false);
+
+        dev.cloud.codeByDpId = {'1': 'switch_led'}; // map learned → safe
+        expect(dev._mayRegisterFrom('cloud')).toBe(true);
+
+        dev.cloud.codeByDpId = {};
+        dev._lanGraceElapsed = true;                // …or the LAN had its head start
+        expect(dev._mayRegisterFrom('cloud')).toBe(true);
+    });
+
+    test('a keyless (cloud-only) device registers off the cloud immediately', () => {
+        const keyless = makeDevice({key: undefined});
+        keyless.cloud = fakeBackend({codeByDpId: {}});
+        expect(keyless._mayRegisterFrom('cloud')).toBe(true);
+    });
+});
+
+describe('TuyaDevice — composition', () => {
+    test('a cloud backend is built when a shared cloud session is supplied', () => {
+        const api = {
+            isConfigured: () => true,
+            getStatus: jest.fn().mockResolvedValue([]),
+            getDeviceInfo: jest.fn().mockResolvedValue({online: true}),
+            sendCommands: jest.fn()
+        };
+        const dev = makeDevice({cloudApi: api});
+        expect(dev.cloud).toBeInstanceOf(TuyaCloudDevice);
+        expect(dev.lan).toBeNull();
+    });
+
+    test('no cloud backend without a shared session', () => {
+        const dev = makeDevice();
+        expect(dev.cloud).toBeNull();
+    });
+
+    test('the cloud backend can see whether the LAN path is currently up', () => {
+        const api = {
+            isConfigured: () => true,
+            getStatus: jest.fn().mockResolvedValue([]),
+            getDeviceInfo: jest.fn().mockResolvedValue({online: true}),
+            sendCommands: jest.fn()
+        };
+        const dev = makeDevice({cloudApi: api});
+
+        expect(dev.cloud.isLanConnected()).toBe(false); // no LAN attached yet
+        dev.lan = {connected: true};
+        expect(dev.cloud.isLanConnected()).toBe(true);  // reflects live LAN state
+    });
+
+    test('attachLan builds the LAN backend with the discovered version (forceVersion still wins)', () => {
+        const dev = makeDevice({ip: '10.0.0.5'});
+        dev.attachLan({ip: '10.0.0.9', version: '3.3'});
+        expect(dev.lan).not.toBeNull();
+        expect(dev.lan.context.ip).toBe('10.0.0.9');
+        expect(dev.lan.context.version).toBe('3.3');
+
+        const forced = makeDevice({forceVersion: '3.5'});
+        forced.attachLan({ip: '10.0.0.9', version: '3.3'});
+        expect(forced.lan.context.version).toBe('3.5');
+    });
+
+    test('attachLan is a no-op without a local key (cloud-only device)', () => {
+        const dev = makeDevice({key: undefined});
+        dev.attachLan({ip: '10.0.0.9'});
+        expect(dev.lan).toBeNull();
+    });
+});

package/test/getCategory.test.js

@@ -23,6 +23,7 @@ const CLASS_DEF = {
     garagedoor: require('../lib/GarageDoorAccessory'),
     simplegaragedoor: require('../lib/SimpleGarageDoorAccessory'),
     simpledimmer: require('../lib/SimpleDimmerAccessory'),
+    wleddimmer: require('../lib/WledDimmerAccessory'),
     simpledimmer2: require('../lib/SimpleDimmer2Accessory'),
     simpleblinds: require('../lib/SimpleBlindsAccessory'),
     simpleheater: require('../lib/SimpleHeaterAccessory'),

package/test/index.test.js

@@ -0,0 +1,271 @@
+'use strict';
+
+// Mock every module that would touch the network or HAP, so we can exercise the
+// platform's orchestration (cloud-session setup, per-device cloud policy, and
+// discovery -> attachLan routing) in isolation.
+jest.mock('../lib/TuyaDevice', () => jest.fn().mockImplementation(function(props) {
+    this.context = {...props};
+    this.cloud = props.cloudApi ? {} : null; // truthy iff a shared cloud session was handed in
+    this.attachLan = jest.fn();
+    this._connect = jest.fn();
+}));
+jest.mock('../lib/TuyaAccessory', () => jest.fn().mockImplementation(function(props) {
+    this.context = {...props};
+    this._connect = jest.fn();
+}));
+jest.mock('../lib/TuyaCloudApi', () => jest.fn().mockImplementation(function(cfg) {
+    this.endpoint = 'https://openapi.example.com';
+    this.cfg = cfg;
+    this.getDeviceInfo = jest.fn();
+}));
+jest.mock('../lib/TuyaCloudMessaging', () => jest.fn().mockImplementation(function() {}));
+jest.mock('../lib/TuyaDiscovery', () => ({
+    start: jest.fn(function() { return this; }),
+    on: jest.fn(function() { return this; })
+}));
+
+const TuyaDevice = require('../lib/TuyaDevice');
+const TuyaAccessory = require('../lib/TuyaAccessory');
+const TuyaCloudApi = require('../lib/TuyaCloudApi');
+const TuyaCloudMessaging = require('../lib/TuyaCloudMessaging');
+const TuyaDiscovery = require('../lib/TuyaDiscovery');
+
+const makeHap = () => ({
+    Characteristic: class { setProps() { return this; } getDefaultValue() { return 0; } },
+    Formats: {FLOAT: 'float', UINT32: 'uint32', UINT16: 'uint16'},
+    Perms: {READ: 'pr', NOTIFY: 'ev', WRITE: 'pw'},
+    Categories: {OTHER: 1, SWITCH: 8, SPRINKLER: 28},
+    Service: {AccessoryInformation: {UUID: '3E'}},
+    uuid: {generate: s => 'uuid:' + s}
+});
+
+// Load the platform factory and capture the registered platform class.
+const factory = require('../index');
+function getPlatformClass() {
+    let cls;
+    factory({
+        platformAccessory: function() {},
+        hap: makeHap(),
+        registerPlatform: (pluginName, platformName, c) => { cls = c; }
+    });
+    return cls;
+}
+
+function makeLog() {
+    const log = jest.fn();
+    log.info = jest.fn(); log.warn = jest.fn(); log.error = jest.fn(); log.debug = jest.fn();
+    return log;
+}
+
+function makeApi() {
+    return {hap: makeHap(), on: jest.fn(), registerPlatformAccessories: jest.fn(), unregisterPlatformAccessories: jest.fn()};
+}
+
+function run(config) {
+    const Platform = getPlatformClass();
+    const platform = new Platform(makeLog(), config, makeApi());
+    platform.addAccessory = jest.fn(); // bypass HAP accessory creation
+    platform.discoverDevices();
+    return platform;
+}
+
+const propsFor = id => {
+    const call = TuyaDevice.mock.calls.find(c => c[0].id === id);
+    return call && call[0];
+};
+const instanceFor = id => TuyaDevice.mock.instances.find(i => i.context && i.context.id === id);
+
+const SW = (extra = {}) => ({id: 'bf11111111111111', key: 'k1', type: 'switch', name: 'Switch', ...extra});
+// A keyless device can't speak the LAN protocol, so it is cloud-only.
+const SLEEPY = (extra = {}) => ({id: 'bf22222222222222', type: 'irrigationsystem', name: 'Sprinklers', ...extra});
+const CLOUD = {accessId: 'aid', accessKey: 'akey', region: 'eu'};
+
+// discoverDevices schedules a long discovery-timeout timer; fake timers keep it
+// from holding the event loop open after the tests finish.
+beforeEach(() => { jest.clearAllMocks(); jest.useFakeTimers(); });
+afterEach(() => { jest.useRealTimers(); });
+
+describe('TuyaLan — cloud session setup', () => {
+    test('no cloud config → no session, devices are pure-LAN', () => {
+        run({devices: [SW()]});
+        expect(TuyaCloudApi).not.toHaveBeenCalled();
+        expect(propsFor('bf11111111111111').cloudApi).toBeUndefined();
+    });
+
+    test('a top-level cloud block creates the single shared session', () => {
+        run({cloud: CLOUD, devices: [SW()]});
+        expect(TuyaCloudApi).toHaveBeenCalledTimes(1);
+        expect(TuyaCloudApi.mock.calls[0][0]).toMatchObject({accessId: 'aid', accessKey: 'akey', region: 'eu'});
+        expect(TuyaCloudMessaging).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('TuyaLan — cloud participation', () => {
+    test('with a session, every device shares the one global fallback', () => {
+        run({cloud: CLOUD, devices: [SW(), SLEEPY()]});
+        expect(propsFor('bf11111111111111').cloudApi).toBeDefined(); // LAN device, cloud fallback
+        expect(propsFor('bf22222222222222').cloudApi).toBeDefined(); // keyless, cloud-only
+    });
+
+    test('without a session, no device gets a cloud backend', () => {
+        run({devices: [SW()]});
+        expect(propsFor('bf11111111111111').cloudApi).toBeUndefined();
+    });
+});
+
+describe('TuyaLan — discovery routing', () => {
+    test('only keyed devices are discovered; keyless ones are cloud-only', () => {
+        run({cloud: CLOUD, devices: [SW(), SLEEPY()]});
+        expect(TuyaDiscovery.start).toHaveBeenCalledTimes(1);
+        expect(TuyaDiscovery.start.mock.calls[0][0].ids).toEqual(['bf11111111111111']);
+    });
+
+    test('a discovered device is handed its LAN target via attachLan', () => {
+        run({cloud: CLOUD, devices: [SW()]});
+        // capture the 'discover' handler registered on the discovery emitter
+        const onDiscover = TuyaDiscovery.on.mock.calls.find(c => c[0] === 'discover');
+        expect(onDiscover).toBeDefined();
+        onDiscover[1]({id: 'bf11111111111111', ip: '10.0.0.7', version: '3.3'});
+        const inst = instanceFor('bf11111111111111');
+        expect(inst.attachLan).toHaveBeenCalledWith({ip: '10.0.0.7', version: '3.3'});
+    });
+
+    test('a cloud-only configuration starts no LAN discovery', () => {
+        run({cloud: CLOUD, devices: [SLEEPY()]});
+        expect(TuyaDiscovery.start).not.toHaveBeenCalled();
+    });
+});
+
+describe('TuyaLan — debug.forceCloudFallback', () => {
+    test('skips LAN discovery so a keyed device never attaches a LAN backend', () => {
+        run({cloud: CLOUD, debug: {forceCloudFallback: true}, devices: [SW()]});
+        expect(TuyaDiscovery.start).not.toHaveBeenCalled();
+        expect(TuyaDiscovery.on).not.toHaveBeenCalled();
+        expect(instanceFor('bf11111111111111').attachLan).not.toHaveBeenCalled();
+    });
+
+    test('the forced device keeps its shared cloud session as its only transport', () => {
+        run({cloud: CLOUD, debug: {forceCloudFallback: true}, devices: [SW()]});
+        expect(propsFor('bf11111111111111').cloudApi).toBeDefined();
+    });
+
+    test('off (or absent) leaves discovery running as usual', () => {
+        run({cloud: CLOUD, debug: {forceCloudFallback: false}, devices: [SW()]});
+        expect(TuyaDiscovery.start).toHaveBeenCalledTimes(1);
+    });
+
+    test('lenient boolean spellings are accepted', () => {
+        run({cloud: CLOUD, debug: {forceCloudFallback: 'true'}, devices: [SW()]});
+        expect(TuyaDiscovery.start).not.toHaveBeenCalled();
+    });
+
+    test('without a cloud session, the unreachable device is reported as an error', () => {
+        const platform = run({debug: {forceCloudFallback: true}, devices: [SW()]});
+        expect(TuyaDiscovery.start).not.toHaveBeenCalled();
+        expect(platform.log.error).toHaveBeenCalled();
+    });
+});
+
+describe('TuyaLan — unconfigured device discovery', () => {
+    const UNKNOWN = {id: 'bf99999999999999', ip: '10.0.0.9'};
+    const BARE = 'Discovered a device that has not been configured yet (%s@%s).';
+    const ENRICHED = 'Discovered a device that has not been configured yet: %s%s (%s@%s).';
+
+    test('without a cloud session, the bare id@ip warning is logged', async () => {
+        const platform = run({devices: [SW()]});
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+    });
+
+    test('with a cloud session, the warning is enriched with the device name and product', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue({name: 'Living Room Light', product_name: 'Smart Bulb', category: 'dj', online: true});
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.cloudApi.getDeviceInfo).toHaveBeenCalledWith(UNKNOWN.id);
+        const [format, ...args] = platform.log.warn.mock.calls[0];
+        expect(format).toBe(ENRICHED);
+        const text = args.join(' ');
+        expect(text).toContain('"Living Room Light"');
+        expect(text).toContain('Smart Bulb');
+        expect(text).toContain('category dj');
+        expect(text).toContain(UNKNOWN.id);
+    });
+
+    test('a cloud lookup that fails falls back to the bare warning', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockRejectedValue(new Error('device not found'));
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+        expect(platform.log.debug).toHaveBeenCalled();
+    });
+
+    test('a cloud record without a name falls back to the bare warning', async () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue({online: true});
+
+        await platform._warnUnconfiguredDevice(UNKNOWN);
+
+        expect(platform.log.warn).toHaveBeenCalledWith(BARE, UNKNOWN.id, UNKNOWN.ip);
+    });
+
+    test('the discover handler routes an unconfigured device through the cloud lookup', () => {
+        const platform = run({cloud: CLOUD, devices: [SW()]});
+        platform.cloudApi.getDeviceInfo.mockResolvedValue(null);
+
+        const onDiscover = TuyaDiscovery.on.mock.calls.find(c => c[0] === 'discover')[1];
+        onDiscover(UNKNOWN);
+
+        expect(platform.cloudApi.getDeviceInfo).toHaveBeenCalledWith(UNKNOWN.id);
+    });
+});
+
+describe('TuyaLan — duplicate device ids', () => {
+    // Two entries sharing an id resolve to one accessory UUID; configuring it twice
+    // used to crash the child bridge (addAccessory read back its own wrapper and
+    // tried to unregister it). The repeat must be dropped with a warning instead.
+    test('a repeated id is configured once and warns', () => {
+        const platform = run({devices: [SW(), SW()]});
+        expect(TuyaDevice).toHaveBeenCalledTimes(1);
+        expect(platform.addAccessory).toHaveBeenCalledTimes(1);
+        expect(platform.log.warn).toHaveBeenCalled();
+    });
+
+    test('distinct ids are all configured', () => {
+        run({devices: [SW(), SLEEPY()]});
+        expect(TuyaDevice).toHaveBeenCalledTimes(2);
+    });
+
+    test('a repeated fake id is configured once', () => {
+        run({devices: [SW({fake: true}), SW({fake: true})]});
+        expect(TuyaAccessory).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('TuyaLan — removeAccessory hardening', () => {
+    function platformWith(PlatformAccessory) {
+        let cls;
+        factory({platformAccessory: PlatformAccessory, hap: makeHap(), registerPlatform: (n, p, c) => { cls = c; }});
+        return new cls(makeLog(), {devices: [SW()]}, makeApi());
+    }
+    const PlatformAccessoryStub = function(name, uuid) { this.displayName = name; this.UUID = uuid; };
+
+    test('a non-PlatformAccessory (e.g. an accessory wrapper) is never unregistered', () => {
+        const platform = platformWith(PlatformAccessoryStub);
+        expect(() => platform.removeAccessory({accessory: {}})).not.toThrow();
+        expect(platform.api.unregisterPlatformAccessories).not.toHaveBeenCalled();
+        expect(platform.log.warn).toHaveBeenCalled();
+    });
+
+    test('a real PlatformAccessory is unregistered and dropped from the cache', () => {
+        const platform = platformWith(PlatformAccessoryStub);
+        const accessory = new PlatformAccessoryStub('Real', 'uuid:x');
+        platform.cachedAccessories.set('uuid:x', accessory);
+        platform.removeAccessory(accessory);
+        expect(platform.api.unregisterPlatformAccessories).toHaveBeenCalledTimes(1);
+        expect(platform.cachedAccessories.has('uuid:x')).toBe(false);
+    });
+});

package/test/support/mocks.js

@@ -34,6 +34,7 @@ const HAP = {
         ProgramMode: { UUID: 'D1', NO_PROGRAM_SCHEDULED: 0, PROGRAM_SCHEDULED: 1, PROGRAM_SCHEDULED_MANUAL_MODE: 2 },
         IsConfigured: { UUID: 'D6', NOT_CONFIGURED: 0, CONFIGURED: 1 },
         ServiceLabelIndex: { UUID: 'CB' },
+        ServiceLabelNamespace: { UUID: 'CD', DOTS: 0, ARABIC_NUMERALS: 1 },
         ConfiguredName: { UUID: 'E3' },
         BatteryLevel: { UUID: '68' },
         StatusLowBattery: { UUID: '79', BATTERY_LEVEL_NORMAL: 0, BATTERY_LEVEL_LOW: 1 },
@@ -65,6 +66,7 @@ const HAP = {
         LockMechanism: { UUID: '45' },
         Valve: { UUID: 'D0' },
         IrrigationSystem: { UUID: 'CF' },
+        ServiceLabel: { UUID: 'CC' },
         Battery: { UUID: '96' },
         ContactSensor: { UUID: '80' },
         LeakSensor: { UUID: '83' },
@@ -73,6 +75,17 @@ const HAP = {
     },
     Formats: { FLOAT: 'float', UINT32: 'uint32', UINT16: 'uint16' },
     Perms: { READ: 'pr', NOTIFY: 'ev', WRITE: 'pw' },
+    // Subset of hap-nodejs HAPStatus + the HapStatusError class, so accessories
+    // can signal "No Response" the proper way (throw a HapStatusError from a
+    // get/set handler) and tests can assert on it.
+    HAPStatus: { SUCCESS: 0, SERVICE_COMMUNICATION_FAILURE: -70402 },
+    HapStatusError: class HapStatusError extends Error {
+        constructor(hapStatus) {
+            super('HapStatusError: ' + hapStatus);
+            this.name = 'HapStatusError';
+            this.hapStatus = hapStatus;
+        }
+    },
     // Mirrors hap-nodejs Categories. Intentionally kept faithful to the real
     // enum (no FANLIGHT, no bare DEHUMIDIFIER) so getCategory() regressions are
     // caught here instead of in production (see issue #45).