matterbridge-lg-thinq-plugin 0.1.0

package/src/services/thinq/mqtt/mqttRetry.test.ts

@@ -0,0 +1,239 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { createMockLogger } from '../../../tests/helpers/testUtils.js';
+import { delayMs, MQTT_RETRY_ATTEMPTS, MQTT_RETRY_DELAY_MS, retryMqttRegistration } from './mqttRetry.js';
+
+describe('mqttRetry', () => {
+	let mockLogger: ReturnType<typeof createMockLogger>;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockLogger = createMockLogger();
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('delayMs', () => {
+		it('should return a promise that resolves after the specified time', async () => {
+			vi.useFakeTimers();
+			const promise = delayMs(1000);
+			const start = Date.now();
+
+			vi.advanceTimersByTime(1000);
+			await promise;
+
+			const elapsed = Date.now() - start;
+			expect(elapsed).toBeGreaterThanOrEqual(1000);
+
+			vi.useRealTimers();
+		});
+
+		it('should resolve immediately for zero delay', async () => {
+			vi.useFakeTimers();
+			const promise = delayMs(0);
+
+			vi.advanceTimersByTime(0);
+			await promise;
+
+			vi.useRealTimers();
+		});
+	});
+
+	describe('retryMqttRegistration', () => {
+		it('should return true when register succeeds on first call', async () => {
+			const register = vi.fn().mockResolvedValue(undefined);
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			const result = await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+			});
+
+			expect(result).toBe(true);
+			expect(register).toHaveBeenCalledTimes(1);
+			expect(delay).not.toHaveBeenCalled();
+		});
+
+		it('should return false after default 5 attempts when register always fails', async () => {
+			const register = vi.fn().mockRejectedValue(new Error('Connection failed'));
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			const result = await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+			});
+
+			expect(result).toBe(false);
+			expect(register).toHaveBeenCalledTimes(MQTT_RETRY_ATTEMPTS);
+			expect(delay).toHaveBeenCalledTimes(MQTT_RETRY_ATTEMPTS - 1);
+			expect(mockLogger.error).toHaveBeenCalledWith('Cannot start MQTT!');
+		});
+
+		it('should return true when register succeeds on the 3rd attempt', async () => {
+			const register = vi
+				.fn()
+				.mockRejectedValueOnce(new Error('Attempt 1 failed'))
+				.mockRejectedValueOnce(new Error('Attempt 2 failed'))
+				.mockResolvedValueOnce(undefined);
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			const result = await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+			});
+
+			expect(result).toBe(true);
+			expect(register).toHaveBeenCalledTimes(3);
+			expect(delay).toHaveBeenCalledTimes(2);
+		});
+
+		it('should respect custom attempts parameter', async () => {
+			const register = vi.fn().mockRejectedValue(new Error('Connection failed'));
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			const result = await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+				attempts: 3,
+			});
+
+			expect(result).toBe(false);
+			expect(register).toHaveBeenCalledTimes(3);
+			expect(delay).toHaveBeenCalledTimes(2);
+		});
+
+		it('should respect custom retryDelayMs parameter', async () => {
+			const register = vi.fn().mockRejectedValue(new Error('Connection failed'));
+			const delay = vi.fn().mockResolvedValue(undefined);
+			const customDelayMs = 1000;
+
+			await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+				attempts: 2,
+				retryDelayMs: customDelayMs,
+			});
+
+			expect(delay).toHaveBeenCalledWith(customDelayMs);
+		});
+
+		it('should use provided delay function', async () => {
+			const register = vi.fn().mockRejectedValueOnce(new Error('Attempt 1 failed')).mockResolvedValueOnce(undefined);
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			const result = await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+			});
+
+			expect(result).toBe(true);
+			expect(delay).toHaveBeenCalledWith(MQTT_RETRY_DELAY_MS);
+		});
+
+		it('should use default delayMs when delay function not provided', async () => {
+			const register = vi.fn().mockRejectedValueOnce(new Error('Attempt 1 failed')).mockResolvedValueOnce(undefined);
+
+			vi.useFakeTimers();
+
+			const resultPromise = retryMqttRegistration({
+				register,
+				logger: mockLogger,
+			});
+
+			// Advance timer to allow delay to complete
+			await vi.advanceTimersByTimeAsync(MQTT_RETRY_DELAY_MS);
+			const result = await resultPromise;
+
+			expect(result).toBe(true);
+			expect(register).toHaveBeenCalledTimes(2);
+
+			vi.useRealTimers();
+		});
+
+		it('should log debug messages on each retry', async () => {
+			const register = vi
+				.fn()
+				.mockRejectedValueOnce(new Error('Attempt 1 failed'))
+				.mockRejectedValueOnce(new Error('Attempt 2 failed'))
+				.mockResolvedValueOnce(undefined);
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+			});
+
+			// Should have debug logs: error message + retry message for each failed attempt before success
+			expect(mockLogger.debug).toHaveBeenCalledWith('Cannot start MQTT, retrying in 5s.');
+			// Two attempts failed, so 2 error messages + 2 retry messages = 4 total debug calls
+			expect(
+				vi.mocked(mockLogger.debug).mock.calls.filter((call) => call[0]?.includes('Cannot start MQTT')),
+			).toHaveLength(2);
+		});
+
+		it('should not call delay after the last failed attempt', async () => {
+			const register = vi.fn().mockRejectedValue(new Error('Connection failed'));
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+				attempts: 3,
+			});
+
+			// delay should be called 2 times (after attempt 1 and 2, but not after attempt 3)
+			expect(delay).toHaveBeenCalledTimes(2);
+		});
+
+		it('should handle error objects in debug logging', async () => {
+			const error = new Error('Custom error message');
+			const register = vi.fn().mockRejectedValue(error);
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+				attempts: 2,
+			});
+
+			expect(mockLogger.debug).toHaveBeenCalledWith('mqtt err: Custom error message');
+		});
+
+		it('should handle non-Error objects in debug logging', async () => {
+			const register = vi.fn().mockRejectedValue('string error');
+			const delay = vi.fn().mockResolvedValue(undefined);
+
+			await retryMqttRegistration({
+				register,
+				logger: mockLogger,
+				delay,
+				attempts: 2,
+			});
+
+			expect(mockLogger.debug).toHaveBeenCalledWith('mqtt err: string error');
+		});
+	});
+
+	describe('MQTT_RETRY_ATTEMPTS constant', () => {
+		it('should be 5', () => {
+			expect(MQTT_RETRY_ATTEMPTS).toBe(5);
+		});
+	});
+
+	describe('MQTT_RETRY_DELAY_MS constant', () => {
+		it('should be 5000', () => {
+			expect(MQTT_RETRY_DELAY_MS).toBe(5000);
+		});
+	});
+});

package/src/services/thinq/mqtt/mqttRetry.ts

@@ -0,0 +1,43 @@
+import { AnsiLogger } from 'matterbridge/logger';
+
+export const MQTT_RETRY_ATTEMPTS = 5;
+export const MQTT_RETRY_DELAY_MS = 5000;
+
+export function delayMs(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Bounded-attempt retry with delay for MQTT registration; ports `retryMqttRegistration` from `mqttCertificate.ts`. */
+export async function retryMqttRegistration(options: {
+	register: () => Promise<void>;
+	logger: Pick<AnsiLogger, 'debug' | 'error'>;
+	delay?: (ms: number) => Promise<void>;
+	attempts?: number;
+	retryDelayMs?: number;
+}): Promise<boolean> {
+	const {
+		register,
+		logger,
+		delay = delayMs,
+		attempts = MQTT_RETRY_ATTEMPTS,
+		retryDelayMs = MQTT_RETRY_DELAY_MS,
+	} = options;
+	let tried = attempts;
+
+	while (tried > 0) {
+		try {
+			await register();
+			return true;
+		} catch (err) {
+			tried--;
+			logger.debug(`mqtt err: ${err instanceof Error ? err.message : String(err)}`);
+			if (tried > 0) {
+				logger.debug('Cannot start MQTT, retrying in 5s.');
+				await delay(retryDelayMs);
+			}
+		}
+	}
+
+	logger.error('Cannot start MQTT!');
+	return false;
+}

package/src/services/thinq/mqtt/thinqMqttListener.test.ts

@@ -0,0 +1,349 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ThinqSnapshot } from '../../../core/domain/value-objects/ThinqSnapshot.js';
+import { asPartial, createMockLogger } from '../../../tests/helpers/testUtils.js';
+import type { ThinqApiClient } from '../thinqApiClient.js';
+import type { MqttKeyRepository } from './mqttKeyRepository.js';
+import { ThinqMqttListener } from './thinqMqttListener.js';
+
+// Mock aws-iot-device-sdk
+const mockMqttDevice = {
+	on: vi.fn((event: string, handler: unknown) => {
+		// Handler registration (no-op)
+		return mockMqttDevice;
+	}),
+	subscribe: vi.fn(),
+	end: vi.fn(),
+};
+
+vi.mock('aws-iot-device-sdk', () => {
+	const DeviceConstructor = function () {
+		return mockMqttDevice;
+	};
+	return {
+		device: DeviceConstructor,
+	};
+});
+
+// Mock file system operations
+vi.mock('node:fs', () => ({
+	promises: {
+		readFile: vi.fn().mockResolvedValue(null),
+		writeFile: vi.fn().mockResolvedValue(undefined),
+		mkdir: vi.fn().mockResolvedValue(undefined),
+	},
+}));
+
+// Mock mqttCertificate module
+vi.mock('./mqttCertificate.js', () => ({
+	downloadRootCa: vi.fn().mockResolvedValue('-----BEGIN CERTIFICATE-----\nFAKE-PEM\n-----END CERTIFICATE-----'),
+	writeMqttCertificateFiles: vi.fn().mockResolvedValue({
+		ca: '/tmp/ca.pem',
+		cert: '/tmp/cert.pem',
+		key: '/tmp/key.pem',
+	}),
+	certificateRequestBody: vi.fn().mockReturnValue('fake-csr-body'),
+}));
+
+describe('ThinqMqttListener', () => {
+	let mockApiClient: ThinqApiClient;
+	let mockKeyRepository: MqttKeyRepository;
+	let mockLogger: ReturnType<typeof createMockLogger>;
+	let listener: ThinqMqttListener;
+	const mqttDir = '/tmp/mqtt';
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		mockLogger = createMockLogger();
+
+		mockApiClient = asPartial<ThinqApiClient>({
+			getMqttRouteInfo: vi.fn(),
+			registerMqttClient: vi.fn(),
+			requestMqttCertificate: vi.fn(),
+			getClientId: vi.fn().mockReturnValue('test-client-id'),
+		});
+
+		mockKeyRepository = asPartial<MqttKeyRepository>({
+			getOrCreateKeyPair: vi.fn(),
+			getOrCreateCsr: vi.fn(),
+		});
+
+		listener = new ThinqMqttListener(mockApiClient, mockKeyRepository, mqttDir, mockLogger);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('stop', () => {
+		it('should set stopped flag', () => {
+			listener.stop();
+
+			expect(listener['stopped']).toBe(true);
+		});
+
+		it('should clear reconnect timer on stop', () => {
+			listener['reconnectTimer'] = setTimeout(() => {
+				// This should not be called
+			}, 5000);
+
+			listener.stop();
+
+			expect(listener['reconnectTimer']).toBeUndefined();
+		});
+
+		it('should be idempotent when called multiple times', () => {
+			listener.stop();
+			listener.stop();
+
+			expect(listener['stopped']).toBe(true);
+		});
+
+		it('should call device end if device exists', () => {
+			const mockEnd = vi.fn();
+			listener['device'] = asPartial({
+				on: vi.fn(),
+				subscribe: vi.fn(),
+				end: mockEnd,
+			});
+
+			listener.stop();
+
+			expect(mockEnd).toHaveBeenCalled();
+		});
+	});
+
+	describe('handleMessage', () => {
+		const onUpdate = vi.fn();
+
+		beforeEach(() => {
+			vi.clearAllMocks();
+		});
+
+		it('should call onUpdate with valid MQTT message', () => {
+			listener['handleMessage'](
+				{
+					deviceId: 'device-123',
+					data: { state: { reported: { 'airState.operation': 1 } } },
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).toHaveBeenCalledWith('device-123', expect.any(ThinqSnapshot));
+		});
+
+		it('should not call onUpdate for message missing deviceId', () => {
+			listener['handleMessage'](
+				{
+					data: { state: { reported: { 'airState.operation': 1 } } },
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+			expect(mockLogger.debug).toHaveBeenCalledWith('ThinQ MQTT: received malformed message, skipping.');
+		});
+
+		it('should not call onUpdate for message missing data', () => {
+			listener['handleMessage'](
+				{
+					deviceId: 'device-123',
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should not call onUpdate for message missing reported state', () => {
+			listener['handleMessage'](
+				{
+					deviceId: 'device-123',
+					data: { state: {} },
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should not call onUpdate for non-object payload', () => {
+			listener['handleMessage']('not an object', onUpdate);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should not call onUpdate for null payload', () => {
+			listener['handleMessage'](null, onUpdate);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should construct ThinqSnapshot with reported data', () => {
+			const reportedData = { 'airState.operation': 1, 'airState.tempState.current': 24 };
+
+			listener['handleMessage'](
+				{
+					deviceId: 'device-123',
+					data: { state: { reported: reportedData } },
+				},
+				onUpdate,
+			);
+
+			const call = vi.mocked(onUpdate).mock.calls[0];
+			const snapshot = call[1];
+			expect(snapshot).toBeInstanceOf(ThinqSnapshot);
+		});
+
+		it('should not call onUpdate for non-string deviceId', () => {
+			listener['handleMessage'](
+				{
+					deviceId: 123,
+					data: { state: { reported: { 'airState.operation': 1 } } },
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+
+		it('should not call onUpdate for non-object reported state', () => {
+			listener['handleMessage'](
+				{
+					deviceId: 'device-123',
+					data: { state: { reported: 'not an object' } },
+				},
+				onUpdate,
+			);
+
+			expect(onUpdate).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('start integration', () => {
+		it('should not reject when start fails', async () => {
+			vi.mocked(mockApiClient.getMqttRouteInfo).mockRejectedValue(new Error('Network error'));
+
+			// Use fake timers to speed up retries
+			vi.useFakeTimers();
+			const startPromise = listener.start(vi.fn());
+
+			// Run all pending timers
+			await vi.runAllTimersAsync();
+
+			vi.useRealTimers();
+
+			await startPromise;
+
+			// Should log error about unable to start
+			expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('unable to start after retries'));
+		});
+	});
+
+	describe('connect happy path', () => {
+		beforeEach(() => {
+			vi.clearAllMocks();
+
+			// Setup successful API responses
+			vi.mocked(mockApiClient.getMqttRouteInfo).mockResolvedValue({
+				mqttServer: 'mqtts://mqtt.example.com:8883',
+			});
+			vi.mocked(mockApiClient.registerMqttClient).mockResolvedValue(undefined);
+			vi.mocked(mockApiClient.requestMqttCertificate).mockResolvedValue({
+				certificatePem: 'FAKE-CERT-PEM',
+				subscriptions: ['topic/1', 'topic/2'],
+			});
+			vi.mocked(mockKeyRepository.getOrCreateKeyPair).mockResolvedValue({
+				privateKey: 'FAKE-PRIVATE-KEY',
+				publicKey: 'FAKE-PUBLIC-KEY',
+			});
+			vi.mocked(mockKeyRepository.getOrCreateCsr).mockResolvedValue('FAKE-CSR');
+		});
+
+		it('should construct awsIotDevice with correct clientId and hostname', async () => {
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getClientId).mockReturnValue('test-client-id');
+
+			await listener['connect'](onUpdate);
+
+			// Verify device was created by checking it was assigned
+			expect(listener['device']).toBe(mockMqttDevice);
+		});
+
+		it('should call wireMqttDeviceEvents after device construction', async () => {
+			const onUpdate = vi.fn();
+			vi.mocked(mockMqttDevice.on).mockClear();
+
+			await listener['connect'](onUpdate);
+
+			// wireMqttDeviceEvents calls device.on to set up event handlers
+			expect(vi.mocked(mockMqttDevice.on)).toHaveBeenCalled();
+		});
+
+		it('should store device instance after successful connection', async () => {
+			const onUpdate = vi.fn();
+
+			await listener['connect'](onUpdate);
+
+			expect(listener['device']).toBeDefined();
+			expect(listener['device']).toBe(mockMqttDevice);
+		});
+
+		it('should call getMqttRouteInfo to get server details', async () => {
+			const onUpdate = vi.fn();
+			vi.mocked(mockApiClient.getMqttRouteInfo).mockClear();
+
+			await listener['connect'](onUpdate);
+
+			expect(vi.mocked(mockApiClient.getMqttRouteInfo)).toHaveBeenCalled();
+		});
+
+		it('should register MQTT client before requesting certificate', async () => {
+			const onUpdate = vi.fn();
+			const callOrder: string[] = [];
+
+			vi.mocked(mockApiClient.registerMqttClient).mockImplementation(async () => {
+				callOrder.push('registerMqttClient');
+			});
+
+			vi.mocked(mockApiClient.requestMqttCertificate).mockImplementation(async () => {
+				callOrder.push('requestMqttCertificate');
+				return { certificatePem: 'FAKE', subscriptions: [] };
+			});
+
+			await listener['connect'](onUpdate);
+
+			expect(callOrder[0]).toBe('registerMqttClient');
+			expect(callOrder[1]).toBe('requestMqttCertificate');
+		});
+
+		it('should get key pair before requesting certificate', async () => {
+			const onUpdate = vi.fn();
+			vi.mocked(mockKeyRepository.getOrCreateKeyPair).mockClear();
+			vi.mocked(mockApiClient.registerMqttClient).mockClear();
+
+			await listener['connect'](onUpdate);
+
+			expect(vi.mocked(mockKeyRepository.getOrCreateKeyPair)).toHaveBeenCalled();
+		});
+
+		it('should get CSR before registering client', async () => {
+			const onUpdate = vi.fn();
+			const callOrder: string[] = [];
+
+			vi.mocked(mockKeyRepository.getOrCreateCsr).mockImplementation(async () => {
+				callOrder.push('getOrCreateCsr');
+				return 'FAKE-CSR';
+			});
+
+			vi.mocked(mockApiClient.registerMqttClient).mockImplementation(async () => {
+				callOrder.push('registerMqttClient');
+			});
+
+			await listener['connect'](onUpdate);
+
+			expect(callOrder.indexOf('getOrCreateCsr')).toBeLessThan(callOrder.indexOf('registerMqttClient'));
+		});
+	});
+});