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

package/test/unit/api/daikin-api.test.ts

@@ -1,384 +0,0 @@
-import {DaikinApi, RateLimitedError, ApiTimeoutError} from '../../../src/api/daikin-api';
-import {OAuthProvider, TokenSet} from '../../../src/api/daikin-types';
-import {MAX_RETRY_ATTEMPTS} from '../../../src/constants';
-import * as https from 'node:https';
-
-jest.mock('node:https');
-
-describe('DaikinApi', () => {
-    let mockOAuth: jest.Mocked<OAuthProvider>;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.useFakeTimers();
-        mockOAuth = {
-            getAccessToken: jest.fn().mockResolvedValue('valid-token'),
-            isAuthenticated: jest.fn().mockReturnValue(true),
-            refreshToken: jest.fn().mockResolvedValue({
-                access_token: 'new-token',
-                refresh_token: 'new-refresh-token',
-                token_type: 'Bearer',
-                expires_in: 3600,
-            } as TokenSet),
-        };
-    });
-
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-
-    // Helper to run async operations with fake timers
-    async function runWithTimers<T>(promise: Promise<T>): Promise<T> {
-        const result = promise;
-        // Run timers until all pending timers are exhausted
-        await jest.runAllTimersAsync();
-        return result;
-    }
-
-    function mockHttpsRequest(statusCode: number, body: string, headers: Record<string, string> = {}) {
-        const mockResponse: any = {
-            statusCode,
-            headers,
-            on: jest.fn((event, callback) => {
-                if (event === 'data') {
-                    callback(body);
-                }
-                if (event === 'end') {
-                    callback();
-                }
-                return mockResponse;
-            }),
-        };
-        const mockRequest = {
-            on: jest.fn().mockReturnThis(),
-            write: jest.fn(),
-            end: jest.fn(),
-        };
-        (https.request as jest.Mock).mockImplementation((options, callback) => {
-            callback(mockResponse);
-            return mockRequest;
-        });
-        return {mockRequest, mockResponse};
-    }
-
-    describe('getDevices', () => {
-        it('should return devices on successful request', async () => {
-            const devices = [{id: 'device-1', managementPoints: []}];
-            mockHttpsRequest(200, JSON.stringify(devices));
-
-            const api = new DaikinApi(mockOAuth);
-            const result = await api.getDevices();
-
-            expect(result).toEqual(devices);
-            expect(mockOAuth.getAccessToken).toHaveBeenCalled();
-        });
-
-        it('should refresh token and retry on 401 Unauthorized with exponential backoff', async () => {
-            const devices = [{id: 'device-1', managementPoints: []}];
-            let callCount = 0;
-
-            const mockRequest = {
-                on: jest.fn().mockReturnThis(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callCount++;
-                const statusCode = callCount === 1 ? 401 : 200;
-                const body = callCount === 1 ? 'Unauthorized' : JSON.stringify(devices);
-
-                const mockResponse: any = {
-                    statusCode,
-                    headers: {},
-                    on: jest.fn((event, cb) => {
-                        if (event === 'data') {
-                            cb(body);
-                        }
-                        if (event === 'end') {
-                            cb();
-                        }
-                        return mockResponse;
-                    }),
-                };
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            // After refresh, return a new token
-            mockOAuth.getAccessToken
-                .mockResolvedValueOnce('expired-token')
-                .mockResolvedValueOnce('new-token');
-
-            const api = new DaikinApi(mockOAuth);
-            const result = await runWithTimers(api.getDevices());
-
-            expect(result).toEqual(devices);
-            expect(mockOAuth.refreshToken).toHaveBeenCalledTimes(1);
-            expect(https.request).toHaveBeenCalledTimes(2);
-        });
-
-        it('should throw error if refresh fails on 401', async () => {
-            mockHttpsRequest(401, 'Unauthorized');
-            mockOAuth.refreshToken.mockRejectedValue(new Error('Refresh failed'));
-
-            const api = new DaikinApi(mockOAuth);
-
-            await expect(api.getDevices()).rejects.toThrow(
-                'Unauthorized (401): Token refresh failed. Please re-authenticate.',
-            );
-            expect(mockOAuth.refreshToken).toHaveBeenCalledTimes(1);
-        });
-
-        it('should throw error if retry after refresh still returns 401', async () => {
-            jest.useRealTimers(); // Use real timers for this test
-            // Always return 401
-            mockHttpsRequest(401, 'Unauthorized');
-
-            const api = new DaikinApi(mockOAuth);
-
-            // Temporarily override sleep to be instant for testing
-            const originalSleep = (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep;
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            await expect(api.getDevices()).rejects.toThrow(
-                'Unauthorized (401): Token expired or invalid',
-            );
-            // Should retry MAX_RETRY_ATTEMPTS times
-            expect(mockOAuth.refreshToken).toHaveBeenCalledTimes(MAX_RETRY_ATTEMPTS);
-            // Initial request + MAX_RETRY_ATTEMPTS retries
-            expect(https.request).toHaveBeenCalledTimes(MAX_RETRY_ATTEMPTS + 1);
-
-            // Restore original sleep
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = originalSleep;
-        });
-
-        it('should not retry more than MAX_RETRY_ATTEMPTS times on 401', async () => {
-            jest.useRealTimers(); // Use real timers for this test
-            // Always return 401
-            mockHttpsRequest(401, 'Unauthorized');
-
-            const api = new DaikinApi(mockOAuth);
-
-            // Temporarily override sleep to be instant for testing
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            await expect(api.getDevices()).rejects.toThrow('Unauthorized');
-            // Should only refresh MAX_RETRY_ATTEMPTS times
-            expect(mockOAuth.refreshToken).toHaveBeenCalledTimes(MAX_RETRY_ATTEMPTS);
-        });
-    });
-
-    describe('rate limiting', () => {
-        it('should throw RateLimitedError on 429', async () => {
-            mockHttpsRequest(429, 'Too Many Requests', {'retry-after': '60'});
-
-            const api = new DaikinApi(mockOAuth);
-
-            await expect(api.getDevices()).rejects.toThrow(RateLimitedError);
-        });
-
-        it('should block subsequent requests after rate limit', async () => {
-            mockHttpsRequest(429, 'Too Many Requests', {'retry-after': '60'});
-
-            const api = new DaikinApi(mockOAuth);
-
-            await expect(api.getDevices()).rejects.toThrow(RateLimitedError);
-            expect(api.isRateLimited()).toBe(true);
-
-            // Reset mock to return 200, but should still be blocked
-            mockHttpsRequest(200, '[]');
-
-            await expect(api.getDevices()).rejects.toThrow(
-                'API request blocked due to rate limit',
-            );
-        });
-    });
-
-    describe('gateway errors', () => {
-        it('should retry on 504 Gateway Timeout and succeed', async () => {
-            const devices = [{id: 'device-1', managementPoints: []}];
-            let callCount = 0;
-
-            const mockRequest = {
-                on: jest.fn().mockReturnThis(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callCount++;
-                // First call returns 504, second returns 200
-                const statusCode = callCount === 1 ? 504 : 200;
-                const body = callCount === 1 ? 'Gateway Timeout' : JSON.stringify(devices);
-
-                const mockResponse: any = {
-                    statusCode,
-                    headers: {},
-                    on: jest.fn((event, cb) => {
-                        if (event === 'data') {
-                            cb(body);
-                        }
-                        if (event === 'end') {
-                            cb();
-                        }
-                        return mockResponse;
-                    }),
-                };
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const api = new DaikinApi(mockOAuth);
-            const result = await runWithTimers(api.getDevices());
-
-            expect(result).toEqual(devices);
-            expect(https.request).toHaveBeenCalledTimes(2);
-        });
-
-        it('should retry on 502 Bad Gateway and succeed', async () => {
-            const devices = [{id: 'device-1', managementPoints: []}];
-            let callCount = 0;
-
-            const mockRequest = {
-                on: jest.fn().mockReturnThis(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callCount++;
-                const statusCode = callCount === 1 ? 502 : 200;
-                const body = callCount === 1 ? 'Bad Gateway' : JSON.stringify(devices);
-
-                const mockResponse: any = {
-                    statusCode,
-                    headers: {},
-                    on: jest.fn((event, cb) => {
-                        if (event === 'data') {
-                            cb(body);
-                        }
-                        if (event === 'end') {
-                            cb();
-                        }
-                        return mockResponse;
-                    }),
-                };
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const api = new DaikinApi(mockOAuth);
-            const result = await runWithTimers(api.getDevices());
-
-            expect(result).toEqual(devices);
-            expect(https.request).toHaveBeenCalledTimes(2);
-        });
-
-        it('should retry on 503 Service Unavailable and succeed', async () => {
-            const devices = [{id: 'device-1', managementPoints: []}];
-            let callCount = 0;
-
-            const mockRequest = {
-                on: jest.fn().mockReturnThis(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callCount++;
-                const statusCode = callCount === 1 ? 503 : 200;
-                const body = callCount === 1 ? 'Service Unavailable' : JSON.stringify(devices);
-
-                const mockResponse: any = {
-                    statusCode,
-                    headers: {},
-                    on: jest.fn((event, cb) => {
-                        if (event === 'data') {
-                            cb(body);
-                        }
-                        if (event === 'end') {
-                            cb();
-                        }
-                        return mockResponse;
-                    }),
-                };
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const api = new DaikinApi(mockOAuth);
-            const result = await runWithTimers(api.getDevices());
-
-            expect(result).toEqual(devices);
-            expect(https.request).toHaveBeenCalledTimes(2);
-        });
-
-        it('should throw ApiTimeoutError after exhausting retries on 504', async () => {
-            // Always return 504
-            mockHttpsRequest(504, 'Gateway Timeout');
-
-            const api = new DaikinApi(mockOAuth);
-
-            // Temporarily override sleep to be instant for testing
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            await expect(api.getDevices()).rejects.toThrow(ApiTimeoutError);
-            // Initial request + MAX_RETRY_ATTEMPTS retries
-            expect(https.request).toHaveBeenCalledTimes(MAX_RETRY_ATTEMPTS + 1);
-        });
-
-        it('should include status code and attempts in ApiTimeoutError', async () => {
-            mockHttpsRequest(504, 'Gateway Timeout');
-
-            const api = new DaikinApi(mockOAuth);
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            try {
-                await api.getDevices();
-                fail('Expected ApiTimeoutError to be thrown');
-            } catch (error) {
-                expect(error).toBeInstanceOf(ApiTimeoutError);
-                const timeoutError = error as ApiTimeoutError;
-                expect(timeoutError.statusCode).toBe(504);
-                expect(timeoutError.attemptsMade).toBe(MAX_RETRY_ATTEMPTS + 1);
-                expect(timeoutError.message).toContain('Gateway Timeout');
-                expect(timeoutError.message).toContain('504');
-            }
-        });
-
-        it('should throw ApiTimeoutError with correct name for 502', async () => {
-            mockHttpsRequest(502, 'Bad Gateway');
-
-            const api = new DaikinApi(mockOAuth);
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            try {
-                await api.getDevices();
-                fail('Expected ApiTimeoutError to be thrown');
-            } catch (error) {
-                expect(error).toBeInstanceOf(ApiTimeoutError);
-                const timeoutError = error as ApiTimeoutError;
-                expect(timeoutError.statusCode).toBe(502);
-                expect(timeoutError.message).toContain('Bad Gateway');
-            }
-        });
-
-        it('should throw ApiTimeoutError with correct name for 503', async () => {
-            mockHttpsRequest(503, 'Service Unavailable');
-
-            const api = new DaikinApi(mockOAuth);
-            (api as unknown as { sleep: (ms: number) => Promise<void> }).sleep = () => Promise.resolve();
-
-            try {
-                await api.getDevices();
-                fail('Expected ApiTimeoutError to be thrown');
-            } catch (error) {
-                expect(error).toBeInstanceOf(ApiTimeoutError);
-                const timeoutError = error as ApiTimeoutError;
-                expect(timeoutError.statusCode).toBe(503);
-                expect(timeoutError.message).toContain('Service Unavailable');
-            }
-        });
-    });
-});

package/test/unit/api/daikin-oauth.test.ts

@@ -1,214 +0,0 @@
-import {DaikinOAuth} from '../../../src/api/daikin-oauth';
-import * as fs from 'node:fs';
-import * as https from 'node:https';
-
-jest.mock('node:fs');
-jest.mock('node:https');
-
-describe('DaikinOAuth', () => {
-    const mockConfig = {
-        clientId: 'test-client-id',
-        clientSecret: 'test-client-secret',
-        callbackServerExternalAddress: '192.168.1.1',
-        callbackServerPort: 8582,
-        tokenFilePath: '/tmp/test-token.json',
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        (fs.existsSync as jest.Mock).mockReturnValue(false);
-    });
-
-    describe('getAccessToken', () => {
-        it('should return the access token if not expired', async () => {
-            const futureExpiry = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
-            const tokenSet = {
-                access_token: 'valid-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: futureExpiry,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('valid-token');
-        });
-
-        it('should refresh the token if expired', async () => {
-            const pastExpiry = Math.floor(Date.now() / 1000) - 100; // 100 seconds ago
-            const tokenSet = {
-                access_token: 'expired-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: pastExpiry,
-            };
-
-            const newTokenSet = {
-                access_token: 'new-token',
-                refresh_token: 'new-refresh-token',
-                token_type: 'Bearer',
-                expires_in: 3600,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            // Mock the HTTPS request for token refresh
-            const mockResponse = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'data') {
-                        callback(JSON.stringify(newTokenSet));
-                    }
-                    if (event === 'end') {
-                        callback();
-                    }
-                }),
-            };
-            const mockRequest = {
-                on: jest.fn(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('new-token');
-            expect(https.request).toHaveBeenCalled();
-        });
-
-        it('should refresh the token if about to expire (within 10 seconds)', async () => {
-            const soonExpiry = Math.floor(Date.now() / 1000) + 5; // 5 seconds from now
-            const tokenSet = {
-                access_token: 'soon-expiring-token',
-                refresh_token: 'refresh-token',
-                token_type: 'Bearer',
-                expires_at: soonExpiry,
-            };
-
-            const newTokenSet = {
-                access_token: 'refreshed-token',
-                refresh_token: 'new-refresh-token',
-                token_type: 'Bearer',
-                expires_in: 3600,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const mockResponse = {
-                on: jest.fn((event, callback) => {
-                    if (event === 'data') {
-                        callback(JSON.stringify(newTokenSet));
-                    }
-                    if (event === 'end') {
-                        callback();
-                    }
-                }),
-            };
-            const mockRequest = {
-                on: jest.fn(),
-                write: jest.fn(),
-                end: jest.fn(),
-            };
-            (https.request as jest.Mock).mockImplementation((options, callback) => {
-                callback(mockResponse);
-                return mockRequest;
-            });
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const token = await oauth.getAccessToken();
-
-            expect(token).toBe('refreshed-token');
-            expect(https.request).toHaveBeenCalled();
-        });
-
-        it('should throw error if token expired and no refresh token', async () => {
-            const pastExpiry = Math.floor(Date.now() / 1000) - 100;
-            const tokenSet = {
-                access_token: 'expired-token',
-                token_type: 'Bearer',
-                expires_at: pastExpiry,
-                // No refresh_token
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-
-            await expect(oauth.getAccessToken()).rejects.toThrow(
-                'Token expired and no refresh token available. Please re-authenticate.',
-            );
-        });
-
-        it('should throw error if not authenticated', async () => {
-            const oauth = new DaikinOAuth(mockConfig);
-
-            await expect(oauth.getAccessToken()).rejects.toThrow(
-                'Not authenticated. Please authenticate first.',
-            );
-        });
-    });
-
-    describe('isAuthenticated', () => {
-        it('should return true if token set exists', () => {
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.isAuthenticated()).toBe(true);
-        });
-
-        it('should return false if no token set', () => {
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.isAuthenticated()).toBe(false);
-        });
-    });
-
-    describe('getTokenExpiration', () => {
-        it('should return expiration date', () => {
-            const expiresAt = Math.floor(Date.now() / 1000) + 3600;
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-                expires_at: expiresAt,
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            const expiration = oauth.getTokenExpiration();
-
-            expect(expiration).toBeInstanceOf(Date);
-            expect(expiration?.getTime()).toBe(expiresAt * 1000);
-        });
-
-        it('should return null if no expiration', () => {
-            const tokenSet = {
-                access_token: 'token',
-                token_type: 'Bearer',
-            };
-
-            (fs.existsSync as jest.Mock).mockReturnValue(true);
-            (fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(tokenSet));
-
-            const oauth = new DaikinOAuth(mockConfig);
-            expect(oauth.getTokenExpiration()).toBeNull();
-        });
-    });
-});

package/test/unit/api/daikinCloud.test.ts

@@ -1,12 +0,0 @@
-import {DaikinCloudRepo} from '../../../src/api/daikin-cloud.repository';
-import {dx4Airco} from '../../fixtures/dx4-airco';
-import {dx23Airco} from '../../fixtures/dx23-airco';
-import {althermaHeatPump} from '../../fixtures/altherma-heat-pump';
-
-test.each<Array<string | any>>([
-    ['dx4', dx4Airco],
-    ['dx23', dx23Airco],
-    ['altherma', althermaHeatPump],
-])('Clean cloud device data for %s device', (name, deviceJson) => {
-    expect(DaikinCloudRepo.maskSensitiveCloudDeviceData(deviceJson)).toMatchSnapshot();
-});