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

package/src/tests/initialData/getSupportedAreas.test.ts

@@ -0,0 +1,181 @@
+import { getSupportedAreas } from '../../initialData/getSupportedAreas';
+import { RoomMap } from '../../model/RoomMap';
+import { Room } from '../../roborockCommunication/Zmodel/room';
+
+const mockLogger = {
+  debug: jest.fn(),
+  error: jest.fn(),
+  notice: jest.fn(),
+};
+
+describe('getSupportedAreas', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const { supportedAreas } = getSupportedAreas(
+      [
+        { id: 2775739, name: 'Garage' },
+        { id: 1474466, name: 'Outside' },
+        { id: 1459590, name: 'AAA room' },
+        { id: 1459587, name: 'BBB’s Room' },
+        { id: 1459580, name: 'CCC’s room' },
+        { id: 1458155, name: 'Dining room' },
+        { id: 1457889, name: 'Bathroom' },
+        { id: 1457888, name: 'Living room' },
+        { id: 991195, name: 'Downstairs Bathroom' },
+        { id: 991190, name: 'Garage Entryway' },
+        { id: 991187, name: 'TV Room' },
+        { id: 991185, name: 'Bedroom' },
+        { id: 612205, name: 'DDD’s Room' },
+        { id: 612204, name: 'Upstairs Bathroom' },
+        { id: 612202, name: 'Hallway' },
+        { id: 612200, name: 'EEE Room' },
+        { id: 609148, name: 'Dining Room' },
+        { id: 609146, name: 'Kitchen' },
+        { id: 609145, name: 'Living Room' },
+      ],
+      {
+        rooms: [
+          { id: 16, globalId: 609146, displayName: 'Kitchen' },
+          { id: 17, globalId: 1457889, displayName: 'Bathroom' },
+          { id: 18, globalId: 612202, displayName: 'Hallway' },
+          { id: 19, globalId: 1458155, displayName: 'Dining room' },
+          { id: 20, globalId: 1457888, displayName: 'Living room' },
+          { id: 21, globalId: 1459580, displayName: 'BBB’s room' },
+          { id: 22, globalId: 612205, displayName: 'CCC’s Room' },
+          { id: 23, globalId: 1474466, displayName: 'Outside' },
+        ],
+      } as RoomMap,
+      false, // enableMultipleMap
+      mockLogger as any,
+    );
+
+    expect(supportedAreas.length).toEqual(8);
+  });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const { supportedAreas } = getSupportedAreas(
+      [
+        { id: 11453731, name: 'Living room' },
+        { id: 11453727, name: 'Kitchen' },
+        { id: 11453415, name: 'Bathroom' },
+        { id: 11453409, name: 'Emile’s Room' },
+        { id: 11453404, name: 'Nadia’s Room' },
+        { id: 11453398, name: 'Hallway' },
+        { id: 11453391, name: 'Dining room' },
+        { id: 11453384, name: 'Outside' },
+      ],
+      {
+        rooms: [
+          { id: 16, globalId: 2775739, displayName: undefined },
+          { id: 17, globalId: 991195, displayName: undefined },
+          { id: 18, globalId: 991187, displayName: undefined },
+          { id: 19, globalId: 991185, displayName: undefined },
+          { id: 20, globalId: 991190, displayName: undefined },
+        ],
+      } as RoomMap,
+      false, // enableMultipleMap
+      mockLogger as any,
+    );
+
+    expect(supportedAreas.length).toEqual(5);
+  });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const { supportedAreas } = getSupportedAreas(
+      [
+        { id: 11453731, name: 'Living room' },
+        { id: 11453727, name: 'Kitchen' },
+        { id: 11453415, name: 'Bathroom' },
+        { id: 11453409, name: 'Emile’s Room' },
+        { id: 11453404, name: 'Nadia’s Room' },
+        { id: 11453398, name: 'Hallway' },
+        { id: 11453391, name: 'Dining room' },
+        { id: 11453384, name: 'Outside' },
+      ],
+      {
+        rooms: [
+          { id: 16, globalId: 2775739, displayName: undefined },
+          { id: 17, globalId: 991195, displayName: undefined },
+          { id: 18, globalId: 991187, displayName: undefined },
+          { id: 19, globalId: 991185, displayName: undefined },
+          { id: 20, globalId: 991190, displayName: undefined },
+        ],
+      } as RoomMap,
+      false, // enableMultipleMap
+      mockLogger as any,
+    );
+
+    expect(supportedAreas.length).toEqual(5);
+  });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const vacuumRooms: Room[] = [
+      { id: 11100845, name: 'Kitchen' },
+      { id: 11100849, name: 'Study' },
+      { id: 11100842, name: 'Living room' },
+      { id: 11100847, name: 'Bedroom' },
+      { id: 12461114, name: 'Guest bedroom' },
+      { id: 12461109, name: 'Master bedroom' },
+      { id: 12461111, name: 'Balcony' },
+    ];
+    const roomMap: RoomMap = {
+      rooms: [
+        { id: 16, globalId: 2775739, displayName: undefined, alternativeId: '161' },
+        { id: 17, globalId: 991195, displayName: undefined, alternativeId: '171' },
+        { id: 18, globalId: 991187, displayName: undefined, alternativeId: '181' },
+        { id: 19, globalId: 991185, displayName: undefined, alternativeId: '191' },
+        { id: 20, globalId: 991190, displayName: undefined, alternativeId: '201' },
+      ],
+    };
+    const { supportedAreas } = getSupportedAreas(vacuumRooms, roomMap, false, mockLogger as any);
+
+    expect(supportedAreas.length).toEqual(5);
+  });
+
+  it('returns default area when rooms and roomMap are empty', () => {
+    const vacuumRooms: Room[] = [
+      { id: 11100845, name: 'Kitchen' },
+      { id: 11100849, name: 'Study' },
+      { id: 11100842, name: 'Living room' },
+      { id: 11100847, name: 'Bedroom' },
+      { id: 11100842, name: 'Living room' },
+      { id: 12461114, name: 'Guest bedroom' },
+      { id: 12461109, name: 'Master bedroom' },
+      { id: 12461111, name: 'Balcony' },
+    ];
+    const roomMap: RoomMap = {
+      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 },
+        { id: 1, globalId: 11100842, displayName: 'Living room', alternativeId: '16', mapId: 1 },
+        { id: 2, globalId: 12461114, displayName: 'Guest bedroom', alternativeId: '23', mapId: 1 },
+        { id: 3, globalId: 12461109, displayName: 'Master bedroom', alternativeId: '32', mapId: 1 },
+        { id: 4, globalId: 12461111, displayName: 'Balcony', alternativeId: '47', mapId: 1 },
+      ],
+      mapInfo: [
+        {
+          id: 0,
+          name: 'First Map',
+        },
+        {
+          id: 1,
+          name: 'Second Map',
+        },
+      ],
+    };
+
+    const mockLogger1 = {
+      debug: jest.fn(),
+      notice: jest.fn(),
+      error: jest.fn(),
+    };
+    const { supportedAreas, supportedMaps } = getSupportedAreas(vacuumRooms, roomMap, true, mockLogger1 as any);
+    expect(supportedAreas.length).toEqual(8);
+    expect(supportedMaps.length).toEqual(2);
+  });
+});

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

@@ -0,0 +1,39 @@
+import { parseDockingStationStatus, hasDockingStationError, DockingStationStatusType, DockingStationStatus } from '../../model/DockingStationStatus';
+
+describe('DockingStationStatus', () => {
+  it('should parse docking station status correctly', () => {
+    const dss = 2729;
+    const status = parseDockingStationStatus(dss);
+
+    expect(status.cleanFluidStatus).toBe(2);
+    expect(status.waterBoxFilterStatus).toBe(2);
+    expect(status.dustBagStatus).toBe(2);
+    expect(status.dirtyWaterBoxStatus).toBe(2);
+    expect(status.clearWaterBoxStatus).toBe(2);
+    expect(status.isUpdownWaterReady).toBe(1);
+  });
+
+  it('should detect error in any status field', () => {
+    const status: DockingStationStatus = {
+      cleanFluidStatus: DockingStationStatusType.OK,
+      waterBoxFilterStatus: DockingStationStatusType.OK,
+      dustBagStatus: DockingStationStatusType.Error,
+      dirtyWaterBoxStatus: DockingStationStatusType.OK,
+      clearWaterBoxStatus: DockingStationStatusType.OK,
+      isUpdownWaterReady: DockingStationStatusType.OK,
+    };
+    expect(hasDockingStationError(status)).toBe(true);
+  });
+
+  it('should return true if error in any field', () => {
+    const status: DockingStationStatus = {
+      cleanFluidStatus: 2,
+      waterBoxFilterStatus: 2,
+      dustBagStatus: 2,
+      dirtyWaterBoxStatus: 2,
+      clearWaterBoxStatus: 1, // This means there is a problem with the clear water box
+      isUpdownWaterReady: 1, // This means there is a problem with the updown water
+    };
+    expect(hasDockingStationError(status)).toBe(true);
+  });
+});

package/src/tests/platformRunner.test.ts

@@ -0,0 +1,188 @@
+import { PlatformRunner } from '../platformRunner';
+import { NotifyMessageTypes } from '../notifyMessageTypes';
+import { RoborockMatterbridgePlatform } from '../platform';
+import { Home } from '../roborockCommunication';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { RoborockVacuumCleaner } from '../rvc';
+import * as initialDataIndex from '../initialData/index';
+import { RvcOperationalState } from 'matterbridge/matter/clusters';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let getOperationalErrorState = jest.fn().mockReturnValue(2);
+
+jest.mock('./src/initialData/index', () => ({
+  ...initialDataIndex,
+  getOperationalErrorState,
+}));
+
+describe('PlatformRunner.updateRobot', () => {
+  let platform: RoborockMatterbridgePlatform;
+  let runner: PlatformRunner;
+  let robotMock: any;
+
+  beforeEach(() => {
+    robotMock = {
+      updateAttribute: jest.fn(),
+      getAttribute: jest.fn(),
+      device: {
+        data: { model: 'test-model' },
+        duid: '123456',
+        rooms: [],
+      },
+      serialNumber: '123456',
+      dockStationStatus: undefined,
+      roomInfo: undefined,
+    };
+
+    const robots = new Map<string, RoborockVacuumCleaner>();
+    robots.set('123456', robotMock);
+
+    platform = {
+      robots: robots,
+      log: {
+        error: jest.fn(),
+        debug: jest.fn(),
+        notice: jest.fn(),
+      },
+      enableExperimentalFeature: undefined,
+    } as unknown as RoborockMatterbridgePlatform;
+
+    runner = new PlatformRunner(platform);
+  });
+
+  it('should set correct attributes from homeData', async () => {
+    const homeDataPath = path.join(__dirname, 'testData', 'mockHomeData-a187.json');
+    const homeData: Home = JSON.parse(fs.readFileSync(homeDataPath, 'utf-8'));
+
+    await runner.updateRobot(NotifyMessageTypes.HomeData, homeData);
+
+    const calls = robotMock.updateAttribute.mock.calls;
+
+    expect(calls).toEqual(
+      expect.arrayContaining([
+        expect.arrayContaining([
+          expect.any(String), // Cluster.id
+          'batPercentRemaining',
+          expect.any(Number),
+          expect.any(Object),
+        ]),
+        expect.arrayContaining([expect.any(String), 'currentMode', expect.any(Number), expect.any(Object)]),
+        expect.arrayContaining([expect.any(String), 'operationalState', expect.any(Number), expect.any(Object)]),
+        expect.arrayContaining([expect.any(String), 'batChargeState', expect.any(Number), expect.any(Object)]),
+      ]),
+    );
+    expect(platform.log.error).not.toHaveBeenCalled();
+  });
+
+  it('should log error if robot not found in homeData', async () => {
+    const homeData: Home = {
+      devices: [{ duid: 'notfound', data: {}, productId: 1 }],
+      products: [],
+    } as any;
+
+    await runner.updateRobot(NotifyMessageTypes.HomeData, homeData);
+
+    expect(platform.log.error).not.toHaveBeenCalledWith(expect.stringContaining('Error5'));
+    // No updateAttribute should be called
+    expect(robotMock.updateAttribute).not.toHaveBeenCalled();
+  });
+
+  it('should log error if device data is undefined', async () => {
+    robotMock.device.data = undefined;
+    const homeData: Home = {
+      devices: [{ duid: '123456', data: {}, productId: 1 }],
+      products: [],
+    } as any;
+
+    await runner.updateRobot(NotifyMessageTypes.HomeData, homeData);
+
+    expect(platform.log.error).toHaveBeenCalledWith('Device not found in home data');
+    expect(robotMock.updateAttribute).not.toHaveBeenCalled();
+  });
+
+  it('should not update attributes if state or matterState is missing', async () => {
+    robotMock.device.data = { model: 'test-model' };
+    robotMock.serialNumber = '123456';
+    const homeData: Home = {
+      devices: [
+        {
+          duid: '123456',
+          data: {
+            model: 'test-model',
+          },
+          productId: 1,
+          deviceStatus: {
+            122: 50,
+          },
+        },
+      ],
+      products: [
+        {
+          id: 1,
+          model: 'test-model',
+          schema: [
+            {
+              id: 122,
+              name: '设备电量',
+              code: 'battery',
+              mode: 'ro',
+              type: 'ENUM',
+              property: '{"range": [""]}',
+            },
+          ],
+        },
+      ],
+    } as any;
+
+    await runner.updateRobot(NotifyMessageTypes.HomeData, homeData);
+
+    // Only battery attributes should be set, not currentMode/operationalState
+    expect(robotMock.updateAttribute).toHaveBeenCalledWith(expect.any(Number), 'batPercentRemaining', 100, expect.any(Object));
+    expect(robotMock.updateAttribute).toHaveBeenCalledWith(expect.any(Number), 'batChargeLevel', expect.any(Number), expect.any(Object));
+    expect(robotMock.updateAttribute).not.toHaveBeenCalledWith(expect.any(Number), 'currentMode', expect.anything(), expect.any(Object));
+    expect(robotMock.updateAttribute).not.toHaveBeenCalledWith(expect.any(Number), 'operationalState', expect.anything(), expect.any(Object));
+  });
+
+  it('should handle NotifyMessageTypes.BatteryUpdate', async () => {
+    const batteryMessage = { percentage: 60 };
+    robotMock.device.data = { model: 'test-model' };
+    robotMock.serialNumber = '123456';
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.BatteryUpdate, batteryMessage, '123456');
+
+    expect(robotMock.updateAttribute).toHaveBeenCalledWith(expect.any(Number), 'batPercentRemaining', 120, expect.any(Object));
+    expect(robotMock.updateAttribute).toHaveBeenCalledWith(expect.any(Number), 'batChargeLevel', expect.any(Number), expect.any(Object));
+  });
+
+  it('should handle NotifyMessageTypes.ErrorOccurred', async () => {
+    const errorMessage = { errorCode: 1 };
+    robotMock.device.data = { model: 'test-model' };
+    robotMock.serialNumber = '123456';
+    getOperationalErrorState = jest.fn().mockReturnValue(RvcOperationalState.OperationalState.Error);
+
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.ErrorOccurred, errorMessage, '123456');
+
+    expect(platform.log.error).toHaveBeenCalledWith('Error occurred: 1');
+    expect(robotMock.updateAttribute).toHaveBeenCalledWith(expect.any(Number), 'operationalState', 3, expect.any(Object));
+  });
+
+  it('should log error if robot not found for MQTT message', async () => {
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.BatteryUpdate, { percentage: 50 }, 'notfound');
+    expect(platform.log.error).toHaveBeenCalledWith('Error1: Robot with DUID notfound not found');
+  });
+
+  it('should log error if device data is undefined for MQTT message', async () => {
+    robotMock.device.data = undefined;
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.BatteryUpdate, { percentage: 50 }, '123456');
+    expect(platform.log.error).toHaveBeenCalledWith('Device data is undefined');
+  });
+
+  it('should log error if robot serial number is undefined for MQTT message', async () => {
+    robotMock.serialNumber = undefined;
+    robotMock.device.data = { model: 'test-model' };
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.BatteryUpdate, { percentage: 50 }, '123456');
+    expect(platform.log.error).toHaveBeenCalledWith('Robot serial number is undefined');
+  });
+});

package/src/tests/platformRunner2.test.ts

@@ -0,0 +1,228 @@
+import { getRoomMapFromDevice } from '../helper';
+import { RoomMap } from '../model/RoomMap';
+import { MapInfo } from '../roborockCommunication';
+
+describe('PlatformRunner.getRoomMapFromDevice', () => {
+  let platform: any;
+
+  beforeEach(() => {
+    platform = {
+      log: {
+        error: jest.fn(),
+        debug: jest.fn(),
+        notice: jest.fn(),
+      },
+      roborockService: {
+        getRoomMappings: jest.fn(),
+        getMapInformation: jest.fn(),
+      },
+    };
+  });
+
+  it('returns RoomMap with roomData from getRoomMappings if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+    const roomData = [
+      [1, '11100845', 14],
+      [2, '11100849', 9],
+      [3, '11100842', 6],
+      [4, '11100847', 1],
+    ];
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(roomData);
+    platform.roborockService.getMapInformation.mockResolvedValue(undefined);
+
+    const result = await getRoomMapFromDevice(device as any, platform);
+
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(4);
+  });
+
+  it('returns RoomMap with roomData from getMapInformation if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+
+    const mapInfo = new MapInfo({
+      max_multi_map: 1,
+      max_bak_map: 1,
+      multi_map_count: 1,
+      map_info: [
+        {
+          mapFlag: 0,
+          add_time: 1753511673,
+          length: 9,
+          name: 'First Map',
+          bak_maps: [{ mapFlag: 4, add_time: 1753578164 }],
+          rooms: [
+            { id: 1, tag: 14, iot_name_id: '11100845', iot_name: 'Kitchen' },
+            { id: 2, tag: 9, iot_name_id: '11100849', iot_name: 'Study' },
+            {
+              id: 3,
+              tag: 6,
+              iot_name_id: '11100842',
+              iot_name: 'Living room',
+            },
+            { id: 4, tag: 1, iot_name_id: '11100847', iot_name: 'Bedroom' },
+          ],
+        },
+        {
+          mapFlag: 1,
+          add_time: 1753579596,
+          length: 10,
+          name: 'Second Map',
+          bak_maps: [{ mapFlag: 5, add_time: 1753578579 }],
+          rooms: [
+            {
+              id: 1,
+              tag: 6,
+              iot_name_id: '11100842',
+              iot_name: 'Living room',
+            },
+            {
+              id: 2,
+              tag: 3,
+              iot_name_id: '12461114',
+              iot_name: 'Guest bedroom',
+            },
+            {
+              id: 3,
+              tag: 2,
+              iot_name_id: '12461109',
+              iot_name: 'Master bedroom',
+            },
+            { id: 4, tag: 7, iot_name_id: '12461111', iot_name: 'Balcony' },
+          ],
+        },
+      ],
+    });
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(undefined);
+    platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
+
+    const result = await getRoomMapFromDevice(device as any, platform);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(4);
+
+    platform.enableExperimentalFeature = {
+      enableExperimentalFeature: true,
+      advancedFeature: {
+        enableMultipleMap: true,
+      },
+    };
+
+    const result1 = await getRoomMapFromDevice(device as any, platform);
+    expect(result1).toBeInstanceOf(RoomMap);
+    expect(result1.rooms.length).toEqual(8);
+  });
+
+  it('returns RoomMap with empty roomData from getMapInformation if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+
+    const mapInfo = new MapInfo({
+      max_multi_map: 4,
+      max_bak_map: 0,
+      multi_map_count: 1,
+      map_info: [
+        {
+          mapFlag: 0,
+          add_time: 1753731408,
+          length: 0,
+          name: '',
+          bak_maps: [],
+        },
+      ],
+    });
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(undefined);
+    platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
+
+    const result = await getRoomMapFromDevice(device as any, platform);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(0);
+
+    platform.enableExperimentalFeature = {
+      enableExperimentalFeature: true,
+      advancedFeature: {
+        enableMultipleMap: true,
+      },
+    };
+
+    const result1 = await getRoomMapFromDevice(device as any, platform);
+    expect(result1).toBeInstanceOf(RoomMap);
+    expect(result1.rooms.length).toEqual(0);
+  });
+
+  it('returns RoomMap with roomData from getMapInformation if available', async () => {
+    const device = {
+      duid: 'duid1',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+
+    const mapInfo = new MapInfo({
+      max_multi_map: 4,
+      max_bak_map: 0,
+      multi_map_count: 1,
+      map_info: [
+        {
+          mapFlag: 0,
+          add_time: 1753731408,
+          length: 0,
+          name: '',
+          bak_maps: [],
+        },
+      ],
+    });
+
+    const roomData = [
+      [1, '11100845', 14],
+      [2, '11100849', 9],
+      [3, '11100842', 6],
+      [4, '11100847', 1],
+    ];
+
+    platform.roborockService.getRoomMappings.mockResolvedValue(roomData);
+    platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
+
+    const result = await getRoomMapFromDevice(device as any, platform);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(result.rooms.length).toEqual(4);
+
+    platform.enableExperimentalFeature = {
+      enableExperimentalFeature: true,
+      advancedFeature: {
+        enableMultipleMap: true,
+      },
+    };
+
+    const result1 = await getRoomMapFromDevice(device as any, platform);
+    expect(result1).toBeInstanceOf(RoomMap);
+    expect(result1.rooms.length).toEqual(4);
+  });
+});

package/src/tests/platformRunner3.test.ts

@@ -0,0 +1,46 @@
+import { PlatformRunner } from '../platformRunner';
+import { NotifyMessageTypes } from '../notifyMessageTypes';
+import { RoborockMatterbridgePlatform } from '../platform';
+import { RoborockVacuumCleaner } from '../rvc';
+
+describe('PlatformRunner.updateRobot', () => {
+  let platform: RoborockMatterbridgePlatform;
+  let runner: PlatformRunner;
+  let robotMock: any;
+
+  beforeEach(() => {
+    robotMock = {
+      updateAttribute: jest.fn(),
+      getAttribute: jest.fn(),
+      device: {
+        data: { model: 'test-model' },
+        duid: '123456',
+        rooms: [],
+      },
+      serialNumber: '123456',
+      dockStationStatus: undefined,
+      roomInfo: undefined,
+    };
+
+    const robots = new Map<string, RoborockVacuumCleaner>();
+    robots.set('123456', robotMock);
+
+    platform = {
+      robots: robots,
+      log: {
+        error: jest.fn(),
+        debug: jest.fn(),
+        notice: jest.fn(),
+      },
+      enableExperimentalFeature: undefined,
+    } as unknown as RoborockMatterbridgePlatform;
+
+    runner = new PlatformRunner(platform);
+  });
+
+  it('should handle unknown message types gracefully', async () => {
+    const mapUpdated = { duid: '123456', dps: { 128: 4 } };
+    await runner['updateFromMQTTMessage'](NotifyMessageTypes.CloudMessage, mapUpdated, '123456');
+    expect(platform.log.notice).toHaveBeenCalled();
+  });
+});