meross-cli 0.4.0 → 0.6.0

package/cli/tests/test-presence.js

@@ -62,8 +62,8 @@ async function runTests(context) {
     
     // Test 2: Get latest sensor readings
     try {
-        if (typeof testDevice.getLatestSensorReadings === 'function') {
-            const readings = await testDevice.getLatestSensorReadings(['presence', 'light'], timeout);
+        if (testDevice.presence && typeof testDevice.presence.get === 'function') {
+            const readings = await testDevice.presence.get({ dataTypes: ['presence', 'light'], channel: 0 });
             
             if (!readings || !readings.latest) {
                 results.push({
@@ -110,8 +110,8 @@ async function runTests(context) {
     
     // Test 3: Get presence data
     try {
-        if (typeof testDevice.getPresence === 'function') {
-            const presence = testDevice.getPresence();
+        if (testDevice.presence && typeof testDevice.presence.getPresence === 'function') {
+            const presence = testDevice.presence.getPresence({ channel: 0 });
             
             // Presence can be null if no data yet, which is acceptable
             if (presence === null) {
@@ -236,8 +236,8 @@ async function runTests(context) {
     
     // Test 5: Get light reading
     try {
-        if (typeof testDevice.getLight === 'function') {
-            const light = testDevice.getLight();
+        if (testDevice.presence && typeof testDevice.presence.getLight === 'function') {
+            const light = testDevice.presence.getLight({ channel: 0 });
             
             // Light can be null if no data yet, which is acceptable
             if (light === null) {
@@ -291,8 +291,8 @@ async function runTests(context) {
     
     // Test 6: Get all sensor readings
     try {
-        if (typeof testDevice.getAllSensorReadings === 'function') {
-            const allReadings = testDevice.getAllSensorReadings();
+        if (testDevice.presence && typeof testDevice.presence.getAllSensorReadings === 'function') {
+            const allReadings = testDevice.presence.getAllSensorReadings({ channel: 0 });
             
             if (!allReadings || typeof allReadings !== 'object') {
                 results.push({
@@ -336,8 +336,8 @@ async function runTests(context) {
     
     // Test 7: Get presence configuration
     try {
-        if (typeof testDevice.getPresenceConfig === 'function') {
-            const config = await testDevice.getPresenceConfig(0, timeout);
+        if (testDevice.presence && typeof testDevice.presence.getConfig === 'function') {
+            const config = await testDevice.presence.getConfig({ channel: 0 });
             
             if (!config) {
                 results.push({
@@ -442,51 +442,6 @@ async function runTests(context) {
         }
     }
     
-    // Test 9: Handle presence push notifications
-    try {
-        // Set up listener for presence push notifications
-        let receivedNotification = false;
-        const notificationHandler = (notification) => {
-            if (notification.namespace === 'Appliance.Control.Sensor.LatestX') {
-                receivedNotification = true;
-            }
-        };
-        
-        testDevice.on('pushNotification', notificationHandler);
-        
-        // Request latest readings (may trigger a push notification)
-        if (typeof testDevice.getLatestSensorReadings === 'function') {
-            await testDevice.getLatestSensorReadings(['presence', 'light'], timeout);
-        }
-        
-        // Wait a bit for potential push notifications
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        
-        // Remove listener
-        testDevice.removeListener('pushNotification', notificationHandler);
-        
-        // Note: We don't assert on receivedNotification since push notifications
-        // are device-initiated and may not occur during testing
-        // This test just verifies the listener mechanism works
-        results.push({
-            name: 'should handle presence push notifications',
-            passed: true,
-            skipped: false,
-            error: null,
-            device: deviceName,
-            details: { notificationReceived: receivedNotification }
-        });
-        
-    } catch (error) {
-        results.push({
-            name: 'should handle presence push notifications',
-            passed: false,
-            skipped: false,
-            error: error.message,
-            device: deviceName
-        });
-    }
-    
     return results;
 }
 

package/cli/tests/test-registry.js

@@ -78,7 +78,7 @@ const TEST_METADATA = {
     'electricity': {
         file: 'test-electricity.js',
         description: 'Tests power consumption metrics and daily consumption data',
-        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
     },
     'dnd': {
@@ -178,6 +178,12 @@ const TEST_METADATA = {
         description: 'Tests presence detection, light readings, and configuration for presence sensor devices',
         requiredAbilities: ['Appliance.Control.Sensor.LatestX'],
         minDevices: 1
+    },
+    'system': {
+        file: 'test-system.js',
+        description: 'Tests system information, hardware, firmware, abilities, and configuration',
+        requiredAbilities: ['Appliance.System.All', 'Appliance.System.Ability'],
+        minDevices: 1
     }
 };
 

package/cli/tests/test-roller-shutter.js

@@ -43,18 +43,21 @@ async function runTests(context) {
     const deviceName = getDeviceName(testDevice);
     
     await waitForDeviceConnection(testDevice, timeout);
-    await testDevice.getRollerShutterState();
+    await testDevice.rollerShutter.get({ channel: 0 });
     await new Promise(resolve => setTimeout(resolve, 1000));
     
     // Test 1: Open roller shutter
     try {
-        await testDevice.getRollerShutterState();
+        await testDevice.rollerShutter.get({ channel: 0 });
         
         // Set timers (if method exists)
-        if (typeof testDevice.setRollerShutterConfig === 'function') {
-            await testDevice.setRollerShutterConfig({
-                openTimerSeconds: DEFAULT_OPEN_TIMER,
-                closeTimerSeconds: DEFAULT_CLOSE_TIMER
+        if (testDevice.rollerShutter && typeof testDevice.rollerShutter.setConfig === 'function') {
+            await testDevice.rollerShutter.setConfig({
+                config: [{
+                    channel: 0,
+                    open_timer_duration_millis: DEFAULT_OPEN_TIMER * 1000,
+                    close_timer_duration_millis: DEFAULT_CLOSE_TIMER * 1000
+                }]
             });
         }
         
@@ -63,36 +66,28 @@ async function runTests(context) {
         let stateIdle = false;
         let positionOpened = false;
         
-        const onData = (namespace, payload) => {
-            if (namespace === 'Appliance.RollerShutter.State') {
-                if (payload.state) {
-                    const state = Array.isArray(payload.state) ? payload.state[0] : payload.state;
-                    if (state.channel === 0) {
-                        if (state.state === 1) { // OPENING
-                            stateOpening = true;
-                        } else if (state.state === 0) { // IDLE
-                            stateIdle = true;
-                        }
+        const onStateChange = (event) => {
+            if (event.type === 'rollerShutter' && event.channel === 0) {
+                if (event.value.state !== undefined) {
+                    if (event.value.state === 1) { // OPENING
+                        stateOpening = true;
+                    } else if (event.value.state === 0) { // IDLE
+                        stateIdle = true;
                     }
                 }
-            }
-            if (namespace === 'Appliance.RollerShutter.Position') {
-                if (payload.position) {
-                    const position = Array.isArray(payload.position) ? payload.position[0] : payload.position;
-                    if (position.channel === 0 && position.position === 100) {
-                        positionOpened = true;
-                    }
+                if (event.value.position !== undefined && event.value.position === 100) {
+                    positionOpened = true;
                 }
             }
         };
         
-        testDevice.on('data', onData);
+        testDevice.on('state', onStateChange);
         
         // Trigger the opening
-        if (typeof testDevice.openRollerShutter === 'function') {
-            await testDevice.openRollerShutter({ channel: 0 });
+        if (testDevice.rollerShutter && typeof testDevice.rollerShutter.open === 'function') {
+            await testDevice.rollerShutter.open({ channel: 0 });
         } else {
-            await testDevice.setRollerShutterPosition({ position: 100, channel: 0 });
+            await testDevice.rollerShutter.set({ position: 100, channel: 0 });
         }
         
         // Wait for state changes
@@ -102,7 +97,7 @@ async function runTests(context) {
         }
         
         if (!stateOpening) {
-            testDevice.removeListener('data', onData);
+            testDevice.removeListener('state', onStateChange);
             results.push({
                 name: 'should open roller shutter',
                 passed: false,
@@ -118,7 +113,7 @@ async function runTests(context) {
         }
         
         if (!stateIdle) {
-            testDevice.removeListener('data', onData);
+            testDevice.removeListener('state', onStateChange);
             results.push({
                 name: 'should open roller shutter',
                 passed: false,
@@ -133,7 +128,7 @@ async function runTests(context) {
             await new Promise(resolve => setTimeout(resolve, 500));
         }
         
-        testDevice.removeListener('data', onData);
+        testDevice.removeListener('state', onStateChange);
         
         if (!positionOpened) {
             results.push({
@@ -165,51 +160,46 @@ async function runTests(context) {
     // Test 2: Close roller shutter
     try {
         // Set timers (if method exists)
-        if (typeof testDevice.setRollerShutterConfig === 'function') {
-            await testDevice.setRollerShutterConfig({
-                openTimerSeconds: DEFAULT_OPEN_TIMER,
-                closeTimerSeconds: DEFAULT_CLOSE_TIMER
+        if (testDevice.rollerShutter && typeof testDevice.rollerShutter.setConfig === 'function') {
+            await testDevice.rollerShutter.setConfig({
+                config: [{
+                    channel: 0,
+                    open_timer_duration_millis: DEFAULT_OPEN_TIMER * 1000,
+                    close_timer_duration_millis: DEFAULT_CLOSE_TIMER * 1000
+                }]
             });
         }
         
         // Update its status
-        await testDevice.getRollerShutterState();
+        await testDevice.rollerShutter.get({ channel: 0 });
         
         // Set up event listeners for state changes
         let stateClosing = false;
         let stateIdle = false;
         let positionClosed = false;
         
-        const onData = (namespace, payload) => {
-            if (namespace === 'Appliance.RollerShutter.State') {
-                if (payload.state) {
-                    const state = Array.isArray(payload.state) ? payload.state[0] : payload.state;
-                    if (state.channel === 0) {
-                        if (state.state === 2) { // CLOSING
-                            stateClosing = true;
-                        } else if (state.state === 0) { // IDLE
-                            stateIdle = true;
-                        }
+        const onStateChange = (event) => {
+            if (event.type === 'rollerShutter' && event.channel === 0) {
+                if (event.value.state !== undefined) {
+                    if (event.value.state === 2) { // CLOSING
+                        stateClosing = true;
+                    } else if (event.value.state === 0) { // IDLE
+                        stateIdle = true;
                     }
                 }
-            }
-            if (namespace === 'Appliance.RollerShutter.Position') {
-                if (payload.position) {
-                    const position = Array.isArray(payload.position) ? payload.position[0] : payload.position;
-                    if (position.channel === 0 && position.position === 0) {
-                        positionClosed = true;
-                    }
+                if (event.value.position !== undefined && event.value.position === 0) {
+                    positionClosed = true;
                 }
             }
         };
         
-        testDevice.on('data', onData);
+        testDevice.on('state', onStateChange);
         
         // Trigger the closing
-        if (typeof testDevice.closeRollerShutter === 'function') {
-            await testDevice.closeRollerShutter({ channel: 0 });
+        if (testDevice.rollerShutter && typeof testDevice.rollerShutter.close === 'function') {
+            await testDevice.rollerShutter.close({ channel: 0 });
         } else {
-            await testDevice.setRollerShutterPosition({ position: 0, channel: 0 });
+            await testDevice.rollerShutter.set({ position: 0, channel: 0 });
         }
         
         // Wait for state changes
@@ -219,7 +209,7 @@ async function runTests(context) {
         }
         
         if (!stateClosing) {
-            testDevice.removeListener('data', onData);
+            testDevice.removeListener('state', onStateChange);
             results.push({
                 name: 'should close roller shutter',
                 passed: false,
@@ -235,7 +225,7 @@ async function runTests(context) {
         }
         
         if (!stateIdle) {
-            testDevice.removeListener('data', onData);
+            testDevice.removeListener('state', onStateChange);
             results.push({
                 name: 'should close roller shutter',
                 passed: false,
@@ -250,7 +240,7 @@ async function runTests(context) {
             await new Promise(resolve => setTimeout(resolve, 500));
         }
         
-        testDevice.removeListener('data', onData);
+        testDevice.removeListener('state', onStateChange);
         
         if (!positionClosed) {
             results.push({
@@ -281,9 +271,7 @@ async function runTests(context) {
     
     // Test 3: Get opening timer duration
     try {
-        await testDevice.getRollerShutterState();
-        
-        const state = testDevice.getCachedRollerShutterState(0);
+        const state = await testDevice.rollerShutter.get({ channel: 0 });
         
         if (!state) {
             results.push({
@@ -327,9 +315,7 @@ async function runTests(context) {
     
     // Test 4: Get closing timer duration
     try {
-        await testDevice.getRollerShutterState();
-        
-        const state = testDevice.getCachedRollerShutterState(0);
+        const state = await testDevice.rollerShutter.get({ channel: 0 });
         
         if (!state) {
             results.push({
@@ -373,10 +359,8 @@ async function runTests(context) {
     
     // Test 5: Set roller shutter config timers
     try {
-        await testDevice.getRollerShutterState();
-        
         // Retrieve original values
-        const originalState = testDevice.getCachedRollerShutterState(0);
+        const originalState = await testDevice.rollerShutter.get({ channel: 0 });
         
         if (!originalState) {
             results.push({
@@ -386,12 +370,12 @@ async function runTests(context) {
                 error: 'Could not get original state',
                 device: deviceName
             });
-        } else if (typeof testDevice.setRollerShutterConfig !== 'function') {
+        } else if (!testDevice.rollerShutter || typeof testDevice.rollerShutter.setConfig !== 'function') {
             results.push({
                 name: 'should set roller shutter config timers',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setRollerShutterConfig',
+                error: 'Device does not support setConfig',
                 device: deviceName
             });
         } else {
@@ -402,16 +386,17 @@ async function runTests(context) {
             const openTimer = Math.floor(Math.random() * (120 - 10 + 1)) + 10; // 10-120 seconds
             const closeTimer = Math.floor(Math.random() * (120 - 10 + 1)) + 10; // 10-120 seconds
             
-            await testDevice.setRollerShutterConfig({
-                openTimerSeconds: openTimer,
-                closeTimerSeconds: closeTimer,
-                channel: 0
+            await testDevice.rollerShutter.setConfig({
+                config: [{
+                    channel: 0,
+                    open_timer_duration_millis: openTimer * 1000,
+                    close_timer_duration_millis: closeTimer * 1000
+                }]
             });
             
             await new Promise(resolve => setTimeout(resolve, 1000));
             
-            await testDevice.getRollerShutterState();
-            const newState = testDevice.getCachedRollerShutterState(0);
+            const newState = await testDevice.rollerShutter.get({ channel: 0 });
             
             if (!newState) {
                 results.push({
@@ -432,10 +417,12 @@ async function runTests(context) {
                 });
             } else {
                 // Restore original values
-                await testDevice.setRollerShutterConfig({
-                    openTimerSeconds: Math.floor(originalOpenTimer / 1000),
-                    closeTimerSeconds: Math.floor(originalCloseTimer / 1000),
-                    channel: 0
+                await testDevice.rollerShutter.setConfig({
+                    config: [{
+                        channel: 0,
+                        open_timer_duration_millis: originalOpenTimer,
+                        close_timer_duration_millis: originalCloseTimer
+                    }]
                 });
                 
                 results.push({
@@ -459,16 +446,17 @@ async function runTests(context) {
     
     // Test 6: Get roller shutter config
     try {
-        if (typeof testDevice.getRollerShutterConfig !== 'function') {
+        if (!testDevice.rollerShutter || typeof testDevice.rollerShutter.getConfig !== 'function') {
             results.push({
                 name: 'should get roller shutter config',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getRollerShutterConfig',
+                error: 'Device does not support getConfig',
                 device: deviceName
             });
         } else {
-            const config = await testDevice.getRollerShutterConfig();
+            const response = await testDevice.rollerShutter.getConfig();
+            const config = response?.config;
             
             if (!config) {
                 results.push({
@@ -501,16 +489,16 @@ async function runTests(context) {
     
     // Test 7: Get roller shutter position
     try {
-        if (typeof testDevice.getRollerShutterPosition !== 'function') {
+        if (!testDevice.rollerShutter || typeof testDevice.rollerShutter.getPosition !== 'function') {
             results.push({
                 name: 'should get roller shutter position',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getRollerShutterPosition',
+                error: 'Device does not support getPosition',
                 device: deviceName
             });
         } else {
-            const response = await testDevice.getRollerShutterPosition({ channel: 0 });
+            const response = await testDevice.rollerShutter.getPosition({ channel: 0 });
             
             if (!response) {
                 results.push({
@@ -553,7 +541,7 @@ async function runTests(context) {
             });
         } else {
             // Get current position first
-            await testDevice.getRollerShutterPosition({ channel: 0 });
+            await testDevice.rollerShutter.getPosition({ channel: 0 });
             await new Promise(resolve => setTimeout(resolve, 1000));
             
             // Note: We don't actually change the position to avoid disrupting the device
@@ -579,16 +567,16 @@ async function runTests(context) {
     
     // Test 9: Get roller shutter adjust
     try {
-        if (typeof testDevice.getRollerShutterAdjust !== 'function') {
+        if (!testDevice.rollerShutter || typeof testDevice.rollerShutter.getAdjust !== 'function') {
             results.push({
                 name: 'should get roller shutter adjust',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support getRollerShutterAdjust',
+                error: 'Device does not support getAdjust',
                 device: deviceName
             });
         } else {
-            const response = await testDevice.getRollerShutterAdjust({ channel: 0 });
+            const response = await testDevice.rollerShutter.getAdjust({ channel: 0 });
             
             if (!response) {
                 results.push({

package/cli/tests/test-screen.js

@@ -47,7 +47,7 @@ async function runTests(context) {
     
     // Test 1: Get screen brightness
     try {
-        const response = await testDevice.getScreenBrightness(0);
+        const response = await testDevice.screen.get({ channel: 0 });
         
         if (!response) {
             results.push({

package/cli/tests/test-sensor-history.js

@@ -53,7 +53,11 @@ async function runTests(context) {
         // Try different capacity values (1, 2, 3 are common)
         for (const capacity of [1, 2, 3]) {
             try {
-                const response = await testDevice.getSensorHistory({ channel: 0, capacity });
+                if (!testDevice.sensorHistory) {
+                    lastError = 'Device does not support sensor history feature';
+                    continue;
+                }
+                const response = await testDevice.sensorHistory.get({ channel: 0, capacity });
                 
                 if (!response) {
                     lastError = `getSensorHistory returned null or undefined for capacity ${capacity}`;
@@ -107,7 +111,7 @@ async function runTests(context) {
     try {
         // Note: We don't actually delete history to avoid data loss
         // We just verify the method exists and can be called
-        if (typeof testDevice.deleteSensorHistory === 'function') {
+        if (testDevice.sensorHistory && typeof testDevice.sensorHistory.delete === 'function') {
             results.push({
                 name: 'should delete sensor history',
                 passed: true,

package/cli/tests/test-smoke-config.js

@@ -44,7 +44,17 @@ async function runTests(context) {
     
     // Test 1: Get smoke config
     try {
-        const response = await testDevice.getSmokeConfig(0);
+        if (!testDevice.smokeConfig) {
+            results.push({
+                name: 'should get smoke config',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support smoke config feature',
+                device: deviceName
+            });
+            return results;
+        }
+        const response = await testDevice.smokeConfig.get({ channel: 0 });
         
         if (!response) {
             results.push({
@@ -84,8 +94,18 @@ async function runTests(context) {
     
     // Test 2: Control smoke config
     try {
+        if (!testDevice.smokeConfig) {
+            results.push({
+                name: 'should control smoke config',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support smoke config feature',
+                device: deviceName
+            });
+            return results;
+        }
         // Get current config first
-        const currentResponse = await testDevice.getSmokeConfig(0);
+        const currentResponse = await testDevice.smokeConfig.get({ channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
         
         if (!currentResponse || !Array.isArray(currentResponse.config)) {
@@ -96,12 +116,12 @@ async function runTests(context) {
                 error: 'Could not get current smoke config or config is not an array',
                 device: deviceName
             });
-        } else if (typeof testDevice.setSmokeConfig !== 'function') {
+        } else if (typeof testDevice.smokeConfig.set !== 'function') {
             results.push({
                 name: 'should control smoke config',
                 passed: false,
                 skipped: true,
-                error: 'Device does not support setSmokeConfig',
+                error: 'Device does not support set',
                 device: deviceName
             });
         } else {

package/cli/tests/test-spray.js

@@ -29,7 +29,7 @@ async function runTests(context) {
     // Wait for devices to be connected
     for (const device of testDevices) {
         await waitForDeviceConnection(device, timeout);
-        await device.getSprayState();
+        await device.spray.get({ channel: 0 });
         await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
@@ -50,10 +50,10 @@ async function runTests(context) {
     // Test: Set different spray modes
     try {
         // Set CONTINUOUS mode
-        await testDevice.setSpray(0, SprayMode.CONTINUOUS);
+        await testDevice.spray.set({ channel: 0, mode: SprayMode.CONTINUOUS });
         await new Promise(resolve => setTimeout(resolve, 1000));
-        
-        const mode1 = testDevice.getCurrentSprayMode(0);
+        await testDevice.spray.get({ channel: 0 });
+        const mode1 = testDevice.spray.getMode({ channel: 0 });
         if (mode1 !== SprayMode.CONTINUOUS) {
             results.push({
                 name: 'should set different spray modes',
@@ -66,10 +66,10 @@ async function runTests(context) {
         }
         
         // Set INTERMITTENT mode
-        await testDevice.setSpray(0, SprayMode.INTERMITTENT);
+        await testDevice.spray.set({ channel: 0, mode: SprayMode.INTERMITTENT });
         await new Promise(resolve => setTimeout(resolve, 1000));
-        
-        const mode2 = testDevice.getCurrentSprayMode(0);
+        await testDevice.spray.get({ channel: 0 });
+        const mode2 = testDevice.spray.getMode({ channel: 0 });
         if (mode2 !== SprayMode.INTERMITTENT) {
             results.push({
                 name: 'should set different spray modes',
@@ -82,10 +82,10 @@ async function runTests(context) {
         }
         
         // Set OFF mode
-        await testDevice.setSpray(0, SprayMode.OFF);
+        await testDevice.spray.set({ channel: 0, mode: SprayMode.OFF });
         await new Promise(resolve => setTimeout(resolve, 1000));
-        
-        const mode3 = testDevice.getCurrentSprayMode(0);
+        await testDevice.spray.get({ channel: 0 });
+        const mode3 = testDevice.spray.getMode({ channel: 0 });
         if (mode3 !== SprayMode.OFF) {
             results.push({
                 name: 'should set different spray modes',
@@ -98,7 +98,7 @@ async function runTests(context) {
         }
         
         // Update state
-        await testDevice.getSprayState();
+        await testDevice.spray.get({ channel: 0 });
         
         results.push({
             name: 'should set different spray modes',