tsvesync 1.0.90 → 1.0.92

package/dist/__tests__/fans/vesyncAir131.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncAir131 air quality data parsing and filter life handling
+ */
+export {};

package/dist/__tests__/fans/vesyncAir131.test.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * Unit tests for VeSyncAir131 air quality data parsing and filter life handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const air131_1 = require("../../lib/fans/air131");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+describe('VeSyncAir131 Air Quality Features', () => {
+    let device;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'LV-PUR131S Test',
+            deviceType: 'LV-PUR131S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'on',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAir131',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        device = new air131_1.VeSyncAir131(deviceDetails, mockManager);
+    });
+    describe('Air Quality Data Parsing', () => {
+        it('should parse air quality data with PM2.5 values', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 2,
+                        speed: 2,
+                        display: true,
+                        child_lock: false,
+                        night_light: 'off',
+                        air_quality: 2,
+                        air_quality_value: 28,
+                        filter_life: {
+                            percent: 68,
+                            replace_indicator: false
+                        },
+                        timer_remain: 0
+                    }
+                }
+            };
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(28);
+            expect(device.filterLife).toBe(68);
+        });
+        it('should handle air quality levels 1-5 mapping', () => {
+            const airQualityMappings = [
+                { level: 1, pm25: 8, description: 'Excellent' },
+                { level: 2, pm25: 22, description: 'Good' },
+                { level: 3, pm25: 38, description: 'Fair' },
+                { level: 4, pm25: 75, description: 'Poor' },
+                { level: 5, pm25: 150, description: 'Very Poor' }
+            ];
+            airQualityMappings.forEach(mapping => {
+                device.details = {
+                    air_quality: mapping.level,
+                    air_quality_value: mapping.pm25,
+                    filter_life: { percent: 50 }
+                };
+                expect(device.airQualityLevel).toBe(mapping.level);
+                expect(device.airQualityValue).toBe(mapping.pm25);
+            });
+        });
+        it('should handle missing air quality data', () => {
+            device.details = {
+                enabled: true,
+                mode: 'manual',
+                level: 3,
+                speed: 3,
+                filter_life: { percent: 45 }
+                // air_quality and air_quality_value missing
+            };
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+        });
+        it('should handle zero PM2.5 readings (perfect air)', () => {
+            device.details = {
+                air_quality: 1,
+                air_quality_value: 0,
+                filter_life: { percent: 85 }
+            };
+            expect(device.airQualityLevel).toBe(1);
+            expect(device.airQualityValue).toBe(0);
+        });
+        it('should handle hazardous air quality levels', () => {
+            device.details = {
+                air_quality: 5,
+                air_quality_value: 500,
+                filter_life: { percent: 25 }
+            };
+            expect(device.airQualityLevel).toBe(5);
+            expect(device.airQualityValue).toBe(500);
+        });
+    });
+    describe('Filter Life Object Format', () => {
+        it('should parse filter life object with percent', () => {
+            device.details = {
+                filter_life: {
+                    percent: 72,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(72);
+        });
+        it('should handle filter replacement indicator', () => {
+            device.details = {
+                filter_life: {
+                    percent: 8,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(8);
+        });
+        it('should handle new filter (100%)', () => {
+            device.details = {
+                filter_life: {
+                    percent: 100,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(100);
+        });
+        it('should handle filter needs replacement (0%)', () => {
+            device.details = {
+                filter_life: {
+                    percent: 0,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle missing percent in filter object', () => {
+            device.details = {
+                filter_life: {
+                    replace_indicator: true
+                    // percent missing
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle null filter life object', () => {
+            device.details = {
+                filter_life: null
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle empty filter life object', () => {
+            device.details = {
+                filter_life: {}
+            };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle malformed filter life object', () => {
+            device.details = {
+                filter_life: {
+                    percent: 'not_a_number',
+                    replace_indicator: 'not_a_boolean'
+                }
+            };
+            expect(device.filterLife).toBe(0);
+        });
+    });
+    describe('Device Configuration and Features', () => {
+        it('should support air quality features for LV-PUR131S', () => {
+            expect(device.hasFeature('air_quality')).toBe(true);
+            expect(device.hasFeature('display')).toBe(true);
+            expect(device.hasFeature('child_lock')).toBe(true);
+            expect(device.hasFeature('night_light')).toBe(true);
+            expect(device.hasFeature('timer')).toBe(true);
+            expect(device.hasFeature('fan_speed')).toBe(true);
+            expect(device.hasFeature('auto_mode')).toBe(true);
+        });
+        it('should return correct maximum speed for LV-PUR131S', () => {
+            expect(device.getMaxFanSpeed()).toBe(3); // LV series has 3 speeds
+        });
+        it('should handle LV-RH131S without air quality', () => {
+            const rh131s = new air131_1.VeSyncAir131({
+                deviceName: 'LV-RH131S Test',
+                deviceType: 'LV-RH131S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(rh131s.hasFeature('air_quality')).toBe(false);
+            expect(rh131s.hasFeature('display')).toBe(true);
+        });
+    });
+    describe('Mode-specific Behavior', () => {
+        it('should support air quality in auto mode', () => {
+            device.details.mode = 'auto';
+            expect(device.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should support air quality in manual mode', () => {
+            device.details.mode = 'manual';
+            expect(device.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+        });
+        it('should restrict fan speed control to manual mode', () => {
+            device.details.mode = 'manual';
+            expect(device.isFeatureSupportedInCurrentMode('fan_speed')).toBe(true);
+            device.details.mode = 'auto';
+            expect(device.isFeatureSupportedInCurrentMode('fan_speed')).toBe(false);
+        });
+        it('should disable display and child lock in sleep mode', () => {
+            device.details.mode = 'sleep';
+            expect(device.isFeatureSupportedInCurrentMode('display')).toBe(false);
+            expect(device.isFeatureSupportedInCurrentMode('child_lock')).toBe(false);
+        });
+    });
+    describe('State Tracking and Updates', () => {
+        it('should track complete device state', () => {
+            device.details = {
+                enabled: true,
+                mode: 'auto',
+                level: 2,
+                speed: 2,
+                display: true,
+                child_lock: false,
+                night_light: 'dim',
+                air_quality: 2,
+                air_quality_value: 32,
+                filter_life: {
+                    percent: 55,
+                    replace_indicator: false
+                },
+                timer_remain: 1800
+            };
+            expect(device.deviceStatus).toBe('on');
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(2);
+            expect(device.screenStatus).toBe('on'); // display: true maps to 'on'
+            expect(device.childLock).toBe(false);
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(32);
+            expect(device.filterLife).toBe(55);
+        });
+        it('should handle boolean display values correctly', () => {
+            device.details = { display: true };
+            expect(device.screenStatus).toBe('on');
+            device.details = { display: false };
+            expect(device.screenStatus).toBe('off');
+        });
+        it('should track filter replacement warnings', () => {
+            // Filter life getting low
+            device.details = {
+                filter_life: {
+                    percent: 15,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(15);
+            // Filter replacement needed
+            device.details = {
+                filter_life: {
+                    percent: 5,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(5);
+        });
+    });
+    describe('Air Quality History and Trends', () => {
+        it('should handle air quality improvements', () => {
+            // Poor air quality initially
+            device.details = {
+                air_quality: 4,
+                air_quality_value: 85,
+                filter_life: { percent: 40 }
+            };
+            expect(device.airQualityLevel).toBe(4);
+            // Air quality improves
+            device.details.air_quality = 2;
+            device.details.air_quality_value = 25;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(25);
+        });
+        it('should handle air quality deterioration', () => {
+            // Good air quality initially
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 20,
+                filter_life: { percent: 60 }
+            };
+            expect(device.airQualityLevel).toBe(2);
+            // Air quality worsens
+            device.details.air_quality = 4;
+            device.details.air_quality_value = 90;
+            expect(device.airQualityLevel).toBe(4);
+            expect(device.airQualityValue).toBe(90);
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        it('should handle completely missing details', () => {
+            device.details = undefined;
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle partial API responses', () => {
+            device.details = {
+                mode: 'auto',
+                speed: 1
+                // All other fields missing
+            };
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(1);
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle network errors gracefully', () => {
+            // Simulate network error - details remain from last update
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 30,
+                filter_life: { percent: 70 }
+            };
+            // Values preserved from last successful update
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(30);
+            expect(device.filterLife).toBe(70);
+        });
+        it('should handle invalid air quality levels', () => {
+            device.details = {
+                air_quality: 10, // Invalid level (should be 1-5)
+                air_quality_value: 50,
+                filter_life: { percent: 50 }
+            };
+            expect(device.airQualityLevel).toBe(10); // Return raw value for debugging
+            expect(device.airQualityValue).toBe(50);
+        });
+        it('should handle negative filter life percent', () => {
+            device.details = {
+                filter_life: {
+                    percent: -10,
+                    replace_indicator: true
+                }
+            };
+            expect(device.filterLife).toBe(-10); // Allow for error detection
+        });
+        it('should handle filter life percent over 100', () => {
+            device.details = {
+                filter_life: {
+                    percent: 150,
+                    replace_indicator: false
+                }
+            };
+            expect(device.filterLife).toBe(150); // Allow for error detection
+        });
+    });
+});

package/dist/__tests__/fans/vesyncAirBaseV2.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncAirBaseV2 air quality data parsing
+ */
+export {};

package/dist/__tests__/fans/vesyncAirBaseV2.test.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Unit tests for VeSyncAirBaseV2 air quality data parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const airBaseV2_1 = require("../../lib/fans/airBaseV2");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+describe('VeSyncAirBaseV2 Air Quality Features', () => {
+    let device;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'LAP-V102S Test',
+            deviceType: 'LAP-V102S-AASR',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'on',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAirBaseV2',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        device = new airBaseV2_1.VeSyncAirBaseV2(deviceDetails, mockManager);
+    });
+    describe('Air Quality Data Parsing', () => {
+        it('should parse comprehensive air quality data', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 2,
+                        speed: 2,
+                        display: 'on',
+                        child_lock: false,
+                        night_light: 'off',
+                        air_quality: 'Good',
+                        air_quality_value: 18,
+                        pm1: 12,
+                        pm10: 22,
+                        aq_percent: 85,
+                        filter_life: 78,
+                        timer_remain: 3600
+                    }
+                }
+            };
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe('Good');
+            expect(device.airQualityValue).toBe(18);
+            expect(device.pm1).toBe(12);
+            expect(device.pm10).toBe(22);
+            expect(device.aqPercent).toBe(85);
+            expect(device.filterLife).toBe(78);
+        });
+        it('should handle numeric air quality levels', () => {
+            device.details = {
+                air_quality: 3,
+                air_quality_value: 45,
+                pm1: 25,
+                pm10: 65,
+                filter_life: 45
+            };
+            expect(device.airQualityLevel).toBe(3);
+            expect(device.airQualityValue).toBe(45);
+            expect(device.pm1).toBe(25);
+            expect(device.pm10).toBe(65);
+        });
+        it('should handle string air quality levels', () => {
+            const qualityLevels = ['Excellent', 'Good', 'Fair', 'Poor', 'Very Poor'];
+            qualityLevels.forEach((level, index) => {
+                device.details = {
+                    air_quality: level,
+                    air_quality_value: (index + 1) * 20
+                };
+                expect(device.airQualityLevel).toBe(level);
+                expect(device.airQualityValue).toBe((index + 1) * 20);
+            });
+        });
+        it('should handle missing PM data gracefully', () => {
+            device.details = {
+                air_quality: 'Good',
+                air_quality_value: 20,
+                filter_life: 60
+                // pm1 and pm10 missing
+            };
+            expect(device.airQualityLevel).toBe('Good');
+            expect(device.airQualityValue).toBe(20);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.aqPercent).toBe(0);
+        });
+        it('should handle all PM values at zero', () => {
+            device.details = {
+                air_quality: 'Excellent',
+                air_quality_value: 0,
+                pm1: 0,
+                pm10: 0,
+                aq_percent: 100
+            };
+            expect(device.airQualityValue).toBe(0);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.aqPercent).toBe(100);
+        });
+        it('should handle extreme air quality values', () => {
+            device.details = {
+                air_quality: 'Hazardous',
+                air_quality_value: 300,
+                pm1: 200,
+                pm10: 400,
+                aq_percent: 5,
+                filter_life: 15
+            };
+            expect(device.airQualityLevel).toBe('Hazardous');
+            expect(device.airQualityValue).toBe(300);
+            expect(device.pm1).toBe(200);
+            expect(device.pm10).toBe(400);
+            expect(device.aqPercent).toBe(5);
+        });
+    });
+    describe('Filter Life Management', () => {
+        it('should handle normal filter life values', () => {
+            const testValues = [0, 25, 50, 75, 100];
+            testValues.forEach(value => {
+                device.details = { filter_life: value };
+                expect(device.filterLife).toBe(value);
+            });
+        });
+        it('should handle low filter life warning threshold', () => {
+            device.details = { filter_life: 5 };
+            expect(device.filterLife).toBe(5);
+        });
+        it('should handle filter replacement needed (0%)', () => {
+            device.details = { filter_life: 0 };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle new filter (100%)', () => {
+            device.details = { filter_life: 100 };
+            expect(device.filterLife).toBe(100);
+        });
+    });
+    describe('Device Configuration', () => {
+        it('should support air quality features for LAP-V102S', () => {
+            expect(device.hasFeature('air_quality')).toBe(true);
+            expect(device.hasFeature('display')).toBe(true);
+            expect(device.hasFeature('child_lock')).toBe(true);
+            expect(device.hasFeature('night_light')).toBe(true);
+            expect(device.hasFeature('timer')).toBe(true);
+            expect(device.hasFeature('fan_speed')).toBe(true);
+            expect(device.hasFeature('auto_mode')).toBe(true);
+        });
+        it('should return correct maximum speed', () => {
+            expect(device.getMaxFanSpeed()).toBe(4); // LAP-V102S has 4 speeds
+        });
+        it('should support air quality in all modes', () => {
+            const modes = ['auto', 'manual', 'sleep', 'turbo'];
+            modes.forEach(mode => {
+                device.details.mode = mode;
+                expect(device.isFeatureSupportedInCurrentMode('air_quality')).toBe(true);
+            });
+        });
+    });
+    describe('Real-time Data Updates', () => {
+        it('should handle real-time air quality updates', () => {
+            // Initial state
+            device.details = {
+                air_quality: 'Good',
+                air_quality_value: 25,
+                pm1: 15,
+                pm10: 35
+            };
+            expect(device.airQualityValue).toBe(25);
+            // Simulate air quality change
+            device.details.air_quality = 'Fair';
+            device.details.air_quality_value = 40;
+            device.details.pm1 = 28;
+            device.details.pm10 = 55;
+            expect(device.airQualityLevel).toBe('Fair');
+            expect(device.airQualityValue).toBe(40);
+            expect(device.pm1).toBe(28);
+            expect(device.pm10).toBe(55);
+        });
+        it('should handle rapid air quality fluctuations', () => {
+            const rapidUpdates = [
+                { quality: 'Good', value: 20 },
+                { quality: 'Fair', value: 35 },
+                { quality: 'Good', value: 22 },
+                { quality: 'Poor', value: 75 },
+                { quality: 'Fair', value: 38 }
+            ];
+            rapidUpdates.forEach(update => {
+                device.details.air_quality = update.quality;
+                device.details.air_quality_value = update.value;
+                expect(device.airQualityLevel).toBe(update.quality);
+                expect(device.airQualityValue).toBe(update.value);
+            });
+        });
+    });
+    describe('Device State Synchronization', () => {
+        it('should maintain consistent state across updates', () => {
+            device.details = {
+                enabled: true,
+                mode: 'auto',
+                level: 3,
+                speed: 3,
+                display: 'on',
+                child_lock: true,
+                air_quality: 'Good',
+                air_quality_value: 22,
+                filter_life: 65
+            };
+            expect(device.deviceStatus).toBe('on');
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(3);
+            expect(device.screenStatus).toBe('on');
+            expect(device.childLock).toBe(true);
+            expect(device.airQualityLevel).toBe('Good');
+            expect(device.filterLife).toBe(65);
+        });
+        it('should handle partial state updates', () => {
+            // Initial state
+            device.details = {
+                mode: 'auto',
+                speed: 2,
+                air_quality_value: 30,
+                filter_life: 70
+            };
+            // Partial update (only some fields changed)
+            device.details.air_quality_value = 35;
+            device.details.speed = 3;
+            expect(device.mode).toBe('auto'); // Unchanged
+            expect(device.speed).toBe(3); // Changed
+            expect(device.airQualityValue).toBe(35); // Changed
+            expect(device.filterLife).toBe(70); // Unchanged
+        });
+    });
+    describe('Error Conditions', () => {
+        it('should handle API errors gracefully', () => {
+            device.details = undefined;
+            expect(device.airQualityValue).toBe(0);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.aqPercent).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle corrupted data fields', () => {
+            device.details = {
+                air_quality: { invalid: 'object' },
+                air_quality_value: 'not_a_number',
+                pm1: null,
+                pm10: undefined,
+                filter_life: []
+            };
+            expect(device.airQualityLevel).toEqual({ invalid: 'object' });
+            expect(device.airQualityValue).toBe(0);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle network timeout scenarios', () => {
+            // Simulate stale data from last successful update
+            device.details = {
+                air_quality: 'Good',
+                air_quality_value: 25,
+                filter_life: 60
+            };
+            // Values should remain from last update
+            expect(device.airQualityLevel).toBe('Good');
+            expect(device.airQualityValue).toBe(25);
+            expect(device.filterLife).toBe(60);
+        });
+    });
+});

package/dist/__tests__/fans/vesyncAirBypass.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncAirBypass air quality data parsing
+ */
+export {};