homebridge-tuya-pool-heater 1.0.1

package/dist/tuyaApi.test.js

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const tuyaApi_1 = require("./tuyaApi");
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+// Mock logger
+const mockLogger = {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+};
+const testOptions = {
+    accessId: 'test_access_id',
+    accessKey: 'test_access_key',
+    endpoint: 'https://openapi.tuyaus.com',
+    username: 'test@example.com',
+    password: 'test_password',
+    countryCode: 1,
+};
+describe('TuyaApi', () => {
+    let api;
+    let mockAxiosInstance;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Create mock axios instance
+        mockAxiosInstance = {
+            get: jest.fn(),
+            post: jest.fn(),
+            request: jest.fn(),
+        };
+        mockedAxios.create.mockReturnValue(mockAxiosInstance);
+        api = new tuyaApi_1.TuyaApi(testOptions, mockLogger);
+    });
+    describe('constructor', () => {
+        it('should create axios instance with correct config', () => {
+            expect(mockedAxios.create).toHaveBeenCalledWith({
+                baseURL: testOptions.endpoint,
+                timeout: 10000,
+            });
+        });
+    });
+    describe('authenticate', () => {
+        it('should request token and authenticate with user credentials', async () => {
+            // Mock token response
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'temp_token',
+                        refresh_token: 'temp_refresh',
+                        expire_time: 7200,
+                        uid: 'temp_uid',
+                    },
+                },
+            });
+            // Mock auth response
+            mockAxiosInstance.post.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'final_token',
+                        refresh_token: 'final_refresh',
+                        expire_time: 7200,
+                        uid: 'user_uid',
+                    },
+                },
+            });
+            await api.authenticate();
+            // Verify token request
+            expect(mockAxiosInstance.get).toHaveBeenCalledTimes(1);
+            const tokenCall = mockAxiosInstance.get.mock.calls[0];
+            expect(tokenCall[0]).toBe('/v1.0/token?grant_type=1');
+            // Verify auth request
+            expect(mockAxiosInstance.post).toHaveBeenCalledTimes(1);
+            const authCall = mockAxiosInstance.post.mock.calls[0];
+            expect(authCall[0]).toBe('/v1.0/iot-01/associated-users/actions/authorized-login');
+            // Verify password is MD5 hashed
+            const authBody = authCall[1];
+            const expectedPasswordHash = crypto_1.default
+                .createHash('md5')
+                .update(testOptions.password)
+                .digest('hex');
+            expect(authBody.password).toBe(expectedPasswordHash);
+            expect(authBody.username).toBe(testOptions.username);
+            expect(authBody.country_code).toBe(testOptions.countryCode.toString());
+            expect(mockLogger.info).toHaveBeenCalledWith('Successfully authenticated with Tuya API');
+        });
+        it('should throw error on token request failure', async () => {
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: false,
+                    msg: 'Invalid credentials',
+                },
+            });
+            await expect(api.authenticate()).rejects.toThrow('Token request failed: Invalid credentials');
+        });
+        it('should throw error on auth request failure', async () => {
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'temp_token',
+                        refresh_token: 'temp_refresh',
+                        expire_time: 7200,
+                        uid: 'temp_uid',
+                    },
+                },
+            });
+            mockAxiosInstance.post.mockResolvedValueOnce({
+                data: {
+                    success: false,
+                    msg: 'User not found',
+                },
+            });
+            await expect(api.authenticate()).rejects.toThrow('Authentication failed: User not found');
+        });
+    });
+    describe('getDeviceStatus', () => {
+        beforeEach(async () => {
+            // Setup authenticated state
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'test_token',
+                        refresh_token: 'test_refresh',
+                        expire_time: 7200,
+                        uid: 'test_uid',
+                    },
+                },
+            });
+            mockAxiosInstance.post.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'final_token',
+                        refresh_token: 'final_refresh',
+                        expire_time: 7200,
+                        uid: 'user_uid',
+                    },
+                },
+            });
+            await api.authenticate();
+        });
+        it('should fetch device status', async () => {
+            const deviceId = 'test_device_id';
+            const mockStatus = [
+                { code: 'switch', value: true },
+                { code: 'temp_current', value: 280 },
+                { code: 'mode', value: 'Heating_Smart' },
+            ];
+            mockAxiosInstance.request.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: mockStatus,
+                },
+            });
+            const status = await api.getDeviceStatus(deviceId);
+            expect(status).toEqual(mockStatus);
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'GET',
+                url: `/v1.0/devices/${deviceId}/status`,
+            }));
+        });
+    });
+    describe('sendCommand', () => {
+        beforeEach(async () => {
+            // Setup authenticated state
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'test_token',
+                        refresh_token: 'test_refresh',
+                        expire_time: 7200,
+                        uid: 'test_uid',
+                    },
+                },
+            });
+            mockAxiosInstance.post.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'final_token',
+                        refresh_token: 'final_refresh',
+                        expire_time: 7200,
+                        uid: 'user_uid',
+                    },
+                },
+            });
+            await api.authenticate();
+        });
+        it('should send command to device', async () => {
+            const deviceId = 'test_device_id';
+            mockAxiosInstance.request.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: true,
+                },
+            });
+            const result = await api.sendCommand(deviceId, 'switch', true);
+            expect(result).toBe(true);
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'POST',
+                url: `/v1.0/devices/${deviceId}/commands`,
+                data: JSON.stringify({ commands: [{ code: 'switch', value: true }] }),
+            }));
+        });
+        it('should return false on command failure', async () => {
+            const deviceId = 'test_device_id';
+            mockAxiosInstance.request.mockRejectedValueOnce(new Error('Command failed'));
+            const result = await api.sendCommand(deviceId, 'switch', true);
+            expect(result).toBe(false);
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+    });
+    describe('sendCommands', () => {
+        beforeEach(async () => {
+            // Setup authenticated state
+            mockAxiosInstance.get.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'test_token',
+                        refresh_token: 'test_refresh',
+                        expire_time: 7200,
+                        uid: 'test_uid',
+                    },
+                },
+            });
+            mockAxiosInstance.post.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: {
+                        access_token: 'final_token',
+                        refresh_token: 'final_refresh',
+                        expire_time: 7200,
+                        uid: 'user_uid',
+                    },
+                },
+            });
+            await api.authenticate();
+        });
+        it('should send multiple commands at once', async () => {
+            const deviceId = 'test_device_id';
+            const commands = [
+                { code: 'switch', value: true },
+                { code: 'mode', value: 'Heating_Smart' },
+            ];
+            mockAxiosInstance.request.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    result: true,
+                },
+            });
+            const result = await api.sendCommands(deviceId, commands);
+            expect(result).toBe(true);
+            expect(mockAxiosInstance.request).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'POST',
+                data: JSON.stringify({ commands }),
+            }));
+        });
+    });
+});
+describe('HMAC-SHA256 Signature', () => {
+    it('should generate correct signature format', () => {
+        // This tests the signature algorithm matches Tuya's requirements
+        const accessId = 'test_id';
+        const accessKey = 'test_key';
+        const timestamp = '1234567890000';
+        const method = 'GET';
+        const path = '/v1.0/token';
+        const body = '';
+        const contentHash = crypto_1.default.createHash('sha256').update(body).digest('hex');
+        const stringToSign = [method, contentHash, '', path].join('\n');
+        const signStr = accessId + timestamp + stringToSign;
+        const expectedSign = crypto_1.default
+            .createHmac('sha256', accessKey)
+            .update(signStr)
+            .digest('hex')
+            .toUpperCase();
+        // Verify the signature is 64 characters (256 bits in hex)
+        expect(expectedSign).toHaveLength(64);
+        // Verify it's uppercase hex
+        expect(expectedSign).toMatch(/^[A-F0-9]{64}$/);
+    });
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "private": false,
+  "displayName": "Homebridge Tuya Pool Heater",
+  "name": "homebridge-tuya-pool-heater",
+  "version": "1.0.1",
+  "description": "Homebridge plugin for Tuya-based pool heat pumps with proper temperature scaling and HeaterCooler/Thermostat support",
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf ./dist && tsc",
+    "prepublishOnly": "npm run build",
+    "watch": "tsc -w",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "tuya",
+    "pool",
+    "heat-pump",
+    "pool-heater",
+    "pool-heat-pump",
+    "thermostat",
+    "heater-cooler",
+    "smart-home",
+    "smart-life",
+    "tuya-smart"
+  ],
+  "author": "bstillitano",
+  "license": "MIT",
+  "homepage": "https://github.com/bstillitano/homebridge-tuya-pool-heater#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bstillitano/homebridge-tuya-pool-heater.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bstillitano/homebridge-tuya-pool-heater/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "homebridge": ">=1.6.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.10.0",
+    "homebridge": "^1.7.0",
+    "jest": "^30.2.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "homebridge": ">=1.6.0"
+  }
+}