matterbridge-roborock-vacuum-plugin-regions 1.1.1-jb.1

package/src/tests/roborockCommunication/RESTAPI/roborockAuthenticateApi.test.ts

@@ -0,0 +1,144 @@
+import { RoborockAuthenticateApi } from '../../../roborockCommunication/RESTAPI/roborockAuthenticateApi';
+
+describe('RoborockAuthenticateApi', () => {
+  let mockLogger: any;
+  let mockAxiosFactory: any;
+  let mockAxiosInstance: any;
+  let api: any;
+
+  beforeEach(() => {
+    mockLogger = { info: jest.fn(), error: jest.fn() };
+    mockAxiosInstance = {
+      post: jest.fn(),
+      get: jest.fn(),
+      interceptors: {
+        request: {
+          use: jest.fn(),
+        },
+        response: {
+          use: jest.fn(),
+        },
+      },
+    };
+    mockAxiosFactory = {
+      create: jest.fn(() => mockAxiosInstance),
+    };
+    api = new RoborockAuthenticateApi(mockLogger, mockAxiosFactory);
+  });
+
+  it('should initialize deviceId, logger, axiosFactory', () => {
+    expect(api.logger).toBe(mockLogger);
+    expect(api.axiosFactory).toBe(mockAxiosFactory);
+    expect(typeof api['deviceId']).toBe('string');
+  });
+
+  it('loginWithUserData should call loginWithAuthToken and return userData', async () => {
+    const spy = jest.spyOn(api as any, 'loginWithAuthToken');
+    const userData = { token: 'abc', other: 'data' };
+    const result = await api.loginWithUserData('user', userData);
+    expect(spy).toHaveBeenCalledWith('user', 'abc');
+    expect(result).toBe(userData);
+  });
+
+  it('loginWithPassword should call auth and return userData', async () => {
+    const userData = { token: 'tok', other: 'data' };
+    const response = { data: { data: userData } };
+    jest.spyOn(api as any, 'getAPIFor').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.post.mockResolvedValue(response);
+    jest.spyOn(api as any, 'auth').mockReturnValue(userData);
+
+    const result = await api.loginWithPassword('user', 'pass');
+    expect(result).toBe(userData);
+    expect(mockAxiosInstance.post).toHaveBeenCalled();
+    expect(api['getAPIFor']).toHaveBeenCalledWith('user');
+    expect(api['auth']).toHaveBeenCalledWith('user', response.data);
+  });
+
+  it('loginWithPassword should throw error if token missing', async () => {
+    const response = { data: { data: null, msg: 'fail', code: 401 } };
+    jest.spyOn(api as any, 'getAPIFor').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.post.mockResolvedValue(response);
+    jest.spyOn(api as any, 'auth').mockImplementation(() => {
+      throw new Error('Authentication failed: fail code: 401');
+    });
+
+    await expect(api.loginWithPassword('user', 'pass')).rejects.toThrow('Authentication failed: fail code: 401');
+  });
+
+  it('getHomeDetails should return undefined if username/authToken missing', async () => {
+    api['username'] = undefined;
+    api['authToken'] = undefined;
+    const result = await api.getHomeDetails();
+    expect(result).toBeUndefined();
+  });
+
+  it('getHomeDetails should throw error if response.data missing', async () => {
+    api['username'] = 'user';
+    api['authToken'] = 'tok';
+    jest.spyOn(api as any, 'getAPIFor').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.get.mockResolvedValue({ data: { data: null } });
+
+    await expect(api.getHomeDetails()).rejects.toThrow('Failed to retrieve the home details');
+  });
+
+  it('getHomeDetails should return HomeInfo if present', async () => {
+    api['username'] = 'user';
+    api['authToken'] = 'tok';
+    const homeInfo = { home: 'info' };
+    jest.spyOn(api as any, 'getAPIFor').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.get.mockResolvedValue({ data: { data: homeInfo } });
+
+    const result = await api.getHomeDetails();
+    expect(result).toBe(homeInfo);
+  });
+
+  it('getBaseUrl should throw error if response.data missing', async () => {
+    jest.spyOn(api as any, 'apiForUser').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.post.mockResolvedValue({ data: { data: null, msg: 'fail' } });
+
+    await expect(api['getBaseUrl']('user')).rejects.toThrow('Failed to retrieve base URL: fail');
+  });
+
+  it('getBaseUrl should return url if present', async () => {
+    jest.spyOn(api as any, 'apiForUser').mockResolvedValue(mockAxiosInstance);
+    mockAxiosInstance.post.mockResolvedValue({ data: { data: { url: 'http://base.url' } } });
+
+    const result = await api['getBaseUrl']('user');
+    expect(result).toBe('http://base.url');
+  });
+
+  it('apiForUser should create AxiosInstance with correct headers', async () => {
+    const username = 'user';
+    const baseUrl = 'http://base.url';
+    const spy = jest.spyOn(mockAxiosFactory, 'create');
+    await api['apiForUser'](username, baseUrl);
+    expect(spy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseURL: baseUrl,
+        headers: expect.objectContaining({
+          header_clientid: expect.any(String),
+          Authorization: undefined,
+        }),
+      }),
+    );
+  });
+
+  it('auth should call loginWithAuthToken and return userData', () => {
+    const spy = jest.spyOn(api as any, 'loginWithAuthToken');
+    const response = { data: { token: 'tok', other: 'data' }, msg: '', code: 0 };
+    const result = api['auth']('user', response);
+    expect(spy).toHaveBeenCalledWith('user', 'tok');
+    expect(result).toBe(response.data);
+  });
+
+  it('auth should throw error if token missing', () => {
+    const response = { data: null, msg: 'fail', code: 401 };
+    expect(() => api['auth']('user', response)).toThrow('Authentication failed: fail code: 401');
+  });
+
+  it('loginWithAuthToken should set username and authToken', () => {
+    api['loginWithAuthToken']('user', 'tok');
+    expect(api['username']).toBe('user');
+    expect(api['authToken']).toBe('tok');
+  });
+});

package/src/tests/roborockCommunication/RESTAPI/roborockIoTApi.test.ts

@@ -0,0 +1,106 @@
+import axios from 'axios';
+import { RoborockIoTApi } from '../../../roborockCommunication/RESTAPI/roborockIoTApi';
+
+describe('RoborockIoTApi', () => {
+  let mockLogger: any;
+  let mockAxiosInstance: any;
+  let mockUserData: any;
+  let api: RoborockIoTApi;
+
+  beforeEach(() => {
+    mockLogger = { error: jest.fn() };
+    mockAxiosInstance = {
+      get: jest.fn(),
+      post: jest.fn(),
+      interceptors: { request: { use: jest.fn() } },
+      getUri: jest.fn((config) => config.url),
+    };
+    mockUserData = {
+      rriot: {
+        r: { a: 'http://base.url' },
+        u: 'uid',
+        s: 'sid',
+        h: 'hkey',
+      },
+    };
+    jest.spyOn(axios, 'create').mockReturnValue(mockAxiosInstance);
+    api = new RoborockIoTApi(mockUserData, mockLogger);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should initialize logger and api', () => {
+    expect(api.logger).toBe(mockLogger);
+    expect(api['api']).toBe(mockAxiosInstance);
+  });
+
+  it('getHome should return home if result exists', async () => {
+    const home = { id: 1 };
+    mockAxiosInstance.get.mockResolvedValue({ data: { result: home } });
+    const result = await api.getHome(1);
+    expect(result).toBe(home);
+  });
+
+  it('getHome should log error and return undefined if result missing', async () => {
+    mockAxiosInstance.get.mockResolvedValue({ data: {} });
+    const result = await api.getHome(1);
+    expect(result).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('Failed to retrieve the home data');
+  });
+
+  it('getHomev2 should return home if result exists', async () => {
+    const home = { id: 2 };
+    mockAxiosInstance.get.mockResolvedValue({ data: { result: home } });
+    const result = await api.getHomev2(2);
+    expect(result).toBe(home);
+  });
+
+  it('getHomev3 should return home if result exists', async () => {
+    const home = { id: 3 };
+    mockAxiosInstance.get.mockResolvedValue({ data: { result: home } });
+    const result = await api.getHomev3(3);
+    expect(result).toBe(home);
+  });
+
+  it('getScenes should return scenes if result exists', async () => {
+    const scenes = [{ id: 1 }, { id: 2 }];
+    mockAxiosInstance.get.mockResolvedValue({ data: { result: scenes } });
+    const result = await api.getScenes(1);
+    expect(result).toBe(scenes);
+  });
+
+  it('getScenes should log error and return undefined if result missing', async () => {
+    mockAxiosInstance.get.mockResolvedValue({ data: {} });
+    const result = await api.getScenes(1);
+    expect(result).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('Failed to retrieve scene');
+  });
+
+  it('startScene should return result if present', async () => {
+    mockAxiosInstance.post.mockResolvedValue({ data: { result: 'started' } });
+    const result = await api.startScene(1);
+    expect(result).toBe('started');
+  });
+
+  it('startScene should log error and return undefined if result missing', async () => {
+    mockAxiosInstance.post.mockResolvedValue({ data: {} });
+    const result = await api.startScene(1);
+    expect(result).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('Failed to execute scene');
+  });
+
+  it('getCustom should return result if present', async () => {
+    mockAxiosInstance.get.mockResolvedValue({ data: { result: 'custom' } });
+    const result = await api.getCustom('/custom/url');
+    expect(result).toBe('custom');
+  });
+
+  it('getCustom should log error and return undefined if result missing', async () => {
+    mockAxiosInstance.get.mockResolvedValue({ data: {} });
+    const result = await api.getCustom('/custom/url');
+    expect(result).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('Failed to execute scene');
+  });
+});

package/src/tests/roborockCommunication/broadcast/client/LocalNetworkClient.test.ts

@@ -0,0 +1,189 @@
+import { LocalNetworkClient } from '../../../../roborockCommunication/broadcast/client/LocalNetworkClient';
+import { Protocol } from '../../../../roborockCommunication/broadcast/model/protocol';
+
+const Sket = jest.fn();
+
+jest.mock('node:net', () => {
+  const actual = jest.requireActual('node:net');
+  return {
+    ...actual,
+    Socket: Sket, // We'll set the implementation in beforeEach
+  };
+});
+
+describe('LocalNetworkClient', () => {
+  let client: LocalNetworkClient;
+  let mockLogger: any;
+  let mockContext: any;
+  let mockSocket: any;
+  const duid = 'duid1';
+  const ip = '127.0.0.1';
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: jest.fn(),
+      error: jest.fn(),
+      notice: jest.fn(),
+      info: jest.fn(),
+    };
+    mockContext = {};
+    mockSocket = {
+      on: jest.fn(),
+      connect: jest.fn(),
+      destroy: jest.fn(),
+      write: jest.fn(),
+      address: jest.fn().mockReturnValue({ address: '127.0.0.1', port: 58867 }),
+    };
+    // Set the Socket mock implementation
+    Sket.mockImplementation(() => mockSocket);
+
+    client = new LocalNetworkClient(mockLogger, mockContext, duid, ip);
+    // Patch serializer/deserializer for send/onMessage
+    (client as any).serializer = { serialize: jest.fn().mockReturnValue({ buffer: Buffer.from([1, 2, 3]), messageId: 123 }) };
+    (client as any).deserializer = { deserialize: jest.fn().mockReturnValue('deserialized') };
+    (client as any).messageListeners = { onMessage: jest.fn() };
+    (client as any).connectionListeners = {
+      onConnected: jest.fn(),
+      onDisconnected: jest.fn(),
+      onError: jest.fn(),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+    // Clear keepConnectionAliveInterval to prevent open handle leaks
+    if (client['keepConnectionAliveInterval']) {
+      clearInterval(client['keepConnectionAliveInterval']);
+      client['keepConnectionAliveInterval'] = undefined;
+    }
+  });
+
+  it('should initialize fields in constructor', () => {
+    expect(client.duid).toBe(duid);
+    expect(client.ip).toBe(ip);
+    expect((client as any).messageIdSeq).toBeDefined();
+  });
+
+  it('connect() should create socket, set handlers, and call connect', () => {
+    client.connect();
+    expect(client['socket']).not.toBeUndefined();
+  });
+
+  it('disconnect() should destroy socket and clear pingInterval', async () => {
+    client['socket'] = mockSocket;
+    client['pingInterval'] = setInterval(() => {
+      jest.fn();
+    }, 1000);
+    await client.disconnect();
+    expect(mockSocket.destroy).toHaveBeenCalled();
+    expect(client['socket']).toBeUndefined();
+  });
+
+  it('disconnect() should do nothing if socket is undefined', async () => {
+    client['socket'] = undefined;
+    await expect(client.disconnect()).resolves.toBeUndefined();
+  });
+
+  it('send() should log error if socket is not connected', async () => {
+    client['socket'] = undefined;
+    client['connected'] = false;
+    await client.send(duid, { toLocalRequest: jest.fn(), secure: false } as any);
+    expect(mockLogger.error).toHaveBeenCalled();
+    expect(mockSocket.write).not.toHaveBeenCalled();
+  });
+
+  it('send() should serialize and write if connected', async () => {
+    client['socket'] = mockSocket;
+    client['connected'] = true;
+    const req = { toLocalRequest: jest.fn().mockReturnValue({}), secure: false };
+    await client.send(duid, req as any);
+    expect(client['serializer'].serialize).toHaveBeenCalled();
+    expect(mockSocket.write).toHaveBeenCalledWith(expect.any(Buffer));
+    expect(mockLogger.debug).toHaveBeenCalled();
+  });
+
+  it('onConnect() should set connected, log, send hello, set ping, call onConnected', async () => {
+    client['socket'] = mockSocket;
+    jest.useFakeTimers();
+    const sendHelloSpy = jest.spyOn(client as any, 'sendHelloMessage').mockResolvedValue(undefined);
+    await (client as any).onConnect();
+    expect(client['connected']).toBe(true);
+    expect(mockLogger.debug).toHaveBeenCalled();
+    expect(sendHelloSpy).toHaveBeenCalled();
+    expect(client['pingInterval']).toBeDefined();
+    expect(client['connectionListeners'].onConnected).toHaveBeenCalled();
+  });
+
+  it('onDisconnect() should log, set connected false, destroy socket, clear ping, call onDisconnected', async () => {
+    client['socket'] = mockSocket;
+    client['pingInterval'] = setInterval(() => {
+      jest.fn();
+    }, 1000);
+    await (client as any).onDisconnect();
+    expect(mockLogger.info).toHaveBeenCalled();
+    expect(client['connected']).toBe(false);
+    expect(mockSocket.destroy).toHaveBeenCalled();
+    expect(client['socket']).toBeUndefined();
+    expect(client['connectionListeners'].onDisconnected).toHaveBeenCalled();
+  });
+
+  it('onError() should log, set connected false, destroy socket, call onError', async () => {
+    client['socket'] = mockSocket;
+    await (client as any).onError(new Error('fail'));
+    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining(' [LocalNetworkClient]: Socket error for'));
+    expect(client['connectionListeners'].onError).toHaveBeenCalledWith('duid1', expect.stringContaining('fail'));
+  });
+
+  it('onMessage() should log debug if message is empty', async () => {
+    client['socket'] = mockSocket;
+    await (client as any).onMessage(Buffer.alloc(0));
+    expect(mockLogger.debug).toHaveBeenCalledWith('LocalNetworkClient received empty message from socket.');
+  });
+
+  it('onMessage() should process complete message and call onMessage', async () => {
+    client['socket'] = mockSocket;
+    // Compose a buffer with a single segment of length 3 (after 4 bytes)
+    const payload = Buffer.from([0, 0, 0, 3, 10, 20, 30]);
+    (client as any).isMessageComplete = jest.fn().mockReturnValue(true);
+    (client as any).buffer = {
+      append: jest.fn(),
+      get: jest.fn().mockReturnValue(payload),
+      reset: jest.fn(),
+    };
+    await (client as any).onMessage(payload);
+    expect(client['deserializer'].deserialize).toHaveBeenCalled();
+    expect(client['messageListeners'].onMessage).toHaveBeenCalledWith('deserialized');
+  });
+
+  it('isMessageComplete() should return true for complete buffer', () => {
+    // 4 bytes length + 3 bytes payload
+    const buf = Buffer.from([0, 0, 0, 3, 1, 2, 3]);
+    expect((client as any).isMessageComplete(buf)).toBe(true);
+  });
+
+  it('isMessageComplete() should return false for incomplete buffer', () => {
+    // 4 bytes length + only 2 bytes payload
+    const buf = Buffer.from([0, 0, 0, 3, 1, 2]);
+    expect((client as any).isMessageComplete(buf)).toBe(false);
+  });
+
+  it('wrapWithLengthData() should prepend length', () => {
+    const data = Buffer.from([1, 2, 3]);
+    const result = (client as any).wrapWithLengthData(data);
+    expect(result.readUInt32BE(0)).toBe(3);
+    expect(result.slice(4).equals(data)).toBe(true);
+  });
+
+  it('sendHelloMessage() should call send with hello_request', async () => {
+    const sendSpy = jest.spyOn(client, 'send').mockResolvedValue(undefined);
+    await (client as any).sendHelloMessage();
+    expect(sendSpy).toHaveBeenCalledWith(duid, expect.objectContaining({ protocol: Protocol.hello_request }));
+  });
+
+  it('sendPingRequest() should call send with ping_request', async () => {
+    const sendSpy = jest.spyOn(client, 'send').mockResolvedValue(undefined);
+    await (client as any).sendPingRequest();
+    expect(sendSpy).toHaveBeenCalledWith(duid, expect.objectContaining({ protocol: Protocol.ping_request }));
+  });
+});

package/src/tests/roborockCommunication/broadcast/client/MQTTClient.test.ts

@@ -0,0 +1,208 @@
+import { MQTTClient } from '../../../../roborockCommunication/broadcast/client/MQTTClient';
+
+const mockConnect = jest.fn();
+jest.mock('mqtt', () => {
+  const actual = jest.requireActual('mqtt');
+  return {
+    ...actual,
+    connect: mockConnect,
+  };
+});
+
+describe('MQTTClient', () => {
+  let logger: any;
+  let context: any;
+  let userdata: any;
+  let client: any;
+  let serializer: any;
+  let deserializer: any;
+  let connectionListeners: any;
+  let messageListeners: any;
+
+  beforeEach(() => {
+    logger = { error: jest.fn(), debug: jest.fn(), notice: jest.fn(), info: jest.fn() };
+    context = {};
+    userdata = {
+      rriot: {
+        u: 'user',
+        k: 'key',
+        s: 'secret',
+        r: { m: 'mqtt://broker' },
+      },
+    };
+    serializer = { serialize: jest.fn(() => ({ buffer: Buffer.from('msg') })) };
+    deserializer = { deserialize: jest.fn(() => 'deserialized') };
+    connectionListeners = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+      onReconnect: jest.fn().mockResolvedValue(undefined),
+    };
+    messageListeners = { onMessage: jest.fn().mockResolvedValue(undefined) };
+
+    // Mock mqtt client instance
+    client = {
+      on: jest.fn(),
+      end: jest.fn(),
+      publish: jest.fn(),
+      subscribe: jest.fn(),
+    };
+    mockConnect.mockReturnValue(client);
+  });
+
+  function createMQTTClient() {
+    // Pass dependencies via constructor if possible, or use a factory/mockable subclass for testing
+    class TestMQTTClient extends MQTTClient {
+      constructor() {
+        super(logger, context, userdata);
+        (this as any).serializer = serializer;
+        (this as any).deserializer = deserializer;
+        (this as any).connectionListeners = connectionListeners;
+        (this as any).messageListeners = messageListeners;
+      }
+    }
+    return new TestMQTTClient();
+  }
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should generate username and password in constructor', () => {
+    const mqttClient = createMQTTClient();
+    expect(mqttClient['mqttUsername']).toBe('c6d6afb9');
+    expect(mqttClient['mqttPassword']).toBe('938f62d6603bde9c');
+  });
+
+  it('should not connect if already connected', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = client;
+    mqttClient.connect();
+    expect(mockConnect).not.toHaveBeenCalled();
+  });
+
+  it('should disconnect if connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = client;
+    mqttClient['connected'] = true;
+    await mqttClient.disconnect();
+    expect(client.end).toHaveBeenCalled();
+  });
+
+  it('should not disconnect if not connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = undefined;
+    mqttClient['connected'] = false;
+    await mqttClient.disconnect();
+    expect(client.end).not.toHaveBeenCalled();
+  });
+
+  it('should log error if disconnect throws', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = {
+      end: jest.fn(() => {
+        throw new Error('fail');
+      }),
+    } as any;
+    mqttClient['connected'] = true;
+    await mqttClient.disconnect();
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('MQTT client failed to disconnect'));
+  });
+
+  it('should publish message if connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = client;
+    mqttClient['connected'] = true;
+    const request = { toMqttRequest: jest.fn(() => 'req') };
+    await mqttClient.send('duid1', request as any);
+    expect(serializer.serialize).toHaveBeenCalledWith('duid1', 'req');
+    expect(client.publish).toHaveBeenCalledWith('rr/m/i/user/c6d6afb9/duid1', Buffer.from('msg'), { qos: 1 });
+  });
+
+  it('should log error if send called when not connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = undefined;
+    mqttClient['connected'] = false;
+    const request = { toMqttRequest: jest.fn() };
+    await mqttClient.send('duid1', request as any);
+    expect(logger.error).toHaveBeenCalled();
+    expect(client.publish).not.toHaveBeenCalled();
+  });
+
+  it('onConnect should set connected, call onConnected, and subscribeToQueue', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = client;
+    mqttClient['subscribeToQueue'] = jest.fn();
+    await mqttClient['onConnect']({} as any);
+    expect(mqttClient['connected']).toBe(true);
+    expect(connectionListeners.onConnected).toHaveBeenCalled();
+    expect(mqttClient['subscribeToQueue']).toHaveBeenCalled();
+  });
+
+  it('subscribeToQueue should call client.subscribe with correct topic', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['mqttClient'] = client;
+    mqttClient['connected'] = true;
+    mqttClient['subscribeToQueue']();
+    expect(client.subscribe).toHaveBeenCalledWith('rr/m/o/user/c6d6afb9/#', expect.any(Function));
+  });
+
+  it('onSubscribe should log error and call onDisconnected if error', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onSubscribe'](new Error('fail'), undefined);
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('failed to subscribe'));
+    expect(mqttClient['connected']).toBe(false);
+    expect(connectionListeners.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('onSubscribe should do nothing if no error', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onSubscribe'](null, undefined);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(connectionListeners.onDisconnected).not.toHaveBeenCalled();
+  });
+
+  it('onDisconnect should call onDisconnected', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onDisconnect']();
+    expect(connectionListeners.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('onError should log error, set connected false, and call onError', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['connected'] = true;
+    await mqttClient['onError'](new Error('fail'));
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('MQTT connection error'));
+    expect(mqttClient['connected']).toBe(false);
+    expect(connectionListeners.onError).toHaveBeenCalledWith('mqtt-c6d6afb9', expect.stringContaining('fail'));
+  });
+
+  it('onReconnect should call subscribeToQueue', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['subscribeToQueue'] = jest.fn();
+    mqttClient['onReconnect']();
+    expect(mqttClient['subscribeToQueue']).toHaveBeenCalled();
+  });
+
+  it('onMessage should call deserializer and messageListeners.onMessage if message', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onMessage']('rr/m/o/user/c6d6afb9/duid1', Buffer.from('msg'));
+    expect(deserializer.deserialize).toHaveBeenCalledWith('duid1', Buffer.from('msg'));
+    expect(messageListeners.onMessage).toHaveBeenCalledWith('deserialized');
+  });
+
+  it('onMessage should log notice if message is falsy', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onMessage']('topic', null as any);
+    expect(logger.notice).toHaveBeenCalledWith(expect.stringContaining('received empty message'));
+  });
+
+  it('onMessage should log error if deserializer throws', async () => {
+    const mqttClient = createMQTTClient();
+    deserializer.deserialize.mockImplementation(() => {
+      throw new Error('fail');
+    });
+    await mqttClient['onMessage']('topic/duid', Buffer.from('msg'));
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('unable to process message'));
+  });
+});