meross-cli 0.1.0

package/cli/tests/test-child-lock.js

@@ -0,0 +1,248 @@
+'use strict';
+
+/**
+ * Child Lock (Physical Lock) Tests
+ * Tests physical lock/child lock safety features
+ */
+
+const { findDevicesByAbility, getDeviceName, OnlineStatus } = require('./test-helper');
+
+const metadata = {
+    name: 'child-lock',
+    description: 'Tests physical lock/child lock safety features',
+    requiredAbilities: ['Appliance.Control.PhysicalLock'],
+    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) {
+        testDevices = await findDevicesByAbility(manager, 'Appliance.Control.PhysicalLock', OnlineStatus.ONLINE);
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should find devices with child lock capability',
+            passed: false,
+            skipped: true,
+            error: 'No devices with child lock capability found',
+            device: null
+        });
+        return results;
+    }
+    
+    results.push({
+        name: 'should find devices with child lock capability',
+        passed: true,
+        skipped: false,
+        error: null,
+        device: null
+    });
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    // Test 1: Get child lock status
+    try {
+        const lockStatus = await testDevice.getChildLock({ channel: 0 });
+        
+        if (!lockStatus) {
+            results.push({
+                name: 'should get child lock status',
+                passed: false,
+                skipped: false,
+                error: 'getChildLock returned null or undefined',
+                device: deviceName
+            });
+        } else if (!lockStatus.lock) {
+            results.push({
+                name: 'should get child lock status',
+                passed: false,
+                skipped: false,
+                error: 'Response does not contain lock property',
+                device: deviceName
+            });
+        } else {
+            results.push({
+                name: 'should get child lock status',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { lockStatus: lockStatus.lock }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get child lock status',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Control child lock status
+    try {
+        // Get initial lock status
+        const initialStatus = await testDevice.getChildLock({ channel: 0 });
+        
+        if (!initialStatus || !initialStatus.lock || !Array.isArray(initialStatus.lock) || initialStatus.lock.length === 0) {
+            results.push({
+                name: 'should control child lock status',
+                passed: false,
+                skipped: true,
+                error: 'Could not get initial lock status or lock array is empty',
+                device: deviceName
+            });
+        } else {
+            const initialLockState = initialStatus.lock[0].onoff;
+            
+            // Toggle lock state
+            const newLockState = initialLockState === 1 ? 0 : 1;
+            const lockData = {
+                channel: 0,
+                onoff: newLockState
+            };
+            
+            await testDevice.setChildLock(lockData);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // Verify the change
+            const updatedStatus = await testDevice.getChildLock({ channel: 0 });
+            
+            if (!updatedStatus || !updatedStatus.lock || !updatedStatus.lock[0]) {
+                results.push({
+                    name: 'should control child lock status',
+                    passed: false,
+                    skipped: false,
+                    error: 'Could not verify updated lock status',
+                    device: deviceName
+                });
+            } else if (updatedStatus.lock[0].onoff !== newLockState) {
+                results.push({
+                    name: 'should control child lock status',
+                    passed: false,
+                    skipped: false,
+                    error: `Lock state did not change. Expected ${newLockState}, got ${updatedStatus.lock[0].onoff}`,
+                    device: deviceName
+                });
+            } else {
+                // Restore original state
+                const restoreLockData = {
+                    channel: 0,
+                    onoff: initialLockState
+                };
+                await testDevice.setChildLock(restoreLockData);
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                
+                const restoredStatus = await testDevice.getChildLock({ channel: 0 });
+                
+                if (!restoredStatus || !restoredStatus.lock || !restoredStatus.lock[0] || 
+                    restoredStatus.lock[0].onoff !== initialLockState) {
+                    results.push({
+                        name: 'should control child lock status',
+                        passed: false,
+                        skipped: false,
+                        error: `Failed to restore lock state. Expected ${initialLockState}, got ${restoredStatus?.lock?.[0]?.onoff}`,
+                        device: deviceName
+                    });
+                } else {
+                    results.push({
+                        name: 'should control child lock status',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should control child lock status',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 3: Handle multiple channel lock control
+    try {
+        // Get initial status for all channels
+        const initialStatus = await testDevice.getChildLock({ channel: 0 });
+        
+        if (!initialStatus || !initialStatus.lock) {
+            results.push({
+                name: 'should handle multiple channel lock control',
+                passed: false,
+                skipped: true,
+                error: 'Could not get initial lock status',
+                device: deviceName
+            });
+        } else {
+            // Control multiple channels using array
+            const lockDataArray = [
+                {
+                    channel: 0,
+                    onoff: initialStatus.lock[0]?.onoff || 0
+                }
+            ];
+            
+            // If device has multiple channels, add them
+            if (initialStatus.lock.length > 1) {
+                for (let i = 1; i < initialStatus.lock.length; i++) {
+                    lockDataArray.push({
+                        channel: initialStatus.lock[i].channel || i,
+                        onoff: initialStatus.lock[i].onoff || 0
+                    });
+                }
+            }
+            
+            await testDevice.setChildLock({ lockData: lockDataArray });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // Verify all channels were set
+            const updatedStatus = await testDevice.getChildLock({ channel: 0 });
+            
+            if (!updatedStatus) {
+                results.push({
+                    name: 'should handle multiple channel lock control',
+                    passed: false,
+                    skipped: false,
+                    error: 'Could not verify updated lock status',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should handle multiple channel lock control',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should handle multiple channel lock control',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};

package/cli/tests/test-config.js

@@ -0,0 +1,133 @@
+'use strict';
+
+/**
+ * Config Device Tests
+ * Tests device configuration and settings
+ */
+
+const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStatus } = require('./test-helper');
+
+const metadata = {
+    name: 'config',
+    description: 'Tests device configuration and settings',
+    requiredAbilities: ['Appliance.Config.OverTemp'],
+    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) {
+        testDevices = await findDevicesByAbility(manager, 'Appliance.Config.OverTemp', OnlineStatus.ONLINE);
+    }
+    
+    // Wait for devices to be connected
+    for (const device of testDevices) {
+        await waitForDeviceConnection(device, timeout);
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should get config over temp',
+            passed: false,
+            skipped: true,
+            error: 'No Config Over Temp device has been found to run this test on',
+            device: null
+        });
+        return results;
+    }
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    // Test 1: Get config over temp
+    try {
+        const response = await testDevice.getConfigOverTemp();
+        
+        if (!response) {
+            results.push({
+                name: 'should get config over temp',
+                passed: false,
+                skipped: false,
+                error: 'getConfigOverTemp returned null or undefined',
+                device: deviceName
+            });
+        } else if (!response.overTemp) {
+            results.push({
+                name: 'should get config over temp',
+                passed: false,
+                skipped: false,
+                error: 'Response does not contain overTemp property',
+                device: deviceName
+            });
+        } else {
+            results.push({
+                name: 'should get config over temp',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { overTemp: response.overTemp }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get config over temp',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Control config over temp
+    try {
+        // Get current config first
+        const currentResponse = await testDevice.getConfigOverTemp();
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        if (!currentResponse || !currentResponse.overTemp) {
+            results.push({
+                name: 'should control config over temp',
+                passed: false,
+                skipped: true,
+                error: 'Could not get current config over temp',
+                device: deviceName
+            });
+        } else {
+            // Note: We don't actually change the config to avoid disrupting the device
+            // We just verify the method exists and can be called
+            results.push({
+                name: 'should control config over temp',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { 
+                    note: 'Method exists, but not changing config to avoid disrupting device',
+                    currentConfig: currentResponse.overTemp
+                }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should control config over temp',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};

package/cli/tests/test-control.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Control Device Tests
+ * Tests multiple control features and device capabilities
+ */
+
+const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStatus } = require('./test-helper');
+
+const metadata = {
+    name: 'control',
+    description: 'Tests multiple control features and device capabilities',
+    requiredAbilities: ['Appliance.Control.Multiple', 'Appliance.Control.Upgrade', 'Appliance.Control.OverTemp'],
+    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 control multiple support (most devices support this)
+        const multipleDevices = await findDevicesByAbility(manager, 'Appliance.Control.Multiple', OnlineStatus.ONLINE);
+        
+        // Also get any online device for testing control features
+        const allDevices = manager.getAllDevices();
+        const onlineDevices = allDevices.filter(device => {
+            const status = device.onlineStatus !== undefined ? device.onlineStatus : (device.dev?.onlineStatus);
+            return status === OnlineStatus.ONLINE;
+        });
+        
+        // Combine and deduplicate
+        testDevices = [...multipleDevices];
+        for (const device of onlineDevices.slice(0, 2)) {
+            const uuid = device.dev?.uuid || device.uuid;
+            if (!testDevices.find(d => (d.dev?.uuid || d.uuid) === uuid)) {
+                testDevices.push(device);
+            }
+        }
+    }
+    
+    // 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 control capabilities',
+            passed: false,
+            skipped: true,
+            error: 'No device has been found to run this test on',
+            device: null
+        });
+        return results;
+    }
+    
+    const device = testDevices[0];
+    const deviceName = getDeviceName(device);
+    
+    // Test 1: Control Multiple
+    try {
+        if (typeof device.setMultiple !== 'function') {
+            results.push({
+                name: 'should execute multiple commands',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support setMultiple',
+                device: deviceName
+            });
+        } else {
+            const commands = [
+                {
+                    namespace: 'Appliance.System.All',
+                    method: 'GET',
+                    payload: {}
+                },
+                {
+                    namespace: 'Appliance.System.Ability',
+                    method: 'GET',
+                    payload: {}
+                }
+            ];
+            
+            const response = await device.setMultiple(commands);
+            
+            if (!response) {
+                results.push({
+                    name: 'should execute multiple commands',
+                    passed: false,
+                    skipped: false,
+                    error: 'setMultiple returned null or undefined',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should execute multiple commands',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should execute multiple commands',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Control Over Temp
+    try {
+        if (typeof device.acknowledgeControlOverTemp !== 'function') {
+            results.push({
+                name: 'should acknowledge over temp event',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support acknowledgeControlOverTemp',
+                device: deviceName
+            });
+        } else {
+            // Note: OverTemp is typically SET by the device, and we acknowledge it
+            // We don't actually trigger an over temp event, just verify the method exists
+            results.push({
+                name: 'should acknowledge over temp event',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { note: 'Method exists, but not triggering actual over temp event' }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should acknowledge over temp event',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 3: Control Upgrade
+    try {
+        if (typeof device.setUpgrade !== 'function') {
+            results.push({
+                name: 'should have upgrade method available',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support setUpgrade',
+                device: deviceName
+            });
+        } else {
+            // Note: We don't actually trigger an upgrade to avoid disrupting the device
+            // We just verify the method exists
+            results.push({
+                name: 'should have upgrade method available',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { note: 'Method exists, but not triggering actual upgrade' }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should have upgrade method available',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};