meross-cli 0.1.0

package/cli/tests/test-dnd.js

@@ -0,0 +1,246 @@
+'use strict';
+
+/**
+ * DND Mode Tests
+ * Tests do-not-disturb mode functionality
+ */
+
+const { findDevicesByAbility, getDeviceName, OnlineStatus } = require('./test-helper');
+const { DNDMode } = require('meross-iot');
+
+const metadata = {
+    name: 'dnd',
+    description: 'Tests do-not-disturb mode functionality',
+    requiredAbilities: ['Appliance.System.DNDMode'],
+    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 that support DND mode (most devices support this)
+        const allDevices = manager.getAllDevices();
+        testDevices = allDevices.filter(d => {
+            const status = d.onlineStatus !== undefined ? d.onlineStatus : (d.dev?.onlineStatus);
+            return status === OnlineStatus.ONLINE &&
+                   typeof d.getDNDMode === 'function' &&
+                   typeof d.setDNDMode === 'function';
+        });
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should find devices with DND mode capability',
+            passed: false,
+            skipped: true,
+            error: 'No online devices found to test DND mode',
+            device: null
+        });
+        return results;
+    }
+    
+    results.push({
+        name: 'should find devices with DND mode capability',
+        passed: true,
+        skipped: false,
+        error: null,
+        device: null
+    });
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    // Test 1: Get and set DND mode
+    try {
+        // Get current DND mode
+        const initialMode = await testDevice.getDNDMode();
+        
+        if (initialMode === null || initialMode === undefined) {
+            results.push({
+                name: 'should get and set DND mode',
+                passed: false,
+                skipped: false,
+                error: 'getDNDMode returned null or undefined',
+                device: deviceName
+            });
+        } else if (initialMode !== DNDMode.DND_DISABLED && initialMode !== DNDMode.DND_ENABLED) {
+            results.push({
+                name: 'should get and set DND mode',
+                passed: false,
+                skipped: false,
+                error: `Invalid DND mode value: ${initialMode}`,
+                device: deviceName
+            });
+        } else {
+            // Toggle DND mode
+            const newMode = initialMode === DNDMode.DND_ENABLED ? DNDMode.DND_DISABLED : DNDMode.DND_ENABLED;
+            await testDevice.setDNDMode({ mode: newMode });
+            
+            // Wait for the change to take effect
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            // Verify the change
+            const updatedMode = await testDevice.getDNDMode();
+            
+            if (updatedMode !== newMode) {
+                results.push({
+                    name: 'should get and set DND mode',
+                    passed: false,
+                    skipped: false,
+                    error: `DND mode did not change. Expected ${newMode}, got ${updatedMode}`,
+                    device: deviceName
+                });
+            } else {
+                // Restore original mode
+                await testDevice.setDNDMode({ mode: initialMode });
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                
+                const restoredMode = await testDevice.getDNDMode();
+                
+                if (restoredMode !== initialMode) {
+                    results.push({
+                        name: 'should get and set DND mode',
+                        passed: false,
+                        skipped: false,
+                        error: `Failed to restore DND mode. Expected ${initialMode}, got ${restoredMode}`,
+                        device: deviceName
+                    });
+                } else {
+                    results.push({
+                        name: 'should get and set DND mode',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get and set DND mode',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Accept boolean values for DND mode
+    try {
+        // Get current mode
+        const initialMode = await testDevice.getDNDMode();
+        const initialBoolean = initialMode === DNDMode.DND_ENABLED;
+        
+        // Set using boolean (true = enabled)
+        await testDevice.setDNDMode({ mode: !initialBoolean });
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        const updatedMode = await testDevice.getDNDMode();
+        const expectedMode = !initialBoolean ? DNDMode.DND_ENABLED : DNDMode.DND_DISABLED;
+        
+        if (updatedMode !== expectedMode) {
+            results.push({
+                name: 'should accept boolean values for DND mode',
+                passed: false,
+                skipped: false,
+                error: `Boolean set failed. Expected ${expectedMode}, got ${updatedMode}`,
+                device: deviceName
+            });
+        } else {
+            // Restore original mode
+            await testDevice.setDNDMode({ mode: initialBoolean });
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            
+            results.push({
+                name: 'should accept boolean values for DND mode',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should accept boolean values for DND mode',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 3: Get raw DND mode value
+    try {
+        if (typeof testDevice.getRawDNDMode !== 'function') {
+            results.push({
+                name: 'should get raw DND mode value',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support getRawDNDMode',
+                device: deviceName
+            });
+        } else {
+            const rawMode = await testDevice.getRawDNDMode();
+            
+            if (typeof rawMode !== 'number') {
+                results.push({
+                    name: 'should get raw DND mode value',
+                    passed: false,
+                    skipped: false,
+                    error: `Raw mode is not a number: ${typeof rawMode}`,
+                    device: deviceName
+                });
+            } else if (rawMode !== 0 && rawMode !== 1) {
+                results.push({
+                    name: 'should get raw DND mode value',
+                    passed: false,
+                    skipped: false,
+                    error: `Invalid raw mode value: ${rawMode} (expected 0 or 1)`,
+                    device: deviceName
+                });
+            } else {
+                // Verify it matches enum value
+                const enumMode = await testDevice.getDNDMode();
+                
+                if (rawMode !== enumMode) {
+                    results.push({
+                        name: 'should get raw DND mode value',
+                        passed: false,
+                        skipped: false,
+                        error: `Raw mode (${rawMode}) does not match enum mode (${enumMode})`,
+                        device: deviceName
+                    });
+                } else {
+                    results.push({
+                        name: 'should get raw DND mode value',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get raw DND mode value',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};

package/cli/tests/test-electricity.js

@@ -0,0 +1,209 @@
+'use strict';
+
+/**
+ * Electricity/Consumption Device Tests
+ * Tests electricity metrics and power consumption tracking
+ */
+
+const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStatus } = require('./test-helper');
+
+const metadata = {
+    name: 'electricity',
+    description: 'Tests electricity metrics and power consumption tracking',
+    requiredAbilities: ['Appliance.Control.ConsumptionX', 'Appliance.Control.Consumption', 'Appliance.Control.Electricity'],
+    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 consumption/electricity devices (try ConsumptionX first, then Consumption, then Electricity)
+        testDevices = await findDevicesByAbility(manager, 'Appliance.Control.ConsumptionX', OnlineStatus.ONLINE);
+        
+        if (testDevices.length === 0) {
+            testDevices = await findDevicesByAbility(manager, 'Appliance.Control.Consumption', OnlineStatus.ONLINE);
+        }
+        
+        if (testDevices.length === 0) {
+            testDevices = await findDevicesByAbility(manager, 'Appliance.Control.Electricity', OnlineStatus.ONLINE);
+        }
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should get instant electricity metrics',
+            passed: false,
+            skipped: true,
+            error: 'No ConsumptionX/Electricity device has been found to run this test on',
+            device: null
+        });
+        return results;
+    }
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    await waitForDeviceConnection(testDevice, timeout);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    
+    // Test 1: Get instant electricity metrics
+    try {
+        // Try to get electricity data
+        let metrics = null;
+        
+        // Check which method is available
+        if (typeof testDevice.getElectricity === 'function') {
+            metrics = await testDevice.getElectricity();
+        } else if (typeof testDevice.getPowerConsumptionX === 'function') {
+            metrics = await testDevice.getPowerConsumptionX();
+        } else if (typeof testDevice.getPowerConsumption === 'function') {
+            metrics = await testDevice.getPowerConsumption();
+        }
+        
+        if (!metrics || typeof metrics !== 'object') {
+            results.push({
+                name: 'should get instant electricity metrics',
+                passed: false,
+                skipped: false,
+                error: 'Metrics is not an object or is null',
+                device: deviceName
+            });
+        } else {
+            results.push({
+                name: 'should get instant electricity metrics',
+                passed: true,
+                skipped: false,
+                error: null,
+                device: deviceName,
+                details: { metrics: metrics }
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get instant electricity metrics',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 2: Get daily power consumption
+    try {
+        if (typeof testDevice.getPowerConsumptionX !== 'function') {
+            results.push({
+                name: 'should get daily power consumption',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support daily power consumption tracking',
+                device: deviceName
+            });
+        } else {
+            const consumption = await testDevice.getPowerConsumptionX();
+            
+            if (!Array.isArray(consumption)) {
+                results.push({
+                    name: 'should get daily power consumption',
+                    passed: false,
+                    skipped: false,
+                    error: 'Consumption is not an array',
+                    device: deviceName
+                });
+            } else {
+                // If we got data, verify structure
+                if (consumption.length > 0) {
+                    const first = consumption[0];
+                    if (!first.date || first.totalConsumptionKwh === undefined) {
+                        results.push({
+                            name: 'should get daily power consumption',
+                            passed: false,
+                            skipped: false,
+                            error: 'Consumption entries missing required properties (date or totalConsumptionKwh)',
+                            device: deviceName
+                        });
+                    } else {
+                        results.push({
+                            name: 'should get daily power consumption',
+                            passed: true,
+                            skipped: false,
+                            error: null,
+                            device: deviceName,
+                            details: { entryCount: consumption.length }
+                        });
+                    }
+                } else {
+                    results.push({
+                        name: 'should get daily power consumption',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName,
+                        details: { entryCount: 0, note: 'No consumption data available' }
+                    });
+                }
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get daily power consumption',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 3: Get consumption config
+    try {
+        if (typeof testDevice.getConsumptionConfig !== 'function') {
+            results.push({
+                name: 'should get consumption config',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support getConsumptionConfig',
+                device: deviceName
+            });
+        } else {
+            const response = await testDevice.getConsumptionConfig();
+            
+            if (!response) {
+                results.push({
+                    name: 'should get consumption config',
+                    passed: false,
+                    skipped: false,
+                    error: 'getConsumptionConfig returned null or undefined',
+                    device: deviceName
+                });
+            } else {
+                results.push({
+                    name: 'should get consumption config',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { config: response }
+                });
+            }
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get consumption config',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};