@mp-consulting/homebridge-daikin-cloud 1.3.6 → 1.3.8

package/test/unit/api/daikin-oauth.test.ts

@@ -1,214 +0,0 @@
-import {DaikinOAuth} from '../../../src/api/daikin-oauth';
-import * as fs from 'node:fs';
-import * as https from 'node:https';
-
-jest.mock('node:fs');
-jest.mock('node:https');
-
-describe('DaikinOAuth', () => {
-    const mockConfig = {
-        clientId: 'test-client-id',
-        clientSecret: 'test-client-secret',
-        callbackServerExternalAddress: '192.168.1.1',
-        callbackServerPort: 8582,
-        tokenFilePath: '/tmp/test-token.json',
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        (fs.existsSync as jest.Mock).mockReturnValue(false);
-    });
-
-    describe('getAccessToken', () => {
-        it('should return the access token if not expired', async () => {
-            const futureExpiry = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
-            const tokenSet = {
-                access_token: 'valid-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: futureExpiry,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('valid-token');
-        });
-
-        it('should refresh the token if expired', async () => {
-            const pastExpiry = Math.floor(Date.now() / 1000) - 100; // 100 seconds ago
-            const tokenSet = {
-                access_token: 'expired-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: pastExpiry,
-            };
-
-            const newTokenSet = {
-                access_token: 'new-token',
-                refresh_token: 'new-refresh-token',
-                token_type: 'Bearer',
-                expires_in: 3600,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            // Mock the HTTPS request for token refresh
-            const mockResponse = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'data') {
-                        callback(JSON.stringify(newTokenSet));
-                    }
-                    if (event === 'end') {
-                        callback();
-                    }
-                }),
-            };
-            const mockRequest = {
-                on: jest.fn(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('new-token');
-            expect(https.request).toHaveBeenCalled();
-        });
-
-        it('should refresh the token if about to expire (within 10 seconds)', async () => {
-            const soonExpiry = Math.floor(Date.now() / 1000) + 5; // 5 seconds from now
-            const tokenSet = {
-                access_token: 'soon-expiring-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: soonExpiry,
-            };
-
-            const newTokenSet = {
-                access_token: 'refreshed-token',
-                refresh_token: 'new-refresh-token',
-                token_type: 'Bearer',
-                expires_in: 3600,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const mockResponse = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'data') {
-                        callback(JSON.stringify(newTokenSet));
-                    }
-                    if (event === 'end') {
-                        callback();
-                    }
-                }),
-            };
-            const mockRequest = {
-                on: jest.fn(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('refreshed-token');
-            expect(https.request).toHaveBeenCalled();
-        });
-
-        it('should throw error if token expired and no refresh token', async () => {
-            const pastExpiry = Math.floor(Date.now() / 1000) - 100;
-            const tokenSet = {
-                access_token: 'expired-token',
-                token_type: 'Bearer',
-                expires_at: pastExpiry,
-                // No refresh_token
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-
-            await expect(oauth.getAccessToken()).rejects.toThrow(
-                'Token expired and no refresh token available. Please re-authenticate.',
-            );
-        });
-
-        it('should throw error if not authenticated', async () => {
-            const oauth = new DaikinOAuth(mockConfig);
-
-            await expect(oauth.getAccessToken()).rejects.toThrow(
-                'Not authenticated. Please authenticate first.',
-            );
-        });
-    });
-
-    describe('isAuthenticated', () => {
-        it('should return true if token set exists', () => {
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.isAuthenticated()).toBe(true);
-        });
-
-        it('should return false if no token set', () => {
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.isAuthenticated()).toBe(false);
-        });
-    });
-
-    describe('getTokenExpiration', () => {
-        it('should return expiration date', () => {
-            const expiresAt = Math.floor(Date.now() / 1000) + 3600;
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-                expires_at: expiresAt,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const expiration = oauth.getTokenExpiration();
-
-            expect(expiration).toBeInstanceOf(Date);
-            expect(expiration?.getTime()).toBe(expiresAt * 1000);
-        });
-
-        it('should return null if no expiration', () => {
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.getTokenExpiration()).toBeNull();
-        });
-    });
-});

package/test/unit/api/daikinCloud.test.ts

@@ -1,12 +0,0 @@
-import {DaikinCloudRepo} from '../../../src/api/daikin-cloud.repository';
-import {dx4Airco} from '../../fixtures/dx4-airco';
-import {dx23Airco} from '../../fixtures/dx23-airco';
-import {althermaHeatPump} from '../../fixtures/altherma-heat-pump';
-
-test.each<Array<string | any>>([
-    ['dx4', dx4Airco],
-    ['dx23', dx23Airco],
-    ['altherma', althermaHeatPump],
-])('Clean cloud device data for %s device', (name, deviceJson) => {
-    expect(DaikinCloudRepo.maskSensitiveCloudDeviceData(deviceJson)).toMatchSnapshot();
-});

package/test/unit/api/token-storage.test.ts

@@ -1,90 +0,0 @@
-import * as fs from 'node:fs';
-import {loadTokenFromFile, saveTokenToFile, deleteTokenFile} from '../../../src/api/token-storage';
-import {TokenSet} from '../../../src/api/daikin-types';
-
-jest.mock('node:fs');
-
-const mockFs = fs as jest.Mocked<typeof fs>;
-
-describe('Token Storage', () => {
-    const filePath = '/tmp/test-token.json';
-    const tokenSet: TokenSet = {
-        access_token: 'test-access-token',
-        refresh_token: 'test-refresh-token',
-        token_type: 'Bearer',
-        expires_in: 3600,
-        expires_at: Math.floor(Date.now() / 1000) + 3600,
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    describe('loadTokenFromFile', () => {
-        it('should return null if file does not exist', () => {
-            mockFs.existsSync.mockReturnValue(false);
-            expect(loadTokenFromFile(filePath)).toBeNull();
-        });
-
-        it('should return parsed token set from file', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue(JSON.stringify(tokenSet));
-            const result = loadTokenFromFile(filePath);
-            expect(result).toEqual(tokenSet);
-        });
-
-        it('should return null on invalid JSON', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockReturnValue('not-json{{{');
-            expect(loadTokenFromFile(filePath)).toBeNull();
-        });
-
-        it('should return null on invalid token structure', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            // Missing required access_token and token_type
-            mockFs.readFileSync.mockReturnValue(JSON.stringify({ foo: 'bar' }));
-            expect(loadTokenFromFile(filePath)).toBeNull();
-        });
-
-        it('should return null if readFileSync throws', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.readFileSync.mockImplementation(() => {
-                throw new Error('Permission denied');
-            });
-            expect(loadTokenFromFile(filePath)).toBeNull();
-        });
-    });
-
-    describe('saveTokenToFile', () => {
-        it('should write token set with restricted permissions', () => {
-            saveTokenToFile(filePath, tokenSet);
-            expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-                filePath,
-                JSON.stringify(tokenSet, null, 2),
-                { encoding: 'utf8', mode: 0o600 },
-            );
-        });
-    });
-
-    describe('deleteTokenFile', () => {
-        it('should delete file if it exists', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            deleteTokenFile(filePath);
-            expect(mockFs.unlinkSync).toHaveBeenCalledWith(filePath);
-        });
-
-        it('should not throw if file does not exist', () => {
-            mockFs.existsSync.mockReturnValue(false);
-            expect(() => deleteTokenFile(filePath)).not.toThrow();
-            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
-        });
-
-        it('should not throw if unlinkSync fails', () => {
-            mockFs.existsSync.mockReturnValue(true);
-            mockFs.unlinkSync.mockImplementation(() => {
-                throw new Error('Permission denied');
-            });
-            expect(() => deleteTokenFile(filePath)).not.toThrow();
-        });
-    });
-});

package/test/unit/config/config-manager.test.ts

@@ -1,271 +0,0 @@
-/**
- * ConfigManager Tests
- */
-
-import {ConfigManager, PluginConfig} from '../../../src/config/config-manager';
-
-describe('ConfigManager', () => {
-    describe('getAuthMode', () => {
-        it('should return mobile_app when configured', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'mobile_app',
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getAuthMode()).toBe('mobile_app');
-        });
-
-        it('should default to developer_portal when not specified', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getAuthMode()).toBe('developer_portal');
-        });
-    });
-
-    describe('getDeveloperCredentials', () => {
-        it('should return credentials when all fields present', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: 'example.com',
-                callbackServerPort: 8582,
-            };
-            const manager = new ConfigManager(config);
-            const creds = manager.getDeveloperCredentials();
-
-            expect(creds).not.toBeNull();
-            expect(creds?.clientId).toBe('test-id');
-            expect(creds?.clientSecret).toBe('test-secret');
-            expect(creds?.callbackServerExternalAddress).toBe('example.com');
-            expect(creds?.callbackServerPort).toBe(8582);
-        });
-
-        it('should return null when fields missing', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                clientId: 'test-id',
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getDeveloperCredentials()).toBeNull();
-        });
-    });
-
-    describe('getMobileCredentials', () => {
-        it('should return credentials when present', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                daikinEmail: 'test@example.com',
-                daikinPassword: 'password123',
-            };
-            const manager = new ConfigManager(config);
-            const creds = manager.getMobileCredentials();
-
-            expect(creds).not.toBeNull();
-            expect(creds?.email).toBe('test@example.com');
-            expect(creds?.password).toBe('password123');
-        });
-
-        it('should return null when fields missing', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                daikinEmail: 'test@example.com',
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getMobileCredentials()).toBeNull();
-        });
-    });
-
-    describe('validate', () => {
-        it('should pass validation for valid developer portal config', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: '192.168.1.100',
-                callbackServerPort: 8582,
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(true);
-            expect(result.errors).toHaveLength(0);
-        });
-
-        it('should fail validation for developer portal without clientId', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: '192.168.1.100',
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain('Client ID is required for Developer Portal mode');
-        });
-
-        it('should fail validation for localhost callback address', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: 'localhost',
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain('Callback address cannot be localhost. Use your external IP or domain.');
-        });
-
-        it('should fail validation for invalid port', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: '192.168.1.100',
-                callbackServerPort: 99999,
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(false);
-            expect(result.errors.length).toBeGreaterThan(0);
-            expect(result.errors.some(e => e.includes('port'))).toBe(true);
-        });
-
-        it('should warn about privileged port', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: '192.168.1.100',
-                callbackServerPort: 443,
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(true);
-            expect(result.warnings).toContain('Port 443 is privileged (< 1024) and may require root permissions.');
-        });
-
-        it('should pass validation for valid mobile app config', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'mobile_app',
-                daikinEmail: 'test@example.com',
-                daikinPassword: 'password123',
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(true);
-            expect(result.errors).toHaveLength(0);
-        });
-
-        it('should fail validation for mobile app without email', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'mobile_app',
-                daikinPassword: 'password123',
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(false);
-            expect(result.errors).toContain('Email is required for Mobile App mode');
-        });
-
-        it('should warn about low update interval for developer portal', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                authMode: 'developer_portal',
-                clientId: 'test-id',
-                clientSecret: 'test-secret',
-                callbackServerExternalAddress: '192.168.1.100',
-                updateIntervalInMinutes: 5,
-            };
-            const manager = new ConfigManager(config);
-            const result = manager.validate();
-
-            expect(result.valid).toBe(true);
-            expect(result.warnings.some(w => w.includes('rate limit'))).toBe(true);
-        });
-    });
-
-    describe('getUpdateIntervalMs', () => {
-        it('should return configured interval in milliseconds', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                updateIntervalInMinutes: 30,
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getUpdateIntervalMs()).toBe(30 * 60 * 1000);
-        });
-
-        it('should return default interval when not configured', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.getUpdateIntervalMs()).toBe(15 * 60 * 1000);
-        });
-    });
-
-    describe('isDeviceExcluded', () => {
-        it('should return true for excluded device', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                excludedDevicesByDeviceId: ['device1', 'device2'],
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.isDeviceExcluded('device1')).toBe(true);
-        });
-
-        it('should return false for non-excluded device', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                excludedDevicesByDeviceId: ['device1', 'device2'],
-            };
-            const manager = new ConfigManager(config);
-            expect(manager.isDeviceExcluded('device3')).toBe(false);
-        });
-    });
-
-    describe('getFeatures', () => {
-        it('should return feature configuration', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                showPowerfulMode: true,
-                showEconoMode: false,
-            };
-            const manager = new ConfigManager(config);
-            const features = manager.getFeatures();
-
-            expect(features.powerfulMode).toBe(true);
-            expect(features.econoMode).toBe(false);
-        });
-
-        it('should use legacy showExtraFeatures when present', () => {
-            const config: PluginConfig = {
-                platform: 'DaikinCloud',
-                showExtraFeatures: true,
-            };
-            const manager = new ConfigManager(config);
-            const features = manager.getFeatures();
-
-            // All features should be true when legacy flag is set
-            expect(features.powerfulMode).toBe(true);
-            expect(features.econoMode).toBe(true);
-            expect(features.streamerMode).toBe(true);
-        });
-    });
-});

package/test/unit/device/daikin-device.test.ts

@@ -1,73 +0,0 @@
-import {PlatformAccessory} from 'homebridge/lib/platformAccessory';
-import {DaikinCloudDevice, DaikinApi} from '../../../src/api';
-import {dx4Airco} from '../../fixtures/dx4-airco';
-import {althermaHeatPump} from '../../fixtures/altherma-heat-pump';
-
-const mockApi = { updateDevice: jest.fn().mockResolvedValue(undefined) } as unknown as DaikinApi;
-
-it('Get deviceModel from device', async () => {
-    const accessory = new PlatformAccessory('NAME', 'efd08509-2edb-41d0-a9ab-ce913323d811');
-    accessory.context.device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-    expect(accessory.context.device.getDescription().deviceModel).toEqual('dx4');
-});
-
-it('Get name from AC device', async () => {
-    const accessory = new PlatformAccessory('NAME', 'efd08509-2edb-41d0-a9ab-ce913323d811');
-    accessory.context.device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-    expect(accessory.context.device.getData('climateControl', 'name', undefined).value).toEqual('Zolder');
-});
-
-it('Get name from Altherma device', async () => {
-    const accessory = new PlatformAccessory('NAME', 'efd08509-2edb-41d0-a9ab-ce913323d811');
-    accessory.context.device = new DaikinCloudDevice(althermaHeatPump as any, mockApi);
-    expect(accessory.context.device.getData('climateControlMainZone', 'name', undefined).value).toEqual('Altherma');
-});
-
-it('Get tankTemperature from device domesticHotWaterTank', async () => {
-    const accessory = new PlatformAccessory('NAME', 'efd08509-2edb-41d0-a9ab-ce913323d811');
-    accessory.context.device = new DaikinCloudDevice(althermaHeatPump as any, mockApi);
-    expect(accessory.context.device.getData('domesticHotWaterTank', 'sensoryData', '/tankTemperature').value).toEqual(48);
-});
-
-it('Get roomTemperature from climateControl sensoryData', async () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-    const result = device.getData('climateControl', 'sensoryData', '/roomTemperature');
-    expect(result.value).toEqual(25);
-});
-
-it('getData navigates nested sensoryData path correctly', () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-
-    const desc = device.desc;
-    const mp = desc.managementPoints?.find((m: any) => m.embeddedId === 'climateControl');
-    expect(mp).toBeDefined();
-    expect(mp?.sensoryData).toBeDefined();
-    expect(mp?.sensoryData?.value?.roomTemperature?.value).toEqual(25);
-
-    const result = device.getData('climateControl', 'sensoryData', '/roomTemperature');
-    expect(result.value).toEqual(25);
-});
-
-it('getData falls back to roomTemperature when controlMode is absent', () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-
-    const managementPointId = 'climateControl';
-    const controlModeResult = device.getData(managementPointId, 'controlMode', undefined);
-    const controlMode = controlModeResult.value ? controlModeResult.value : 'roomTemperature';
-
-    const path = '/' + controlMode;
-    const temperature = device.getData(managementPointId, 'sensoryData', path);
-    expect(temperature.value).toEqual(25);
-});
-
-it('updateRawData replaces device data', () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-    const originalId = device.getId();
-
-    const modifiedData = { ...dx4Airco, id: 'new-id' } as any;
-    device.updateRawData(modifiedData);
-
-    expect(device.getId()).toEqual('new-id');
-    expect(device.desc.id).toEqual('new-id');
-    expect(device.getId()).not.toEqual(originalId);
-});