meross-cli 0.3.0 → 0.5.0

package/cli/tests/test-config.js

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

package/cli/tests/test-control.js

@@ -63,12 +63,12 @@ async function runTests(context) {
     
     // Test 1: Control Multiple
     try {
-        if (typeof device.setMultiple !== 'function') {
+        if (!device.control || typeof device.control.setMultiple !== 'function') {
             results.push({
                 name: 'should execute multiple commands',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setMultiple',
+                error: 'Device does not support control.setMultiple',
                 device: deviceName
             });
         } else {
@@ -85,14 +85,14 @@ async function runTests(context) {
                 }
             ];
             
-            const response = await device.setMultiple(commands);
+            const response = await device.control.setMultiple({ commands });
             
             if (!response) {
                 results.push({
                     name: 'should execute multiple commands',
                     passed: false,
                     skipped: false,
-                    error: 'setMultiple returned null or undefined',
+                    error: 'control.setMultiple returned null or undefined',
                     device: deviceName
                 });
             } else {
@@ -117,12 +117,12 @@ async function runTests(context) {
     
     // Test 2: Control Over Temp
     try {
-        if (typeof device.acknowledgeControlOverTemp !== 'function') {
+        if (!device.control || typeof device.control.acknowledgeOverTemp !== 'function') {
             results.push({
                 name: 'should acknowledge over temp event',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support acknowledgeControlOverTemp',
+                error: 'Device does not support control.acknowledgeOverTemp',
                 device: deviceName
             });
         } else {
@@ -149,12 +149,12 @@ async function runTests(context) {
     
     // Test 3: Control Upgrade
     try {
-        if (typeof device.setUpgrade !== 'function') {
+        if (!device.control || typeof device.control.setUpgrade !== 'function') {
             results.push({
                 name: 'should have upgrade method available',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setUpgrade',
+                error: 'Device does not support control.setUpgrade',
                 device: deviceName
             });
         } else {

package/cli/tests/test-diffuser.js

@@ -43,13 +43,13 @@ async function runTests(context) {
     // Wait for devices to be connected
     for (const device of lightDevices) {
         await waitForDeviceConnection(device, timeout);
-        await device.getDiffuserLightState();
+        await device.diffuser.get({ type: 'light', channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
     for (const device of sprayDevices) {
         await waitForDeviceConnection(device, timeout);
-        await device.getDiffuserSprayState();
+        await device.diffuser.get({ type: 'spray', channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
@@ -67,7 +67,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             // Set mode to FIXED_RGB
             await light.setDiffuserLight({
@@ -142,7 +142,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             // Set mode to FIXED RGB
             await light.setDiffuserLight({
@@ -275,7 +275,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             await light.setDiffuserLight({
                 channel: 0,
@@ -365,7 +365,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(light);
         
         try {
-            await light.getDiffuserLightState();
+            await light.diffuser.get({ type: 'light', channel: 0 });
             
             await light.setDiffuserLight({
                 channel: 0,
@@ -430,7 +430,7 @@ async function runTests(context) {
         const deviceName = getDeviceName(spray);
         
         try {
-            await spray.getDiffuserSprayState();
+            await spray.diffuser.getSpray({ channel: 0 });
             
             await spray.setDiffuserSpray(0, DiffuserSprayMode.LIGHT);
             await new Promise(resolve => setTimeout(resolve, 1000));

package/cli/tests/test-dnd.js

@@ -27,8 +27,9 @@ async function runTests(context) {
         const allDevices = manager.devices.list();
         testDevices = allDevices.filter(d => {
             return d.onlineStatus === OnlineStatus.ONLINE &&
-                   typeof d.getDNDMode === 'function' &&
-                   typeof d.setDNDMode === 'function';
+                   d.dnd &&
+                   typeof d.dnd.get === 'function' &&
+                   typeof d.dnd.set === 'function';
         });
     }
     
@@ -56,67 +57,77 @@ async function runTests(context) {
     
     // Test 1: Get and set DND mode
     try {
-        // Get current DND mode
-        const initialMode = await testDevice.getDNDMode();
-        
-        if (initialMode === null || initialMode === undefined) {
+        if (!testDevice.dnd) {
             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}`,
+                skipped: true,
+                error: 'Device does not support DND feature',
                 device: deviceName
             });
         } else {
-            // Toggle DND mode
-            const newMode = initialMode === DNDMode.DND_ENABLED ? DNDMode.DND_DISABLED : DNDMode.DND_ENABLED;
-            await testDevice.setDNDMode({ mode: newMode });
+            // Get current DND mode
+            const initialMode = await testDevice.dnd.get();
             
-            // 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) {
+            if (initialMode === null || initialMode === undefined) {
                 results.push({
                     name: 'should get and set DND mode',
                     passed: false,
                     skipped: false,
-                    error: `DND mode did not change. Expected ${newMode}, got ${updatedMode}`,
+                    error: 'dnd.get() 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 {
-                // Restore original mode
-                await testDevice.setDNDMode({ mode: initialMode });
+                // Toggle DND mode
+                const newMode = initialMode === DNDMode.DND_ENABLED ? DNDMode.DND_DISABLED : DNDMode.DND_ENABLED;
+                await testDevice.dnd.set({ mode: newMode });
+                
+                // Wait for the change to take effect
                 await new Promise(resolve => setTimeout(resolve, 2000));
                 
-                const restoredMode = await testDevice.getDNDMode();
+                // Verify the change
+                const updatedMode = await testDevice.dnd.get();
                 
-                if (restoredMode !== initialMode) {
+                if (updatedMode !== newMode) {
                     results.push({
                         name: 'should get and set DND mode',
                         passed: false,
                         skipped: false,
-                        error: `Failed to restore DND mode. Expected ${initialMode}, got ${restoredMode}`,
+                        error: `DND mode did not change. Expected ${newMode}, got ${updatedMode}`,
                         device: deviceName
                     });
                 } else {
-                    results.push({
-                        name: 'should get and set DND mode',
-                        passed: true,
-                        skipped: false,
-                        error: null,
-                        device: deviceName
-                    });
+                    // Restore original mode
+                    await testDevice.dnd.set({ mode: initialMode });
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    
+                    const restoredMode = await testDevice.dnd.get();
+                    
+                    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
+                        });
+                    }
                 }
             }
         }
@@ -132,37 +143,47 @@ async function runTests(context) {
     
     // 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) {
+        if (!testDevice.dnd) {
             results.push({
                 name: 'should accept boolean values for DND mode',
                 passed: false,
-                skipped: false,
-                error: `Boolean set failed. Expected ${expectedMode}, got ${updatedMode}`,
+                skipped: true,
+                error: 'Device does not support DND feature',
                 device: deviceName
             });
         } else {
-            // Restore original mode
-            await testDevice.setDNDMode({ mode: initialBoolean });
+            // Get current mode
+            const initialMode = await testDevice.dnd.get();
+            const initialBoolean = initialMode === DNDMode.DND_ENABLED;
+            
+            // Set using boolean (true = enabled)
+            await testDevice.dnd.set({ 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
-            });
+            const updatedMode = await testDevice.dnd.get();
+            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.dnd.set({ 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({
@@ -176,16 +197,16 @@ async function runTests(context) {
     
     // Test 3: Get raw DND mode value
     try {
-        if (typeof testDevice.getRawDNDMode !== 'function') {
+        if (!testDevice.dnd || typeof testDevice.dnd.getRaw !== 'function') {
             results.push({
                 name: 'should get raw DND mode value',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getRawDNDMode',
+                error: 'Device does not support dnd.getRaw',
                 device: deviceName
             });
         } else {
-            const rawMode = await testDevice.getRawDNDMode();
+            const rawMode = await testDevice.dnd.getRaw();
             
             if (typeof rawMode !== 'number') {
                 results.push({
@@ -205,7 +226,7 @@ async function runTests(context) {
                 });
             } else {
                 // Verify it matches enum value
-                const enumMode = await testDevice.getDNDMode();
+                const enumMode = await testDevice.dnd.get();
                 
                 if (rawMode !== enumMode) {
                     results.push({

package/cli/tests/test-electricity.js

@@ -10,7 +10,7 @@ const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStat
 const metadata = {
     name: 'electricity',
     description: 'Tests electricity metrics and power consumption tracking',
-    requiredAbilities: ['Appliance.Control.ConsumptionX', 'Appliance.Control.Consumption', 'Appliance.Control.Electricity'],
+    requiredAbilities: ['Appliance.Control.ConsumptionH', 'Appliance.Control.ConsumptionX', 'Appliance.Control.Consumption', 'Appliance.Control.Electricity'],
     minDevices: 1
 };
 
@@ -22,8 +22,12 @@ async function runTests(context) {
     // 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);
+        // Find consumption/electricity devices (try ConsumptionH first, then ConsumptionX, then Consumption, then Electricity)
+        testDevices = await findDevicesByAbility(manager, 'Appliance.Control.ConsumptionH', OnlineStatus.ONLINE);
+        
+        if (testDevices.length === 0) {
+            testDevices = await findDevicesByAbility(manager, 'Appliance.Control.ConsumptionX', OnlineStatus.ONLINE);
+        }
         
         if (testDevices.length === 0) {
             testDevices = await findDevicesByAbility(manager, 'Appliance.Control.Consumption', OnlineStatus.ONLINE);
@@ -39,7 +43,7 @@ async function runTests(context) {
             name: 'should get instant electricity metrics',
             passed: false,
             skipped: true,
-            error: 'No ConsumptionX/Electricity device has been found to run this test on',
+            error: 'No ConsumptionH/ConsumptionX/Consumption/Electricity device has been found to run this test on',
             device: null
         });
         return results;
@@ -53,35 +57,35 @@ async function runTests(context) {
     
     // 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') {
+        if (!testDevice.electricity || typeof testDevice.electricity.get !== 'function') {
             results.push({
                 name: 'should get instant electricity metrics',
                 passed: false,
-                skipped: false,
-                error: 'Metrics is not an object or is null',
+                skipped: true,
+                error: 'Device does not support electricity feature',
                 device: deviceName
             });
         } else {
-            results.push({
-                name: 'should get instant electricity metrics',
-                passed: true,
-                skipped: false,
-                error: null,
-                device: deviceName,
-                details: { metrics: metrics }
-            });
+            const metrics = await testDevice.electricity.get({ channel: 0 });
+            
+            if (!metrics || typeof metrics !== 'object') {
+                results.push({
+                    name: 'should get instant electricity metrics',
+                    passed: false,
+                    skipped: false,
+                    error: 'electricity.get() returned null, undefined, or non-object',
+                    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({
@@ -95,7 +99,7 @@ async function runTests(context) {
     
     // Test 2: Get daily power consumption
     try {
-        if (typeof testDevice.getPowerConsumptionX !== 'function') {
+        if (!testDevice.consumption) {
             results.push({
                 name: 'should get daily power consumption',
                 passed: false,
@@ -104,7 +108,7 @@ async function runTests(context) {
                 device: deviceName
             });
         } else {
-            const consumption = await testDevice.getPowerConsumptionX();
+            const consumption = await testDevice.consumption.get({ channel: 0 });
             
             if (!Array.isArray(consumption)) {
                 results.push({
@@ -160,23 +164,23 @@ async function runTests(context) {
     
     // Test 3: Get consumption config
     try {
-        if (typeof testDevice.getConsumptionConfig !== 'function') {
+        if (!testDevice.consumption) {
             results.push({
                 name: 'should get consumption config',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getConsumptionConfig',
+                error: 'Device does not support consumption config',
                 device: deviceName
             });
         } else {
-            const response = await testDevice.getConsumptionConfig();
+            const response = await testDevice.consumption.getConfig();
             
             if (!response) {
                 results.push({
                     name: 'should get consumption config',
                     passed: false,
                     skipped: false,
-                    error: 'getConsumptionConfig returned null or undefined',
+                    error: 'getConfig returned null or undefined',
                     device: deviceName
                 });
             } else {

package/cli/tests/test-encryption.js

@@ -61,21 +61,21 @@ async function runTests(context) {
     
     // Test 1: Detect encryption support
     try {
-        if (typeof testDevice.supportEncryption !== 'function') {
+        if (!testDevice.encryption || typeof testDevice.encryption.supportEncryption !== 'function') {
             results.push({
                 name: 'should detect encryption support',
                 passed: false,
                 skipped: true,
-                error: 'Device does not have encryption feature methods',
+                error: 'Device does not have encryption feature',
                 device: deviceName
             });
         } else {
-            const supportsEncryption = testDevice.supportEncryption();
+            const supportsEncryption = testDevice.encryption.supportEncryption();
             
             // Check if encryption key is set
             let isKeySet = false;
             if (supportsEncryption) {
-                isKeySet = testDevice.isEncryptionKeySet();
+                isKeySet = testDevice.encryption.isEncryptionKeySet();
             }
             
             results.push({
@@ -102,7 +102,7 @@ async function runTests(context) {
     
     // Test 2: Set encryption key if supported
     try {
-        if (typeof testDevice.supportEncryption !== 'function' || !testDevice.supportEncryption()) {
+        if (!testDevice.encryption || typeof testDevice.encryption.supportEncryption !== 'function' || !testDevice.encryption.supportEncryption()) {
             results.push({
                 name: 'should set encryption key if supported',
                 passed: false,
@@ -112,13 +112,13 @@ async function runTests(context) {
             });
         } else {
             // Check if key is already set
-            const isKeySet = testDevice.isEncryptionKeySet();
+            const isKeySet = testDevice.encryption.isEncryptionKeySet();
             
             // If key is not set and we have the required info, set it
             if (!isKeySet && testDevice.uuid && manager.key && testDevice.macAddress) {
-                testDevice.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
+                testDevice.encryption.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
                 
-                const keySetAfter = testDevice.isEncryptionKeySet();
+                const keySetAfter = testDevice.encryption.isEncryptionKeySet();
                 
                 if (!keySetAfter) {
                     results.push({
@@ -169,7 +169,7 @@ async function runTests(context) {
     
     // Test 3: Encrypt and decrypt messages if encryption key is set
     try {
-        if (typeof testDevice.supportEncryption !== 'function' || !testDevice.supportEncryption()) {
+        if (!testDevice.encryption || typeof testDevice.encryption.supportEncryption !== 'function' || !testDevice.encryption.supportEncryption()) {
             results.push({
                 name: 'should encrypt and decrypt messages if encryption key is set',
                 passed: false,
@@ -179,9 +179,9 @@ async function runTests(context) {
             });
         } else {
             // Ensure encryption key is set
-            if (!testDevice.isEncryptionKeySet()) {
+            if (!testDevice.encryption.isEncryptionKeySet()) {
                 if (testDevice.uuid && manager.key && testDevice.macAddress) {
-                    testDevice.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
+                    testDevice.encryption.setEncryptionKey(testDevice.uuid, manager.key, testDevice.macAddress);
                 } else {
                     results.push({
                         name: 'should encrypt and decrypt messages if encryption key is set',
@@ -198,7 +198,7 @@ async function runTests(context) {
             const testMessage = { test: 'data', value: 123 };
             
             try {
-                const encrypted = testDevice.encryptMessage(testMessage);
+                const encrypted = testDevice.encryption.encryptMessage(testMessage);
                 
                 if (!encrypted) {
                     results.push({
@@ -223,7 +223,7 @@ async function runTests(context) {
                     return results;
                 }
                 
-                const decrypted = testDevice.decryptMessage(encrypted);
+                const decrypted = testDevice.encryption.decryptMessage(encrypted);
                 
                 if (!decrypted) {
                     results.push({