meross-cli 0.3.0 → 0.5.0

package/cli/tests/test-system.js

@@ -0,0 +1,375 @@
+'use strict';
+
+/**
+ * System Device Tests
+ * Tests system information, hardware, firmware, abilities, and configuration
+ */
+
+const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStatus } = require('./test-helper');
+
+const metadata = {
+    name: 'system',
+    description: 'Tests system information, hardware, firmware, abilities, and configuration',
+    requiredAbilities: ['Appliance.System.All', 'Appliance.System.Ability'],
+    minDevices: 1
+};
+
+async function runTests(context) {
+    const { manager, devices, options = {} } = context;
+    const timeout = options.timeout || 30000;
+    const results = [];
+    
+    // If no devices provided, discover them
+    let testDevices = devices || [];
+    if (testDevices.length === 0) {
+        // Find devices with system abilities (most devices support this)
+        const systemDevices = await findDevicesByAbility(manager, 'Appliance.System.All', OnlineStatus.ONLINE);
+        
+        // Also try System.Ability if no devices found
+        if (systemDevices.length === 0) {
+            const abilityDevices = await findDevicesByAbility(manager, 'Appliance.System.Ability', OnlineStatus.ONLINE);
+            testDevices = abilityDevices;
+        } else {
+            testDevices = systemDevices;
+        }
+        
+        // Fallback: get any online device (most devices support system features)
+        if (testDevices.length === 0) {
+            const allDevices = manager.devices.list();
+            const onlineDevices = allDevices.filter(device => {
+                return device.onlineStatus === OnlineStatus.ONLINE;
+            });
+            testDevices = onlineDevices.slice(0, 1);
+        }
+    }
+    
+    // Wait for devices to be connected
+    for (const device of testDevices) {
+        await waitForDeviceConnection(device, timeout);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should find devices with system capabilities',
+            passed: false,
+            skipped: true,
+            error: 'No device has been found to run this test on',
+            device: null
+        });
+        return results;
+    }
+    
+    results.push({
+        name: 'should find devices with system capabilities',
+        passed: true,
+        skipped: false,
+        error: null,
+        device: null
+    });
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    // Test 1: Get all system data
+    try {
+        if (!testDevice.system || typeof testDevice.system.getAllData !== 'function') {
+            results.push({
+                name: 'should get all system data',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getAllData',
+                device: deviceName
+            });
+        } else {
+            const allData = await testDevice.system.getAllData();
+            
+            if (!allData || typeof allData !== 'object') {
+                results.push({
+                    name: 'should get all system data',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getAllData() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get all system data',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasAllData: !!allData.all }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get all system data',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Get device abilities
+    try {
+        if (!testDevice.system || typeof testDevice.system.getAbilities !== 'function') {
+            results.push({
+                name: 'should get device abilities',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getAbilities',
+                device: deviceName
+            });
+        } else {
+            const abilities = await testDevice.system.getAbilities();
+            
+            if (!abilities || typeof abilities !== 'object') {
+                results.push({
+                    name: 'should get device abilities',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getAbilities() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                const abilityCount = abilities.ability ? Object.keys(abilities.ability).length : 0;
+                results.push({
+                    name: 'should get device abilities',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { abilityCount: abilityCount }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get device abilities',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 3: Get hardware information
+    try {
+        if (!testDevice.system || typeof testDevice.system.getHardware !== 'function') {
+            results.push({
+                name: 'should get hardware information',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getHardware',
+                device: deviceName
+            });
+        } else {
+            const hardware = await testDevice.system.getHardware();
+            
+            if (!hardware || typeof hardware !== 'object') {
+                results.push({
+                    name: 'should get hardware information',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getHardware() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get hardware information',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasHardware: !!hardware.hardware }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get hardware information',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 4: Get firmware information
+    try {
+        if (!testDevice.system || typeof testDevice.system.getFirmware !== 'function') {
+            results.push({
+                name: 'should get firmware information',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getFirmware',
+                device: deviceName
+            });
+        } else {
+            const firmware = await testDevice.system.getFirmware();
+            
+            if (!firmware || typeof firmware !== 'object') {
+                results.push({
+                    name: 'should get firmware information',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getFirmware() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get firmware information',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasFirmware: !!firmware.firmware }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get firmware information',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 5: Get online status
+    try {
+        if (!testDevice.system || typeof testDevice.system.getOnlineStatus !== 'function') {
+            results.push({
+                name: 'should get online status',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getOnlineStatus',
+                device: deviceName
+            });
+        } else {
+            const onlineStatus = await testDevice.system.getOnlineStatus();
+            
+            if (!onlineStatus || typeof onlineStatus !== 'object') {
+                results.push({
+                    name: 'should get online status',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getOnlineStatus() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get online status',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasOnlineStatus: !!onlineStatus.online }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get online status',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 6: Get time information
+    try {
+        if (!testDevice.system || typeof testDevice.system.getTime !== 'function') {
+            results.push({
+                name: 'should get time information',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getTime',
+                device: deviceName
+            });
+        } else {
+            const time = await testDevice.system.getTime();
+            
+            if (!time || typeof time !== 'object') {
+                results.push({
+                    name: 'should get time information',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getTime() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get time information',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasTime: !!time.time }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get time information',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 7: Get LED mode (if supported)
+    try {
+        if (!testDevice.system || typeof testDevice.system.getLedMode !== 'function') {
+            results.push({
+                name: 'should get LED mode',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support system.getLedMode',
+                device: deviceName
+            });
+        } else {
+            const ledMode = await testDevice.system.getLedMode();
+            
+            if (!ledMode || typeof ledMode !== 'object') {
+                results.push({
+                    name: 'should get LED mode',
+                    passed: false,
+                    skipped: false,
+                    error: 'system.getLedMode() returned null, undefined, or non-object',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get LED mode',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { hasLedMode: !!ledMode.ledMode }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get LED mode',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};

package/cli/tests/test-temp-unit.js

@@ -47,7 +47,17 @@ async function runTests(context) {
     
     // Test 1: Get temp unit
     try {
-        const response = await testDevice.getTempUnit(0);
+        if (!testDevice.tempUnit) {
+            results.push({
+                name: 'should get temp unit',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support temp unit feature',
+                device: deviceName
+            });
+            return results;
+        }
+        const response = await testDevice.tempUnit.get({ channel: 0 });
         
         if (!response) {
             results.push({
@@ -87,8 +97,18 @@ async function runTests(context) {
     
     // Test 2: Control temp unit
     try {
+        if (!testDevice.tempUnit) {
+            results.push({
+                name: 'should control temp unit',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support temp unit feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get current temp unit first
-        const currentResponse = await testDevice.getTempUnit(0);
+        const currentResponse = await testDevice.tempUnit.get({ channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
         
         if (!currentResponse || !Array.isArray(currentResponse.tempUnit) || currentResponse.tempUnit.length === 0) {

package/cli/tests/test-template.js

@@ -90,21 +90,20 @@ async function runTests(context) {
     const deviceName = getDeviceName(testDevice);
     
     try {
-        if (typeof testDevice.getToggleState === 'function') {
-            const toggleState = await testDevice.getToggleState(0);
+        if (testDevice.toggle) {
+            const toggleState = await testDevice.toggle.get({ channel: 0 });
             
             if (!toggleState) {
                 results.push({
                     name: 'should get toggle state',
                     passed: false,
                     skipped: false,
-                    error: 'getToggleState returned null or undefined',
+                    error: 'toggle.get() returned null or undefined',
                     device: deviceName
                 });
             } else {
                 // Check cached toggle state
-                const cachedState = testDevice.getCachedToggleState(0);
-                const isOn = testDevice.isOn(0);
+                const isOn = testDevice.toggle.isOn({ channel: 0 });
                 
                 results.push({
                     name: 'should get toggle state',
@@ -114,7 +113,6 @@ async function runTests(context) {
                     device: deviceName,
                     details: {
                         toggleState: toggleState,
-                        cachedState: cachedState,
                         isOn: isOn
                     }
                 });
@@ -124,7 +122,7 @@ async function runTests(context) {
                 name: 'should get toggle state',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getToggleState',
+                error: 'Device does not support toggle feature',
                 device: deviceName
             });
         }
@@ -140,81 +138,71 @@ async function runTests(context) {
     
     // Test 3: Control toggle state (turn on/off)
     try {
-        // Get initial state
-        let initialState = undefined;
-        if (typeof testDevice.getToggleState === 'function') {
-            const stateResponse = await testDevice.getToggleState(0);
-            if (stateResponse && stateResponse.togglex) {
-                initialState = stateResponse.togglex[0]?.onoff || stateResponse.togglex.onoff;
-            }
-        } else if (typeof testDevice.isOn === 'function') {
-            initialState = testDevice.isOn(0);
-        }
-        
-        // Test turnOn if available
-        if (typeof testDevice.turnOn === 'function') {
-            await testDevice.turnOn(0);
+        if (!testDevice.toggle) {
+            results.push({
+                name: 'should control toggle state',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support toggle feature',
+                device: deviceName
+            });
+        } else {
+            // Get initial state
+            let initialState = testDevice.toggle.isOn({ channel: 0 });
+            
+            // Test turn on
+            await testDevice.toggle.set({ on: true, channel: 0 });
             await new Promise(resolve => setTimeout(resolve, 2000));
             
             // Verify state
-            if (typeof testDevice.isOn === 'function') {
-                const isOnAfter = testDevice.isOn(0);
-                if (!isOnAfter) {
-                    results.push({
-                        name: 'should control toggle state (turn on)',
-                        passed: false,
-                        skipped: false,
-                        error: 'Device did not turn on after turnOn() call',
-                        device: deviceName
-                    });
-                } else {
-                    results.push({
-                        name: 'should control toggle state (turn on)',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName
-                    });
-                }
+            const isOnAfter = testDevice.toggle.isOn({ channel: 0 });
+            if (!isOnAfter) {
+                results.push({
+                    name: 'should control toggle state (turn on)',
+                    passed: false,
+                    skipped: false,
+                    error: 'Device did not turn on after toggle.set({ on: true, channel: 0 }) call',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should control toggle state (turn on)',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
             }
-        }
-        
-        // Test turnOff if available
-        if (typeof testDevice.turnOff === 'function') {
-            await testDevice.turnOff(0);
+            
+            // Test turn off
+            await testDevice.toggle.set({ on: false, channel: 0 });
             await new Promise(resolve => setTimeout(resolve, 2000));
             
             // Verify state
-            if (typeof testDevice.isOn === 'function') {
-                const isOnAfter = testDevice.isOn(0);
-                if (isOnAfter) {
-                    results.push({
-                        name: 'should control toggle state (turn off)',
-                        passed: false,
-                        skipped: false,
-                        error: 'Device did not turn off after turnOff() call',
-                        device: deviceName
-                    });
-                } else {
-                    results.push({
-                        name: 'should control toggle state (turn off)',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName
-                    });
-                }
-            }
-        }
-        
-        // Restore initial state if we changed it
-        if (initialState !== undefined && typeof testDevice.turnOn === 'function' && typeof testDevice.turnOff === 'function') {
-            if (initialState === 1 || initialState === true) {
-                await testDevice.turnOn(0);
+            const isOffAfter = testDevice.toggle.isOn({ channel: 0 });
+            if (isOffAfter) {
+                results.push({
+                    name: 'should control toggle state (turn off)',
+                    passed: false,
+                    skipped: false,
+                    error: 'Device did not turn off after toggle.set({ on: false, channel: 0 }) call',
+                    device: deviceName
+                });
             } else {
-                await testDevice.turnOff(0);
+                results.push({
+                    name: 'should control toggle state (turn off)',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
+            }
+            
+            // Restore initial state if we changed it
+            if (initialState !== undefined) {
+                await testDevice.toggle.set({ on: initialState, channel: 0 });
+                await new Promise(resolve => setTimeout(resolve, 2000));
             }
-            await new Promise(resolve => setTimeout(resolve, 2000));
         }
         
     } catch (error) {