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

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/listener/implementation/chainedConnectionListener.test.ts

@@ -0,0 +1,59 @@
+import { ChainedConnectionListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/chainedConnectionListener';
+
+describe('ChainedConnectionListener', () => {
+  let chained: ChainedConnectionListener;
+  let listener1: any;
+  let listener2: any;
+
+  beforeEach(() => {
+    chained = new ChainedConnectionListener();
+    listener1 = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+    };
+    listener2 = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('should register listeners', () => {
+    chained.register(listener1);
+    chained.register(listener2);
+
+    // @ts-expect-error Accessing private property for testing
+    expect(chained.listeners).toEqual([listener1, listener2]);
+  });
+
+  it('should call onConnected on all listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onConnected('test-duid');
+    expect(listener1.onConnected).toHaveBeenCalled();
+    expect(listener2.onConnected).toHaveBeenCalled();
+  });
+
+  it('should call onDisconnected on all listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onDisconnected('test-duid');
+    expect(listener1.onDisconnected).toHaveBeenCalled();
+    expect(listener2.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('should call onError on all listeners with the same message', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onError('test-duid', 'error message');
+    expect(listener1.onError).toHaveBeenCalledWith('test-duid', 'error message');
+    expect(listener2.onError).toHaveBeenCalledWith('test-duid', 'error message');
+  });
+
+  it('should work with no listeners registered', async () => {
+    await expect(chained.onConnected('test-duid')).resolves.toBeUndefined();
+    await expect(chained.onDisconnected('test-duid')).resolves.toBeUndefined();
+    await expect(chained.onError('test-duid', 'msg')).resolves.toBeUndefined();
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/chainedMessageListener.test.ts

@@ -0,0 +1,46 @@
+import { ChainedMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/chainedMessageListener';
+import { AbstractMessageListener } from '../../../../../roborockCommunication/broadcast/listener/abstractMessageListener';
+
+describe('ChainedMessageListener', () => {
+  let chained: ChainedMessageListener;
+  let listener1: jest.Mocked<AbstractMessageListener>;
+  let listener2: jest.Mocked<AbstractMessageListener>;
+  const message = { foo: 'bar' } as any;
+
+  beforeEach(() => {
+    chained = new ChainedMessageListener();
+    listener1 = { onMessage: jest.fn().mockResolvedValue(undefined) } as any;
+    listener2 = { onMessage: jest.fn().mockResolvedValue(undefined) } as any;
+  });
+
+  it('should call onMessage on all registered listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+
+    await chained.onMessage(message);
+
+    expect(listener1.onMessage).toHaveBeenCalledWith(message);
+    expect(listener2.onMessage).toHaveBeenCalledWith(message);
+  });
+
+  it('should not fail if no listeners registered', async () => {
+    await expect(chained.onMessage(message)).resolves.toBeUndefined();
+  });
+
+  it('should call listeners in order', async () => {
+    const callOrder: string[] = [];
+    listener1.onMessage.mockImplementation(async () => {
+      callOrder.push('first');
+    });
+    listener2.onMessage.mockImplementation(async () => {
+      callOrder.push('second');
+    });
+
+    chained.register(listener1);
+    chained.register(listener2);
+
+    await chained.onMessage(message);
+
+    expect(callOrder).toEqual(['first', 'second']);
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/simpleMessageListener.test.ts

@@ -0,0 +1,71 @@
+import { SimpleMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/simpleMessageListener';
+import { Protocol } from '../../../../../roborockCommunication/broadcast/model/protocol';
+
+describe('SimpleMessageListener', () => {
+  let listener: SimpleMessageListener;
+  let handler: any;
+  let message: any;
+
+  beforeEach(() => {
+    listener = new SimpleMessageListener();
+    handler = {
+      onStatusChanged: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+      onBatteryUpdate: jest.fn().mockResolvedValue(undefined),
+      onAdditionalProps: jest.fn().mockResolvedValue(undefined),
+    };
+    message = {
+      contain: jest.fn(),
+      get: jest.fn(),
+    };
+    listener.registerListener(handler);
+  });
+
+  it('should do nothing if no handler registered', async () => {
+    const l = new SimpleMessageListener();
+    await expect(l.onMessage(message)).resolves.toBeUndefined();
+  });
+
+  it('should do nothing if message is rpc_response or map_response', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.rpc_response || proto === Protocol.map_response);
+    await listener.onMessage(message);
+    expect(handler.onStatusChanged).not.toHaveBeenCalled();
+    expect(handler.onError).not.toHaveBeenCalled();
+    expect(handler.onBatteryUpdate).not.toHaveBeenCalled();
+    expect(handler.onAdditionalProps).not.toHaveBeenCalled();
+  });
+
+  it('should call onStatusChanged if status_update present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.status_update);
+    await listener.onMessage(message);
+    expect(handler.onStatusChanged).toHaveBeenCalled();
+  });
+
+  it('should call onError if error present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.error);
+    message.get.mockReturnValue('42');
+    await listener.onMessage(message);
+    expect(handler.onError).toHaveBeenCalledWith(42);
+  });
+
+  it('should call onBatteryUpdate if battery present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.battery);
+    message.get.mockReturnValue('77');
+    await listener.onMessage(message);
+    expect(handler.onBatteryUpdate).toHaveBeenCalledWith(77);
+  });
+
+  it('should call onAdditionalProps if additional_props present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.additional_props);
+    message.get.mockReturnValue('99');
+    await listener.onMessage(message);
+    expect(handler.onAdditionalProps).toHaveBeenCalledWith(99);
+  });
+
+  it('should not call handler methods if they are undefined', async () => {
+    const handlerPartial = {};
+    listener.registerListener(handlerPartial as any);
+    message.contain.mockReturnValue(true);
+    await expect(listener.onMessage(message)).resolves.toBeUndefined();
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/syncMessageListener.test.ts

@@ -0,0 +1,86 @@
+import { SyncMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/syncMessageListener';
+import { Protocol } from '../../../../../roborockCommunication/broadcast/model/protocol';
+import { RequestMessage } from '../../../../../roborockCommunication/broadcast/model/requestMessage';
+
+describe('SyncMessageListener', () => {
+  let listener: SyncMessageListener;
+  let logger: any;
+
+  beforeEach(() => {
+    logger = { info: jest.fn(), error: jest.fn(), debug: jest.fn(), warn: jest.fn() };
+    listener = new SyncMessageListener(logger);
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it('should call resolve and remove pending on rpc_response', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 123;
+    listener.waitFor(messageId, { method: 'test' } as RequestMessage, resolve, reject);
+
+    const dps = { id: messageId, result: { foo: 'bar' } };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.rpc_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(resolve).toHaveBeenCalledWith(dps.result);
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+
+  it('should call resolve if result is ["ok"]', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 456;
+    listener.waitFor(messageId, { method: 'test' } as RequestMessage, resolve, reject);
+
+    const dps = { id: messageId, result: ['ok'] };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.rpc_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(resolve).toHaveBeenCalled();
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+
+  it('should remove pending on map_response', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 789;
+    listener.waitFor(messageId, { method: 'test' } as RequestMessage, resolve, reject);
+
+    const dps = { id: messageId };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.map_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+
+  it('should call reject after timeout if not resolved', () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 321;
+    listener.waitFor(messageId, { method: 'test' } as RequestMessage, resolve, reject);
+
+    expect(listener['pending'].has(messageId)).toBe(true);
+
+    jest.advanceTimersByTime(10000);
+
+    expect(reject).toHaveBeenCalled();
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+});

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

@@ -0,0 +1,126 @@
+import { MessageProcessor } from '../../../roborockCommunication/broadcast/messageProcessor';
+import { DeviceStatus } from '../../../roborockCommunication/Zmodel/deviceStatus';
+
+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 () => {
+    mockClient.get.mockResolvedValue([[1, 2]]);
+    const result = await processor.getRooms('duid');
+    expect(result).not.toBeUndefined();
+  });
+
+  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.get).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();
+  });
+});

package/src/tests/roborockService.setSelectedAreas.test.ts

@@ -0,0 +1,61 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../roborockService';
+import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { RoomIndexMap } from '../model/roomIndexMap';
+
+describe('RoborockService - startClean', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+  let mockLoginApi: any;
+  let mockIotApi: any;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: jest.fn(),
+      notice: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    mockMessageProcessor = {
+      startClean: jest.fn(),
+      startRoomClean: jest.fn(),
+    } as any;
+
+    mockLoginApi = {
+      loginWithPassword: jest.fn(),
+      loginWithUserData: jest.fn(),
+    };
+
+    roborockService = new RoborockService(() => mockLoginApi, jest.fn(), 10, {} as any, mockLogger);
+    roborockService['auth'] = jest.fn((ud) => ud);
+    roborockService['messageProcessorMap'] = new Map<string, MessageProcessor>([['test-duid', mockMessageProcessor]]);
+
+    mockIotApi = { getCustom: jest.fn() };
+    roborockService['iotApi'] = mockIotApi;
+  });
+
+  it('setSelectedAreas should set selected areas', () => {
+    roborockService.setSupportedAreaIndexMap(
+      'duid',
+      new RoomIndexMap(
+        new Map([
+          [100, { roomId: 1, mapId: 0 }],
+          [101, { roomId: 2, mapId: 0 }],
+          [102, { roomId: 3, mapId: 0 }],
+          [103, { roomId: 4, mapId: 0 }],
+          [104, { roomId: 1, mapId: 1 }],
+          [105, { roomId: 2, mapId: 1 }],
+          [106, { roomId: 3, mapId: 1 }],
+          [107, { roomId: 4, mapId: 1 }],
+          [108, { roomId: 5, mapId: 1 }],
+        ]),
+      ),
+    );
+    roborockService.setSelectedAreas('duid', [106, 108]);
+
+    expect(roborockService['selectedAreas'].get('duid')).toEqual([3, 5]);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - setSelectedAreas - roomIds', [3, 5]);
+  });
+});