matterbridge-roborock-vacuum-plugin 1.0.8-rc09 → 1.1.0-rc02

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

@@ -0,0 +1,333 @@
+import { MQTTClient } from '../../../../roborockCommunication/broadcast/client/MQTTClient';
+
+// Pseudocode plan:
+// 1. Mock dependencies: mqtt, CryptoUtils, AbstractClient, serializer, deserializer, logger, connectionListeners, messageListeners.
+// 2. Test constructor: verify username/password are generated as expected.
+// 3. Test connect():
+//    - Should call mqtt.connect with correct params.
+//    - Should set up event listeners.
+//    - Should not connect if already connected.
+// 4. Test disconnect():
+//    - Should call client.end if connected.
+//    - Should not call if not connected.
+//    - Should log error if exception thrown.
+// 5. Test send():
+//    - Should publish correct topic/message if connected.
+//    - Should log error if not connected.
+// 6. Test onConnect():
+//    - Should set connected, call onConnected, subscribeToQueue.
+// 7. Test subscribeToQueue():
+//    - Should call client.subscribe with correct topic.
+// 8. Test onSubscribe():
+//    - Should log error and call onDisconnected if error.
+//    - Should do nothing if no error.
+// 9. Test onDisconnect():
+//    - Should call onDisconnected.
+// 10. Test onError():
+//    - Should log error, set connected false, call onError.
+// 11. Test onReconnect():
+//    - Should call subscribeToQueue.
+// 12. Test onMessage():
+//    - Should call deserializer and messageListeners.onMessage if message.
+//    - Should log notice if message is falsy.
+//    - Should log error if deserializer throws.
+
+const mockConnect = jest.fn();
+jest.mock('mqtt', () => {
+  const actual = jest.requireActual('mqtt');
+  return {
+    ...actual,
+    connect: mockConnect,
+  };
+});
+
+describe('MQTTClient', () => {
+  let logger: any;
+  let context: any;
+  let userdata: any;
+  let client: any;
+  let serializer: any;
+  let deserializer: any;
+  let connectionListeners: any;
+  let messageListeners: any;
+
+  beforeEach(() => {
+    logger = { error: jest.fn(), debug: jest.fn(), notice: jest.fn() };
+    context = {};
+    userdata = {
+      rriot: {
+        u: 'user',
+        k: 'key',
+        s: 'secret',
+        r: { m: 'mqtt://broker' },
+      },
+    };
+    serializer = { serialize: jest.fn(() => ({ buffer: Buffer.from('msg') })) };
+    deserializer = { deserialize: jest.fn(() => 'deserialized') };
+    connectionListeners = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+    };
+    messageListeners = { onMessage: jest.fn().mockResolvedValue(undefined) };
+
+    // Mock mqtt client instance
+    client = {
+      on: jest.fn(),
+      end: jest.fn(),
+      publish: jest.fn(),
+      subscribe: jest.fn(),
+    };
+    mockConnect.mockReturnValue(client);
+  });
+
+  function createMQTTClient() {
+    // Pass dependencies via constructor if possible, or use a factory/mockable subclass for testing
+    class TestMQTTClient extends MQTTClient {
+      constructor() {
+        super(logger, context, userdata);
+        (this as any).serializer = serializer;
+        (this as any).deserializer = deserializer;
+        (this as any).connectionListeners = connectionListeners;
+        (this as any).messageListeners = messageListeners;
+      }
+    }
+    return new TestMQTTClient();
+  }
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should generate username and password in constructor', () => {
+    const mqttClient = createMQTTClient();
+    expect(mqttClient['mqttUsername']).toBe('c6d6afb9');
+    expect(mqttClient['mqttPassword']).toBe('938f62d6603bde9c');
+  });
+
+  it('should not connect if already connected', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = client;
+    mqttClient.connect();
+    expect(mockConnect).not.toHaveBeenCalled();
+  });
+
+  it('should disconnect if connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = client;
+    mqttClient['connected'] = true;
+    await mqttClient.disconnect();
+    expect(client.end).toHaveBeenCalled();
+  });
+
+  it('should not disconnect if not connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = undefined;
+    mqttClient['connected'] = false;
+    await mqttClient.disconnect();
+    expect(client.end).not.toHaveBeenCalled();
+  });
+
+  it('should log error if disconnect throws', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = {
+      end: jest.fn(() => {
+        throw new Error('fail');
+      }),
+      on: jest.fn(),
+      publish: jest.fn(),
+      subscribe: jest.fn(),
+      connected: true,
+      disconnecting: false,
+      disconnected: false,
+      reconnecting: false,
+      options: {},
+      removeListener: jest.fn(),
+      removeAllListeners: jest.fn(),
+      addListener: jest.fn(),
+      emit: jest.fn(),
+      eventNames: jest.fn(),
+      getMaxListeners: jest.fn(),
+      listenerCount: jest.fn(),
+      listeners: jest.fn(),
+      off: jest.fn(),
+      once: jest.fn(),
+      prependListener: jest.fn(),
+      prependOnceListener: jest.fn(),
+      rawListeners: jest.fn(),
+      setMaxListeners: jest.fn(),
+      handleMessage: jest.fn(),
+      subscribeAsync: jest.fn(),
+      unsubscribe: jest.fn(),
+      unsubscribeAsync: jest.fn(),
+      publishAsync: jest.fn(),
+      reconnect: jest.fn(),
+      destroy: jest.fn(),
+      removeOutgoingMessage: jest.fn(),
+      connectedTime: 0,
+      disconnect: jest.fn(),
+      stream: {} as any,
+      messageIdToTopic: {},
+      outgoingStore: {} as any,
+      incomingStore: {} as any,
+      queueQoSZero: jest.fn(),
+      _resubscribeTopics: {},
+      _resubscribeTopicsList: [],
+      _resubscribeTopicsMap: {},
+      _resubscribeTopicsTimer: null,
+      _resubscribeTopicsTimeout: 0,
+      _resubscribeTopicsInProgress: false,
+      _resubscribeTopicsCallback: jest.fn(),
+      _resubscribeTopicsError: null,
+      _resubscribeTopicsErrorCallback: jest.fn(),
+      _resubscribeTopicsErrorTimer: null,
+      _resubscribeTopicsErrorTimeout: 0,
+      _resubscribeTopicsErrorInProgress: false,
+      _resubscribeTopicsErrorCallback2: jest.fn(),
+      _resubscribeTopicsError2: null,
+      _resubscribeTopicsErrorTimer2: null,
+      _resubscribeTopicsErrorTimeout2: 0,
+      _resubscribeTopicsErrorInProgress2: false,
+      _resubscribeTopicsErrorCallback3: jest.fn(),
+      _resubscribeTopicsError3: null,
+      _resubscribeTopicsErrorTimer3: null,
+      _resubscribeTopicsErrorTimeout3: 0,
+      _resubscribeTopicsErrorInProgress3: false,
+      _resubscribeTopicsErrorCallback4: jest.fn(),
+      _resubscribeTopicsError4: null,
+      _resubscribeTopicsErrorTimer4: null,
+      _resubscribeTopicsErrorTimeout4: 0,
+      _resubscribeTopicsErrorInProgress4: false,
+      _resubscribeTopicsErrorCallback5: jest.fn(),
+      _resubscribeTopicsError5: null,
+      _resubscribeTopicsErrorTimer5: null,
+      _resubscribeTopicsErrorTimeout5: 0,
+      _resubscribeTopicsErrorInProgress5: false,
+      _resubscribeTopicsErrorCallback6: jest.fn(),
+      _resubscribeTopicsError6: null,
+      _resubscribeTopicsErrorTimer6: null,
+      _resubscribeTopicsErrorTimeout6: 0,
+      _resubscribeTopicsErrorInProgress6: false,
+      _resubscribeTopicsErrorCallback7: jest.fn(),
+      _resubscribeTopicsError7: null,
+      _resubscribeTopicsErrorTimer7: null,
+      _resubscribeTopicsErrorTimeout7: 0,
+      _resubscribeTopicsErrorInProgress7: false,
+      _resubscribeTopicsErrorCallback8: jest.fn(),
+      _resubscribeTopicsError8: null,
+      _resubscribeTopicsErrorTimer8: null,
+      _resubscribeTopicsErrorTimeout8: 0,
+      _resubscribeTopicsErrorInProgress8: false,
+      _resubscribeTopicsErrorCallback9: jest.fn(),
+      _resubscribeTopicsError9: null,
+      _resubscribeTopicsErrorTimer9: null,
+      _resubscribeTopicsErrorTimeout9: 0,
+      _resubscribeTopicsErrorInProgress9: false,
+      _resubscribeTopicsErrorCallback10: jest.fn(),
+      _resubscribeTopicsError10: null,
+      _resubscribeTopicsErrorTimer10: null,
+      _resubscribeTopicsErrorTimeout10: 0,
+      _resubscribeTopicsErrorInProgress10: false,
+      // Add more properties as needed for your codebase or use a proper mock library
+    } as any;
+    mqttClient['connected'] = true;
+    await mqttClient.disconnect();
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('MQTT client failed to disconnect'));
+  });
+
+  it('should publish message if connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = client;
+    mqttClient['connected'] = true;
+    const request = { toMqttRequest: jest.fn(() => 'req') };
+    await mqttClient.send('duid1', request as any);
+    expect(serializer.serialize).toHaveBeenCalledWith('duid1', 'req');
+    expect(client.publish).toHaveBeenCalledWith('rr/m/i/user/c6d6afb9/duid1', Buffer.from('msg'), { qos: 1 });
+  });
+
+  it('should log error if send called when not connected', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = undefined;
+    mqttClient['connected'] = false;
+    const request = { toMqttRequest: jest.fn() };
+    await mqttClient.send('duid1', request as any);
+    expect(logger.error).toHaveBeenCalled();
+    expect(client.publish).not.toHaveBeenCalled();
+  });
+
+  it('onConnect should set connected, call onConnected, and subscribeToQueue', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = client;
+    mqttClient['subscribeToQueue'] = jest.fn();
+    await mqttClient['onConnect']({} as any);
+    expect(mqttClient['connected']).toBe(true);
+    expect(connectionListeners.onConnected).toHaveBeenCalled();
+    expect(mqttClient['subscribeToQueue']).toHaveBeenCalled();
+  });
+
+  it('subscribeToQueue should call client.subscribe with correct topic', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['client'] = client;
+    mqttClient['subscribeToQueue']();
+    expect(client.subscribe).toHaveBeenCalledWith('rr/m/o/user/c6d6afb9/#', expect.any(Function));
+  });
+
+  it('onSubscribe should log error and call onDisconnected if error', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onSubscribe'](new Error('fail'));
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('failed to subscribe'));
+    expect(mqttClient['connected']).toBe(false);
+    expect(connectionListeners.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('onSubscribe should do nothing if no error', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onSubscribe'](null);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(connectionListeners.onDisconnected).not.toHaveBeenCalled();
+  });
+
+  it('onDisconnect should call onDisconnected', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onDisconnect']();
+    expect(connectionListeners.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('onError should log error, set connected false, and call onError', async () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['connected'] = true;
+    await mqttClient['onError'](new Error('fail'));
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('MQTT connection error'));
+    expect(mqttClient['connected']).toBe(false);
+    expect(connectionListeners.onError).toHaveBeenCalledWith(expect.stringContaining('fail'));
+  });
+
+  it('onReconnect should call subscribeToQueue', () => {
+    const mqttClient = createMQTTClient();
+    mqttClient['subscribeToQueue'] = jest.fn();
+    mqttClient['onReconnect']();
+    expect(mqttClient['subscribeToQueue']).toHaveBeenCalled();
+  });
+
+  it('onMessage should call deserializer and messageListeners.onMessage if message', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onMessage']('rr/m/o/user/c6d6afb9/duid1', Buffer.from('msg'));
+    expect(deserializer.deserialize).toHaveBeenCalledWith('duid1', Buffer.from('msg'));
+    expect(messageListeners.onMessage).toHaveBeenCalledWith('deserialized');
+  });
+
+  it('onMessage should log notice if message is falsy', async () => {
+    const mqttClient = createMQTTClient();
+    await mqttClient['onMessage']('topic', null as any);
+    expect(logger.notice).toHaveBeenCalledWith(expect.stringContaining('received empty message'));
+  });
+
+  it('onMessage should log error if deserializer throws', async () => {
+    const mqttClient = createMQTTClient();
+    deserializer.deserialize.mockImplementation(() => {
+      throw new Error('fail');
+    });
+    await mqttClient['onMessage']('topic/duid', Buffer.from('msg'));
+    expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('unable to process message'));
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/chainedConnectionListener.test.ts

@@ -0,0 +1,59 @@
+import { ChainedConnectionListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/chainedConnectionListener';
+
+describe('ChainedConnectionListener', () => {
+  let chained: ChainedConnectionListener;
+  let listener1: any;
+  let listener2: any;
+
+  beforeEach(() => {
+    chained = new ChainedConnectionListener();
+    listener1 = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+    };
+    listener2 = {
+      onConnected: jest.fn().mockResolvedValue(undefined),
+      onDisconnected: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+    };
+  });
+
+  it('should register listeners', () => {
+    chained.register(listener1);
+    chained.register(listener2);
+
+    // @ts-expect-error Accessing private property for testing
+    expect(chained.listeners).toEqual([listener1, listener2]);
+  });
+
+  it('should call onConnected on all listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onConnected();
+    expect(listener1.onConnected).toHaveBeenCalled();
+    expect(listener2.onConnected).toHaveBeenCalled();
+  });
+
+  it('should call onDisconnected on all listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onDisconnected();
+    expect(listener1.onDisconnected).toHaveBeenCalled();
+    expect(listener2.onDisconnected).toHaveBeenCalled();
+  });
+
+  it('should call onError on all listeners with the same message', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+    await chained.onError('error message');
+    expect(listener1.onError).toHaveBeenCalledWith('error message');
+    expect(listener2.onError).toHaveBeenCalledWith('error message');
+  });
+
+  it('should work with no listeners registered', async () => {
+    await expect(chained.onConnected()).resolves.toBeUndefined();
+    await expect(chained.onDisconnected()).resolves.toBeUndefined();
+    await expect(chained.onError('msg')).resolves.toBeUndefined();
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/chainedMessageListener.test.ts

@@ -0,0 +1,46 @@
+import { ChainedMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/chainedMessageListener';
+import { AbstractMessageListener } from '../../../../../roborockCommunication/broadcast/listener/abstractMessageListener';
+
+describe('ChainedMessageListener', () => {
+  let chained: ChainedMessageListener;
+  let listener1: jest.Mocked<AbstractMessageListener>;
+  let listener2: jest.Mocked<AbstractMessageListener>;
+  const message = { foo: 'bar' } as any;
+
+  beforeEach(() => {
+    chained = new ChainedMessageListener();
+    listener1 = { onMessage: jest.fn().mockResolvedValue(undefined) } as any;
+    listener2 = { onMessage: jest.fn().mockResolvedValue(undefined) } as any;
+  });
+
+  it('should call onMessage on all registered listeners', async () => {
+    chained.register(listener1);
+    chained.register(listener2);
+
+    await chained.onMessage(message);
+
+    expect(listener1.onMessage).toHaveBeenCalledWith(message);
+    expect(listener2.onMessage).toHaveBeenCalledWith(message);
+  });
+
+  it('should not fail if no listeners registered', async () => {
+    await expect(chained.onMessage(message)).resolves.toBeUndefined();
+  });
+
+  it('should call listeners in order', async () => {
+    const callOrder: string[] = [];
+    listener1.onMessage.mockImplementation(async () => {
+      callOrder.push('first');
+    });
+    listener2.onMessage.mockImplementation(async () => {
+      callOrder.push('second');
+    });
+
+    chained.register(listener1);
+    chained.register(listener2);
+
+    await chained.onMessage(message);
+
+    expect(callOrder).toEqual(['first', 'second']);
+  });
+});

package/src/tests/roborockCommunication/broadcast/listener/implementation/simpleMessageListener.test.ts

@@ -0,0 +1,71 @@
+import { SimpleMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/simpleMessageListener';
+import { Protocol } from '../../../../../roborockCommunication/broadcast/model/protocol';
+
+describe('SimpleMessageListener', () => {
+  let listener: SimpleMessageListener;
+  let handler: any;
+  let message: any;
+
+  beforeEach(() => {
+    listener = new SimpleMessageListener();
+    handler = {
+      onStatusChanged: jest.fn().mockResolvedValue(undefined),
+      onError: jest.fn().mockResolvedValue(undefined),
+      onBatteryUpdate: jest.fn().mockResolvedValue(undefined),
+      onAdditionalProps: jest.fn().mockResolvedValue(undefined),
+    };
+    message = {
+      contain: jest.fn(),
+      get: jest.fn(),
+    };
+    listener.registerListener(handler);
+  });
+
+  it('should do nothing if no handler registered', async () => {
+    const l = new SimpleMessageListener();
+    await expect(l.onMessage(message)).resolves.toBeUndefined();
+  });
+
+  it('should do nothing if message is rpc_response or map_response', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.rpc_response || proto === Protocol.map_response);
+    await listener.onMessage(message);
+    expect(handler.onStatusChanged).not.toHaveBeenCalled();
+    expect(handler.onError).not.toHaveBeenCalled();
+    expect(handler.onBatteryUpdate).not.toHaveBeenCalled();
+    expect(handler.onAdditionalProps).not.toHaveBeenCalled();
+  });
+
+  it('should call onStatusChanged if status_update present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.status_update);
+    await listener.onMessage(message);
+    expect(handler.onStatusChanged).toHaveBeenCalled();
+  });
+
+  it('should call onError if error present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.error);
+    message.get.mockReturnValue('42');
+    await listener.onMessage(message);
+    expect(handler.onError).toHaveBeenCalledWith(42);
+  });
+
+  it('should call onBatteryUpdate if battery present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.battery);
+    message.get.mockReturnValue('77');
+    await listener.onMessage(message);
+    expect(handler.onBatteryUpdate).toHaveBeenCalledWith(77);
+  });
+
+  it('should call onAdditionalProps if additional_props present', async () => {
+    message.contain.mockImplementation((proto: Protocol) => proto === Protocol.additional_props);
+    message.get.mockReturnValue('99');
+    await listener.onMessage(message);
+    expect(handler.onAdditionalProps).toHaveBeenCalledWith(99);
+  });
+
+  it('should not call handler methods if they are undefined', async () => {
+    const handlerPartial = {};
+    listener.registerListener(handlerPartial as any);
+    message.contain.mockReturnValue(true);
+    await expect(listener.onMessage(message)).resolves.toBeUndefined();
+  });
+});

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

@@ -0,0 +1,85 @@
+import { SyncMessageListener } from '../../../../../roborockCommunication/broadcast/listener/implementation/syncMessageListener';
+import { Protocol } from '../../../../../roborockCommunication/broadcast/model/protocol';
+
+describe('SyncMessageListener', () => {
+  let listener: SyncMessageListener;
+  let logger: any;
+
+  beforeEach(() => {
+    logger = { info: jest.fn(), error: jest.fn(), debug: jest.fn(), warn: jest.fn() };
+    listener = new SyncMessageListener(logger);
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  it('should call resolve and remove pending on rpc_response', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 123;
+    listener.waitFor(messageId, resolve, reject);
+
+    const dps = { id: messageId, result: { foo: 'bar' } };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.rpc_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(resolve).toHaveBeenCalledWith(dps.result);
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+
+  it('should not call resolve if result is ["ok"]', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 456;
+    listener.waitFor(messageId, resolve, reject);
+
+    const dps = { id: messageId, result: ['ok'] };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.rpc_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(resolve).not.toHaveBeenCalled();
+    expect(listener['pending'].has(messageId)).toBe(true);
+  });
+
+  it('should remove pending on map_response', async () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 789;
+    listener.waitFor(messageId, resolve, reject);
+
+    const dps = { id: messageId };
+    const message = {
+      contain: (proto: Protocol) => proto === Protocol.map_response,
+      get: () => dps,
+    } as any;
+
+    await listener.onMessage(message);
+
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+
+  it('should call reject after timeout if not resolved', () => {
+    const resolve = jest.fn();
+    const reject = jest.fn();
+    const messageId = 321;
+    listener.waitFor(messageId, resolve, reject);
+
+    expect(listener['pending'].has(messageId)).toBe(true);
+
+    jest.advanceTimersByTime(10000);
+
+    expect(reject).toHaveBeenCalled();
+    expect(listener['pending'].has(messageId)).toBe(false);
+  });
+});

package/tsconfig.jest.json

@@ -11,5 +11,11 @@
         "**/*.spec.ts",
         "**/*.test.ts",
         "**/__test__/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "build",
+        "coverage",
     ]
 }