@mp-consulting/homebridge-daikin-cloud 1.3.5 → 1.3.7

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,79 +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 %s', 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 device %s', 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 device %s', 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('Debug: trace getData path for roomTemperature', () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-
-    // Check that management point is found
-    const desc = device.desc;
-    const mp = desc.managementPoints?.find((m: any) => m.embeddedId === 'climateControl');
-    expect(mp).toBeDefined();
-    expect(mp?.sensoryData).toBeDefined();
-
-    // Check sensoryData structure
-    const sensoryData = mp?.sensoryData;
-    expect(sensoryData?.value?.roomTemperature?.value).toEqual(25);
-
-    // Now test through getData
-    const result = device.getData('climateControl', 'sensoryData', '/roomTemperature');
-    console.log('getData result:', JSON.stringify(result, null, 2));
-    expect(result.value).toEqual(25);
-});
-
-it('Integration: simulate full AC accessory temperature get', () => {
-    const device = new DaikinCloudDevice(dx4Airco as any, mockApi);
-
-    // Test the path that ClimateControlService uses
-    const managementPointId = 'climateControl';
-
-    // 1. getCurrentControlMode() checks controlMode first
-    const controlModeResult = device.getData(managementPointId, 'controlMode', undefined);
-    console.log('controlMode result:', JSON.stringify(controlModeResult, null, 2));
-
-    // For AC devices, controlMode should not exist, so it defaults to 'roomTemperature'
-    const controlMode = controlModeResult.value ? controlModeResult.value : 'roomTemperature';
-    console.log('controlMode:', controlMode);
-
-    // 2. handleCurrentTemperatureGet uses this path
-    const path = '/' + controlMode;
-    console.log('path:', path);
-
-    const temperature = device.getData(managementPointId, 'sensoryData', path);
-    console.log('temperature result:', JSON.stringify(temperature, null, 2));
-
-    expect(temperature.value).toEqual(25);
-});

package/test/unit/services/hot-water-tank.service.test.ts

@@ -1,123 +0,0 @@
-import {HotWaterTankService} from '../../../src/services';
-import {DaikinCloudDevice, DaikinApi} from '../../../src/api';
-import {MockPlatformConfig} from '../../mocks';
-import {DaikinCloudAccessoryContext, DaikinCloudPlatform} from '../../../src/platform';
-import {PlatformAccessory} from 'homebridge/lib/platformAccessory';
-import {Characteristic, uuid} from 'hap-nodejs';
-import {althermaHeatPump} from '../../fixtures/altherma-heat-pump';
-
-import {HomebridgeAPI} from 'homebridge/lib/api.js';
-import {Logger} from 'homebridge/lib/logger.js';
-
-// Helper to get management point data from the device
-const getManagementPoint = (device: DaikinCloudDevice, embeddedId: string): any => {
-    return (device as any).rawData.managementPoints.find((mp: any) => mp.embeddedId === embeddedId);
-};
-
-// Use fake timers to prevent tests from hanging due to setInterval/setTimeout in platform
-beforeEach(() => {
-    jest.useFakeTimers();
-});
-
-afterEach(() => {
-    jest.clearAllTimers();
-    jest.useRealTimers();
-});
-
-describe('HotWaterTankService', () => {
-    let accessory: PlatformAccessory<DaikinCloudAccessoryContext>;
-    let service: HotWaterTankService;
-
-    const EMBEDDED_ID = 'domesticHotWaterTank';
-
-    beforeEach(() => {
-        const mockApi = {} as DaikinApi;
-        accessory = new PlatformAccessory<DaikinCloudAccessoryContext>('ACCESSORY_NAME', uuid.generate('ACCESSORY_UUID'));
-        // Use a deep copy of the fixture to isolate test mutations
-        accessory.context['device'] = new DaikinCloudDevice(JSON.parse(JSON.stringify(althermaHeatPump)) as any, mockApi);
-        accessory.context.device.getLastUpdated = jest.fn().mockReturnValue(new Date(1987, 0, 19, 0, 0, 0, 0));
-
-        const platform = new DaikinCloudPlatform(new Logger(), new MockPlatformConfig(true), new HomebridgeAPI());
-
-        service = new HotWaterTankService(platform, accessory, EMBEDDED_ID);
-    });
-
-    it('should get the current heating cooling state', async () => {
-        expect(await service.handleHotWaterTankCurrentHeatingCoolingStateGet()).toBe(Characteristic.CurrentHeatingCoolingState.HEAT);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['onOffMode'] = { value: 'off' };
-
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.CurrentHeatingCoolingState.OFF);
-    });
-
-    it('should get the current temperature', async () => {
-        expect(await service.handleHotWaterTankCurrentTemperatureGet()).toBe(48);
-    });
-
-    it('should get the target heating cooling temperature', async () => {
-        expect(await service.handleHotWaterTankHeatingTargetTemperatureGet()).toBe(48);
-    });
-
-    it('should get the target heating cooling state', async () => {
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.HEAT);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['operationMode'] = {
-            'settable': true,
-            'values': [
-                'auto',
-                'dry',
-                'cooling',
-                'heating',
-                'fanOnly',
-            ],
-            'value': 'cooling',
-        };
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.COOL);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['operationMode'] = {
-            'settable': true,
-            'values': [
-                'auto',
-                'dry',
-                'cooling',
-                'heating',
-                'fanOnly',
-            ],
-            'value': 'auto',
-        };
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.AUTO);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['operationMode'] = {
-            'settable': true,
-            'values': [
-                'auto',
-                'dry',
-                'cooling',
-                'heating',
-                'fanOnly',
-            ],
-            'value': 'fanOnly',
-        };
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.AUTO);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['operationMode'] = {
-            'settable': true,
-            'values': [
-                'auto',
-                'dry',
-                'cooling',
-                'heating',
-                'fanOnly',
-            ],
-            'value': 'dry',
-        };
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.AUTO);
-
-        getManagementPoint(accessory.context.device, EMBEDDED_ID)['onOffMode'] = { value: 'off' };
-        expect(await service.handleHotWaterTankTargetHeatingCoolingStateGet()).toBe(Characteristic.TargetHeatingCoolingState.OFF);
-    });
-
-    it('should get the powerful mode', async () => {
-        expect(await service.handlePowerfulModeGet()).toBe(false);
-    });
-});