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

package/src/tests/roborockService3.test.ts

@@ -0,0 +1,133 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../roborockService';
+
+describe('RoborockService - listDevices', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockIotApi: any;
+  let mockLoginApi: any;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), error: jest.fn() } as any;
+    mockIotApi = {
+      getHome: jest.fn(),
+      getScenes: jest.fn(),
+      getHomev3: jest.fn(),
+      getHomev2: jest.fn(),
+    };
+    mockLoginApi = {
+      getHomeDetails: jest.fn(),
+    };
+    roborockService = new RoborockService(
+      () => mockLoginApi,
+      () => mockIotApi,
+      10,
+      {} as any,
+      mockLogger,
+    );
+    roborockService['iotApi'] = mockIotApi;
+    roborockService['userdata'] = { foo: 'bar' } as any;
+  });
+
+  it('should throw if homeDetails is missing', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue(undefined);
+    await expect(roborockService.listDevices('user')).rejects.toThrow('Failed to retrieve the home details');
+  });
+
+  it('should return empty array if homeData is missing', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue(undefined);
+    const result = await roborockService.listDevices('user');
+    expect(result).toEqual([]);
+  });
+
+  it('should return devices with correct mapping', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'm1', category: 'cat1' }],
+      devices: [{ duid: 'd1', localKey: 'lk', pv: 'pv', sn: 'sn', productId: 'p1', deviceStatus: { battery: 50 }, fv: 'fw', data: {} }],
+      receivedDevices: [],
+      rooms: [{ id: 1 }],
+    });
+    mockIotApi.getScenes.mockResolvedValue([{ param: JSON.stringify({ action: { items: [{ entityId: 'd1' }] } }) }]);
+    const result = await roborockService.listDevices('user');
+    expect(result.length).toBe(1);
+    expect(result[0].duid).toBe('d1');
+    expect(result[0].data.batteryLevel).toBe(100);
+    expect(result[0].scenes.length).toBe(1);
+  });
+
+  it('should throw if getHomev3 fails when v3 API is needed', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'roborock.vacuum.ss07' }],
+      devices: [],
+      receivedDevices: [],
+      rooms: [],
+    });
+    mockIotApi.getHomev3.mockResolvedValue(undefined);
+    await expect(roborockService.listDevices('user')).rejects.toThrow('Failed to retrieve the home data from v3 API');
+  });
+
+  it('should merge v3 devices and receivedDevices if v3 API is needed', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'roborock.vacuum.ss07' }],
+      devices: [],
+      receivedDevices: [],
+      rooms: [],
+    });
+    mockIotApi.getHomev3.mockResolvedValue({
+      devices: [{ duid: 'd2', localKey: 'lk2', pv: 'pv2', sn: 'sn2', productId: 'p1', deviceStatus: {}, fv: 'fw2', data: {} }],
+      receivedDevices: [{ duid: 'rd2', localKey: 'lk3', pv: 'pv3', sn: 'sn3', productId: 'p1', deviceStatus: {}, fv: 'fw3', data: {} }],
+      rooms: [],
+    });
+    mockIotApi.getScenes.mockResolvedValue([]);
+    const result = await roborockService.listDevices('user');
+    expect(result.some((d) => d.duid === 'd2')).toBe(true);
+    expect(result.some((d) => d.duid === 'rd2')).toBe(true);
+  });
+
+  it('should fallback batteryLevel to 100 if not present', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'm1', category: 'cat1' }],
+      devices: [{ duid: 'd1', localKey: 'lk', pv: 'pv', sn: 'sn', productId: 'p1', deviceStatus: {}, fv: 'fw', data: {} }],
+      receivedDevices: [],
+      rooms: [{ id: 1 }],
+    });
+    mockIotApi.getScenes.mockResolvedValue([]);
+    const result = await roborockService.listDevices('user');
+    expect(result[0].data.batteryLevel).toBe(100);
+  });
+
+  it('should filter scenes correctly for devices', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'm1', category: 'cat1' }],
+      devices: [{ duid: 'd1', localKey: 'lk', pv: 'pv', sn: 'sn', productId: 'p1', deviceStatus: {}, fv: 'fw', data: {} }],
+      receivedDevices: [],
+      rooms: [{ id: 1 }],
+    });
+    mockIotApi.getScenes.mockResolvedValue([
+      { param: JSON.stringify({ action: { items: [{ entityId: 'd1' }, { entityId: 'd2' }] } }) },
+      { param: JSON.stringify({ action: { items: [{ entityId: 'd2' }] } }) },
+    ]);
+    const result = await roborockService.listDevices('user');
+    expect(result[0].scenes.length).toBe(1);
+  });
+
+  it('should handle rooms fallback from v2 and v3 APIs', async () => {
+    mockLoginApi.getHomeDetails.mockResolvedValue({ rrHomeId: 1 });
+    mockIotApi.getHome.mockResolvedValue({
+      products: [{ id: 'p1', model: 'm1', category: 'cat1' }],
+      devices: [],
+      receivedDevices: [],
+      rooms: [],
+    });
+    mockIotApi.getHomev2.mockResolvedValue({ rooms: [{ id: 2 }], products: [], devices: [], receivedDevices: [] });
+    mockIotApi.getScenes.mockResolvedValue([]);
+    const result = await roborockService.listDevices('user');
+    expect(result.length).toBe(0);
+  });
+});

package/src/tests/roborockService4.test.ts

@@ -0,0 +1,76 @@
+import RoborockService from '../roborockService';
+
+describe('getHomeDataForUpdating', () => {
+  let service;
+  let mockIotApi;
+  let mockLogger;
+  const homeid = 123;
+  let mockLoginApi: any;
+
+  beforeEach(() => {
+    mockIotApi = {
+      getHomev2: jest.fn(),
+      getHomev3: jest.fn(),
+      getHome: jest.fn(),
+    };
+    mockLogger = { debug: jest.fn(), error: jest.fn(), warn: jest.fn() };
+    mockLoginApi = {
+      getHomeDetails: jest.fn(),
+    };
+    service = new RoborockService(
+      () => mockLoginApi,
+      () => mockIotApi,
+      10,
+      {} as any,
+      mockLogger,
+    );
+    service.iotApi = mockIotApi;
+    service.userdata = { user: 'test' };
+  });
+
+  it('returns home data from v2 API when rooms are present', async () => {
+    const homeData = {
+      products: [{ id: 'p1', model: 'm1' }],
+      devices: [{ duid: 'd1', productId: 'p1', sn: 'sn1', fv: '1.0', localKey: 'lk', pv: 'pv', deviceStatus: { 8: 50 } }],
+      receivedDevices: [],
+      rooms: [{ id: 1 }],
+    };
+    mockIotApi.getHomev2.mockResolvedValue(homeData);
+    const result = await service.getHomeDataForUpdating(homeid);
+    expect(result.devices[0].rooms).toEqual(homeData.rooms);
+    expect(result.devices[0].data.batteryLevel).toBe(100);
+  });
+
+  it('falls back to v3 API for rooms if v2 rooms are empty', async () => {
+    const homeData = {
+      products: [{ id: 'p1', model: 'm1' }],
+      devices: [{ duid: 'd1', productId: 'p1', sn: 'sn1', fv: '1.0', localKey: 'lk', pv: 'pv', deviceStatus: {} }],
+      receivedDevices: [],
+      rooms: [],
+    };
+    const v3Data = { rooms: [{ id: 2 }] };
+    mockIotApi.getHomev2.mockResolvedValue(homeData);
+    mockIotApi.getHomev3.mockResolvedValue(v3Data);
+    const result = await service.getHomeDataForUpdating(homeid);
+    expect(result.devices[0].rooms).toEqual(v3Data.rooms);
+  });
+
+  it('falls back to v1 API for rooms if v2 and v3 rooms are empty', async () => {
+    const homeData = {
+      products: [{ id: 'p1', model: 'm1' }],
+      devices: [{ duid: 'd1', productId: 'p1', sn: 'sn1', fv: '1.0', localKey: 'lk', pv: 'pv', deviceStatus: {} }],
+      receivedDevices: [],
+      rooms: [],
+    };
+    mockIotApi.getHomev2.mockResolvedValue(homeData);
+    mockIotApi.getHomev3.mockResolvedValue({ rooms: [] });
+    mockIotApi.getHome.mockResolvedValue({ rooms: [{ id: 3 }] });
+    const result = await service.getHomeDataForUpdating(homeid);
+    expect(result.devices[0].rooms).toEqual([{ id: 3 }]);
+  });
+
+  it('throws error if home data cannot be retrieved', async () => {
+    mockIotApi.getHomev2.mockResolvedValue(undefined);
+    await expect(service.getHomeDataForUpdating(homeid)).rejects.toThrow('Failed to retrieve the home data');
+  });
+});

package/src/tests/roborockService5.test.ts

@@ -0,0 +1,79 @@
+import RoborockService from '../roborockService';
+
+describe('initializeMessageClientForLocal', () => {
+  let service: any;
+  let mockMessageClient: any;
+  let mockLogger: any;
+  let mockDevice: any;
+  let mockMessageProcessor: any;
+  let mockLocalClient: any;
+  let mockLoginApi: any;
+  let mockIotApi: any;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), error: jest.fn(), warn: jest.fn() };
+    mockMessageClient = {
+      registerClient: jest.fn(),
+      isConnected: jest.fn(),
+      registerMessageListener: jest.fn(),
+    };
+    mockDevice = { duid: 'd1', pv: 'pv', data: { model: 'm1' }, localKey: 'lk' };
+    mockMessageProcessor = {
+      injectLogger: jest.fn(),
+      registerListener: jest.fn(),
+      getNetworkInfo: jest.fn(),
+    };
+    mockLocalClient = {
+      connect: jest.fn(),
+      isConnected: jest.fn(),
+    };
+    mockLoginApi = {
+      getHomeDetails: jest.fn(),
+    };
+    service = new RoborockService(
+      () => mockLoginApi,
+      () => mockIotApi,
+      10,
+      {} as any,
+      mockLogger,
+    );
+    service.messageClient = mockMessageClient;
+    service.deviceNotify = jest.fn();
+    service.ipMap = new Map();
+    service.localClientMap = new Map();
+    service.mqttAlwaysOnDevices = new Map();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns false if messageClient is undefined', async () => {
+    service.messageClient = undefined;
+    const result = await service.initializeMessageClientForLocal(mockDevice);
+    expect(result).toBe(false);
+    expect(mockLogger.error).toHaveBeenCalledWith('messageClient not initialized');
+  });
+
+  it('returns true and sets mqttAlwaysOnDevices if device.pv is B01', async () => {
+    mockDevice.pv = 'B01';
+    const result = await service.initializeMessageClientForLocal(mockDevice);
+    expect(result).toBe(true);
+    expect(service.mqttAlwaysOnDevices.get(mockDevice.duid)).toBe(true);
+    expect(mockLogger.warn).toHaveBeenCalledWith('Device does not support local connection', mockDevice.duid);
+  });
+
+  it('returns false if local client does not connect after attempts', async () => {
+    mockMessageProcessor.getNetworkInfo.mockResolvedValue({ ip: '1.2.3.4' });
+    jest.spyOn(service, 'getMessageProcessor').mockReturnValue(mockMessageProcessor);
+    mockMessageClient.registerClient.mockReturnValue(mockLocalClient);
+    mockLocalClient.connect.mockImplementation(() => {
+      void 0;
+    });
+    mockLocalClient.isConnected.mockReturnValue(false);
+    service.ipMap.delete(mockDevice.duid);
+    const result = await service.initializeMessageClientForLocal(mockDevice);
+    expect(result).toBe(false);
+    expect(mockLogger.error).toHaveBeenCalledWith('Error requesting network info', expect.any(Error));
+  });
+});

package/src/tests/runtimes/handleCloudMessage.test.ts

@@ -0,0 +1,200 @@
+import { AdditionalPropCode, Protocol } from '../../roborockCommunication/index.js';
+import { handleCloudMessage } from '../../runtimes/handleCloudMessage';
+import { mapInfo, roomData, roomIndexMap, supportedAreas, supportedMaps } from '../testData/mockData.js';
+
+// Mocks for dependencies
+const mockUpdateAttribute = jest.fn().mockImplementation((clusterId: number, attributeName: string, value: any, log: any) => {
+  log.debug(`Mock updateAttribute called with clusterId: ${clusterId}, attributeName: ${attributeName}, value: ${value}`);
+});
+const mockSetSupportedAreas = jest.fn();
+const mockSetSelectedAreas = jest.fn();
+const mockSetSupportedAreaIndexMap = jest.fn();
+const mockGetCleanModeData = jest.fn();
+const mockUpdateFromMQTTMessage = jest.fn();
+const mockGetRoomMapFromDevice = jest.fn();
+const mockGetSupportedAreas = jest.fn();
+
+jest.mock('./src/helper', () => ({
+  getRoomMapFromDevice: (...args: any[]) => mockGetRoomMapFromDevice(...args),
+  isStatusUpdate: (result: any) => result === 'status',
+}));
+jest.mock('./src/initialData/getSupportedAreas', () => ({
+  getSupportedAreas: (...args: any[]) => mockGetSupportedAreas(...args),
+}));
+
+const duid = 'test-duid';
+const robot = {
+  updateAttribute: mockUpdateAttribute,
+  device: {
+    data: { model: 'test-model' },
+    rooms: [
+      { id: 11100845, name: 'Kitchen' },
+      { id: 11100849, name: 'Study' },
+      { id: 11100842, name: 'Living room' },
+      { id: 11100847, name: 'Bedroom' },
+      { id: 12469150, name: 'Dining room' },
+      { id: 12461114, name: 'Guest bedroom' },
+      { id: 12461109, name: 'Master bedroom' },
+      { id: 12461111, name: 'Balcony' },
+      { id: 11100842, name: 'Living room' },
+    ],
+  },
+  dockStationStatus: {},
+};
+const platform = {
+  robots: new Map([[duid, robot]]),
+  log: {
+    error: jest.fn(),
+    debug: jest.fn(),
+    notice: jest.fn(),
+    /* eslint-disable no-console */
+    fatal: jest.fn().mockImplementation((message: string, ...arg: unknown[]) => console.info(message, ...arg)),
+  },
+  roborockService: {
+    getCleanModeData: mockGetCleanModeData,
+    setSupportedAreas: mockSetSupportedAreas,
+    setSelectedAreas: mockSetSelectedAreas,
+    setSupportedAreaIndexMap: mockSetSupportedAreaIndexMap,
+    getMapInformation: jest.fn().mockResolvedValue(mapInfo),
+    getRoomMappings: jest.fn().mockResolvedValue(roomData),
+  },
+  enableExperimentalFeature: {
+    enableExperimentalFeature: true,
+    advancedFeature: {
+      enableMultipleMap: true,
+    },
+  },
+};
+const runner = { updateFromMQTTMessage: mockUpdateFromMQTTMessage };
+
+describe('handleCloudMessage', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('handles status_update', async () => {
+    const data = { duid: 'test-duid', dps: { 121: 6, 128: 3, 139: 5 } };
+    await handleCloudMessage(data as any, platform as any, runner as any, duid);
+    await new Promise(process.nextTick);
+    expect(mockUpdateAttribute).toHaveBeenCalled();
+  });
+
+  it('handles rpc_response with status', async () => {
+    const data = {
+      duid: 'test-duid',
+      dps: {
+        102: {
+          id: 19937,
+          result: [
+            {
+              msg_ver: 2,
+              msg_seq: 2609,
+              state: 5,
+              battery: 99,
+              clean_time: 12,
+              clean_area: 0,
+              error_code: 0,
+              map_present: 1,
+              in_cleaning: 1,
+              in_returning: 0,
+              in_fresh_state: 0,
+              lab_status: 3,
+              water_box_status: 1,
+              fan_power: 101,
+              dnd_enabled: 0,
+              map_status: 3,
+              is_locating: 0,
+              lock_status: 0,
+              water_box_mode: 202,
+              distance_off: 60,
+              water_box_carriage_status: 0,
+              mop_forbidden_enable: 0,
+              adbumper_status: [0, 0, 0],
+              dock_type: 5,
+              dust_collection_status: 0,
+              auto_dust_collection: 1,
+              debug_mode: 0,
+              switch_map_mode: 0,
+              dock_error_status: 0,
+              charge_status: 1,
+            },
+          ],
+        },
+      },
+    };
+
+    await handleCloudMessage(data as any, platform as any, runner as any, duid);
+    await new Promise(process.nextTick);
+    expect(mockUpdateFromMQTTMessage).toHaveBeenCalled();
+  });
+
+  it('handles additional_props with map_change', async () => {
+    mockGetRoomMapFromDevice.mockResolvedValueOnce({});
+    mockGetSupportedAreas.mockReturnValueOnce({
+      supportedAreas,
+      supportedMaps,
+      roomIndexMap,
+    });
+    const data = { dps: { [Protocol.additional_props]: AdditionalPropCode.map_change } };
+    await handleCloudMessage(data as any, platform as any, runner as any, duid);
+
+    await new Promise(process.nextTick);
+    expect(mockSetSupportedAreas).toHaveBeenCalled();
+    expect(mockSetSelectedAreas).toHaveBeenCalled();
+    expect(mockUpdateAttribute).toHaveBeenCalled();
+  });
+
+  it('logs error if robot not found', async () => {
+    const fakePlatform = { ...platform, robots: new Map() };
+    const data = { dps: { [Protocol.status_update]: 1 } };
+    await handleCloudMessage(data as any, fakePlatform as any, runner as any, duid);
+    await new Promise(process.nextTick);
+    expect(platform.log.error).toHaveBeenCalled();
+  });
+
+  it('handles unknown message type', async () => {
+    const data = { dps: { 999: 42 } };
+    await handleCloudMessage(data as any, platform as any, runner as any, duid);
+    await new Promise(process.nextTick);
+    expect(platform.log.notice).toHaveBeenCalled();
+  });
+
+  it('handles map_change', async () => {
+    const data = { dps: { 128: 4 } };
+    mockGetRoomMapFromDevice.mockReturnValue({
+      rooms: [
+        { id: 1, globalId: 11100845, displayName: 'Kitchen', alternativeId: '114', mapId: 0 },
+        { id: 2, globalId: 11100849, displayName: 'Study', alternativeId: '29', mapId: 0 },
+        { id: 3, globalId: 11100842, displayName: 'Living room', alternativeId: '36', mapId: 0 },
+        { id: 4, globalId: 11100847, displayName: 'Bedroom', alternativeId: '41', mapId: 0 },
+      ],
+      mapInfo: [
+        {
+          id: 0,
+          name: 'First Map',
+          rooms: [
+            { id: 1, globalId: 11100845, iot_name_id: '11100845', tag: 14, displayName: 'Kitchen', mapId: 0 },
+            { id: 2, globalId: 11100849, iot_name_id: '11100849', tag: 9, displayName: 'Study', mapId: 0 },
+            { id: 3, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 0 },
+            { id: 4, globalId: 11100847, iot_name_id: '11100847', tag: 1, displayName: 'Bedroom', mapId: 0 },
+          ],
+        },
+        {
+          id: 1,
+          name: 'Second Map',
+          rooms: [
+            { id: 1, globalId: 12469150, iot_name_id: '12469150', tag: 13, displayName: 'Dining room', mapId: 1 },
+            { id: 2, globalId: 12461114, iot_name_id: '12461114', tag: 3, displayName: 'Guest bedroom', mapId: 1 },
+            { id: 3, globalId: 12461109, iot_name_id: '12461109', tag: 2, displayName: 'Master bedroom', mapId: 1 },
+            { id: 4, globalId: 12461111, iot_name_id: '12461111', tag: 7, displayName: 'Balcony', mapId: 1 },
+            { id: 5, globalId: 11100842, iot_name_id: '11100842', tag: 6, displayName: 'Living room', mapId: 1 },
+          ],
+        },
+      ],
+    });
+
+    await handleCloudMessage(data as any, platform as any, runner as any, duid);
+    await new Promise(process.nextTick);
+    expect(platform.log.notice).toHaveBeenCalled();
+  });
+});

package/src/tests/runtimes/handleHomeDataMessage.test.ts

@@ -0,0 +1,54 @@
+import { DeviceData } from '../../roborockCommunication/Zmodel/device';
+import { updateFromHomeData } from '../../runtimes/handleHomeDataMessage';
+import { homeData } from '../testData/mockData';
+import { PowerSource, RvcRunMode } from 'matterbridge/matter/clusters';
+
+// Mocks
+const mockUpdateAttribute = jest.fn();
+const duid = 'test-duid';
+const robot = {
+  updateAttribute: mockUpdateAttribute,
+  device: { data: { model: 'test-model' } as DeviceData | undefined },
+  dockStationStatus: {},
+};
+const platform = {
+  robots: new Map([[duid, robot]]),
+  log: {
+    error: jest.fn(),
+    debug: jest.fn(),
+    notice: jest.fn(),
+    /* eslint-disable no-console */
+    fatal: jest.fn().mockImplementation((message: string, ...arg: unknown[]) => console.info(message, ...arg)),
+  },
+  roborockService: {},
+  enableExperimentalFeature: {},
+};
+
+describe('updateFromHomeData', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should update robot attributes when valid data is provided', async () => {
+    await updateFromHomeData(homeData, platform as any);
+
+    expect(mockUpdateAttribute).toHaveBeenCalledWith(PowerSource.Cluster.id, 'batPercentRemaining', 200, expect.anything());
+    expect(mockUpdateAttribute).toHaveBeenCalledWith(PowerSource.Cluster.id, 'batChargeLevel', 0, expect.anything());
+    expect(mockUpdateAttribute).toHaveBeenCalledWith(RvcRunMode.Cluster.id, 'currentMode', 1, expect.anything());
+    expect(mockUpdateAttribute).toHaveBeenCalledWith(PowerSource.Cluster.id, 'batChargeState', PowerSource.BatChargeState.IsAtFullCharge, expect.anything());
+    expect(platform.log.error).not.toHaveBeenCalled();
+  });
+
+  it('should log error if robot is not found', async () => {
+    platform.robots.clear();
+    await updateFromHomeData(homeData, platform as any);
+    expect(platform.log.error).not.toHaveBeenCalledWith(expect.stringContaining('Robot with DUID'));
+  });
+
+  it('should log error if device data is undefined', async () => {
+    platform.robots.clear();
+    platform.robots.set('test-duid', { ...robot, device: { data: undefined } });
+    await updateFromHomeData(homeData, platform as any);
+    expect(platform.log.error).toHaveBeenCalledWith('Device not found in home data');
+  });
+});