tsvesync 1.0.11

package/dist/test/testService.d.ts

@@ -0,0 +1,62 @@
+/**
+ * VeSync API Test Service
+ * Tests core functionality of the VeSync API implementation
+ */
+export declare class VeSyncTestService {
+    private manager;
+    private testResults;
+    private verbose;
+    constructor(verbose?: boolean);
+    /**
+     * Get directory for device type and category
+     */
+    private getDeviceDirectory;
+    /**
+     * Find YAML spec file for a device
+     */
+    private findDeviceSpec;
+    /**
+     * Convert snake_case to camelCase
+     */
+    private snakeToCamel;
+    /**
+     * Convert camelCase to snake_case
+     */
+    private camelToSnake;
+    /**
+     * Convert spec method name to implementation method name
+     */
+    private specToImplMethod;
+    /**
+     * Convert implementation method name to spec method name
+     */
+    private implToSpecMethod;
+    /**
+     * Analyze methods for a device
+     */
+    private analyzeMethods;
+    /**
+     * Test device methods against YAML spec
+     */
+    private testDeviceMethods;
+    /**
+     * Generate test parameters for a method
+     */
+    private generateTestParameters;
+    /**
+     * Validate an API call against its spec
+     */
+    private validateApiCall;
+    /**
+     * Generate method stub from YAML spec
+     */
+    private generateMethodStub;
+    /**
+     * Display test summary
+     */
+    private displaySummary;
+    /**
+     * Run all tests
+     */
+    run(): Promise<void>;
+}

package/dist/test/testService.js

@@ -0,0 +1,540 @@
+"use strict";
+/**
+ * VeSync API Test Service
+ * Tests core functionality of the VeSync API implementation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeSyncTestService = void 0;
+// Set environment variables for testing
+process.env.VESYNC_API_URL = 'http://localhost:8000';
+const vesync_1 = require("../src/lib/vesync");
+const vesyncBaseDevice_1 = require("../src/lib/vesyncBaseDevice");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const helpers_1 = require("../src/lib/helpers");
+// Constants for device type to directory mapping
+const TYPE_TO_DIRECTORY = {
+    // Switches (check these first as they're more specific)
+    'ESWL': 'vesyncswitch',
+    'ESWD': 'vesyncswitch',
+    // Outlets
+    'wifi-switch': 'vesyncoutlet',
+    'ESW': 'vesyncoutlet',
+    'ESO': 'vesyncoutlet',
+    // Bulbs
+    'ESL': 'vesyncbulb',
+    'XYD': 'vesyncbulb',
+    // Fans
+    'Core': 'vesyncfan',
+    'LAP': 'vesyncfan',
+    'LUH': 'vesyncfan',
+    'LEH': 'vesyncfan',
+    'LTF': 'vesyncfan',
+    'LV-PUR': 'vesyncfan'
+};
+class VeSyncTestService {
+    constructor(verbose = false) {
+        this.testResults = new Map();
+        this.verbose = false;
+        this.manager = new vesync_1.VeSync('test@example.com', 'test123');
+        this.verbose = verbose;
+    }
+    /**
+     * Get directory for device type and category
+     */
+    getDeviceDirectory(deviceType, category) {
+        // Find the correct subdirectory based on device type prefix
+        for (const [prefix, dir] of Object.entries(TYPE_TO_DIRECTORY)) {
+            if (deviceType.startsWith(prefix)) {
+                return dir;
+            }
+        }
+        // If no mapping found, use the category name
+        switch (category.toLowerCase()) {
+            case 'switches':
+                return 'vesyncswitch';
+            case 'outlets':
+                return 'vesyncoutlet';
+            case 'bulbs':
+                return 'vesyncbulb';
+            case 'fans':
+                return 'vesyncfan';
+            default:
+                const baseName = category.toLowerCase();
+                return `vesync${baseName.endsWith('s') ? baseName.slice(0, -1) : baseName}`;
+        }
+    }
+    /**
+     * Find YAML spec file for a device
+     */
+    findDeviceSpec(device) {
+        const deviceType = device.deviceType;
+        const apiDir = path.join(__dirname, '..', 'api');
+        const subDir = this.getDeviceDirectory(deviceType, device.deviceCategory);
+        // Look for exact match first
+        const exactPath = path.join(apiDir, subDir, `${deviceType}.yaml`);
+        if (fs.existsSync(exactPath)) {
+            return exactPath;
+        }
+        // Look for partial matches
+        const files = fs.readdirSync(path.join(apiDir, subDir));
+        for (const file of files) {
+            if (file.endsWith('.yaml') && deviceType.includes(file.replace('.yaml', ''))) {
+                return path.join(apiDir, subDir, file);
+            }
+        }
+        console.warn(`Could not find API spec file for device type: ${deviceType}`);
+        return null;
+    }
+    /**
+     * Convert snake_case to camelCase
+     */
+    snakeToCamel(str) {
+        return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+    }
+    /**
+     * Convert camelCase to snake_case
+     */
+    camelToSnake(str) {
+        return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    }
+    /**
+     * Convert spec method name to implementation method name
+     */
+    specToImplMethod(specMethod) {
+        return this.snakeToCamel(specMethod);
+    }
+    /**
+     * Convert implementation method name to spec method name
+     */
+    implToSpecMethod(implMethod) {
+        return this.camelToSnake(implMethod);
+    }
+    /**
+     * Analyze methods for a device
+     */
+    analyzeMethods(specMethods, implMethods) {
+        // Get all methods (for display purposes)
+        const allImplMethods = Array.from(implMethods);
+        const allSpecMethods = specMethods;
+        // Filter out utility methods from implementation
+        const utilityMethods = ['update', 'display', 'displayJSON', 'hasFeature'];
+        const filteredImplMethods = allImplMethods.filter(m => !utilityMethods.includes(m));
+        // Find matching methods
+        const matchedMethods = filteredImplMethods.filter(m => allSpecMethods.includes(this.implToSpecMethod(m)));
+        // Find missing methods (excluding update)
+        const missingMethods = allSpecMethods.filter(m => m !== 'update' && !matchedMethods.includes(this.specToImplMethod(m)));
+        // Find extra methods
+        const extraMethods = filteredImplMethods.filter(m => !allSpecMethods.includes(this.implToSpecMethod(m)));
+        return {
+            allImplMethods,
+            allSpecMethods,
+            matchedMethods,
+            missingMethods,
+            extraMethods
+        };
+    }
+    /**
+     * Test device methods against YAML spec
+     */
+    async testDeviceMethods(device) {
+        const specFile = this.findDeviceSpec(device);
+        if (!specFile)
+            return;
+        const spec = yaml.load(fs.readFileSync(specFile, 'utf8'));
+        if (!spec) {
+            console.warn(`Empty or invalid YAML spec for device type: ${device.deviceType}`);
+            return;
+        }
+        console.log(`\nTesting methods for device: ${device.deviceName} (${device.deviceType})`);
+        console.log(`  Using spec file: ${specFile}\n`);
+        // Get methods from spec and implementation
+        const specMethods = Object.keys(spec);
+        console.log('\nSpec methods:', specMethods);
+        const implMethods = new Set();
+        // Get all methods from the prototype chain up to but not including VeSyncBaseDevice
+        let proto = Object.getPrototypeOf(device);
+        while (proto && proto.constructor !== vesyncBaseDevice_1.VeSyncBaseDevice) {
+            const methods = Object.getOwnPropertyNames(proto)
+                .filter(name => {
+                if (name === 'constructor' || name.startsWith('_'))
+                    return false;
+                const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+                return descriptor && typeof descriptor.value === 'function';
+            });
+            console.log('Found methods in', proto.constructor.name + ':', methods);
+            methods.forEach(name => implMethods.add(name));
+            proto = Object.getPrototypeOf(proto);
+        }
+        console.log('All implementation methods:', Array.from(implMethods));
+        // Analyze methods
+        const analysis = this.analyzeMethods(specMethods, implMethods);
+        // Store test results
+        const testResult = {
+            deviceType: device.deviceType,
+            category: device.deviceCategory,
+            specMethods,
+            implMethods,
+            missingMethods: analysis.missingMethods,
+            extraMethods: analysis.extraMethods,
+            logs: []
+        };
+        this.testResults.set(device.deviceType, testResult);
+        console.log(`  Methods defined in YAML spec: ${analysis.allSpecMethods.join(', ')}`);
+        console.log(`  Methods in implementation: ${analysis.allImplMethods.join(', ')}\n`);
+        if (analysis.missingMethods.length > 0) {
+            console.log(`  ✗ Missing methods: ${analysis.missingMethods.join(', ')}`);
+            throw new Error(`Device ${device.deviceType} is missing required methods: ${analysis.missingMethods.join(', ')}`);
+        }
+        if (analysis.extraMethods.length > 0) {
+            console.log(`  ! Extra methods not in spec: ${analysis.extraMethods.join(', ')}`);
+        }
+        // Test each method in the spec
+        for (const method of specMethods) {
+            if (method === 'update')
+                continue; // Skip testing update method
+            console.log(`\n  Testing method: ${method}`);
+            console.log('  YAML Specification:');
+            console.log(`    URL: ${spec[method].url}`);
+            console.log(`    Method: ${spec[method].method}`);
+            console.log('    Headers:', JSON.stringify(spec[method].headers, null, 2));
+            console.log('    Body:', JSON.stringify(spec[method].body, null, 2));
+            const implMethod = this.specToImplMethod(method);
+            if (analysis.matchedMethods.includes(implMethod)) {
+                console.log('\n  Executing method...');
+                try {
+                    // Generate test parameters based on method signature
+                    const params = this.generateTestParameters(device, implMethod, spec[method]);
+                    // Create a proxy to intercept API calls and logs
+                    const manager = device.manager;
+                    const originalCallApi = manager.callApi;
+                    let apiCallMade = false;
+                    let lastRequest = null;
+                    let lastResponse = null;
+                    let lastError = null;
+                    // Intercept logError calls
+                    const originalLogError = device.logError;
+                    device.logError = (method, error) => {
+                        const errorMsg = `Error in ${device.deviceName}.${method}: ${error?.message || error}`;
+                        if (error?.response?.data) {
+                            const responseData = error.response.data;
+                            const msg = responseData.msg || responseData.message || JSON.stringify(responseData);
+                            testResult.logs.push(`${errorMsg} - ${msg}`);
+                            console.log(`  ${errorMsg}`);
+                            console.log(`  Response: ${msg}`);
+                        }
+                        else {
+                            testResult.logs.push(errorMsg);
+                            console.log(`  ${errorMsg}`);
+                        }
+                        lastError = error;
+                    };
+                    // Intercept API calls
+                    manager.callApi = async (url, method, body, headers) => {
+                        apiCallMade = true;
+                        lastRequest = { url, method, body, headers };
+                        try {
+                            lastResponse = await originalCallApi.call(manager, url, method, body, headers);
+                            if (lastResponse[0]?.msg) {
+                                console.log('  Response message:', lastResponse[0].msg);
+                            }
+                            return lastResponse;
+                        }
+                        catch (error) {
+                            lastError = error;
+                            throw error;
+                        }
+                    };
+                    // Execute the method with parameters
+                    const result = await device[implMethod](...params);
+                    // Restore original functions
+                    manager.callApi = originalCallApi;
+                    device.logError = originalLogError;
+                    // Validate API call was made
+                    if (!apiCallMade) {
+                        console.log('  ⚠ Warning: Method did not make any API calls');
+                    }
+                    else {
+                        // Validate request against spec
+                        this.validateApiCall(lastRequest, spec[method]);
+                        // Print response details
+                        if (lastResponse) {
+                            const [data, status] = lastResponse;
+                            console.log(`  Response status: ${status}`);
+                            if (data) {
+                                console.log('  Response data:', JSON.stringify(data, null, 2));
+                            }
+                        }
+                        // Print any error details
+                        if (lastError) {
+                            console.log('  Error details:');
+                            if (lastError.response) {
+                                console.log('    Status:', lastError.response.status);
+                                console.log('    Data:', JSON.stringify(lastError.response.data, null, 2));
+                            }
+                            else {
+                                console.log('    Message:', lastError.message);
+                            }
+                        }
+                    }
+                    // Log result
+                    console.log(`  ✓ Method executed (returned: ${JSON.stringify(result)})`);
+                }
+                catch (error) {
+                    console.log('  ✗ Method execution failed:');
+                    if (error instanceof Error) {
+                        console.log(`    Type: ${error.constructor.name}`);
+                        console.log(`    Message: ${error.message}`);
+                        if (this.verbose) {
+                            console.log('    Stack:', error.stack);
+                        }
+                    }
+                    else {
+                        console.log(`    Error: ${error}`);
+                    }
+                }
+            }
+            else {
+                console.log('  ✗ Method not implemented');
+                console.log('  Implementation required based on YAML spec:');
+                this.generateMethodStub(method, spec[method]);
+            }
+        }
+    }
+    /**
+     * Generate test parameters for a method
+     */
+    generateTestParameters(device, method, spec) {
+        const params = [];
+        // Extract parameters from the YAML spec's json_object
+        if (spec.json_object?.payload?.data) {
+            const data = spec.json_object.payload.data;
+            switch (method) {
+                case 'setColorTemp':
+                    if ('colorTempe' in data)
+                        params.push(data.colorTempe);
+                    break;
+                case 'setBrightness':
+                    if ('brightness' in data)
+                        params.push(data.brightness);
+                    break;
+                case 'changeFanSpeed':
+                    if ('level' in data)
+                        params.push(data.level);
+                    break;
+                case 'setMistLevel':
+                    if ('level' in data && data.type === 'mist')
+                        params.push(data.level);
+                    break;
+                case 'setWarmLevel':
+                    if ('level' in data && data.type === 'warm')
+                        params.push(data.level);
+                    break;
+                case 'setTimer':
+                    if ('total' in data)
+                        params.push(data.total);
+                    break;
+                case 'setTargetHumidity':
+                    if ('humidity' in data)
+                        params.push(data.humidity);
+                    break;
+                case 'setDryingModeEnabled':
+                    if ('autoDryingSwitch' in data)
+                        params.push(data.autoDryingSwitch === 1);
+                    break;
+                default:
+                    // For methods without parameters or unknown methods
+                    break;
+            }
+        }
+        // If no parameters found in spec, use defaults
+        if (params.length === 0) {
+            switch (method) {
+                case 'setColorTemp':
+                    params.push(2700);
+                    break;
+                case 'setBrightness':
+                    params.push(50);
+                    break;
+                case 'changeFanSpeed':
+                case 'setMistLevel':
+                case 'setWarmLevel':
+                    params.push(1);
+                    break;
+                case 'setTimer':
+                    params.push(30);
+                    break;
+                case 'setTargetHumidity':
+                    params.push(50);
+                    break;
+                case 'setDryingModeEnabled':
+                    params.push(true);
+                    break;
+            }
+        }
+        return params;
+    }
+    /**
+     * Validate an API call against its spec
+     */
+    validateApiCall(request, spec) {
+        if (!request)
+            return;
+        let hasError = false;
+        // Check URL
+        if (request.url !== spec.url) {
+            console.log(`  ⚠ Warning: URL mismatch`);
+            console.log(`    Expected: ${spec.url}`);
+            console.log(`    Actual: ${request.url}`);
+            hasError = true;
+        }
+        // Check method
+        if (request.method.toLowerCase() !== spec.method.toLowerCase()) {
+            console.log(`  ⚠ Warning: HTTP method mismatch`);
+            console.log(`    Expected: ${spec.method}`);
+            console.log(`    Actual: ${request.method}`);
+            hasError = true;
+        }
+        // Check required headers
+        for (const [key, value] of Object.entries(spec.headers || {})) {
+            if (!request.headers[key]) {
+                console.log(`  ⚠ Warning: Missing required header: ${key}`);
+                hasError = true;
+            }
+        }
+        // Check required body fields
+        if (spec.body) {
+            for (const [key, value] of Object.entries(spec.body)) {
+                if (!(key in request.body)) {
+                    console.log(`  ⚠ Warning: Missing required body field: ${key}`);
+                    hasError = true;
+                }
+            }
+        }
+        if (!hasError) {
+            console.log('  ✓ API call matches specification');
+        }
+    }
+    /**
+     * Generate method stub from YAML spec
+     */
+    generateMethodStub(method, spec) {
+        const camelMethod = this.snakeToCamel(method);
+        console.log(`  async ${camelMethod}(): Promise<boolean> {`);
+        console.log('    // TODO: Implement according to YAML spec');
+        console.log(`    // URL: ${spec.url}`);
+        console.log(`    // Method: ${spec.method.toUpperCase()}`);
+        console.log('    // Required headers:', JSON.stringify(spec.headers, null, 2));
+        console.log('    // Required body:', JSON.stringify(spec.body, null, 2));
+        console.log('  }');
+    }
+    /**
+     * Display test summary
+     */
+    displaySummary() {
+        console.log('\n=== Test Summary ===\n');
+        // Group devices by category
+        const devicesByCategory = new Map();
+        for (const result of this.testResults.values()) {
+            if (!devicesByCategory.has(result.category)) {
+                devicesByCategory.set(result.category, []);
+            }
+            devicesByCategory.get(result.category).push(result);
+        }
+        // Display results by category
+        for (const [category, devices] of devicesByCategory) {
+            console.log(`${category}:`);
+            for (const device of devices) {
+                console.log(`  ${device.deviceType}:`);
+                // Group errors by type
+                const apiErrors = device.logs.filter(log => log.includes('Invalid response code'));
+                const otherErrors = device.logs.filter(log => !log.includes('Invalid response code'));
+                if (apiErrors.length > 0) {
+                    console.log('    API Errors:');
+                    apiErrors.forEach(error => {
+                        const [method, code] = error.match(/\.(\w+): Invalid response code: (\d+)/)?.slice(1) || [];
+                        console.log(`      ${method}: Response code ${code}`);
+                    });
+                }
+                if (otherErrors.length > 0) {
+                    console.log('    Other Errors:');
+                    otherErrors.forEach(error => console.log(`      ${error}`));
+                }
+                if (device.missingMethods.length > 0) {
+                    console.log(`    Missing Methods: ${device.missingMethods.join(', ')}`);
+                }
+            }
+            console.log();
+        }
+    }
+    /**
+     * Run all tests
+     */
+    async run() {
+        (0, helpers_1.setApiBaseUrl)('http://localhost:8000');
+        console.log('Using credentials:', {
+            username: this.manager.username,
+            password: this.manager.password
+        });
+        console.log('\nTesting login...');
+        if (!await this.manager.login()) {
+            console.error('Login failed');
+            return;
+        }
+        console.log('\nTesting device discovery...');
+        await this.manager.getDevices();
+        // Test devices if any are found
+        if (this.manager.devices && this.manager.devices.length > 0) {
+            for (const device of this.manager.devices) {
+                await this.testDeviceMethods(device);
+            }
+        }
+        else {
+            console.log('No devices found. Tests will be skipped.');
+        }
+        // Display test summary
+        this.displaySummary();
+        console.log('\n✓ All tests completed');
+    }
+}
+exports.VeSyncTestService = VeSyncTestService;
+// Run tests if this file is executed directly
+if (require.main === module) {
+    const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+    const testService = new VeSyncTestService(verbose);
+    testService.run();
+}

package/dist/test/testSpecial.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Special test for VeSync API
+ * Uses credentials from .env file in test directory
+ */
+export {};