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

package/src/tests/behaviors/roborock.vacuum/default/default.test.ts

@@ -0,0 +1,134 @@
+import { BehaviorDeviceGeneric } from '../../../../behaviors/BehaviorDeviceGeneric.js';
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../../../../roborockService.js';
+import { CleanModeSettings } from '../../../../model/ExperimentalFeatureSetting.js';
+import { MopRoute, MopWaterFlow, setDefaultCommandHandler, VacuumSuctionPower } from '../../../../behaviors/roborock.vacuum/default/default.js';
+
+describe('setDefaultCommandHandler', () => {
+  let handler: BehaviorDeviceGeneric<any>;
+  let logger: AnsiLogger;
+  let roborockService: jest.Mocked<RoborockService>;
+  let cleanModeSettings: CleanModeSettings;
+  const duid = 'test-duid';
+
+  beforeEach(() => {
+    handler = {
+      setCommandHandler: jest.fn(),
+    } as any;
+
+    logger = {
+      notice: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    roborockService = {
+      startClean: jest.fn(),
+      changeCleanMode: jest.fn(),
+      setSelectedAreas: jest.fn(),
+      pauseClean: jest.fn(),
+      resumeClean: jest.fn(),
+      stopAndGoHome: jest.fn(),
+      playSoundToLocate: jest.fn(),
+    } as any;
+
+    cleanModeSettings = {
+      vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+      mopping: { waterFlowMode: 'High', mopRouteMode: 'Fast', distanceOff: 85 },
+      vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'Low',
+        mopRouteMode: 'Deep',
+        distanceOff: 85,
+      },
+      enableCleanModeMapping: true,
+    };
+  });
+
+  it('should set all command handlers', () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('changeToMode', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('selectAreas', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('pause', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('resume', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('goHome', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('playSoundToLocate', expect.any(Function));
+  });
+
+  it('should call startClean for Cleaning mode', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(2); // 2 = Cleaning
+    expect(roborockService.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call changeCleanMode for Mop with correct values', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(31); // 31 = Mop Default
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPower.Off,
+      waterFlow: MopWaterFlow.High,
+      mopRoute: MopRoute.Fast,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vacuum with correct values', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(66); // 66 = Vacuum Default
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPower.Max,
+      waterFlow: MopWaterFlow.Off,
+      mopRoute: MopRoute.DeepPlus,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vac & Mop with correct values', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(5); // 5 = Vac & Mop Default
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPower.Turbo,
+      waterFlow: MopWaterFlow.Low,
+      mopRoute: MopRoute.Deep,
+      distance_off: 0,
+    });
+  });
+
+  it('should call setSelectedAreas', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, selectAreasHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'selectAreas');
+    await (selectAreasHandler as (areas: number[]) => Promise<void>)([1, 2, 3]);
+    expect(roborockService.setSelectedAreas).toHaveBeenCalledWith(duid, [1, 2, 3]);
+  });
+
+  it('should call pauseClean', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, pauseHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'pause');
+    await (pauseHandler as () => Promise<void>)();
+    expect(roborockService.pauseClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call resumeClean', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, resumeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'resume');
+    await (resumeHandler as () => Promise<void>)();
+    expect(roborockService.resumeClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call stopAndGoHome', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, goHomeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'goHome');
+    await (goHomeHandler as () => Promise<void>)();
+    expect(roborockService.stopAndGoHome).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call playSoundToLocate', async () => {
+    setDefaultCommandHandler(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, playSoundHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'playSoundToLocate');
+    await (playSoundHandler as (arg: number) => Promise<void>)(1);
+    expect(roborockService.playSoundToLocate).toHaveBeenCalledWith(duid);
+  });
+});

package/src/tests/behaviors/roborock.vacuum/smart/runtimes.test.ts

@@ -0,0 +1,64 @@
+import { getCurrentCleanModeSmart } from '../../../../behaviors/roborock.vacuum/smart/runtimes';
+import { MopWaterFlowSmart, VacuumSuctionPowerSmart } from '../../../../behaviors/roborock.vacuum/smart/smart';
+
+describe('getCurrentCleanModeSmart', () => {
+  it('returns undefined if input is undefined', () => {
+    expect(getCurrentCleanModeSmart(undefined as any)).toBeUndefined();
+  });
+
+  it('returns the correct key if an exact CleanSetting match exists', () => {
+    // Exact match for 'Vac & Mop Default' (key 5)
+    expect(
+      getCurrentCleanModeSmart({
+        suctionPower: VacuumSuctionPowerSmart.Balanced,
+        waterFlow: MopWaterFlowSmart.Medium,
+        distance_off: 0,
+        mopRoute: 300,
+      }),
+    ).toBe(5);
+  });
+
+  it('returns 12 for MopMax', () => {
+    expect(
+      getCurrentCleanModeSmart({
+        suctionPower: VacuumSuctionPowerSmart.Off,
+        waterFlow: MopWaterFlowSmart.High,
+        distance_off: 0,
+        mopRoute: 300,
+      }),
+    ).toBe(32);
+  });
+
+  it('returns 16 for Vacuum Default if waterFlow is Off', () => {
+    expect(
+      getCurrentCleanModeSmart({
+        suctionPower: VacuumSuctionPowerSmart.Balanced,
+        waterFlow: MopWaterFlowSmart.Off,
+        distance_off: 0,
+        mopRoute: 300,
+      }),
+    ).toBe(66);
+  });
+
+  it('returns 5 for Vac & Mop Default if neither suctionPower nor waterFlow is Off', () => {
+    expect(
+      getCurrentCleanModeSmart({
+        suctionPower: VacuumSuctionPowerSmart.Balanced,
+        waterFlow: MopWaterFlowSmart.Medium,
+        distance_off: 1,
+        mopRoute: 300,
+      }),
+    ).toBe(5);
+  });
+
+  it('returns undefined if no match and no fallback applies', () => {
+    expect(
+      getCurrentCleanModeSmart({
+        suctionPower: 999,
+        waterFlow: 999,
+        distance_off: 999,
+        mopRoute: 999,
+      }),
+    ).toBe(5);
+  });
+});

package/src/tests/behaviors/roborock.vacuum/smart/smart.test.ts

@@ -0,0 +1,215 @@
+import { setCommandHandlerSmart, VacuumSuctionPowerSmart, MopWaterFlowSmart, MopRouteSmart } from '../../../../behaviors/roborock.vacuum/smart/smart';
+import { BehaviorDeviceGeneric } from '../../../../behaviors/BehaviorDeviceGeneric';
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../../../../roborockService';
+import { CleanModeSettings } from '../../../../model/ExperimentalFeatureSetting';
+
+describe('setCommandHandlerSmart', () => {
+  let handler: BehaviorDeviceGeneric<any>;
+  let logger: AnsiLogger;
+  let roborockService: jest.Mocked<RoborockService>;
+  let cleanModeSettings: CleanModeSettings;
+  const duid = 'test-duid';
+
+  beforeEach(() => {
+    handler = {
+      setCommandHandler: jest.fn(),
+    } as any;
+
+    logger = {
+      notice: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    roborockService = {
+      startClean: jest.fn(),
+      changeCleanMode: jest.fn(),
+      setSelectedAreas: jest.fn(),
+      pauseClean: jest.fn(),
+      resumeClean: jest.fn(),
+      stopAndGoHome: jest.fn(),
+      playSoundToLocate: jest.fn(),
+    } as any;
+
+    cleanModeSettings = {
+      vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+      mopping: { waterFlowMode: 'High', mopRouteMode: 'Fast', distanceOff: 25 },
+      vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'Low',
+        mopRouteMode: 'Deep',
+        distanceOff: 25,
+      },
+      enableCleanModeMapping: true,
+    };
+  });
+
+  it('should set all command handlers', () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('changeToMode', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('selectAreas', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('pause', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('resume', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('goHome', expect.any(Function));
+    expect(handler.setCommandHandler).toHaveBeenCalledWith('playSoundToLocate', expect.any(Function));
+  });
+
+  it('should call startClean for Cleaning mode', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(2); // 2 = Cleaning
+    expect(roborockService.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call changeCleanMode for Smart Plan', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(4); // 4 = Smart Plan
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: 0,
+      waterFlow: 0,
+      distance_off: 0,
+      mopRoute: MopRouteSmart.Smart,
+    });
+  });
+
+  it('should call changeCleanMode for Mop with correct values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, undefined);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(31); // 31 = Mop Default
+    // mopping: { waterFlowMode: 'High', mopRouteMode: 'Fast', distanceOff: 85 },
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Off,
+      waterFlow: MopWaterFlowSmart.Medium,
+      mopRoute: MopRouteSmart.Standard,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Mop with custom values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, {
+      vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+      mopping: { waterFlowMode: 'CustomizeWithDistanceOff', mopRouteMode: 'Fast', distanceOff: 25 },
+      vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'Low',
+        mopRouteMode: 'Deep',
+        distanceOff: 25,
+      },
+      enableCleanModeMapping: true,
+    });
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(31); // 31 = Mop Default
+    // vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Off,
+      waterFlow: MopWaterFlowSmart.CustomizeWithDistanceOff,
+      mopRoute: MopRouteSmart.Fast,
+      distance_off: 85,
+    });
+  });
+
+  it('should call changeCleanMode for Vacuum with correct values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, undefined);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(66); // 66 = Vacuum Default
+    // vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Balanced,
+      waterFlow: MopWaterFlowSmart.Off,
+      mopRoute: MopRouteSmart.Standard,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vacuum with custom values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(66); // 66 = Vacuum Default
+    // vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Max,
+      waterFlow: MopWaterFlowSmart.Off,
+      mopRoute: MopRouteSmart.DeepPlus,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vac & Mop with correct values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, undefined);
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(5); // 5 = Vac & Mop Default
+    /*
+    vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'Low',
+        mopRouteMode: 'Deep',
+        distanceOff: 85,
+    },
+    */
+
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Balanced,
+      waterFlow: MopWaterFlowSmart.Medium,
+      mopRoute: MopRouteSmart.Standard,
+      distance_off: 0,
+    });
+  });
+
+  it('should call changeCleanMode for Vac & Mop with custom values', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, {
+      vacuuming: { fanMode: 'Max', mopRouteMode: 'DeepPlus' },
+      mopping: { waterFlowMode: 'CustomizeWithDistanceOff', mopRouteMode: 'Fast', distanceOff: 25 },
+      vacmop: {
+        fanMode: 'Turbo',
+        waterFlowMode: 'CustomizeWithDistanceOff',
+        mopRouteMode: 'Deep',
+        distanceOff: 25,
+      },
+      enableCleanModeMapping: true,
+    });
+    const [[, changeToModeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'changeToMode');
+    await (changeToModeHandler as (mode: number) => Promise<void>)(5); // 5 = Vac & Mop Default
+    expect(roborockService.changeCleanMode).toHaveBeenCalledWith(duid, {
+      suctionPower: VacuumSuctionPowerSmart.Turbo,
+      waterFlow: MopWaterFlowSmart.CustomizeWithDistanceOff,
+      mopRoute: MopRouteSmart.Deep,
+      distance_off: 85,
+    });
+  });
+
+  it('should call setSelectedAreas', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, selectAreasHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'selectAreas');
+    await (selectAreasHandler as (areas: number[]) => Promise<void>)([1, 2, 3]);
+    expect(roborockService.setSelectedAreas).toHaveBeenCalledWith(duid, [1, 2, 3]);
+  });
+
+  it('should call pauseClean', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, pauseHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'pause');
+    await (pauseHandler as () => Promise<void>)();
+    expect(roborockService.pauseClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call resumeClean', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, resumeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'resume');
+    await (resumeHandler as () => Promise<void>)();
+    expect(roborockService.resumeClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call stopAndGoHome', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, goHomeHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'goHome');
+    await (goHomeHandler as () => Promise<void>)();
+    expect(roborockService.stopAndGoHome).toHaveBeenCalledWith(duid);
+  });
+
+  it('should call playSoundToLocate', async () => {
+    setCommandHandlerSmart(duid, handler, logger, roborockService, cleanModeSettings);
+    const [[, playSoundHandler]] = (handler.setCommandHandler as jest.Mock).mock.calls.filter(([cmd]) => cmd === 'playSoundToLocate');
+    await (playSoundHandler as (arg: number) => Promise<void>)(1);
+    expect(roborockService.playSoundToLocate).toHaveBeenCalledWith(duid);
+  });
+});

package/src/tests/helper.test.ts

@@ -0,0 +1,162 @@
+import { getRoomMapFromDevice } from '../helper';
+import { RoomMap } from '../model/RoomMap';
+
+const mockLog = {
+  notice: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  verbose: jest.fn(),
+};
+
+const mockRoborockService = {
+  getRoomMappings: jest.fn(),
+  getMapInformation: jest.fn(),
+};
+
+const mockPlatform = {
+  log: mockLog,
+  roborockService: mockRoborockService,
+};
+
+describe('getRoomMapFromDevice', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns RoomMap from getRoomMappings if available', async () => {
+    const device = {
+      duid: '123',
+      rooms: [
+        {
+          'id': 12461114,
+          'name': 'Guest bedroom',
+        },
+        {
+          'id': 12461111,
+          'name': 'Balcony',
+        },
+        {
+          'id': 12461109,
+          'name': 'Master bedroom',
+        },
+        {
+          'id': 11100849,
+          'name': 'Study',
+        },
+        {
+          'id': 11100847,
+          'name': 'Bedroom',
+        },
+        {
+          'id': 11100845,
+          'name': 'Kitchen',
+        },
+        {
+          'id': 11100842,
+          'name': 'Living room',
+        },
+      ],
+    };
+    mockRoborockService.getRoomMappings.mockResolvedValue([
+      [1, '11100842', 6],
+      [2, '12461114', 3],
+      [3, '12461109', 2],
+      [4, '12461111', 7],
+    ]);
+    mockRoborockService.getMapInformation.mockResolvedValue(undefined);
+
+    const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+
+    // console.log('Result:', result);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(mockRoborockService.getRoomMappings).toHaveBeenCalledWith('123');
+    expect(result.rooms.length).toBeGreaterThan(0);
+  });
+
+  it('returns RoomMap from getRoomMappings if available', async () => {
+    const device = {
+      duid: '123',
+      rooms: [
+        { id: 1, name: 'Kitchen' },
+        { id: 2, name: 'Study' },
+        { id: 3, name: 'Living room' },
+        { id: 4, name: 'Bedroom' },
+      ],
+    };
+    mockRoborockService.getRoomMappings.mockResolvedValue([
+      [1, '11100845', 14],
+      [2, '11100849', 9],
+      [3, '11100842', 6],
+      [4, '11100847', 1],
+    ]);
+    mockRoborockService.getMapInformation.mockResolvedValue(undefined);
+
+    const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+
+    // console.log('Result:', result);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(mockRoborockService.getRoomMappings).toHaveBeenCalledWith('123');
+    expect(result.rooms.length).toBeGreaterThan(0);
+  });
+
+  it('returns RoomMap from getMapInformation if available', async () => {
+    const device = {
+      duid: '123',
+      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' },
+      ],
+    };
+    mockRoborockService.getRoomMappings.mockResolvedValue(undefined);
+    mockRoborockService.getMapInformation.mockResolvedValue({
+      maps: [
+        {
+          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 },
+          ],
+        },
+      ],
+      allRooms: [
+        { 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, 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 },
+      ],
+    });
+
+    const result = await getRoomMapFromDevice(device as any, mockPlatform as any);
+    expect(result).toBeInstanceOf(RoomMap);
+    expect(mockRoborockService.getMapInformation).toHaveBeenCalledWith('123');
+    expect(result.rooms.length).toBeGreaterThan(0);
+  });
+});