matterbridge-roborock-vacuum-plugin 1.1.0-rc13 → 1.1.0-rc15

package/src/helper.ts

@@ -1,4 +1,8 @@
+import { debugStringify } from 'matterbridge/logger';
+import { RoomMap } from './model/RoomMap.js';
+import { RoborockMatterbridgePlatform } from './platform.js';
 import { Device } from './roborockCommunication/index.js';
+import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
 
 export function getVacuumProperty(device: Device, property: string): number | undefined {
   if (device) {
@@ -20,3 +24,82 @@ export function getVacuumProperty(device: Device, property: string): number | un
 export function isSupportedDevice(model: string): boolean {
   return model.startsWith('roborock.vacuum.');
 }
+
+export function isStatusUpdate(result: unknown): boolean {
+  return (
+    Array.isArray(result) &&
+    result.length > 0 &&
+    typeof result[0] === 'object' &&
+    result[0] !== null &&
+    'msg_ver' in result[0] &&
+    (result[0] as CloudMessageResult).msg_ver !== undefined &&
+    (result[0] as CloudMessageResult).msg_ver !== null
+  );
+}
+
+export async function getRoomMap(duid: string, platform: RoborockMatterbridgePlatform): Promise<RoomMap | undefined> {
+  const robot = platform.robots.get(duid);
+  if (robot === undefined) {
+    platform.log.error(`Error6: Robot with DUID ${duid} not found`);
+    return undefined;
+  }
+
+  if (platform.roborockService === undefined) return undefined;
+
+  const rooms = robot.device.rooms ?? [];
+  // if (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
+  if (robot.roomInfo === undefined) {
+    const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      robot.roomInfo = new RoomMap(roomData ?? [], rooms);
+      return robot.roomInfo;
+    }
+  }
+
+  if (robot.roomInfo === undefined) {
+    const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
+    if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
+      platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
+
+      const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
+      robot.roomInfo = new RoomMap(roomDataMap, rooms);
+    }
+  }
+
+  return robot.roomInfo;
+}
+
+export async function getRoomMapFromDevice(device: Device, platform: RoborockMatterbridgePlatform): Promise<RoomMap> {
+  const rooms = device?.rooms ?? [];
+
+  platform.log.notice('-------------------------------------------0--------------------------------------------------------');
+  platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
+
+  if (device && platform.roborockService) {
+    const roomData = await platform.roborockService.getRoomMappings(device.duid);
+    if (roomData !== undefined && roomData.length > 0) {
+      platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
+
+      const roomMap = new RoomMap(roomData ?? [], rooms);
+
+      platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+      platform.log.notice('-------------------------------------------1--------------------------------------------------------');
+      return roomMap;
+    }
+
+    const mapInfo = await platform.roborockService.getMapInformation(device.duid);
+    platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
+
+    if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
+      const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
+
+      const roomMap = new RoomMap(roomDataMap, rooms);
+
+      platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
+      platform.log.notice('-------------------------------------------2--------------------------------------------------------');
+      return roomMap;
+    }
+  }
+
+  return new RoomMap([], rooms);
+}

package/src/initialData/getSupportedAreas.ts

@@ -1,6 +1,6 @@
 import { AnsiLogger, debugStringify } from 'matterbridge/logger';
 import { ServiceArea } from 'matterbridge/matter/clusters';
-import RoomMap from '../model/RoomMap.js';
+import { RoomMap } from '../model/RoomMap.js';
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 import { randomInt } from 'node:crypto';
 

package/src/model/RoomMap.ts

@@ -17,7 +17,7 @@ roomMap = {
 
 import { Room } from '../roborockCommunication/Zmodel/room.js';
 
-export default class RoomMap {
+export class RoomMap {
   readonly rooms: {
     id: number;
     globalId: number | undefined;

package/src/platform.ts

@@ -4,7 +4,7 @@ import { AnsiLogger, debugStringify, LogLevel } from 'matterbridge/logger';
 import RoborockService from './roborockService.js';
 import { PLUGIN_NAME } from './settings.js';
 import ClientManager from './clientManager.js';
-import { isSupportedDevice } from './helper.js';
+import { getRoomMapFromDevice, isSupportedDevice } from './helper.js';
 import { PlatformRunner } from './platformRunner.js';
 import { RoborockVacuumCleaner } from './rvc.js';
 import { configurateBehavior } from './behaviorFactory.js';
@@ -33,9 +33,9 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
     super(matterbridge, log, config);
 
     // Verify that Matterbridge is the correct version
-    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.6')) {
+    if (this.verifyMatterbridgeVersion === undefined || typeof this.verifyMatterbridgeVersion !== 'function' || !this.verifyMatterbridgeVersion('3.1.7')) {
       throw new Error(
-        `This plugin requires Matterbridge version >= "3.1.6". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`,
+        `This plugin requires Matterbridge version >= "3.1.7". Please update Matterbridge from ${this.matterbridge.matterbridgeVersion} to the latest version in the frontend.`,
       );
     }
     this.log.info('Initializing platform:', this.config.name);
@@ -231,7 +231,7 @@ export class RoborockMatterbridgePlatform extends MatterbridgeDynamicPlatform {
       vacuum.rooms = rooms.map((room) => ({ id: room.id, name: room.displayName }) as Room);
     }
 
-    const roomMap = await this.platformRunner.getRoomMapFromDevice(vacuum);
+    const roomMap = await getRoomMapFromDevice(vacuum, this);
 
     this.log.debug('Initializing - roomMap: ', debugStringify(roomMap));
 

package/src/platformRunner.ts

@@ -1,10 +1,9 @@
 import { RvcRunMode, PowerSource, ServiceArea, RvcOperationalState, RvcCleanMode } from 'matterbridge/matter/clusters';
-import { getVacuumProperty } from './helper.js';
+import { getRoomMap, getVacuumProperty, isStatusUpdate } from './helper.js';
 import { getRunningMode } from './initialData/getSupportedRunModes.js';
 import { CloudMessageModel } from './model/CloudMessageModel.js';
 import { RoborockMatterbridgePlatform } from './platform.js';
 import { state_to_matter_operational_status, state_to_matter_state } from './share/function.js';
-import RoomMap from './model/RoomMap.js';
 import { getBatteryState, getBatteryStatus, getOperationalErrorState } from './initialData/index.js';
 import { NotifyMessageTypes } from './notifyMessageTypes.js';
 import { CloudMessageResult } from './roborockCommunication/Zmodel/messageResult.js';
@@ -41,76 +40,6 @@ export class PlatformRunner {
     await this.updateRobot(NotifyMessageTypes.HomeData, homeData);
   }
 
-  public async getRoomMapFromDevice(device: Device): Promise<RoomMap> {
-    const platform = this.platform;
-    const rooms = device?.rooms ?? [];
-
-    platform.log.notice('-------------------------------------------0--------------------------------------------------------');
-    platform.log.notice(`getRoomMapFromDevice: ${debugStringify(rooms)}`);
-
-    if (device && platform.roborockService) {
-      const roomData = await platform.roborockService.getRoomMappings(device.duid);
-      if (roomData !== undefined && roomData.length > 0) {
-        platform.log.notice(`getRoomMapFromDevice - roomData: ${debugStringify(roomData ?? [])}`);
-
-        const roomMap = new RoomMap(roomData ?? [], rooms);
-
-        platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-        platform.log.notice('-------------------------------------------1--------------------------------------------------------');
-        return roomMap;
-      }
-
-      const mapInfo = await platform.roborockService.getMapInformation(device.duid);
-      platform.log.notice(`getRoomMapFromDevice - mapInfo: ${mapInfo ? debugStringify(mapInfo) : 'undefined'}`);
-
-      if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-        const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
-
-        const roomMap = new RoomMap(roomDataMap, rooms);
-
-        platform.log.notice(`getRoomMapFromDevice - roomMap: ${debugStringify(roomMap)}`);
-        platform.log.notice('-------------------------------------------2--------------------------------------------------------');
-        return roomMap;
-      }
-    }
-
-    return new RoomMap([], rooms);
-  }
-
-  private async getRoomMap(duid: string): Promise<RoomMap | undefined> {
-    const platform = this.platform;
-
-    const robot = platform.robots.get(duid);
-    if (robot === undefined) {
-      platform.log.error(`Error6: Robot with DUID ${duid} not found`);
-      return undefined;
-    }
-
-    if (platform.roborockService === undefined) return undefined;
-
-    const rooms = robot.device.rooms ?? [];
-    // if (platform.robot?.device === undefined || platform.roborockService === undefined) return undefined;
-    if (robot.roomInfo === undefined) {
-      const roomData = await platform.roborockService.getRoomMappings(robot.device.duid);
-      if (roomData !== undefined && roomData.length > 0) {
-        robot.roomInfo = new RoomMap(roomData ?? [], rooms);
-        return robot.roomInfo;
-      }
-    }
-
-    if (robot.roomInfo === undefined) {
-      const mapInfo = await platform.roborockService.getMapInformation(robot.device.duid);
-      if (mapInfo && mapInfo.maps && mapInfo.maps.length > 0) {
-        platform.log.error(`getRoomMap - mapInfo: ${debugStringify(mapInfo.maps)}`);
-
-        const roomDataMap = mapInfo.maps[0].rooms.map((r) => [r.id, parseInt(r.iot_name_id), r.tag] as [number, number, number]);
-        robot.roomInfo = new RoomMap(roomDataMap, rooms);
-      }
-    }
-
-    return robot.roomInfo;
-  }
-
   private async updateFromMQTTMessage(messageSource: NotifyMessageTypes, messageData: unknown, duid = '', tracked = false): Promise<void> {
     const platform = this.platform;
     duid = duid || (messageData as DeviceStatusNotify)?.duid || '';
@@ -191,7 +120,7 @@ export class PlatformRunner {
             robot.updateAttribute(ServiceArea.Cluster.id, 'selectedAreas', [], platform.log);
           } else {
             const currentMappedAreas = this.platform.roborockService?.getSupportedAreas(duid);
-            const roomMap = await this.getRoomMap(duid);
+            const roomMap = await getRoomMap(duid, this.platform);
 
             // Get current room from segment_id
             const segment_id = data.cleaning_info?.segment_id ?? -1;
@@ -311,7 +240,7 @@ export class PlatformRunner {
         case Protocol.rpc_response: {
           const response = data.dps[messageType] as DpsPayload;
           // ignore network info
-          if (!self.isStatusUpdate(response.result)) {
+          if (!isStatusUpdate(response.result)) {
             platform.log.debug('Ignore message:', debugStringify(data));
             return;
           }
@@ -398,18 +327,6 @@ export class PlatformRunner {
     return undefined;
   }
 
-  private isStatusUpdate(result: unknown): boolean {
-    return (
-      Array.isArray(result) &&
-      result.length > 0 &&
-      typeof result[0] === 'object' &&
-      result[0] !== null &&
-      'msg_ver' in result[0] &&
-      (result[0] as CloudMessageResult).msg_ver !== undefined &&
-      (result[0] as CloudMessageResult).msg_ver !== null
-    );
-  }
-
   private updateFromHomeData(homeData: Home): void {
     const platform = this.platform;
 

package/src/roborockCommunication/broadcast/client/LocalNetworkClient.ts

@@ -16,6 +16,7 @@ export class LocalNetworkClient extends AbstractClient {
   private buffer: ChunkBuffer = new ChunkBuffer();
   private messageIdSeq: Sequence;
   private pingInterval?: NodeJS.Timeout;
+  private keepConnectionAliveInterval: NodeJS.Timeout | undefined = undefined;
   duid: string;
   ip: string;
 
@@ -45,6 +46,8 @@ export class LocalNetworkClient extends AbstractClient {
     // Data event listener
     this.socket.on('data', this.onMessage.bind(this));
     this.socket.connect(58867, this.ip);
+
+    this.keepConnectionAlive();
   }
 
   public async disconnect(): Promise<void> {
@@ -75,8 +78,8 @@ export class LocalNetworkClient extends AbstractClient {
   }
 
   private async onConnect(): Promise<void> {
-    this.logger.debug(`LocalNetworkClient: ${this.duid} connected to ${this.ip}`);
-    this.logger.debug(`LocalNetworkClient: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
+    this.logger.debug(` [LocalNetworkClient]: ${this.duid} connected to ${this.ip}`);
+    this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket writable: ${this.socket?.writable}, readable: ${this.socket?.readable}`);
     this.connected = true;
     this.retryCount = 0;
 
@@ -85,25 +88,8 @@ export class LocalNetworkClient extends AbstractClient {
     await this.connectionListeners.onConnected(this.duid);
   }
 
-  private async onEnd(): Promise<void> {
-    await this.destroySocket('Socket has ended.');
-    await this.connectionListeners.onDisconnected(this.duid, 'Socket has ended.');
-  }
-
   private async onDisconnect(hadError: boolean): Promise<void> {
-    await this.destroySocket(`Socket disconnected. Had error: ${hadError}`);
-
-    if (!hadError) {
-      await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
-    }
-  }
-
-  private async onTimeout(): Promise<void> {
-    this.logger.error(`LocalNetworkClient: Socket for ${this.duid} timed out.`);
-  }
-
-  private async destroySocket(message: string): Promise<void> {
-    this.logger.error(`LocalNetworkClient: Destroying socket for ${this.duid} due to: ${message}`);
+    this.logger.info(` [LocalNetworkClient]: ${this.duid} socket disconnected. Had error: ${hadError}`);
     this.connected = false;
 
     if (this.socket) {
@@ -113,22 +99,20 @@ export class LocalNetworkClient extends AbstractClient {
     if (this.pingInterval) {
       clearInterval(this.pingInterval);
     }
+    await this.connectionListeners.onDisconnected(this.duid, 'Socket disconnected. Had no error.');
   }
 
   private async onError(error: Error): Promise<void> {
-    this.logger.error('LocalNetworkClient: Socket connection error: ' + error.message);
-    this.connected = false;
-
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = undefined;
-    }
+    this.logger.error(` [LocalNetworkClient]: Socket error for ${this.duid}: ${error.message}`);
+    await this.connectionListeners.onError(this.duid, error.message);
+  }
 
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-    }
+  private async onTimeout(): Promise<void> {
+    this.logger.error(` [LocalNetworkClient]: Socket for ${this.duid} timed out.`);
+  }
 
-    await this.connectionListeners.onError(this.duid, error.message);
+  private async onEnd(): Promise<void> {
+    this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket ended.`);
   }
 
   private async onMessage(message: Buffer): Promise<void> {
@@ -212,4 +196,21 @@ export class LocalNetworkClient extends AbstractClient {
     });
     await this.send(this.duid, request);
   }
+
+  private keepConnectionAlive(): void {
+    if (this.keepConnectionAliveInterval) {
+      clearTimeout(this.keepConnectionAliveInterval);
+      this.keepConnectionAliveInterval.unref();
+    }
+
+    this.keepConnectionAliveInterval = setInterval(
+      () => {
+        if (this.socket === undefined || !this.connected || !this.socket.writable || this.socket.readable) {
+          this.logger.debug(` [LocalNetworkClient]: ${this.duid} socket is not writable or readable, reconnecting...`);
+          this.connect();
+        }
+      },
+      60 * 60 * 1000,
+    );
+  }
 }

package/src/roborockCommunication/broadcast/client/MQTTClient.ts

@@ -36,8 +36,8 @@ export class MQTTClient extends AbstractClient {
       username: this.mqttUsername,
       password: this.mqttPassword,
       keepalive: 30,
-      log: (...args: unknown[]) => {
-        this.logger.debug(`MQTTClient args: ${debugStringify(args)}`);
+      log: () => {
+        // ...args: unknown[] this.logger.debug(`MQTTClient args: ${debugStringify(args)}`);
       },
     });
 

package/src/roborockCommunication/broadcast/clientRouter.ts

@@ -15,9 +15,9 @@ export class ClientRouter implements Client {
   protected readonly messageListeners = new ChainedMessageListener();
 
   private readonly context: MessageContext;
-  private readonly mqttClient: MQTTClient;
   private readonly localClients = new Map<string, LocalNetworkClient>();
   private readonly logger: AnsiLogger;
+  private mqttClient: MQTTClient;
 
   public constructor(logger: AnsiLogger, userdata: UserData) {
     this.context = new MessageContext(userdata);

package/src/roborockCommunication/broadcast/listener/implementation/connectionStateListener.ts

@@ -43,11 +43,10 @@ export class ConnectionStateListener implements AbstractConnectionListener {
       return;
     }
 
-    this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
-
     setTimeout(() => {
+      this.logger.info(`Re-registering device with DUID ${duid} to ${this.clientName}`);
       this.client.connect();
-    }, 3000);
+    }, 10000);
 
     this.client.isInDisconnectingStep = false;
   }

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

@@ -28,10 +28,10 @@ export class SyncMessageListener implements AbstractMessageListener {
       const messageId = dps.id;
 
       const responseHandler = this.pending.get(messageId);
-      const result = dps.result as Record<string, unknown>;
-      if (result && result.length == 1 && result[0] == 'ok') {
-        return;
-      }
+      // const result = dps.result as Record<string, unknown>;
+      // if (result && result.length == 1 && result[0] == 'ok') {
+      //   return;
+      // }
 
       if (responseHandler) {
         responseHandler(dps.result as ResponseMessage);

package/src/roborockCommunication/broadcast/messageProcessor.ts

@@ -34,11 +34,6 @@ export class MessageProcessor {
     return await this.client.get(duid, request);
   }
 
-  // public async getDeviceStatus(duid: string): Promise<DeviceStatus> {
-  //   const request = new RequestMessage({ method: 'get_status' });
-  //   return this.client.get<CloudMessageResult[]>(duid, request).then((response) => new DeviceStatus(response[0]));
-  // }
-
   public async getDeviceStatus(duid: string): Promise<DeviceStatus | undefined> {
     const request = new RequestMessage({ method: 'get_status' });
     const response = await this.client.get<CloudMessageResult[]>(duid, request);
@@ -51,6 +46,18 @@ export class MessageProcessor {
     return undefined;
   }
 
+  public async getDeviceStatusOverMQTT(duid: string): Promise<DeviceStatus | undefined> {
+    const request = new RequestMessage({ method: 'get_status', secure: true });
+    const response = await this.client.get<CloudMessageResult[]>(duid, request);
+
+    if (response) {
+      this.logger?.debug('MQTT - Device status: ', debugStringify(response));
+      return new DeviceStatus(response);
+    }
+
+    return undefined;
+  }
+
   public async getRooms(duid: string, rooms: Room[]): Promise<RoomInfo> {
     const request = new RequestMessage({ method: 'get_room_mapping' });
     return this.client.get<number[][] | undefined>(duid, request).then((response) => new RoomInfo(rooms, response ?? []));
@@ -98,9 +105,9 @@ export class MessageProcessor {
     return this.client.get(duid, def);
   }
 
-  public async findMyRobot(duid: string): Promise<void> {
+  public async findMyRobot(duid: string): Promise<unknown> {
     const request = new RequestMessage({ method: 'find_me' });
-    return this.client.send(duid, request);
+    return this.client.get(duid, request);
   }
 
   public async getCleanModeData(duid: string): Promise<{ suctionPower: number; waterFlow: number; distance_off: number; mopRoute: number }> {

package/src/roborockCommunication/broadcast/model/protocol.ts

@@ -12,8 +12,17 @@ export enum Protocol {
   battery = 122,
   suction_power = 123,
   water_box_mode = 124,
+  main_brush_work_time = 125,
+  side_brush_work_time = 126,
+  filter_work_time = 127,
   additional_props = 128,
+  task_complete = 130,
+  task_cancel_low_power = 131,
+  task_cancel_in_motion = 132,
+  charge_status = 133,
+  drying_status = 134,
   back_type = 139, // WTF is this
   map_response = 301,
+  some_thing_happened_when_socket_closed = 500,
 }
 // "deviceStatus":{"120":0,"121":8,"122":100,"123":110,"124":209,"125":99,"126":96,"127":97,"128":0,"133":1,"134":1,"135":0,"139":0}

package/src/roborockService.ts

@@ -274,7 +274,7 @@ export default class RoborockService {
         await messageProcessor.getDeviceStatus(device.duid).then((response: DeviceStatus | undefined) => {
           if (self.deviceNotify && response) {
             const message = { duid: device.duid, ...response.errorStatus, ...response.message } as DeviceStatusNotify;
-            self.logger.debug('Device status update', debugStringify(message));
+            self.logger.debug('Socket - Device status update', debugStringify(message));
             self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
           }
         });
@@ -284,6 +284,26 @@ export default class RoborockService {
     }, this.refreshInterval * 1000);
   }
 
+  public activateDeviceNotifyOverMQTT(device: Device): void {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    this.logger.notice('Requesting device info for device over MQTT', device.duid);
+    const messageProcessor = this.getMessageProcessor(device.duid);
+    this.requestDeviceStatusInterval = setInterval(async () => {
+      if (messageProcessor) {
+        await messageProcessor.getDeviceStatusOverMQTT(device.duid).then((response: DeviceStatus | undefined) => {
+          if (self.deviceNotify && response) {
+            const message = { duid: device.duid, ...response.errorStatus, ...response.message } as DeviceStatusNotify;
+            self.logger.debug('MQTT - Device status update', debugStringify(message));
+            self.deviceNotify(NotifyMessageTypes.LocalMessage, message);
+          }
+        });
+      } else {
+        self.logger.error('Local client not initialized');
+      }
+    }, this.refreshInterval * 500);
+  }
+
   public async listDevices(username: string): Promise<Device[]> {
     assert(this.iotApi !== undefined);
     assert(this.userdata !== undefined);

package/src/rvc.ts

@@ -1,5 +1,5 @@
 import { RoboticVacuumCleaner } from 'matterbridge/devices';
-import RoomMap from './model/RoomMap.js';
+import { RoomMap } from './model/RoomMap.js';
 import { Device } from './roborockCommunication/index.js';
 import { getOperationalStates, getSupportedAreas, getSupportedCleanModes, getSupportedRunModes } from './initialData/index.js';
 import { AnsiLogger } from 'matterbridge/logger';

package/src/tests/platformRunner2.test.ts

@@ -1,11 +1,9 @@
-import RoomMap from '../model/RoomMap';
-import { RoborockMatterbridgePlatform } from '../platform';
-import { PlatformRunner } from '../platformRunner';
+import { getRoomMapFromDevice } from '../helper';
+import { RoomMap } from '../model/RoomMap';
 import { MapInfo } from '../roborockCommunication';
 
 describe('PlatformRunner.getRoomMapFromDevice', () => {
   let platform: any;
-  let runner: PlatformRunner;
 
   beforeEach(() => {
     platform = {
@@ -19,7 +17,6 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
         getMapInformation: jest.fn(),
       },
     };
-    runner = new PlatformRunner(platform as RoborockMatterbridgePlatform);
   });
 
   it('returns RoomMap with roomData from getRoomMappings if available', async () => {
@@ -42,7 +39,7 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
     platform.roborockService.getRoomMappings.mockResolvedValue(roomData);
     platform.roborockService.getMapInformation.mockResolvedValue(undefined);
 
-    const result = await runner.getRoomMapFromDevice(device as any);
+    const result = await getRoomMapFromDevice(device as any, platform);
 
     expect(result).toBeInstanceOf(RoomMap);
     expect(result.rooms.length).toEqual(4);
@@ -83,7 +80,7 @@ describe('PlatformRunner.getRoomMapFromDevice', () => {
     platform.roborockService.getRoomMappings.mockResolvedValue(undefined);
     platform.roborockService.getMapInformation.mockResolvedValue(mapInfo);
 
-    const result = await runner.getRoomMapFromDevice(device as any);
+    const result = await getRoomMapFromDevice(device as any, platform);
 
     expect(result).toBeInstanceOf(RoomMap);
     expect(result.rooms.length).toEqual(4);