matterbridge-lg-thinq-plugin 0.1.0

package/src/tests/helpers/testUtils.ts

@@ -0,0 +1,118 @@
+import type { AnsiLogger } from 'matterbridge/logger';
+import { vi } from 'vitest';
+
+import type { GatewayData } from '../../services/thinq/gateway.js';
+import type { ThinqDeviceData } from '../../services/thinq/thinqApiClient.js';
+
+/**
+ * Creates a mock AnsiLogger for testing.
+ * All methods are vitest spies that can be asserted against.
+ */
+export function createMockLogger(): AnsiLogger {
+	return {
+		debug: vi.fn(),
+		info: vi.fn(),
+		notice: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		setMaxListeners: vi.fn(),
+		getMaxListeners: vi.fn(),
+		addListener: vi.fn(),
+		on: vi.fn(),
+		once: vi.fn(),
+		removeListener: vi.fn(),
+		off: vi.fn(),
+		removeAllListeners: vi.fn(),
+		listeners: vi.fn(),
+		rawListeners: vi.fn(),
+		emit: vi.fn(),
+		listenerCount: vi.fn(),
+		prependListener: vi.fn(),
+		prependOnceListener: vi.fn(),
+		eventNames: vi.fn(),
+	} as unknown as AnsiLogger;
+}
+
+/**
+ * Helper to create a partial object of a type without `as any`.
+ * Used for test fixtures where only specific properties are needed.
+ */
+export function asPartial<T>(partial: Partial<T>): T {
+	return partial as T;
+}
+
+/**
+ * Builds a mock GatewayData response for testing.
+ */
+export function buildGatewayResponse(overrides?: Partial<GatewayData>): GatewayData {
+	return {
+		empTermsUri: 'https://emp-terms.lgecloud.com',
+		empSpxUri: 'https://emp-spx.lgecloud.com',
+		thinq2Uri: 'https://aic-service.lgecloud.com',
+		thinq1Uri: 'https://v1aic-service.lgecloud.com',
+		countryCode: 'US',
+		languageCode: 'en',
+		...overrides,
+	};
+}
+
+/**
+ * Builds a mock ThinqDeviceData response for testing.
+ */
+export function buildThinqDeviceData(overrides?: Partial<ThinqDeviceData>): ThinqDeviceData {
+	return {
+		deviceId: '12345678-1234-1234-1234-123456789012',
+		alias: 'Living Room AC',
+		modelJsonUri: 'https://example.com/model.json',
+		deviceType: 401,
+		modelName: 'DualCool Plus',
+		manufacture: {
+			macAddress: '00:00:00:00:00:00',
+			salesModel: 'AC123',
+			serialNo: 'SN12345',
+			manufactureModel: 'AC123-MANU',
+		},
+		modemInfo: {
+			appVersion: '1.0',
+			modelName: 'AC123',
+		},
+		snapshot: {
+			online: true,
+			'airState.operation': 1,
+			'airState.tempState.current': 24,
+			'airState.tempState.target': 22,
+			'airState.opMode': 0,
+			'airState.windStrength': 2,
+		},
+		platformType: 'THINQ',
+		online: true,
+		...overrides,
+	};
+}
+
+/**
+ * Creates a mock node-persist LocalStorage for testing.
+ */
+export function createMockNodePersist() {
+	return {
+		getItem: vi.fn(),
+		setItem: vi.fn(),
+		removeItem: vi.fn(),
+		clear: vi.fn(),
+		keys: vi.fn(),
+		length: vi.fn(),
+	};
+}
+
+/**
+ * Helper to set a readonly property on an object for testing.
+ * Useful for testing readonly class properties.
+ */
+export function setReadOnlyProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
+	Object.defineProperty(obj, key, {
+		value,
+		writable: false,
+		configurable: true,
+	});
+}

package/src/tests/model/LgThinqPluginPlatformConfig.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+
+import { createDefaultAdvancedFeature, createDefaultThinqConfig } from '../../model/LgThinqPluginPlatformConfig.js';
+
+describe('LgThinqPluginPlatformConfig', () => {
+	describe('createDefaultAdvancedFeature', () => {
+		it('should return expected default values', () => {
+			const result = createDefaultAdvancedFeature();
+			expect(result).toEqual({
+				settings: {
+					debug: false,
+					clearStorageOnStartup: false,
+					forceAuthentication: false,
+					unregisterOnShutdown: false,
+					overrideMatterConfiguration: false,
+					matterOverrideSettings: {
+						matterVendorName: 'Matterbridge',
+						matterVendorId: 0xfff1,
+					},
+				},
+			});
+		});
+
+		it('should include overrideMatterConfiguration field with value false', () => {
+			const result = createDefaultAdvancedFeature();
+			expect(result.settings.overrideMatterConfiguration).toBe(false);
+		});
+
+		it('should include matterOverrideSettings with default vendor names only', () => {
+			const result = createDefaultAdvancedFeature();
+			expect(result.settings.matterOverrideSettings).toEqual({
+				matterVendorName: 'Matterbridge',
+				matterVendorId: 0xfff1,
+			});
+			expect(result.settings.matterOverrideSettings).not.toHaveProperty('matterProductName');
+			expect(result.settings.matterOverrideSettings).not.toHaveProperty('matterProductId');
+		});
+
+		it('should return a fresh object on each call', () => {
+			const first = createDefaultAdvancedFeature();
+			const second = createDefaultAdvancedFeature();
+
+			// Verify both are equal
+			expect(first).toEqual(second);
+
+			// Mutate the first object
+			first.settings.debug = true;
+
+			// Verify the second object is unaffected
+			expect(second.settings.debug).toBe(false);
+		});
+	});
+
+	describe('createDefaultThinqConfig', () => {
+		it('should return expected default values', () => {
+			const result = createDefaultThinqConfig();
+			expect(result).toEqual({
+				loginType: 'account',
+				country: 'US',
+				language: 'en-US',
+				devices: [],
+			});
+		});
+
+		it('should return a fresh object on each call', () => {
+			const first = createDefaultThinqConfig();
+			const second = createDefaultThinqConfig();
+
+			// Verify both are equal
+			expect(first).toEqual(second);
+
+			// Mutate the first object
+			first.loginType = 'token';
+			first.devices.push({ deviceId: 'test' });
+
+			// Verify the second object is unaffected
+			expect(second.loginType).toBe('account');
+			expect(second.devices).toHaveLength(0);
+		});
+	});
+});

package/src/tests/platform/deviceRegistry.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, it } from 'vitest';
+
+import { DeviceRegistry } from '../../platform/deviceRegistry.js';
+
+describe('DeviceRegistry', () => {
+	describe('register', () => {
+		it('should register a device and retrieve it', () => {
+			const registry = new DeviceRegistry();
+			const device = { id: '123', name: 'Test Device' };
+
+			registry.register('device-1', device);
+			expect(registry.getDevice('device-1')).toBe(device);
+		});
+
+		it('should not register device with empty id', () => {
+			const registry = new DeviceRegistry();
+			const device = { id: '123', name: 'Test Device' };
+
+			registry.register('', device);
+			expect(registry.getDevice('')).toBeUndefined();
+			expect(registry.size).toBe(0);
+		});
+
+		it('should overwrite device when registering with same id', () => {
+			const registry = new DeviceRegistry();
+			const device1 = { id: '123', name: 'Device 1' };
+			const device2 = { id: '456', name: 'Device 2' };
+
+			registry.register('device-1', device1);
+			registry.register('device-1', device2);
+
+			expect(registry.getDevice('device-1')).toBe(device2);
+			expect(registry.size).toBe(1);
+		});
+	});
+
+	describe('unregister', () => {
+		it('should remove a registered device', () => {
+			const registry = new DeviceRegistry();
+			const device = { id: '123', name: 'Test Device' };
+
+			registry.register('device-1', device);
+			expect(registry.size).toBe(1);
+
+			registry.unregister('device-1');
+			expect(registry.getDevice('device-1')).toBeUndefined();
+			expect(registry.size).toBe(0);
+		});
+
+		it('should silently ignore unregistering non-existent device', () => {
+			const registry = new DeviceRegistry();
+			expect(() => registry.unregister('non-existent')).not.toThrow();
+			expect(registry.size).toBe(0);
+		});
+	});
+
+	describe('getDevice', () => {
+		it('should return undefined for unregistered device', () => {
+			const registry = new DeviceRegistry();
+			expect(registry.getDevice('non-existent')).toBeUndefined();
+		});
+
+		it('should return registered device', () => {
+			const registry = new DeviceRegistry();
+			const device = { id: '123', name: 'Test Device' };
+
+			registry.register('device-1', device);
+			expect(registry.getDevice('device-1')).toBe(device);
+		});
+	});
+
+	describe('getAllDevices', () => {
+		it('should return empty array when no devices registered', () => {
+			const registry = new DeviceRegistry();
+			expect(registry.getAllDevices()).toEqual([]);
+		});
+
+		it('should return all registered devices', () => {
+			const registry = new DeviceRegistry();
+			const device1 = { id: '123', name: 'Device 1' };
+			const device2 = { id: '456', name: 'Device 2' };
+			const device3 = { id: '789', name: 'Device 3' };
+
+			registry.register('device-1', device1);
+			registry.register('device-2', device2);
+			registry.register('device-3', device3);
+
+			const allDevices = registry.getAllDevices();
+			expect(allDevices).toHaveLength(3);
+			expect(allDevices).toEqual(expect.arrayContaining([device1, device2, device3]));
+		});
+	});
+
+	describe('size getter', () => {
+		it('should return 0 when no devices registered', () => {
+			const registry = new DeviceRegistry();
+			expect(registry.size).toBe(0);
+		});
+
+		it('should return count after register', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+			registry.register('device-2', { id: '456' });
+
+			expect(registry.size).toBe(2);
+		});
+
+		it('should decrement count after unregister', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+			registry.register('device-2', { id: '456' });
+
+			registry.unregister('device-1');
+			expect(registry.size).toBe(1);
+		});
+
+		it('should return 0 after clear', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+			registry.register('device-2', { id: '456' });
+
+			registry.clear();
+			expect(registry.size).toBe(0);
+		});
+	});
+
+	describe('hasDevices', () => {
+		it('should return false when no devices registered', () => {
+			const registry = new DeviceRegistry();
+			expect(registry.hasDevices()).toBe(false);
+		});
+
+		it('should return true when devices are registered', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+
+			expect(registry.hasDevices()).toBe(true);
+		});
+
+		it('should return false after all devices removed', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+			registry.register('device-2', { id: '456' });
+
+			registry.unregister('device-1');
+			expect(registry.hasDevices()).toBe(true);
+
+			registry.unregister('device-2');
+			expect(registry.hasDevices()).toBe(false);
+		});
+	});
+
+	describe('clear', () => {
+		it('should remove all devices', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+			registry.register('device-2', { id: '456' });
+			registry.register('device-3', { id: '789' });
+
+			expect(registry.size).toBe(3);
+			registry.clear();
+			expect(registry.size).toBe(0);
+			expect(registry.hasDevices()).toBe(false);
+		});
+
+		it('should allow re-registering after clear', () => {
+			const registry = new DeviceRegistry();
+			registry.register('device-1', { id: '123' });
+
+			registry.clear();
+			expect(registry.size).toBe(0);
+
+			registry.register('device-1', { id: '123' });
+			expect(registry.size).toBe(1);
+		});
+	});
+});