@mp-consulting/homebridge-daikin-cloud 1.3.5 → 1.3.7

package/test/unit/utils/error-handler.test.ts

@@ -1,274 +0,0 @@
-/**
- * ErrorHandler Tests
- */
-
-import {ErrorHandler, ErrorCategory, ErrorSeverity} from '../../../src/utils/error-handler';
-import {Logger} from 'homebridge';
-
-describe('ErrorHandler', () => {
-    let mockLogger: Logger;
-    let handler: ErrorHandler;
-
-    beforeEach(() => {
-        mockLogger = {
-            debug: jest.fn(),
-            info: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-            log: jest.fn(),
-        } as unknown as Logger;
-
-        handler = new ErrorHandler(mockLogger, 'TestContext');
-    });
-
-    describe('categorize', () => {
-        it('should categorize authentication errors', () => {
-            const error = new Error('Unauthorized token expired');
-            expect(handler.categorize(error)).toBe(ErrorCategory.AUTHENTICATION);
-        });
-
-        it('should categorize rate limit errors', () => {
-            const error = new Error('Rate limit exceeded');
-            expect(handler.categorize(error)).toBe(ErrorCategory.RATE_LIMIT);
-        });
-
-        it('should categorize network errors', () => {
-            const error = new Error('ECONNRESET connection failed');
-            expect(handler.categorize(error)).toBe(ErrorCategory.NETWORK);
-        });
-
-        it('should categorize websocket errors', () => {
-            const error = new Error('ws: connection closed');
-            expect(handler.categorize(error)).toBe(ErrorCategory.WEBSOCKET);
-        });
-
-        it('should categorize validation errors', () => {
-            const error = new Error('Invalid configuration value');
-            expect(handler.categorize(error)).toBe(ErrorCategory.VALIDATION);
-        });
-
-        it('should categorize device errors', () => {
-            const error = new Error('Device not responding');
-            expect(handler.categorize(error)).toBe(ErrorCategory.DEVICE);
-        });
-
-        it('should categorize unknown errors', () => {
-            const error = new Error('Something went wrong');
-            expect(handler.categorize(error)).toBe(ErrorCategory.UNKNOWN);
-        });
-    });
-
-    describe('determineSeverity', () => {
-        it('should mark rate limit as warning', () => {
-            const error = new Error('Rate limit');
-            const severity = handler.determineSeverity(error, ErrorCategory.RATE_LIMIT);
-            expect(severity).toBe(ErrorSeverity.WARNING);
-        });
-
-        it('should mark authentication as fatal', () => {
-            const error = new Error('Auth failed');
-            const severity = handler.determineSeverity(error, ErrorCategory.AUTHENTICATION);
-            expect(severity).toBe(ErrorSeverity.FATAL);
-        });
-
-        it('should mark configuration as fatal', () => {
-            const error = new Error('Config error');
-            const severity = handler.determineSeverity(error, ErrorCategory.CONFIGURATION);
-            expect(severity).toBe(ErrorSeverity.FATAL);
-        });
-
-        it('should mark network as warning', () => {
-            const error = new Error('Network error');
-            const severity = handler.determineSeverity(error, ErrorCategory.NETWORK);
-            expect(severity).toBe(ErrorSeverity.WARNING);
-        });
-
-        it('should mark device as error', () => {
-            const error = new Error('Device error');
-            const severity = handler.determineSeverity(error, ErrorCategory.DEVICE);
-            expect(severity).toBe(ErrorSeverity.ERROR);
-        });
-    });
-
-    describe('isRetryable', () => {
-        it('should mark network errors as retryable', () => {
-            const error = new Error('ECONNRESET');
-            expect(handler.isRetryable(error)).toBe(true);
-        });
-
-        it('should mark timeout errors as retryable', () => {
-            const error = new Error('ETIMEDOUT');
-            expect(handler.isRetryable(error)).toBe(true);
-        });
-
-        it('should mark gateway errors as retryable', () => {
-            const error = new Error('Bad gateway');
-            expect(handler.isRetryable(error)).toBe(true);
-        });
-
-        it('should mark rate limit as retryable', () => {
-            const error = new Error('Rate limit exceeded');
-            expect(handler.isRetryable(error)).toBe(true);
-        });
-
-        it('should not mark validation errors as retryable', () => {
-            const error = new Error('Invalid input');
-            expect(handler.isRetryable(error)).toBe(false);
-        });
-    });
-
-    describe('handle', () => {
-        it('should handle error and log with context', () => {
-            const error = new Error('Test error');
-            const context = {
-                category: ErrorCategory.API,
-                operation: 'testOperation',
-                deviceId: 'device123',
-            };
-
-            const handled = handler.handle(error, context);
-
-            expect(handled.message).toBe('Test error');
-            expect(handled.context.category).toBe(ErrorCategory.API);
-            expect(handled.context.operation).toBe('testOperation');
-            expect(handled.context.deviceId).toBe('device123');
-            expect(mockLogger.error).toHaveBeenCalled();
-        });
-
-        it('should auto-categorize when category not provided', () => {
-            const error = new Error('Unauthorized');
-            const handled = handler.handle(error);
-
-            expect(handled.context.category).toBe(ErrorCategory.AUTHENTICATION);
-        });
-
-        it('should auto-determine severity', () => {
-            const error = new Error('Rate limit');
-            const handled = handler.handle(error);
-
-            expect(handled.context.severity).toBe(ErrorSeverity.WARNING);
-        });
-
-        it('should detect retryability', () => {
-            const error = new Error('ECONNRESET');
-            const handled = handler.handle(error);
-
-            expect(handled.context.retryable).toBe(true);
-        });
-
-        it('should record error in history', () => {
-            const error = new Error('Test error');
-            handler.handle(error);
-
-            const history = handler.getRecentErrors(1);
-            expect(history).toHaveLength(1);
-            expect(history[0].message).toBe('Test error');
-        });
-    });
-
-    describe('handleWithMessage', () => {
-        it('should return user-friendly message for authentication', () => {
-            const error = new Error('Token expired');
-            const message = handler.handleWithMessage(error, {
-                category: ErrorCategory.AUTHENTICATION,
-            });
-
-            expect(message).toContain('Authentication failed');
-        });
-
-        it('should return user-friendly message for rate limit', () => {
-            const error = new Error('Too many requests');
-            const message = handler.handleWithMessage(error, {
-                category: ErrorCategory.RATE_LIMIT,
-            });
-
-            expect(message).toContain('rate limit');
-        });
-
-        it('should return user-friendly message for network', () => {
-            const error = new Error('Connection failed');
-            const message = handler.handleWithMessage(error, {
-                category: ErrorCategory.NETWORK,
-            });
-
-            expect(message).toContain('Network connection');
-        });
-    });
-
-    describe('getRecentErrors', () => {
-        it('should return limited number of recent errors', () => {
-            for (let i = 0; i < 10; i++) {
-                handler.handle(new Error(`Error ${i}`));
-            }
-
-            const recent = handler.getRecentErrors(5);
-            expect(recent).toHaveLength(5);
-        });
-
-        it('should return all errors when no limit specified', () => {
-            for (let i = 0; i < 5; i++) {
-                handler.handle(new Error(`Error ${i}`));
-            }
-
-            const all = handler.getRecentErrors();
-            expect(all).toHaveLength(5);
-        });
-    });
-
-    describe('getErrorsByCategory', () => {
-        it('should filter errors by category', () => {
-            handler.handle(new Error('Auth error'), {category: ErrorCategory.AUTHENTICATION});
-            handler.handle(new Error('Network error'), {category: ErrorCategory.NETWORK});
-            handler.handle(new Error('Another auth error'), {category: ErrorCategory.AUTHENTICATION});
-
-            const authErrors = handler.getErrorsByCategory(ErrorCategory.AUTHENTICATION);
-            expect(authErrors).toHaveLength(2);
-        });
-    });
-
-    describe('clearHistory', () => {
-        it('should clear all error history', () => {
-            handler.handle(new Error('Error 1'));
-            handler.handle(new Error('Error 2'));
-            expect(handler.getRecentErrors()).toHaveLength(2);
-
-            handler.clearHistory();
-            expect(handler.getRecentErrors()).toHaveLength(0);
-        });
-    });
-
-    describe('logging', () => {
-        it('should log fatal errors with stack trace', () => {
-            const error = new Error('Fatal error');
-            error.stack = 'Stack trace here';
-
-            handler.handle(error, {
-                category: ErrorCategory.AUTHENTICATION,
-                severity: ErrorSeverity.FATAL,
-            });
-
-            expect(mockLogger.error).toHaveBeenCalledTimes(2); // Message + stack
-        });
-
-        it('should log warnings with warn level', () => {
-            handler.handle(new Error('Warning'), {
-                severity: ErrorSeverity.WARNING,
-            });
-
-            expect(mockLogger.warn).toHaveBeenCalled();
-        });
-
-        it('should include context in log messages', () => {
-            handler.handle(new Error('Test'), {
-                category: ErrorCategory.DEVICE,
-                deviceId: 'device123',
-                operation: 'update',
-            });
-
-            const logCall = (mockLogger.error as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('DEVICE');
-            expect(logCall).toContain('device123');
-            expect(logCall).toContain('update');
-        });
-    });
-});

package/test/unit/utils/log-context.test.ts

@@ -1,271 +0,0 @@
-/**
- * StructuredLogger Tests
- */
-
-import {
-    StructuredLogger,
-    LogLevel,
-    LogCategory,
-    createLogger,
-    createCategoryLogger,
-    createDeviceLogger,
-} from '../../../src/utils/log-context';
-import {Logger} from 'homebridge';
-
-describe('StructuredLogger', () => {
-    let mockLogger: Logger;
-    let logger: StructuredLogger;
-
-    beforeEach(() => {
-        mockLogger = {
-            debug: jest.fn(),
-            info: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-            log: jest.fn(),
-        } as unknown as Logger;
-
-        logger = new StructuredLogger(mockLogger);
-    });
-
-    describe('basic logging', () => {
-        it('should log debug messages', () => {
-            logger.debug('Debug message');
-            expect(mockLogger.debug).toHaveBeenCalledWith('Debug message');
-        });
-
-        it('should log info messages', () => {
-            logger.info('Info message');
-            expect(mockLogger.info).toHaveBeenCalledWith('Info message');
-        });
-
-        it('should log warn messages', () => {
-            logger.warn('Warning message');
-            expect(mockLogger.warn).toHaveBeenCalledWith('Warning message');
-        });
-
-        it('should log error messages', () => {
-            logger.error('Error message');
-            expect(mockLogger.error).toHaveBeenCalledWith('Error message');
-        });
-    });
-
-    describe('context formatting', () => {
-        it('should include category in log message', () => {
-            logger.log(LogLevel.INFO, 'Test', {category: LogCategory.API});
-            expect(mockLogger.info).toHaveBeenCalledWith('[API] Test');
-        });
-
-        it('should include device name in log message', () => {
-            logger.log(LogLevel.INFO, 'Test', {deviceName: 'Living Room'});
-            expect(mockLogger.info).toHaveBeenCalledWith('[Living Room] Test');
-        });
-
-        it('should include device ID when no name', () => {
-            logger.log(LogLevel.INFO, 'Test', {deviceId: 'device123'});
-            expect(mockLogger.info).toHaveBeenCalledWith('[Device:device123] Test');
-        });
-
-        it('should include operation in log message', () => {
-            logger.log(LogLevel.INFO, 'Test', {operation: 'update'});
-            expect(mockLogger.info).toHaveBeenCalledWith('(update) Test');
-        });
-
-        it('should include embedded ID', () => {
-            logger.log(LogLevel.INFO, 'Test', {embeddedId: 'climateControl'});
-            expect(mockLogger.info).toHaveBeenCalledWith('[climateControl] Test');
-        });
-
-        it('should include feature name', () => {
-            logger.log(LogLevel.INFO, 'Test', {feature: 'PowerfulMode'});
-            expect(mockLogger.info).toHaveBeenCalledWith('[Feature:PowerfulMode] Test');
-        });
-
-        it('should combine multiple context fields', () => {
-            logger.log(LogLevel.INFO, 'Test', {
-                category: LogCategory.DEVICE,
-                deviceName: 'Kitchen',
-                operation: 'setState',
-            });
-            expect(mockLogger.info).toHaveBeenCalledWith('[Device] [Kitchen] (setState) Test');
-        });
-
-        it('should append metadata as JSON', () => {
-            logger.log(LogLevel.INFO, 'Test', {
-                metadata: {temp: 25, mode: 'cool'},
-            });
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('{"temp":25,"mode":"cool"}');
-        });
-    });
-
-    describe('default context', () => {
-        it('should merge default context with call context', () => {
-            const loggerWithDefaults = new StructuredLogger(mockLogger, {
-                category: LogCategory.PLATFORM,
-            });
-
-            loggerWithDefaults.log(LogLevel.INFO, 'Test', {deviceId: 'device123'});
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[Platform]');
-            expect(logCall).toContain('[Device:device123]');
-        });
-
-        it('should override default context with call context', () => {
-            const loggerWithDefaults = new StructuredLogger(mockLogger, {
-                category: LogCategory.PLATFORM,
-            });
-
-            loggerWithDefaults.log(LogLevel.INFO, 'Test', {
-                category: LogCategory.API,
-            });
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[API]');
-            expect(logCall).not.toContain('[Platform]');
-        });
-
-        it('should merge metadata objects', () => {
-            const loggerWithDefaults = new StructuredLogger(mockLogger, {
-                metadata: {defaultKey: 'defaultValue'},
-            });
-
-            loggerWithDefaults.log(LogLevel.INFO, 'Test', {
-                metadata: {callKey: 'callValue'},
-            });
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('defaultKey');
-            expect(logCall).toContain('callKey');
-        });
-    });
-
-    describe('child logger', () => {
-        it('should create child logger with additional context', () => {
-            const child = logger.child({category: LogCategory.DEVICE});
-            child.info('Test message');
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[Device]');
-        });
-
-        it('should inherit parent context', () => {
-            const parent = new StructuredLogger(mockLogger, {
-                category: LogCategory.PLATFORM,
-            });
-
-            const child = parent.child({deviceName: 'Kitchen'});
-            child.info('Test');
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[Platform]');
-            expect(logCall).toContain('[Kitchen]');
-        });
-    });
-
-    describe('log history', () => {
-        it('should record log entries in history', () => {
-            logger.info('Message 1');
-            logger.warn('Message 2');
-            logger.error('Message 3');
-
-            const history = logger.getHistory();
-            expect(history).toHaveLength(3);
-        });
-
-        it('should return limited history', () => {
-            for (let i = 0; i < 10; i++) {
-                logger.info(`Message ${i}`);
-            }
-
-            const history = logger.getHistory(5);
-            expect(history).toHaveLength(5);
-        });
-
-        it('should include context in history entries', () => {
-            logger.info('Test', {category: LogCategory.API, deviceId: 'device123'});
-
-            const history = logger.getHistory();
-            expect(history[0].message).toBe('Test');
-            expect(history[0].context?.category).toBe(LogCategory.API);
-            expect(history[0].context?.deviceId).toBe('device123');
-        });
-
-        it('should include timestamp in history entries', () => {
-            const before = new Date();
-            logger.info('Test');
-            const after = new Date();
-
-            const history = logger.getHistory();
-            expect(history[0].timestamp.getTime()).toBeGreaterThanOrEqual(before.getTime());
-            expect(history[0].timestamp.getTime()).toBeLessThanOrEqual(after.getTime());
-        });
-
-        it('should clear history', () => {
-            logger.info('Message 1');
-            logger.info('Message 2');
-            expect(logger.getHistory()).toHaveLength(2);
-
-            logger.clearHistory();
-            expect(logger.getHistory()).toHaveLength(0);
-        });
-    });
-
-    describe('helper functions', () => {
-        it('createLogger should create StructuredLogger', () => {
-            const newLogger = createLogger(mockLogger);
-            expect(newLogger).toBeInstanceOf(StructuredLogger);
-        });
-
-        it('createLogger should accept default context', () => {
-            const newLogger = createLogger(mockLogger, {category: LogCategory.API});
-            newLogger.info('Test');
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[API]');
-        });
-
-        it('createCategoryLogger should create logger with category', () => {
-            const newLogger = createCategoryLogger(mockLogger, LogCategory.WEBSOCKET);
-            newLogger.info('Test');
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[WebSocket]');
-        });
-
-        it('createDeviceLogger should create logger with device context', () => {
-            const newLogger = createDeviceLogger(mockLogger, 'device123', 'Kitchen AC');
-            newLogger.info('Test');
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toContain('[Device]');
-            expect(logCall).toContain('[Kitchen AC]');
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle empty message', () => {
-            logger.info('');
-            expect(mockLogger.info).toHaveBeenCalled();
-        });
-
-        it('should handle undefined context', () => {
-            logger.info('Test', undefined);
-            expect(mockLogger.info).toHaveBeenCalledWith('Test');
-        });
-
-        it('should handle empty metadata', () => {
-            logger.info('Test', {metadata: {}});
-
-            const logCall = (mockLogger.info as jest.Mock).mock.calls[0][0];
-            expect(logCall).toBe('Test');
-        });
-
-        it('should handle special characters in messages', () => {
-            logger.info('Test [brackets] (parens) {braces}');
-            expect(mockLogger.info).toHaveBeenCalled();
-        });
-    });
-});