meross-cli 0.1.0

package/cli/tests/test-toggle.js

@@ -0,0 +1,342 @@
+'use strict';
+
+/**
+ * Toggle/Switch Device Tests
+ * Tests on/off control for switches and smart plugs
+ */
+
+const { findDevicesByAbility, waitForDeviceConnection, getDeviceName, OnlineStatus } = require('./test-helper');
+
+/**
+ * Test metadata
+ */
+const metadata = {
+    name: 'switch',
+    description: 'Tests on/off control for switches and smart plugs',
+    requiredAbilities: ['Appliance.Control.ToggleX', 'Appliance.Control.Toggle'],
+    minDevices: 1
+};
+
+/**
+ * Helper function to find all toggle-capable devices
+ * @param {Object} manager - MerossManager instance
+ * @returns {Promise<Array>} Array of toggle devices
+ */
+async function findAllToggleDevices(manager) {
+    const toggleXDevices = await findDevicesByAbility(manager, 'Appliance.Control.ToggleX', OnlineStatus.ONLINE);
+    const toggleDevices = await findDevicesByAbility(manager, 'Appliance.Control.Toggle', OnlineStatus.ONLINE);
+    
+    // Combine and deduplicate
+    const allToggleDevices = [...toggleXDevices];
+    for (const device of toggleDevices) {
+        const uuid = device.dev?.uuid || device.uuid;
+        if (!allToggleDevices.find(d => (d.dev?.uuid || d.uuid) === uuid)) {
+            allToggleDevices.push(device);
+        }
+    }
+    return allToggleDevices;
+}
+
+/**
+ * Runs all tests for toggle/switch devices
+ * @param {Object} context - Test context object
+ * @param {Object} context.manager - MerossManager instance (already connected)
+ * @param {Array<Object>} context.devices - Pre-filtered devices (from CLI selection or auto-discovery)
+ * @param {Object} context.options - Test options (timeout, verbose, etc.)
+ * @returns {Promise<Array>} Array of test result objects
+ */
+async function runTests(context) {
+    const { manager, devices, options = {} } = context;
+    const timeout = options.timeout || 30000;
+    const results = [];
+    
+    // If no devices provided, discover them
+    let toggleDevices = devices || [];
+    if (toggleDevices.length === 0) {
+        toggleDevices = await findAllToggleDevices(manager);
+    }
+    
+    // Wait for devices to be connected
+    for (const device of toggleDevices) {
+        await waitForDeviceConnection(device, timeout);
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    
+    // Test 1: Check if devices were found
+    if (toggleDevices.length === 0) {
+        results.push({
+            name: 'should find devices with toggle capability',
+            passed: false,
+            skipped: true,
+            error: 'No devices with toggle capability found',
+            device: null
+        });
+        return results; // Early return if no devices
+    }
+    
+    results.push({
+        name: 'should find devices with toggle capability',
+        passed: true,
+        skipped: false,
+        error: null,
+        device: null
+    });
+    
+    const testDevice = toggleDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    // Test 2: Get toggle state
+    try {
+        if (typeof testDevice.getToggleState === 'function') {
+            const toggleState = await testDevice.getToggleState(0);
+            
+            if (!toggleState) {
+                results.push({
+                    name: 'should get toggle state',
+                    passed: false,
+                    skipped: false,
+                    error: 'getToggleState returned null or undefined',
+                    device: deviceName
+                });
+            } else {
+                // Check cached toggle state
+                const cachedState = testDevice.getCachedToggleState(0);
+                const isOn = testDevice.isOn(0);
+                
+                results.push({
+                    name: 'should get toggle state',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: {
+                        toggleState: toggleState,
+                        cachedState: cachedState,
+                        isOn: isOn
+                    }
+                });
+            }
+        } else {
+            results.push({
+                name: 'should get toggle state',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support getToggleState',
+                device: deviceName
+            });
+        }
+    } catch (error) {
+        results.push({
+            name: 'should get toggle state',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // 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') {
+            const turnOnResult = await testDevice.turnOn(0);
+            
+            if (!turnOnResult) {
+                results.push({
+                    name: 'should control toggle state (turn on)',
+                    passed: false,
+                    skipped: false,
+                    error: 'turnOn() returned null or undefined',
+                    device: deviceName
+                });
+            } else {
+                // Wait a bit for state to update
+                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
+                        });
+                    }
+                } else {
+                    // Can't verify, but command succeeded
+                    results.push({
+                        name: 'should control toggle state (turn on)',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName,
+                        details: { note: 'turnOn succeeded but cannot verify state (isOn not available)' }
+                    });
+                }
+            }
+        } else {
+            results.push({
+                name: 'should control toggle state (turn on)',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support turnOn',
+                device: deviceName
+            });
+        }
+        
+        // Test turnOff if available
+        if (typeof testDevice.turnOff === 'function') {
+            const turnOffResult = await testDevice.turnOff(0);
+            
+            if (!turnOffResult) {
+                results.push({
+                    name: 'should control toggle state (turn off)',
+                    passed: false,
+                    skipped: false,
+                    error: 'turnOff() returned null or undefined',
+                    device: deviceName
+                });
+            } else {
+                // Wait a bit for state to update
+                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
+                        });
+                    }
+                } else {
+                    // Can't verify, but command succeeded
+                    results.push({
+                        name: 'should control toggle state (turn off)',
+                        passed: true,
+                        skipped: false,
+                        error: null,
+                        device: deviceName,
+                        details: { note: 'turnOff succeeded but cannot verify state (isOn not available)' }
+                    });
+                }
+            }
+        } else {
+            results.push({
+                name: 'should control toggle state (turn off)',
+                passed: false,
+                skipped: true,
+                error: 'Device does not support turnOff',
+                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);
+            } else {
+                await testDevice.turnOff(0);
+            }
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        
+    } catch (error) {
+        results.push({
+            name: 'should control toggle state',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    // Test 4: Handle toggle push notifications
+    try {
+        const testDeviceForPush = toggleDevices[0];
+        
+        // Set up listener for toggle push notifications
+        let receivedNotification = false;
+        const notificationHandler = (notification) => {
+            if (notification.namespace === 'Appliance.Control.ToggleX' || 
+                notification.namespace === 'Appliance.Control.Toggle') {
+                receivedNotification = true;
+            }
+        };
+        
+        testDeviceForPush.on('pushNotification', notificationHandler);
+        
+        // Get toggle state (may trigger a push notification)
+        if (typeof testDeviceForPush.getToggleState === 'function') {
+            await testDeviceForPush.getToggleState(0);
+        }
+        
+        // Wait a bit for potential push notifications
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        // Remove listener
+        testDeviceForPush.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 toggle push notifications',
+            passed: true,
+            skipped: false,
+            error: null,
+            device: getDeviceName(testDeviceForPush),
+            details: { notificationReceived: receivedNotification }
+        });
+        
+    } catch (error) {
+        results.push({
+            name: 'should handle toggle push notifications',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: toggleDevices.length > 0 ? getDeviceName(toggleDevices[0]) : null
+        });
+    }
+    
+    return results;
+}
+
+// Export metadata and runTests function
+module.exports = {
+    metadata,
+    runTests
+};

package/cli/tests/test-trigger.js

@@ -0,0 +1,279 @@
+'use strict';
+
+/**
+ * Trigger Tests
+ * Tests trigger creation, management, and push notifications
+ */
+
+const { findDevicesByAbility, getDeviceName, OnlineStatus } = require('./test-helper');
+const { TriggerType, TriggerUtils } = require('meross-iot');
+const { createTrigger } = TriggerUtils;
+
+const metadata = {
+    name: 'trigger',
+    description: 'Tests trigger creation, management, and push notifications',
+    requiredAbilities: ['Appliance.Control.TriggerX'],
+    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.TriggerX', OnlineStatus.ONLINE);
+    }
+    
+    if (testDevices.length === 0) {
+        results.push({
+            name: 'should find devices with trigger capability',
+            passed: false,
+            skipped: true,
+            error: 'No devices with trigger capability found',
+            device: null
+        });
+        return results;
+    }
+    
+    results.push({
+        name: 'should find devices with trigger capability',
+        passed: true,
+        skipped: false,
+        error: null,
+        device: null
+    });
+    
+    const testDevice = testDevices[0];
+    const deviceName = getDeviceName(testDevice);
+    
+    let createdTriggerId = null;
+    
+    // Test 1: Create a trigger and verify it exists
+    try {
+        // Create a test trigger using the utility function
+        const testTrigger = createTrigger({
+            alias: 'Test Trigger - CLI Test',
+            duration: '30m', // 30 minutes
+            days: ['weekday'],
+            type: TriggerType.SINGLE_POINT_WEEKLY_CYCLE,
+            channel: 0,
+            enabled: true
+        });
+        
+        // Wait for push notification after SET (as per API spec: "PUSH after SET")
+        let triggerIdFromPush = null;
+        const pushNotificationPromise = new Promise((resolve) => {
+            const handler = (notification) => {
+                if (notification.namespace === 'Appliance.Control.TriggerX' && notification.triggerxData) {
+                    const triggerData = Array.isArray(notification.triggerxData) ? notification.triggerxData : [notification.triggerxData];
+                    const createdTrigger = triggerData.find(t => 
+                        t.channel === 0 && 
+                        t.alias === 'Test Trigger - CLI Test' &&
+                        t.id
+                    );
+                    if (createdTrigger && createdTrigger.id) {
+                        triggerIdFromPush = createdTrigger.id;
+                        testDevice.removeListener('pushNotification', handler);
+                        resolve();
+                    }
+                }
+            };
+            testDevice.on('pushNotification', handler);
+            
+            // Timeout after 5 seconds if no push notification arrives
+            setTimeout(() => {
+                testDevice.removeListener('pushNotification', handler);
+                resolve();
+            }, 5000);
+        });
+        
+        const createResult = await testDevice.setTriggerX(testTrigger);
+        
+        if (!createResult) {
+            results.push({
+                name: 'should create trigger',
+                passed: false,
+                skipped: false,
+                error: 'setTriggerX returned null or undefined',
+                device: deviceName
+            });
+            return results;
+        }
+        
+        // Wait for push notification (contains trigger with ID)
+        await pushNotificationPromise;
+        
+        // Get the trigger ID from push notification, or fallback to generated ID
+        if (triggerIdFromPush) {
+            createdTriggerId = triggerIdFromPush;
+        } else if (testTrigger.id) {
+            createdTriggerId = testTrigger.id;
+        } else {
+            // Wait a bit and query by alias to find it
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            const triggers = await testDevice.getTriggerX(0);
+            const foundTrigger = triggers?.triggerx?.find(t => t.alias === 'Test Trigger - CLI Test');
+            if (foundTrigger && foundTrigger.id) {
+                createdTriggerId = foundTrigger.id;
+            }
+        }
+        
+        if (!createdTriggerId) {
+            results.push({
+                name: 'should create trigger',
+                passed: false,
+                skipped: false,
+                error: 'Could not get trigger ID after creation',
+                device: deviceName
+            });
+            return results;
+        }
+        
+        // Verify trigger exists by querying it
+        const triggerInfo = await testDevice.getTriggerX(0);
+        const triggerExists = triggerInfo?.triggerx?.some(t => t.id === createdTriggerId);
+        
+        if (!triggerExists) {
+            results.push({
+                name: 'should create trigger',
+                passed: false,
+                skipped: false,
+                error: 'Created trigger not found when querying',
+                device: deviceName
+            });
+            return results;
+        }
+        
+        // Verify cached trigger state
+        const cachedTriggers = testDevice.getCachedTriggerX(0);
+        
+        results.push({
+            name: 'should create trigger',
+            passed: true,
+            skipped: false,
+            error: null,
+            device: deviceName,
+            details: { 
+                triggerId: createdTriggerId,
+                cachedTriggerCount: cachedTriggers ? cachedTriggers.length : 0
+            }
+        });
+    } catch (error) {
+        results.push({
+            name: 'should create trigger',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+        return results;
+    }
+    
+    // Test 2: Delete the trigger
+    if (createdTriggerId) {
+        try {
+            const deleteResponse = await testDevice.deleteTriggerX(createdTriggerId, 0);
+            
+            // Check what the DELETE response contains
+            const deleteResponseError = deleteResponse?.error;
+            const hasError = deleteResponseError !== null && deleteResponseError !== undefined;
+            const isIdNotFound = deleteResponseError?.code === 5050 || 
+                                 deleteResponseError?.detail === 'id not found';
+            
+            // If DELETE returned an error other than "id not found", this is a real failure
+            if (hasError && !isIdNotFound) {
+                results.push({
+                    name: 'should delete trigger',
+                    passed: false,
+                    skipped: false,
+                    error: `DELETE command failed: ${JSON.stringify(deleteResponseError)}`,
+                    device: deviceName,
+                    details: { 
+                        triggerId: createdTriggerId,
+                        deleteResponse: deleteResponse
+                    }
+                });
+            } else {
+                // DELETE succeeded (no error, or error 5050)
+                // Error 5050 means "id not found" which indicates the trigger is deleted (success)
+                // Empty DELETEACK also means deletion was accepted
+                results.push({
+                    name: 'should delete trigger',
+                    passed: true,
+                    skipped: false,
+                    error: null,
+                    device: deviceName,
+                    details: { 
+                        triggerId: createdTriggerId,
+                        deleteResponse: isIdNotFound ? 'Trigger deleted (error 5050 - id not found)' : 'DELETE command accepted (empty DELETEACK)'
+                    }
+                });
+            }
+        } catch (error) {
+            results.push({
+                name: 'should delete trigger',
+                passed: false,
+                skipped: false,
+                error: error.message,
+                device: deviceName,
+                details: { 
+                    triggerId: createdTriggerId
+                }
+            });
+        }
+    }
+    
+    // Test 3: Handle trigger push notifications
+    try {
+        // Set up listener for trigger push notifications
+        let receivedNotification = false;
+        const notificationHandler = (notification) => {
+            if (notification.namespace === 'Appliance.Control.TriggerX') {
+                receivedNotification = true;
+            }
+        };
+        
+        testDevice.on('pushNotification', notificationHandler);
+        
+        // Get trigger info (may trigger a push notification)
+        await testDevice.getTriggerX(0);
+        
+        // Wait a bit for potential push notifications
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        // 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
+        results.push({
+            name: 'should handle trigger push notifications',
+            passed: true,
+            skipped: false,
+            error: null,
+            device: deviceName,
+            details: { 
+                notificationReceived: receivedNotification,
+                note: 'Push notifications are device-initiated and may not occur during testing'
+            }
+        });
+    } catch (error) {
+        results.push({
+            name: 'should handle trigger push notifications',
+            passed: false,
+            skipped: false,
+            error: error.message,
+            device: deviceName
+        });
+    }
+    
+    return results;
+}
+
+module.exports = {
+    metadata,
+    runTests
+};