homebridge-tuya-plus 3.14.0-dev.4 → 3.14.0-dev.41

package/test/SimpleGarageDoorAccessory.test.js

@@ -52,6 +52,8 @@ function makeSimpleGarage(initialContext = {}) {
     instance.stopBeforeCloseMs = 1500;
     instance.partialStopTimer = null;
     instance.pendingCloseTimer = null;
+    instance.partialPending = false;
+    instance.partialGeneration = 0;
     instance.currentDoorState = CDS.CLOSED;
     instance.characteristicCurrentDoorState = {
         value: CDS.CLOSED,
@@ -373,11 +375,13 @@ describe('SimpleGarageDoorAccessory.setTargetDoorState — close (stop-before-cl
 // Disconnect handling
 // ---------------------------------------------------------------------------
 describe('SimpleGarageDoorAccessory — disconnected', () => {
-    test('Skips writes when the device is disconnected', () => {
+    test('Surfaces a No Response error and writes nothing when disconnected', () => {
         const { instance, device } = makeSimpleGarage();
         device.connected = false;
 
-        instance.setTargetDoorState(TDS.OPEN);
+        // A tap on an unreachable gate must fail in HomeKit instead of being
+        // silently dropped while HomeKit believes the open/close succeeded.
+        expect(() => instance.setTargetDoorState(TDS.OPEN)).toThrow(HAP.HapStatusError);
 
         expect(device.update).not.toHaveBeenCalled();
     });
@@ -407,35 +411,71 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
     beforeEach(() => jest.useFakeTimers());
     afterEach(() => jest.useRealTimers());
 
-    test('Fires open, then fires stop after partialOpenMs', () => {
+    test('Stop is anchored to the gate reporting it is moving, not the button press', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        // Gate starts closed, so the open command needs time to reach it and
+        // get the gate moving before a stop can do anything.
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
 
         instance._handlePartialOpen();
 
-        // Open goes out immediately.
+        // Open goes out immediately, but the auto-stop is NOT armed yet.
         expect(device.update).toHaveBeenCalledTimes(1);
         expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
         expect(instance.characteristicTargetDoorState.value).toBe(TDS.OPEN);
+        expect(instance.partialStopTimer).toBeNull();
+        expect(instance.partialPending).toBe(true);
+
+        // No amount of waiting fires a stop until the gate reports it's moving —
+        // this is what stops a too-early stop from being a dropped no-op.
+        jest.advanceTimersByTime(10_000);
+        expect(device.update).toHaveBeenCalledTimes(1);
+
+        // Controller reports it has started opening: now the countdown arms.
+        emitState(device, STATE_OPENING_OR_OPEN);
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
 
-        // Nothing happens until the timer elapses.
         jest.advanceTimersByTime(2000 - 1);
         expect(device.update).toHaveBeenCalledTimes(1);
 
-        // Then a single stop is fired.
+        // The stop fires, and is re-sent a couple of times to survive a dropped
+        // write (the controller occasionally drops a lone command).
         jest.advanceTimersByTime(1);
         expect(device.update).toHaveBeenCalledTimes(2);
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(3, { '103': true });
+        jest.advanceTimersByTime(300);
+        expect(device.update).toHaveBeenNthCalledWith(4, { '103': true });
 
-        // And nothing more after that.
+        // And nothing more after the re-sends.
         jest.advanceTimersByTime(10_000);
-        expect(device.update).toHaveBeenCalledTimes(2);
+        expect(device.update).toHaveBeenCalledTimes(4);
         expect(instance.partialStopTimer).toBeNull();
     });
 
-    test('Re-entrant press while armed is ignored (idempotent)', () => {
+    test('Arms straight away when the gate already reports open/opening', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN;
+
+        instance._handlePartialOpen();
+
+        // Open fired and the countdown armed without waiting for a fresh report.
+        expect(device.update).toHaveBeenNthCalledWith(1, { '101': true });
+        expect(instance.partialStopTimer).not.toBeNull();
+        expect(instance.partialPending).toBe(false);
+
+        jest.advanceTimersByTime(2000);
+        expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
+    });
+
+    test('Re-entrant press while in progress is ignored (idempotent)', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_OPENING_OR_OPEN; // arms immediately
 
         instance._handlePartialOpen();
         expect(device.update).toHaveBeenCalledTimes(1);
@@ -452,6 +492,20 @@ describe('SimpleGarageDoorAccessory._handlePartialOpen', () => {
         expect(device.update).toHaveBeenNthCalledWith(2, { '103': true });
     });
 
+    test('Re-entrant press while waiting for movement is ignored', () => {
+        const { instance, device } = makeSimpleGarage();
+        instance.partialOpenMs = 2000;
+        device.state['105'] = STATE_CLOSING_OR_CLOSED;
+
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1); // open
+        expect(instance.partialPending).toBe(true);
+
+        // A second press before the gate reports moving must not fire another open.
+        instance._handlePartialOpen();
+        expect(device.update).toHaveBeenCalledTimes(1);
+    });
+
     test('A direct close cancels the partial auto-stop and runs stop-before-close', () => {
         const { instance, device } = makeSimpleGarage();
         instance.partialOpenMs = 2000;

package/test/TuyaAccessory.protocol.test.js

@@ -155,6 +155,78 @@ describe('protocol version normalization', () => {
     });
 });
 
+// A wrong-length local key made crypto.createCipheriv throw "Invalid key length"
+// from inside a socket callback (see _send_3_3), which goes unhandled and crashes
+// Homebridge into a restart loop. An out-of-spec key must be refused clearly,
+// up front, without ever reaching the cipher or taking the process down.
+describe('invalid local key handling', () => {
+    describe('isValidLocalKey', () => {
+        test.each([
+            ['0123456789abcdef', true],    // 16 ASCII chars
+            ['short', false],
+            ['0123456789abcdefXX', false], // 18 chars
+            ['', false],
+            ['012345678901234é', false],   // 16 chars but 17 UTF-8 bytes
+            [Buffer.alloc(16), true],
+            [Buffer.alloc(8), false],
+            [null, false],
+            [undefined, false],
+            [12345678901234567, false],    // not a string/Buffer
+        ])('isValidLocalKey(%p) === %p', (key, expected) => {
+            expect(TuyaAccessory.isValidLocalKey(key)).toBe(expected);
+        });
+    });
+
+    test('a wrong-length key is flagged and logged without throwing', () => {
+        let device;
+        expect(() => { device = makeDevice('3.3', {key: 'too-short'}); }).not.toThrow();
+        expect(device._invalidKey).toBe(true);
+        expect(device.log.error).toHaveBeenCalledWith(expect.stringContaining('16 characters'));
+        const logged = device.log.error.mock.calls.flat().join(' ');
+        expect(logged).toContain('Protocol Test Device');
+    });
+
+    test('a valid 16-character key is accepted and logs no error', () => {
+        const device = makeDevice('3.3');
+        expect(device._invalidKey).toBe(false);
+        expect(device.log.error).not.toHaveBeenCalled();
+    });
+
+    test('_connect() opens no socket for an invalid-key device', () => {
+        const device = makeDevice('3.5', {key: 'bad'});
+        device._connect();
+        expect(device._socket).toBeUndefined();
+        expect(device.connected).toBe(false);
+    });
+
+    // The exact path that used to crash: a connected device whose update() flows
+    // into _send -> _send_3_x -> createCipheriv. It must short-circuit to false.
+    test.each(['3.1', '3.3', '3.4', '3.5'])(
+        'update() never reaches the cipher for an invalid-key %s device, even when connected',
+        version => {
+            const device = makeDevice(version, {key: 'nope'});
+            const written = attachSocketStub(device); // also forces connected = true
+
+            let result;
+            expect(() => { result = device.update({1: true}); }).not.toThrow();
+            expect(result).toBe(false);
+            expect(written).toHaveLength(0);
+        }
+    );
+
+    test('a fake device without a key is never treated as invalid', () => {
+        const device = new TuyaAccessory({
+            id: 'bf1234567890abcdef12',
+            name: 'Fake Device',
+            fake: true,
+            connect: false,
+            log: makeLog(),
+        });
+        expect(device._invalidKey).toBe(false);
+        expect(device.log.error).not.toHaveBeenCalled();
+    });
+});
+
 describe('message handler routing', () => {
     const HANDLERS = ['_msgHandler_3_1', '_msgHandler_3_3', '_msgHandler_3_4', '_msgHandler_3_5'];
 
@@ -607,9 +679,10 @@ describe('graceful disconnect handling', () => {
         jest.advanceTimersByTime(1000);
         expect(pingErrors).toHaveLength(0);
 
-        // The log reflects a clean disconnect, never a ping failure.
-        expect(device.log.info).toHaveBeenCalledWith('Disconnected from', device.context.name);
-        const logged = device.log.info.mock.calls.flat().join(' ');
+        // The log reflects a clean disconnect, never a ping failure. (A device
+        // recycling its socket is routine, so the disconnect is logged at debug.)
+        expect(device.log.debug).toHaveBeenCalledWith('Disconnected from', device.context.name);
+        const logged = device.log.debug.mock.calls.flat().join(' ');
         expect(logged).not.toMatch(/ERR_PING_TIMED_OUT/);
     });
 

package/test/TuyaCloudApi.test.js

@@ -138,6 +138,31 @@ describe('TuyaCloudApi — endpoints', () => {
         await expect(api.getStatus('dev')).resolves.toEqual([{code: 'switch_1', value: true}]);
     });
 
+    test('getShadowProperties returns the properties array (code + dp_id)', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => {
+            path = p;
+            return {success: true, result: {properties: [{code: 'switch_led', dp_id: 20, value: true}]}};
+        };
+        await expect(api.getShadowProperties('dev')).resolves.toEqual([{code: 'switch_led', dp_id: 20, value: true}]);
+        expect(path).toBe('/v2.0/cloud/thing/dev/shadow/properties');
+    });
+
+    test('getShadowProperties returns null (never throws) when the shadow API is unavailable', async () => {
+        const api = ready();
+        api._httpsRequest = async () => ({success: false, code: 1106, msg: 'permission deny'});
+        await expect(api.getShadowProperties('dev')).resolves.toBeNull();
+    });
+
+    test('getDeviceInfo returns the device record (with online status)', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => { path = p; return {success: true, result: {id: 'dev', online: false, name: 'X'}}; };
+        await expect(api.getDeviceInfo('dev')).resolves.toEqual({id: 'dev', online: false, name: 'X'});
+        expect(path).toBe('/v1.0/devices/dev');
+    });
+
     test('sendCommands posts the commands and reports success', async () => {
         const api = ready();
         let captured;
@@ -148,7 +173,7 @@ describe('TuyaCloudApi — endpoints', () => {
         const ok = await api.sendCommands('dev', [{code: 'switch_1', value: true}]);
         expect(ok).toBe(true);
         expect(captured.method).toBe('POST');
-        expect(captured.path).toBe('/v1.0/devices/dev/commands');
+        expect(captured.path).toBe('/v1.0/iot-03/devices/dev/commands');
         expect(captured.body).toEqual({commands: [{code: 'switch_1', value: true}]});
     });
 
@@ -159,6 +184,35 @@ describe('TuyaCloudApi — endpoints', () => {
         expect(api._httpsRequest).not.toHaveBeenCalled();
     });
 
+    test('getStatus reads from the iot-03 device endpoint', async () => {
+        const api = ready();
+        let path;
+        api._httpsRequest = async (method, p) => { path = p; return {success: true, result: []}; };
+        await api.getStatus('dev');
+        expect(path).toBe('/v1.0/iot-03/devices/dev/status');
+    });
+
+    test('sendProperties issues thing-model properties as a JSON-string body', async () => {
+        const api = ready();
+        let captured;
+        api._httpsRequest = async (method, path, headers, bodyStr) => {
+            captured = {method, path, body: JSON.parse(bodyStr)};
+            return {success: true, result: true};
+        };
+        const ok = await api.sendProperties('dev', [{code: 'wfh_close', value: true}]);
+        expect(ok).toBe(true);
+        expect(captured.method).toBe('POST');
+        expect(captured.path).toBe('/v2.0/cloud/thing/dev/shadow/properties/issue');
+        expect(captured.body).toEqual({properties: JSON.stringify({wfh_close: true})});
+    });
+
+    test('sendProperties short-circuits on an empty command list', async () => {
+        const api = ready();
+        api._httpsRequest = jest.fn();
+        await expect(api.sendProperties('dev', [])).resolves.toBe(true);
+        expect(api._httpsRequest).not.toHaveBeenCalled();
+    });
+
     test('getMqttConfig posts the expected body and returns the broker config', async () => {
         const api = ready();
         api.uid = 'UID';
@@ -194,3 +248,58 @@ describe('TuyaCloudApi — endpoints', () => {
         await expect(api.request('GET', '/x')).rejects.toThrow(/no permissions/);
     });
 });
+
+describe('TuyaCloudApi — HTTP trace (debug.logCloudHttp)', () => {
+    const makeLog = () => ({info: () => {}, warn: () => {}, error: () => {}, debug: jest.fn()});
+
+    test('logHttp is off unless explicitly enabled', () => {
+        expect(makeApi().logHttp).toBe(false);
+        expect(makeApi({logHttp: true}).logHttp).toBe(true);
+    });
+
+    test('redaction masks credentials but keeps device data', () => {
+        const api = makeApi();
+        const redacted = api._redactForLog({
+            client_id: 'aid1234567890', access_token: 'tok_abcdef123456', sign: 'SIGNATUREVALUE', t: '1700', nonce: 'n-1',
+            result: {access_token: 'inner-token-xyz', refresh_token: 'refresh-xyz', uid: 'uid-1234567', online: true},
+            commands: [{code: 'switch_1', value: true}]
+        });
+
+        expect(redacted.client_id).not.toBe('aid1234567890');
+        expect(redacted.access_token).not.toBe('tok_abcdef123456');
+        expect(redacted.sign).not.toBe('SIGNATUREVALUE');
+        expect(redacted.result.access_token).not.toBe('inner-token-xyz');
+        expect(redacted.result.refresh_token).not.toBe('refresh-xyz');
+        expect(redacted.result.uid).not.toBe('uid-1234567');
+        // Non-secret fields and the actual device data-points pass through intact.
+        expect(redacted.t).toBe('1700');
+        expect(redacted.nonce).toBe('n-1');
+        expect(redacted.result.online).toBe(true);
+        expect(redacted.commands).toEqual([{code: 'switch_1', value: true}]);
+    });
+
+    test('no trace is logged when the switch is off', () => {
+        const log = makeLog();
+        const api = makeApi({log});
+        api._traceHttp('POST', '/v1.0/devices/dev/commands', {sign: 'X'}, '{"commands":[]}', 200, {success: true});
+        expect(log.debug).not.toHaveBeenCalled();
+    });
+
+    test('a trace carries the request/response but never the raw token or signature', () => {
+        const log = makeLog();
+        const api = makeApi({log, logHttp: true});
+        const headers = {client_id: 'aid', sign: 'SIGN_SECRET_VALUE', access_token: 'TOKEN_SECRET_VALUE', t: '1', nonce: 'n', 'Content-Type': 'application/json'};
+        const body = JSON.stringify({commands: [{code: 'wfh_open', value: true}]});
+
+        api._traceHttp('POST', '/v1.0/devices/dev/commands', headers, body, 200, {success: false, code: 2008, msg: 'command or value not support'});
+
+        expect(log.debug).toHaveBeenCalledTimes(1);
+        const line = log.debug.mock.calls[0][0];
+        expect(line).toContain('POST /v1.0/devices/dev/commands');
+        expect(line).toContain('wfh_open');           // the attempted command is visible
+        expect(line).toContain('2008');                // and the cloud's verdict
+        expect(line).toContain('command or value not support');
+        expect(line).not.toContain('TOKEN_SECRET_VALUE'); // …but secrets are not
+        expect(line).not.toContain('SIGN_SECRET_VALUE');
+    });
+});