tsvesync 1.0.89 → 1.0.91

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 {};

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

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Unit tests for VeSyncAirBypass air quality data parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const airBypass_1 = require("../../lib/fans/airBypass");
+// Mock VeSync manager
+const mockManager = {
+    username: 'test@example.com',
+    password: 'testpass',
+    token: 'testtoken',
+    accountID: 'testaccount',
+    apiKey: 'testapikey',
+    apiBase: 'testbase',
+    timezone: 'UTC'
+};
+describe('VeSyncAirBypass Air Quality Features', () => {
+    let device;
+    beforeEach(() => {
+        const deviceDetails = {
+            deviceName: 'Core300S Test',
+            deviceType: 'Core300S',
+            cid: 'test-cid',
+            uuid: 'test-uuid',
+            deviceStatus: 'on',
+            deviceRegion: 'US',
+            configModule: 'VeSyncAirBypass',
+            macId: '00:11:22:33:44:55',
+            deviceCategory: 'fan',
+            connectionStatus: 'online'
+        };
+        device = new airBypass_1.VeSyncAirBypass(deviceDetails, mockManager);
+    });
+    describe('Air Quality Data Parsing', () => {
+        it('should parse air quality data from device response', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 3,
+                        speed: 3,
+                        display: 'on',
+                        child_lock: false,
+                        night_light: 'dim',
+                        air_quality: 2,
+                        air_quality_value: 15,
+                        filter_life: 85,
+                        timer_remain: 0
+                    }
+                }
+            };
+            // Simulate API response parsing
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe(2);
+            expect(device.airQualityValue).toBe(15);
+            expect(device.filterLife).toBe(85);
+        });
+        it('should handle missing air quality data gracefully', () => {
+            const mockResponse = {
+                result: {
+                    code: 0,
+                    result: {
+                        enabled: true,
+                        mode: 'auto',
+                        level: 3,
+                        speed: 3,
+                        display: 'on',
+                        child_lock: false,
+                        filter_life: 85
+                        // air_quality and air_quality_value missing
+                    }
+                }
+            };
+            device.details = mockResponse.result.result;
+            expect(device.airQualityLevel).toBe('');
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(85);
+        });
+        it('should handle various air quality value ranges', () => {
+            const testCases = [
+                { value: 0, level: 1, expected: 'Excellent' },
+                { value: 12, level: 1, expected: 'Good' },
+                { value: 25, level: 2, expected: 'Fair' },
+                { value: 55, level: 3, expected: 'Inferior' },
+                { value: 150, level: 4, expected: 'Poor' },
+                { value: 500, level: 5, expected: 'Poor' }
+            ];
+            testCases.forEach(testCase => {
+                device.details = {
+                    air_quality: testCase.level,
+                    air_quality_value: testCase.value,
+                    filter_life: 50
+                };
+                expect(device.airQualityValue).toBe(testCase.value);
+                expect(device.airQualityLevel).toBe(testCase.level);
+            });
+        });
+        it('should handle extended air quality data with PM1 and PM10', () => {
+            device.details = {
+                air_quality: 2,
+                air_quality_value: 20,
+                pm1: 15,
+                pm10: 35,
+                aq_percent: 75,
+                filter_life: 60
+            };
+            expect(device.airQualityValue).toBe(20);
+            expect(device.pm1).toBe(15);
+            expect(device.pm10).toBe(35);
+            expect(device.aqPercent).toBe(75);
+        });
+        it('should handle zero PM values correctly', () => {
+            device.details = {
+                air_quality: 1,
+                air_quality_value: 0,
+                pm1: 0,
+                pm10: 0,
+                aq_percent: 100,
+                filter_life: 100
+            };
+            expect(device.airQualityValue).toBe(0);
+            expect(device.pm1).toBe(0);
+            expect(device.pm10).toBe(0);
+            expect(device.aqPercent).toBe(100);
+        });
+    });
+    describe('Filter Life Parsing', () => {
+        it('should parse filter life as number', () => {
+            device.details = { filter_life: 75 };
+            expect(device.filterLife).toBe(75);
+        });
+        it('should handle zero filter life', () => {
+            device.details = { filter_life: 0 };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle 100% filter life', () => {
+            device.details = { filter_life: 100 };
+            expect(device.filterLife).toBe(100);
+        });
+        it('should handle missing filter life data', () => {
+            device.details = { mode: 'auto', speed: 3 };
+            expect(device.filterLife).toBe(0);
+        });
+        it('should handle invalid filter life data types', () => {
+            device.details = { filter_life: 'invalid' };
+            expect(device.filterLife).toBe(0);
+        });
+    });
+    describe('Feature Support', () => {
+        it('should support air quality features for Core300S', () => {
+            expect(device.hasFeature('air_quality')).toBe(true);
+            expect(device.hasFeature('auto_mode')).toBe(true);
+            expect(device.hasFeature('display')).toBe(true);
+            expect(device.hasFeature('child_lock')).toBe(true);
+            expect(device.hasFeature('night_light')).toBe(true);
+        });
+        it('should not support air quality for Core200S', () => {
+            const core200s = new airBypass_1.VeSyncAirBypass({
+                deviceName: 'Core200S Test',
+                deviceType: 'Core200S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(core200s.hasFeature('air_quality')).toBe(false);
+            expect(core200s.hasFeature('auto_mode')).toBe(false);
+        });
+        it('should return correct max speed for different models', () => {
+            expect(device.getMaxFanSpeed()).toBe(4); // Core300S has 4 speeds
+            const core200s = new airBypass_1.VeSyncAirBypass({
+                deviceName: 'Core200S Test',
+                deviceType: 'Core200S',
+                cid: 'test-cid',
+                uuid: 'test-uuid'
+            }, mockManager);
+            expect(core200s.getMaxFanSpeed()).toBe(3); // Core200S has 3 speeds
+        });
+    });
+    describe('Device State Management', () => {
+        it('should track device state correctly', () => {
+            device.details = {
+                enabled: true,
+                mode: 'auto',
+                level: 3,
+                speed: 3,
+                display: 'on',
+                child_lock: false,
+                air_quality: 2,
+                air_quality_value: 25,
+                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(false);
+        });
+        it('should handle device off state', () => {
+            device.deviceStatus = 'off';
+            device.details = {
+                enabled: false,
+                mode: 'manual',
+                level: 0,
+                speed: 0,
+                air_quality_value: 0
+            };
+            expect(device.deviceStatus).toBe('off');
+            expect(device.speed).toBe(0);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle malformed API responses', () => {
+            device.details = null;
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+            expect(device.mode).toBe('');
+            expect(device.speed).toBe(0);
+        });
+        it('should handle partial API responses', () => {
+            device.details = {
+                mode: 'auto'
+                // Other fields missing
+            };
+            expect(device.airQualityValue).toBe(0);
+            expect(device.filterLife).toBe(0);
+            expect(device.mode).toBe('auto');
+            expect(device.speed).toBe(0);
+        });
+        it('should handle negative values gracefully', () => {
+            device.details = {
+                air_quality_value: -10,
+                pm1: -5,
+                pm10: -15,
+                filter_life: -20
+            };
+            expect(device.airQualityValue).toBe(-10); // Allow negative for error detection
+            expect(device.pm1).toBe(-5);
+            expect(device.pm10).toBe(-15);
+            expect(device.filterLife).toBe(-20);
+        });
+        it('should handle extremely high values', () => {
+            device.details = {
+                air_quality_value: 9999,
+                pm1: 5000,
+                pm10: 8000,
+                filter_life: 200,
+                aq_percent: 150
+            };
+            expect(device.airQualityValue).toBe(9999);
+            expect(device.pm1).toBe(5000);
+            expect(device.pm10).toBe(8000);
+            expect(device.filterLife).toBe(200);
+            expect(device.aqPercent).toBe(150);
+        });
+    });
+});

package/dist/__tests__/vesyncFan.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for VeSyncFan base class and air quality features
+ */
+export {};