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

package/src/tests/roborockService.test.ts

@@ -0,0 +1,517 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import { ServiceArea } from 'matterbridge/matter/clusters';
+import RoborockService from '../roborockService';
+import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { Device, MultipleMap, RequestMessage } from '../roborockCommunication';
+import { RoomIndexMap } from '../model/roomIndexMap';
+
+describe('RoborockService - startClean', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+  let mockLoginApi: any;
+  let mockMapInfo: any;
+  let mockMessageClient: 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(),
+    };
+
+    mockMapInfo = 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('should return result from iotApi.getCustom', async () => {
+    mockIotApi.getCustom.mockResolvedValue({ foo: 'bar' });
+    const result = await roborockService.getCustomAPI('http://test');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - getCustomAPI', 'http://test');
+    expect(result).toEqual({ foo: 'bar' });
+  });
+
+  it('should log error and return error object if iotApi.getCustom throws', async () => {
+    mockIotApi.getCustom.mockRejectedValue(new Error('fail'));
+    const result = await roborockService.getCustomAPI('http://test');
+    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to get custom API with url http://test:'));
+    expect(result).toEqual({ result: undefined, error: expect.stringContaining('Failed to get custom API with url http://test') });
+  });
+
+  it('should return MapInfo if response contains maps', async () => {
+    const mapData = [
+      {
+        map_info: [
+          {
+            rooms: [{ id: 1, iot_name_id: 'room1', tag: 0, iot_name: 'Living Room' }],
+            mapFlag: 1,
+            name: 'Living Room Map',
+          },
+        ],
+      },
+    ] as MultipleMap[];
+    mockMessageClient = {
+      get: jest.fn(),
+    };
+    roborockService.messageClient = mockMessageClient;
+    mockMessageClient.get.mockResolvedValue(mapData);
+    mockMapInfo.mockImplementation((data) => ({ map: data }));
+
+    const result = await roborockService.getMapInformation('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - getMapInformation', 'duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - getMapInformation response', expect.anything());
+    expect(result?.maps.length).toEqual(1);
+  });
+
+  it('should return undefined if response is empty', async () => {
+    mockMessageClient = { get: jest.fn() };
+    mockMessageClient.get.mockResolvedValue(undefined);
+    roborockService.messageClient = mockMessageClient;
+
+    const result = await roborockService.getMapInformation('duid');
+    expect(result).toBeUndefined();
+  });
+
+  it('should return vacuumRoom if present', async () => {
+    roborockService.customGet = jest.fn();
+    (roborockService.customGet as jest.Mock).mockResolvedValue({ vacuumRoom: 42 });
+    const result = await roborockService.getRoomIdFromMap('duid');
+    expect(roborockService.customGet).toHaveBeenCalledWith('duid', expect.any(Object));
+    expect(result).toBe(42);
+  });
+
+  it('should return undefined if vacuumRoom is not present', async () => {
+    roborockService.customGet = jest.fn();
+    (roborockService.customGet as jest.Mock).mockResolvedValue({});
+    const result = await roborockService.getRoomIdFromMap('duid');
+    expect(result).toBeUndefined();
+  });
+
+  it('should login with password if no saved user data', async () => {
+    const username = 'user';
+    const password = 'pass';
+    const userData = { foo: 'bar' };
+    mockLoginApi.loginWithPassword.mockResolvedValue(userData);
+    const loadSavedUserData = jest.fn().mockResolvedValue(undefined);
+    const savedUserData = jest.fn().mockResolvedValue(undefined);
+
+    const result = await roborockService.loginWithPassword(username, password, loadSavedUserData, savedUserData);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('No saved user data found, logging in with password');
+    expect(mockLoginApi.loginWithPassword).toHaveBeenCalledWith(username, password);
+    expect(savedUserData).toHaveBeenCalledWith(userData);
+    expect(roborockService['auth']).toHaveBeenCalledWith(userData);
+    expect(result).toBe(userData);
+  });
+
+  it('should login with user data if saved user data exists', async () => {
+    const username = 'user';
+    const password = 'pass';
+    const userData = { foo: 'bar' };
+    mockLoginApi.loginWithUserData.mockResolvedValue(userData);
+    const loadSavedUserData = jest.fn().mockResolvedValue(userData);
+    const savedUserData = jest.fn();
+
+    const result = await roborockService.loginWithPassword(username, password, loadSavedUserData, savedUserData);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('Using saved user data for login', expect.anything());
+    expect(mockLoginApi.loginWithUserData).toHaveBeenCalledWith(username, userData);
+    expect(roborockService['auth']).toHaveBeenCalledWith(userData);
+    expect(result).toBe(userData);
+  });
+
+  it('should start global clean when no areas or selected areas are provided', async () => {
+    const duid = 'test-duid';
+    roborockService['supportedAreas'].set(duid, []);
+    roborockService['selectedAreas'].set(duid, []);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startGlobalClean');
+    expect(mockMessageProcessor.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should start room clean when selected areas match supported areas', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+    ];
+    const selectedAreas = [1];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startRoomClean', expect.anything());
+    expect(mockMessageProcessor.startRoomClean).toHaveBeenCalledWith(duid, selectedAreas, 1);
+  });
+
+  it('should start global clean when all selected areas match all supported areas', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+    ];
+    const selectedAreas = [1, 2];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startGlobalClean');
+    expect(mockMessageProcessor.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should start scene when a routine is selected', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+    ];
+    const supportedRoutines: ServiceArea.Area[] = [{ areaId: 99, mapId: null, areaInfo: {} as any }];
+    const selectedAreas = [99];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['supportedRoutines'].set(duid, supportedRoutines);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    roborockService['iotApi'] = {
+      startScene: jest.fn(),
+    } as any;
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startScene', expect.anything());
+    expect(roborockService['iotApi']!.startScene).toHaveBeenCalledWith(99);
+  });
+
+  it('should warn when multiple routines are selected', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+    ];
+    const supportedRoutines: ServiceArea.Area[] = [
+      { areaId: 99, mapId: null, areaInfo: {} as any },
+      { areaId: 100, mapId: null, areaInfo: {} as any },
+    ];
+    const selectedAreas = [99, 100];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['supportedRoutines'].set(duid, supportedRoutines);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.warn).toHaveBeenCalledWith('RoborockService - Multiple routines selected, which is not supported.', expect.anything());
+  });
+
+  it('should start global clean if all selected rooms match supportedRooms even with routines defined', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+    ];
+    const supportedRoutines: ServiceArea.Area[] = [{ areaId: 99, mapId: null, areaInfo: {} as any }];
+    const selectedAreas = [1, 2];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['supportedRoutines'].set(duid, supportedRoutines);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startGlobalClean');
+    expect(mockMessageProcessor.startClean).toHaveBeenCalledWith(duid);
+  });
+
+  it('should start room clean if only rooms are selected and not all rooms', async () => {
+    const duid = 'test-duid';
+    const supportedAreas: ServiceArea.Area[] = [
+      { areaId: 1, mapId: null, areaInfo: {} as any },
+      { areaId: 2, mapId: null, areaInfo: {} as any },
+      { areaId: 3, mapId: null, areaInfo: {} as any },
+    ];
+    const supportedRoutines: ServiceArea.Area[] = [{ areaId: 99, mapId: null, areaInfo: {} as any }];
+    const selectedAreas = [1, 3];
+
+    roborockService['supportedAreas'].set(duid, supportedAreas);
+    roborockService['supportedRoutines'].set(duid, supportedRoutines);
+    roborockService['selectedAreas'].set(duid, selectedAreas);
+
+    await roborockService.startClean(duid);
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - startRoomClean', expect.anything());
+    expect(mockMessageProcessor.startRoomClean).toHaveBeenCalledWith(duid, [1, 3], 1);
+  });
+
+  it('should initialize and store MessageProcessor for the given duid', () => {
+    const duid = 'test-duid';
+    roborockService.initializeMessageClientForLocal({ duid } as Device);
+    const storedProcessor = roborockService['messageProcessorMap'].get(duid);
+    expect(storedProcessor).not.toBeUndefined();
+  });
+});
+
+describe('RoborockService - basic setters/getters', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+  });
+
+  it('setSelectedAreas should set selected areas', () => {
+    roborockService.setSupportedAreaIndexMap(
+      'duid',
+      new RoomIndexMap(
+        new Map([
+          [1, { roomId: 1, mapId: 0 }],
+          [2, { roomId: 2, mapId: 1 }],
+        ]),
+      ),
+    );
+    roborockService.setSelectedAreas('duid', [1, 2]);
+
+    expect(roborockService['selectedAreas'].get('duid')).toEqual([1, 2]);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - setSelectedAreas', [1, 2]);
+  });
+
+  it('setSupportedAreas should set supported areas', () => {
+    const areas = [{ areaId: 1, mapId: null, areaInfo: {} as any }];
+    roborockService.setSupportedAreas('duid', areas);
+    expect(roborockService['supportedAreas'].get('duid')).toEqual(areas);
+  });
+
+  it('setSupportedScenes should set supported routines', () => {
+    const routines = [{ areaId: 99, mapId: null, areaInfo: {} as any }];
+    roborockService.setSupportedScenes('duid', routines);
+    expect(roborockService['supportedRoutines'].get('duid')).toEqual(routines);
+  });
+
+  it('getSupportedAreas should return supported areas', () => {
+    const areas = [{ areaId: 1, mapId: null, areaInfo: {} as any }];
+    roborockService['supportedAreas'].set('duid', areas);
+    expect(roborockService.getSupportedAreas('duid')).toEqual(areas);
+  });
+});
+
+describe('RoborockService - getMessageProcessor', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { startClean: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+  });
+
+  it('should return processor if present', () => {
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+    expect(roborockService.getMessageProcessor('duid')).toBe(mockMessageProcessor);
+  });
+
+  it('should log error if processor not present', () => {
+    expect(roborockService.getMessageProcessor('unknown')).toBeUndefined();
+    expect(mockLogger.error).toHaveBeenCalledWith('MessageApi is not initialized.');
+  });
+});
+
+describe('RoborockService - getCleanModeData', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { getCleanModeData: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('should return clean mode data', async () => {
+    mockMessageProcessor.getCleanModeData.mockResolvedValue({ suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    const result = await roborockService.getCleanModeData('duid');
+    expect(result).toEqual({ suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    expect(mockLogger.notice).toHaveBeenCalledWith('RoborockService - getCleanModeData');
+  });
+});
+
+describe('RoborockService - changeCleanMode', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = { changeCleanMode: jest.fn() } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('should call changeCleanMode on processor', async () => {
+    await roborockService.changeCleanMode('duid', { suctionPower: 1, waterFlow: 2, distance_off: 3, mopRoute: 4 });
+    expect(mockLogger.notice).toHaveBeenCalledWith('RoborockService - changeCleanMode');
+    expect(mockMessageProcessor.changeCleanMode).toHaveBeenCalledWith('duid', 1, 2, 4, 3);
+  });
+});
+
+describe('RoborockService - pause/stop/resume/playSound', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = {
+      pauseClean: jest.fn(),
+      gotoDock: jest.fn(),
+      resumeClean: jest.fn(),
+      findMyRobot: jest.fn(),
+    } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('pauseClean should call processor and log', async () => {
+    await roborockService.pauseClean('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - pauseClean');
+    expect(mockMessageProcessor.pauseClean).toHaveBeenCalledWith('duid');
+  });
+
+  it('stopAndGoHome should call processor and log', async () => {
+    await roborockService.stopAndGoHome('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - stopAndGoHome');
+    expect(mockMessageProcessor.gotoDock).toHaveBeenCalledWith('duid');
+  });
+
+  it('resumeClean should call processor and log', async () => {
+    await roborockService.resumeClean('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - resumeClean');
+    expect(mockMessageProcessor.resumeClean).toHaveBeenCalledWith('duid');
+  });
+
+  it('playSoundToLocate should call processor and log', async () => {
+    await roborockService.playSoundToLocate('duid');
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - findMe');
+    expect(mockMessageProcessor.findMyRobot).toHaveBeenCalledWith('duid');
+  });
+});
+
+describe('RoborockService - customGet/customGetInSecure/customSend', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageProcessor = {
+      getCustomMessage: jest.fn(),
+      sendCustomMessage: jest.fn(),
+    } as any;
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService['messageProcessorMap'].set('duid', mockMessageProcessor);
+  });
+
+  it('customGet should call getCustomMessage', async () => {
+    mockMessageProcessor.getCustomMessage.mockResolvedValue('result');
+    const result = await roborockService.customGet('duid', { method: 'method', params: undefined, secure: true } as RequestMessage);
+    expect(mockLogger.debug).toHaveBeenCalledWith('RoborockService - customSend-message', 'method', undefined, true);
+    expect(mockMessageProcessor.getCustomMessage).toHaveBeenCalledWith('duid', expect.any(Object));
+    expect(result).toBe('result');
+  });
+
+  it('customSend should call sendCustomMessage', async () => {
+    const req = { foo: 'bar' } as any;
+    await roborockService.customSend('duid', req);
+    expect(mockMessageProcessor.sendCustomMessage).toHaveBeenCalledWith('duid', req);
+  });
+});
+
+describe('RoborockService - stopService', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageClient: any;
+  let mockLocalClient: any;
+  let mockMessageProcessor: any;
+
+  beforeEach(() => {
+    mockLogger = { debug: jest.fn(), notice: jest.fn(), error: jest.fn(), warn: jest.fn() } as any;
+    mockMessageClient = { disconnect: jest.fn() };
+    mockLocalClient = { disconnect: jest.fn(), isConnected: jest.fn() };
+    mockMessageProcessor = {};
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, mockLogger);
+    roborockService.messageClient = mockMessageClient;
+    roborockService.localClientMap.set('duid', mockLocalClient);
+    roborockService.messageProcessorMap.set('duid', mockMessageProcessor);
+    roborockService.requestDeviceStatusInterval = setInterval(() => {
+      jest.fn();
+    }, 1000);
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  it('should disconnect messageClient, localClient, remove processors, clear interval', () => {
+    roborockService.stopService();
+    expect(mockMessageClient.disconnect).toHaveBeenCalled();
+    expect(mockLocalClient.disconnect).toHaveBeenCalled();
+    expect(roborockService.localClientMap.size).toBe(0);
+    expect(roborockService.messageProcessorMap.size).toBe(0);
+    expect(roborockService.requestDeviceStatusInterval).toBeUndefined();
+  });
+});
+
+describe('RoborockService - setDeviceNotify', () => {
+  it('should set deviceNotify callback', () => {
+    const roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, {} as any);
+    const cb = jest.fn();
+    roborockService.setDeviceNotify(cb);
+    expect(roborockService.deviceNotify).toBe(cb);
+  });
+});
+
+describe('RoborockService - sleep', () => {
+  it('should resolve after ms', async () => {
+    const roborockService = new RoborockService(jest.fn(), jest.fn(), 10, {} as any, {} as any);
+    const start = Date.now();
+    await roborockService['sleep'](100);
+    expect(Date.now() - start).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('RoborockService - auth', () => {
+  it('should set userdata and iotApi', () => {
+    const mockLogger = {} as any;
+    const mockIotApiFactory = jest.fn().mockReturnValue('iotApi');
+    const roborockService = new RoborockService(jest.fn(), mockIotApiFactory, 10, {} as any, mockLogger);
+    const userData = { foo: 'bar' } as any;
+    const result = roborockService['auth'](userData);
+    expect(roborockService['userdata']).toBe(userData);
+    expect(roborockService['iotApi']).toBe('iotApi');
+    expect(result).toBe(userData);
+  });
+});

package/src/tests/roborockService2.test.ts

@@ -0,0 +1,69 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import RoborockService from '../roborockService';
+import { MessageProcessor } from '../roborockCommunication/broadcast/messageProcessor';
+import { Device, DeviceStatus } from '../roborockCommunication';
+
+jest.useFakeTimers();
+
+describe('RoborockService - activateDeviceNotify', () => {
+  let roborockService: RoborockService;
+  let mockLogger: AnsiLogger;
+  let mockMessageProcessor: jest.Mocked<MessageProcessor>;
+  let mockDeviceNotify: jest.Mock;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: jest.fn(),
+      notice: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+    } as any;
+
+    mockMessageProcessor = {
+      getDeviceStatus: jest.fn(),
+    } as any;
+
+    mockDeviceNotify = jest.fn(() => {
+      jest.fn();
+    });
+
+    roborockService = new RoborockService(jest.fn(), jest.fn(), 1, {} as any, mockLogger); // refreshInterval = 1
+    roborockService['deviceNotify'] = mockDeviceNotify;
+    roborockService['getMessageProcessor'] = jest.fn().mockReturnValue(mockMessageProcessor);
+    roborockService['refreshInterval'] = 1;
+  });
+
+  it('should call getDeviceStatus periodically and notify with status message', async () => {
+    const duid = 'test-duid';
+    const device: Device = { duid } as Device;
+
+    const fakeStatus: DeviceStatus = {
+      errorStatus: { errorCode: 0 },
+      message: { battery: 80 },
+    } as any;
+
+    (roborockService['getMessageProcessor'] as jest.Mock).mockReturnValue(mockMessageProcessor);
+    mockMessageProcessor.getDeviceStatus.mockResolvedValue(fakeStatus);
+
+    await roborockService.activateDeviceNotify(device);
+
+    jest.advanceTimersByTime(2000); // 1s = 1 cycle
+
+    expect(mockLogger.debug).toHaveBeenCalledWith('Requesting device info for device', duid);
+    expect(mockMessageProcessor.getDeviceStatus).toHaveBeenCalledWith(duid);
+  });
+
+  it('should log error if message processor is not found', async () => {
+    const duid = 'not-found-duid';
+    const device: Device = { duid } as Device;
+
+    (roborockService['getMessageProcessor'] as jest.Mock).mockReturnValue(undefined);
+
+    await roborockService.activateDeviceNotify(device);
+
+    jest.advanceTimersByTime(1000); // trigger the interval
+
+    expect(mockLogger.error).toHaveBeenCalledWith('Local client not initialized');
+    expect(mockDeviceNotify).not.toHaveBeenCalled();
+  });
+});