matterbridge-roborock-vacuum-plugin 1.1.0-rc13 → 1.1.0-rc14

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

@@ -0,0 +1,136 @@
+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(),
+    };
+    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

@@ -43,6 +43,7 @@ describe('LocalNetworkClient', () => {
       debug: jest.fn(),
       error: jest.fn(),
       notice: jest.fn(),
+      info: jest.fn(),
     };
     mockContext = {};
     mockSocket = {
@@ -134,7 +135,7 @@ describe('LocalNetworkClient', () => {
       jest.fn();
     }, 1000);
     await (client as any).onDisconnect();
-    expect(mockLogger.error).toHaveBeenCalled();
+    expect(mockLogger.info).toHaveBeenCalled();
     expect(client['connected']).toBe(false);
     expect(mockSocket.destroy).toHaveBeenCalled();
     expect(client['socket']).toBeUndefined();
@@ -144,10 +145,7 @@ describe('LocalNetworkClient', () => {
   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('Socket connection error'));
-    expect(client['connected']).toBe(false);
-    expect(mockSocket.destroy).toHaveBeenCalled();
-    expect(client['socket']).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining(' [LocalNetworkClient]: Socket error for'));
     expect(client['connectionListeners'].onError).toHaveBeenCalledWith('duid1', expect.stringContaining('fail'));
   });
 

package/src/tests/roborockCommunication/broadcast/clientRouter.test.ts

@@ -0,0 +1,168 @@
+import { RequestMessage, UserData } from '../../../roborockCommunication';
+import { ClientRouter } from '../../../roborockCommunication/broadcast/clientRouter';
+
+describe('ClientRouter', () => {
+  let mockLogger: any;
+  let mockUserData: UserData;
+
+  let mockMQTTClient: any;
+  let mockLocalNetworkClient: any;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn() };
+    mockUserData = {
+      uid: '123',
+      token: '123:123/lfrZhw==:123',
+      rruid: '123',
+      region: 'eu',
+      countrycode: '33',
+      country: 'FR',
+      nickname: '123',
+      rriot: {
+        u: '123',
+        s: '123',
+        h: '123',
+        k: '123',
+        r: {
+          r: 'EU',
+          a: 'https://api-eu.roborock.com',
+          m: 'ssl://mqtt-eu-2.roborock.com:8883',
+          l: 'https://wood-eu.roborock.com',
+        },
+      },
+    };
+
+    mockMQTTClient = {
+      isConnected: jest.fn().mockReturnValue(true),
+      connect: jest.fn(),
+      disconnect: jest.fn(),
+    };
+
+    mockLocalNetworkClient = {
+      isConnected: jest.fn().mockReturnValue(true),
+      connect: jest.fn(),
+      disconnect: jest.fn(),
+      send: jest.fn(),
+      get: jest.fn(),
+    };
+  });
+
+  it('registerConnectionListener should call connectionListeners.register', () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    const listener = {};
+    const spy = jest.spyOn(router['connectionListeners'], 'register');
+    router.registerConnectionListener(listener as any);
+    expect(spy).toHaveBeenCalledWith(listener);
+  });
+
+  it('registerMessageListener should call messageListeners.register', () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    const listener = {};
+    const spy = jest.spyOn(router['messageListeners'], 'register');
+    router.registerMessageListener(listener as any);
+    expect(spy).toHaveBeenCalledWith(listener);
+  });
+
+  it('isConnected should return mqttClient.isConnected', () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    mockMQTTClient = {
+      isConnected: jest.fn().mockReturnValue(true),
+    };
+    router['mqttClient'] = mockMQTTClient;
+    expect(router.isConnected()).toBe(true);
+  });
+
+  it('connect should call connect on mqttClient and all localClients', () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router['mqttClient'] = mockMQTTClient;
+
+    router.registerClient('duid', '127.0.0.1');
+    router['localClients'].set('duid', mockLocalNetworkClient);
+
+    router.connect();
+    expect(mockMQTTClient.connect).toHaveBeenCalled();
+    expect(mockLocalNetworkClient.connect).toHaveBeenCalled();
+  });
+
+  it('disconnect should call disconnect on mqttClient and all localClients', async () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router.registerClient('duid', '127.0.0.1');
+    mockMQTTClient = {
+      isConnected: jest.fn().mockReturnValue(false),
+      connect: jest.fn(),
+      disconnect: jest.fn(),
+    };
+    router['mqttClient'] = mockMQTTClient;
+
+    router['localClients'].set('duid', mockLocalNetworkClient);
+
+    await router.disconnect();
+    expect(mockMQTTClient.disconnect).toHaveBeenCalled();
+    expect(mockLocalNetworkClient.disconnect).toHaveBeenCalled();
+  });
+
+  it('send should use mqttClient for secure requests', async () => {
+    mockMQTTClient = {
+      isConnected: jest.fn().mockReturnValue(false),
+      connect: jest.fn(),
+      disconnect: jest.fn(),
+      send: jest.fn(),
+    };
+
+    const router = new ClientRouter(mockLogger, mockUserData);
+    const request: RequestMessage = { secure: true } as any;
+
+    router['mqttClient'] = mockMQTTClient;
+    await router.send('duid', request);
+    expect(mockMQTTClient.send).toHaveBeenCalledWith('duid', request);
+  });
+
+  it('send should use localClient for non-secure requests', async () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router.registerClient('duid', '127.0.0.1');
+    const request: RequestMessage = { secure: false } as any;
+    router['localClients'].set('duid', mockLocalNetworkClient);
+    await router.send('duid', request);
+    expect(mockLocalNetworkClient.send).toHaveBeenCalledWith('duid', request);
+  });
+
+  it('get should use mqttClient for secure requests', async () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    const request: RequestMessage = { secure: true } as any;
+
+    mockMQTTClient = {
+      isConnected: jest.fn().mockReturnValue(false),
+      connect: jest.fn(),
+      disconnect: jest.fn(),
+      send: jest.fn(),
+      get: jest.fn(),
+    };
+    router['mqttClient'] = mockMQTTClient;
+    await router.get('duid', request);
+    expect(mockMQTTClient.get).toHaveBeenCalledWith('duid', request);
+  });
+
+  it('get should use localClient for non-secure requests', async () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router.registerClient('duid', '127.0.0.1');
+    const request: RequestMessage = { secure: false } as any;
+    router['localClients'].set('duid', mockLocalNetworkClient);
+    await router.get('duid', request);
+    expect(mockLocalNetworkClient.get).toHaveBeenCalledWith('duid', request);
+  });
+
+  it('getClient should return localClient if connected', () => {
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router.registerClient('duid', '127.0.0.1');
+    router['localClients'].set('duid', mockLocalNetworkClient);
+    expect(router['getClient']('duid')).toBe(mockLocalNetworkClient);
+  });
+
+  it('getClient should return mqttClient if localClient not connected', () => {
+    mockLocalNetworkClient.isConnected.mockReturnValue(false);
+    const router = new ClientRouter(mockLogger, mockUserData);
+    router.registerClient('duid', '127.0.0.1');
+    router['mqttClient'] = mockMQTTClient;
+    expect(router['getClient']('duid')).toBe(mockMQTTClient);
+  });
+});

package/src/tests/roborockCommunication/broadcast/messageProcessor.test.ts

@@ -0,0 +1,131 @@
+import { MessageProcessor } from '../../../roborockCommunication/broadcast/messageProcessor';
+import { DeviceStatus } from '../../../roborockCommunication/Zmodel/deviceStatus';
+import { RoomInfo } from '../../../roborockCommunication/Zmodel/roomInfo';
+
+describe('MessageProcessor', () => {
+  let mockClient: any;
+  let processor: MessageProcessor;
+  let mockLogger: any;
+
+  beforeEach(() => {
+    mockClient = {
+      registerMessageListener: jest.fn().mockImplementation(() => {
+        void 0;
+      }),
+      get: jest.fn(),
+      send: jest.fn(),
+    };
+    processor = new MessageProcessor(mockClient);
+    mockLogger = { debug: jest.fn(), notice: jest.fn() };
+    processor.injectLogger(mockLogger);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should inject logger', () => {
+    processor.injectLogger(mockLogger);
+    expect(processor.logger).toBe(mockLogger);
+  });
+
+  it('getNetworkInfo should call client.get with correct params', async () => {
+    mockClient.get.mockResolvedValue('networkInfo');
+    const result = await processor.getNetworkInfo('duid');
+    expect(mockClient.get).toHaveBeenCalledWith('duid', expect.any(Object));
+    expect(result).toBe('networkInfo');
+  });
+
+  it('getDeviceStatus should return DeviceStatus if response exists', async () => {
+    const mockDeviceStatus = { status: 'ok' };
+    mockClient.get.mockResolvedValue([mockDeviceStatus]);
+    const result = await processor.getDeviceStatus('duid');
+    expect(mockLogger.debug).toHaveBeenCalled();
+    expect(result).toBeInstanceOf(DeviceStatus);
+  });
+
+  it('getDeviceStatus should return undefined if response is falsy', async () => {
+    mockClient.get.mockResolvedValue(undefined);
+    const result = await processor.getDeviceStatus('duid');
+    expect(result).toBeUndefined();
+  });
+
+  it('getRooms should return RoomInfo', async () => {
+    const rooms = [
+      { id: 1, name: 'Room1' },
+      { id: 2, name: 'Room2' },
+    ];
+    mockClient.get.mockResolvedValue([[1, 2]]);
+    const result = await processor.getRooms('duid', rooms);
+    expect(result).toBeInstanceOf(RoomInfo);
+  });
+
+  it('gotoDock should call client.send', async () => {
+    await processor.gotoDock('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('startClean should call client.send', async () => {
+    await processor.startClean('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('startRoomClean should call client.send with correct params', async () => {
+    await processor.startRoomClean('duid', [1, 2], 3);
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('pauseClean should call client.send', async () => {
+    await processor.pauseClean('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('resumeClean should call client.send', async () => {
+    await processor.resumeClean('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('stopClean should call client.send', async () => {
+    await processor.stopClean('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('sendCustomMessage should call client.send', async () => {
+    const def = { method: 'custom' };
+    await processor.sendCustomMessage('duid', def as any);
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('getCustomMessage should call client.get', async () => {
+    const def = { method: 'custom' };
+    await processor.getCustomMessage('duid', def as any);
+    expect(mockClient.get).toHaveBeenCalledWith('duid', def);
+  });
+
+  it('findMyRobot should call client.send', async () => {
+    await processor.findMyRobot('duid');
+    expect(mockClient.send).toHaveBeenCalledWith('duid', expect.any(Object));
+  });
+
+  it('getCleanModeData should parse and return correct values', async () => {
+    mockClient.get
+      .mockResolvedValueOnce([306]) // get_mop_mode
+      .mockResolvedValueOnce([101]) // get_custom_mode
+      .mockResolvedValueOnce({ water_box_mode: 207, distance_off: 5 }); // get_water_box_custom_mode
+
+    const result = await processor.getCleanModeData('duid');
+    expect(result).toEqual({
+      suctionPower: 101,
+      waterFlow: 207,
+      distance_off: 5,
+      mopRoute: 306,
+    });
+  });
+
+  it('changeCleanMode should call logger.notice and client.send as needed', async () => {
+    mockLogger.notice = jest.fn();
+    mockClient.get.mockResolvedValueOnce(110); // currentMopMode
+    await processor.changeCleanMode('duid', 101, 207, 306, 5);
+    expect(mockLogger.notice).toHaveBeenCalled();
+  });
+});