mm_os 4.2.4 → 4.2.7

package/com/mqtt/index.test.js

@@ -0,0 +1,503 @@
+/**
+ * MQTT模块单元测试
+ * 测试修复的线程阻塞点：match缓存、dict_msg O(1)查找、并行处理
+ */
+
+// Mock 框架扩展方法
+String.prototype.fullname = function (base) {
+  return base ? base + '/' + this : this;
+};
+String.prototype.hasDir = function () {
+  return false;
+};
+Array.prototype.getObj = function () {
+  return null;
+};
+Array.prototype.to2D = function (size) {
+  var result = [];
+  for (var i = 0; i < this.length; i += size) {
+    result.push(this.slice(i, i + size));
+  }
+  return result;
+};
+
+// Mock global $ 对象
+global.$ = {
+  sleep: jest.fn(() => Promise.resolve()),
+  pool: {},
+  val: { scope: 'test' },
+  admin: {
+    mqtt: null,
+    sql: jest.fn(() => ({
+      db: jest.fn(() => ({
+        get: jest.fn(() => Promise.resolve([])),
+        set: jest.fn(() => Promise.resolve()),
+      })),
+    })),
+  },
+};
+
+// Mock mm_machine Manager
+const mockGetMods = jest.fn(() => ({}));
+const mockGetInfos = jest.fn(() => []);
+const mockGetMod = jest.fn(() => null);
+const mockLog = jest.fn();
+
+jest.mock('mm_machine', () => {
+  class MockManager {
+    constructor(config, parent) {
+      this.config = config;
+      this.parent = parent;
+    }
+  }
+  MockManager.prototype.getMods = mockGetMods;
+  MockManager.prototype.getInfos = mockGetInfos;
+  MockManager.prototype.getMod = mockGetMod;
+  MockManager.prototype.log = mockLog;
+  MockManager.prototype.getEventer = jest.fn(() => ({}));
+  MockManager.prototype.getParentKey = jest.fn(() => 'Mqtt_test');
+  MockManager.prototype.getBaseDir = jest.fn(() => __dirname);
+  MockManager.prototype.getTplDir = jest.fn(() => __dirname);
+  MockManager.prototype.getDirName = jest.fn(() => 'mqtt_test');
+  return { Manager: MockManager, Drive: class MockDrive {}, MODE: { HOT_RELOAD: 3 } };
+});
+
+jest.mock('mqtt', () => ({
+  connect: jest.fn(() => ({
+    on: jest.fn(),
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    publish: jest.fn(),
+    end: jest.fn(),
+    removeAllListeners: jest.fn(),
+    options: { clientId: 'test_client' },
+  })),
+}));
+
+const { Mqtt } = require('./index');
+
+describe('Mqtt 类', () => {
+  let mqtt;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mqtt = new Mqtt({ name: 'test' });
+    mqtt._preset();
+  });
+
+  describe('match() 正则缓存', () => {
+    test('完全匹配应返回true', () => {
+      expect(mqtt.match('face/device1/status', 'face/device1/status')).toBe(true);
+    });
+
+    test('+通配符匹配', () => {
+      expect(mqtt.match('face/device1/status', 'face/+/status')).toBe(true);
+    });
+
+    test('#通配符匹配', () => {
+      expect(mqtt.match('face/device1/status/extra', 'face/device1/#')).toBe(true);
+    });
+
+    test('不匹配应返回false', () => {
+      expect(mqtt.match('other/topic', 'face/+/status')).toBe(false);
+    });
+
+    test('正则缓存生效：相同模式复用RegExp', () => {
+      mqtt.match('face/device1/status', 'face/+/status');
+      mqtt.match('face/device2/status', 'face/+/status');
+      // 缓存中应有该模式
+      expect(mqtt._regex_cache['face/+/status']).toBeDefined();
+      expect(mqtt._regex_cache['face/+/status'] instanceof RegExp).toBe(true);
+    });
+  });
+
+  describe('dict_msg O(1)查找', () => {
+    test('req() 应同步维护 dict_msg', () => {
+      mqtt.client = {
+        options: { clientId: 'test' },
+        publish: jest.fn(),
+        on: jest.fn(),
+      };
+      mqtt.send = jest.fn();
+      var callback = jest.fn();
+      mqtt.req('test/topic', 'testMethod', { key: 'val' }, callback);
+
+      expect(mqtt.list_msg.length).toBe(1);
+      expect(mqtt.dict_msg[mqtt.list_msg[0].id]).toBeDefined();
+      expect(mqtt.dict_msg[mqtt.list_msg[0].id].func).toBe(callback);
+    });
+
+    test('_handleResponse() O(1) 查找并执行回调', () => {
+      var callback = jest.fn();
+      var msg_id = 'test_id_123';
+      mqtt.dict_msg[msg_id] = {
+        id: msg_id,
+        func: callback,
+        timer: null,
+      };
+      mqtt.list_msg.push({ id: msg_id, func: callback });
+
+      mqtt._handleResponse({ id: msg_id, result: 'ok' });
+
+      expect(callback).toHaveBeenCalledWith({ id: msg_id, result: 'ok' });
+      // 消息应从dict_msg中删除
+      expect(mqtt.dict_msg[msg_id]).toBeUndefined();
+    });
+
+    test('_handleResponse() 无id时应安全返回', () => {
+      expect(() => mqtt._handleResponse(null)).not.toThrow();
+      expect(() => mqtt._handleResponse({})).not.toThrow();
+    });
+
+    test('_delMsgById() 同步清理 dict_msg 和 list_msg', () => {
+      var msg_id = 'del_test_123';
+      mqtt.dict_msg[msg_id] = { id: msg_id, timer: null };
+      mqtt.list_msg.push({ id: msg_id });
+
+      mqtt._delMsgById(msg_id);
+
+      expect(mqtt.dict_msg[msg_id]).toBeUndefined();
+      expect(mqtt.list_msg.length).toBe(0);
+    });
+
+    test('_delMsgById() 清除关联定时器', () => {
+      var clear_fn = jest.spyOn(global, 'clearTimeout');
+      var msg_id = 'timer_test_123';
+      var mock_timer = { _id: 999 };
+      mqtt.dict_msg[msg_id] = { id: msg_id, timer: mock_timer };
+      mqtt.list_msg.push({ id: msg_id });
+
+      mqtt._delMsgById(msg_id);
+
+      expect(clear_fn).toHaveBeenCalledWith(mock_timer);
+      clear_fn.mockRestore();
+    });
+  });
+
+  describe('_collectTopicPromises() 收集匹配主题', () => {
+    test('应收集所有匹配主题的handler Promise', () => {
+      var mockHandle = jest.fn(() => Promise.resolve('handled'));
+      var mockMod = {
+        config: { state: 1, topic: ['face/+/status', 'face/+/event'] },
+        call: jest.fn((method, ...args) => {
+          if (method === 'handle') {
+            return mockHandle(...args);
+          }
+          return Promise.resolve();
+        }),
+      };
+      mockGetMods.mockReturnValue({ mod1: mockMod });
+
+      var result = mqtt._collectTopicPromises('face/device1/status', { data: 'test' });
+
+      expect(result.promises.length).toBe(1);
+      expect(result.topic).toBe('face/+/event');
+    });
+
+    test('应跳过 state !== 1 的mod', () => {
+      var mockMod = {
+        config: { state: 0, topic: ['face/+/status'] },
+        call: jest.fn(),
+      };
+      mockGetMods.mockReturnValue({ mod1: mockMod });
+
+      var result = mqtt._collectTopicPromises('face/device1/status', {});
+
+      expect(result.promises.length).toBe(0);
+    });
+
+    test('应跳过无topic的mod', () => {
+      var mockMod = {
+        config: { state: 1 },
+        call: jest.fn(),
+      };
+      mockGetMods.mockReturnValue({ mod1: mockMod });
+
+      var result = mqtt._collectTopicPromises('face/device1/status', {});
+
+      expect(result.promises.length).toBe(0);
+    });
+  });
+
+  describe('_processTopics() 并行处理', () => {
+    test('应并行执行多个handler', async () => {
+      var call_order = [];
+      var mockMod1 = {
+        config: { state: 1, topic: ['face/+/status'] },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                call_order.push('mod1');
+                resolve('result1');
+              }, 50);
+            });
+          }
+          return Promise.resolve();
+        }),
+      };
+      var mockMod2 = {
+        config: { state: 1, topic: ['face/+/status'] },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                call_order.push('mod2');
+                resolve('result2');
+              }, 10);
+            });
+          }
+          return Promise.resolve();
+        }),
+      };
+      mockGetMods.mockReturnValue({ mod1: mockMod1, mod2: mockMod2 });
+
+      var result = await mqtt._processTopics('face/device1/status', {});
+
+      // mod2(10ms)应在mod1(50ms)之前完成，证明是并行执行的
+      expect(call_order[0]).toBe('mod2');
+      expect(call_order[1]).toBe('mod1');
+      // Promise.allSettled 保持输入顺序，从后往前取最后一个非空结果
+      // 输入顺序: [mod1, mod2]，所以 result = 'result2'
+      expect(result.result).toBe('result2');
+      expect(result.topic).toBe('face/+/status');
+    });
+
+    test('一个handler失败不应影响其他', async () => {
+      var mod2_called = false;
+      var mockMod1 = {
+        config: { state: 1, topic: ['face/+/status'] },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            return Promise.reject(new Error('mod1 failed'));
+          }
+          return Promise.resolve();
+        }),
+      };
+      var mockMod2 = {
+        config: { state: 1, topic: ['face/+/status'] },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            mod2_called = true;
+            return Promise.resolve('result2');
+          }
+          return Promise.resolve();
+        }),
+      };
+      mockGetMods.mockReturnValue({ mod1: mockMod1, mod2: mockMod2 });
+
+      var result = await mqtt._processTopics('face/device1/status', {});
+
+      expect(mod2_called).toBe(true);
+      expect(result.result).toBe('result2');
+    });
+  });
+
+  describe('updateAfter() 并行初始化', () => {
+    test('应并行执行所有mod的init', async () => {
+      var init_order = [];
+      var createMod = (name, delay) => ({
+        config: { name },
+        do: jest.fn((method) => {
+          if (method === 'init') {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                init_order.push(name);
+                resolve();
+              }, delay);
+            });
+          }
+          return Promise.resolve();
+        }),
+      });
+
+      mockGetInfos.mockReturnValue([
+        { name: 'mod1', state: 1 },
+        { name: 'mod2', state: 1 },
+      ]);
+      mockGetMod.mockImplementation((name) => {
+        if (name === 'mod1') return createMod('mod1', 50);
+        if (name === 'mod2') return createMod('mod2', 10);
+        return null;
+      });
+
+      await mqtt.updateAfter();
+
+      // mod2(10ms)应在mod1(50ms)之前完成
+      expect(init_order[0]).toBe('mod2');
+      expect(init_order[1]).toBe('mod1');
+    });
+  });
+
+  describe('_updateDeviceStatus() 并行DB写入', () => {
+    test('应并行执行所有saveOnline调用', async () => {
+      mqtt.saveOnline = jest.fn(() => Promise.resolve());
+
+      var list_offline = ['dev1', 'dev2', 'dev3', 'dev4'];
+      var list_online = ['dev5', 'dev6'];
+
+      await mqtt._updateDeviceStatus(list_offline, list_online);
+
+      // saveOnline 应被调用(批次不固定，取决于to2D分组)
+      expect(mqtt.saveOnline).toHaveBeenCalled();
+      var calls = mqtt.saveOnline.mock.calls;
+      // 验证离线设备传入online=0
+      var off_calls = calls.filter((c) => c[1] === 0);
+      expect(off_calls.length).toBeGreaterThan(0);
+      // 验证在线设备传入online=1
+      var on_calls = calls.filter((c) => c[1] === 1);
+      expect(on_calls.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('start() 定时器启动', () => {
+    test('start() 不应包含setTimeout延迟', () => {
+      var setTimeout_spy = jest.spyOn(global, 'setTimeout');
+      mockGetInfos.mockReturnValue([]);
+
+      // start() 内部会调用_createClient，但connect会失败
+      // 我们只验证没有setTimeout调用
+      mqtt._createClient = jest.fn(() => {
+        mqtt.client = { on: true };
+      });
+      mqtt._setupClientEvents = jest.fn(() => Promise.resolve('connected'));
+
+      mqtt.start();
+
+      // 验证start()内部没有调用setTimeout
+      var start_calls = setTimeout_spy.mock.calls.filter(
+        (c) => typeof c[1] === 'number' && c[1] === 2000,
+      );
+      expect(start_calls.length).toBe(0);
+
+      setTimeout_spy.mockRestore();
+    });
+  });
+
+  describe('多厂商并行处理场景 (模拟 example/app/face/mqtt/)', () => {
+    /**
+     * 模拟真实场景：多个设备协议mod同时订阅同一主题
+     * 例如 face/+/status 主题被 DA、TS、EF 三个厂商mod同时匹配
+     * 每个mod的handler可能执行DB查询、HTTP请求、日志记录等耗时操作
+     */
+    test('多个厂商mod应并行处理同一条消息', async () => {
+      var call_order = [];
+
+      // 创建模拟mod的工厂函数
+      var createMod = (name, delay) => ({
+        config: {
+          name,
+          state: 1,
+          topic: ['face/+/status', 'face/+/event/recognition'],
+        },
+        call: jest.fn((method, push_topic, msg, topic, n) => {
+          if (method === 'handle') {
+            return new Promise((resolve) => {
+              setTimeout(() => {
+                call_order.push(name);
+                // 模拟真实场景：handler返回处理结果
+                resolve({ result: 'ok', mod: name });
+              }, delay);
+            });
+          }
+          return Promise.resolve();
+        }),
+      });
+
+      // 模拟5个厂商mod，各自有不同的处理耗时
+      mockGetMods.mockReturnValue({
+        da: createMod('DA', 80),   // RV1109云对接协议 - 较慢
+        ts: createMod('TS', 30),   // 自定设备 - 中等
+        ef: createMod('EF', 60),   // 另一个厂商
+        df: createMod('DF', 10),   // 快速
+        zs: createMod('ZS', 110),  // 最慢（可能涉及HTTP请求）
+      });
+
+      var result = await mqtt._processTopics('face/device1/status', {
+        cmd: 'reportVisitRecord',
+        param: { CustomID: 'test_user', Name: '测试用户' },
+      });
+
+      // 验证并行执行：最快的DF(10ms)先完成，ZS(110ms)最后完成
+      expect(call_order[0]).toBe('DF');
+      expect(call_order[call_order.length - 1]).toBe('ZS');
+      // 所有5个mod都被调用了
+      expect(call_order.length).toBe(5);
+      // 有返回结果
+      expect(result.result).toBeDefined();
+      expect(result.result.mod).toBeDefined();
+    });
+
+    test('一个厂商handler失败不应影响其他厂商', async () => {
+      var called = [];
+
+      var createMod = (name, should_fail) => ({
+        config: {
+          name,
+          state: 1,
+          topic: ['face/+/event/recognition'],
+        },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            if (should_fail) {
+              return Promise.reject(new Error(name + ' handler failed'));
+            }
+            called.push(name);
+            return Promise.resolve({ result: 'ok', mod: name });
+          }
+          return Promise.resolve();
+        }),
+      });
+
+      mockGetMods.mockReturnValue({
+        da: createMod('DA', false),
+        ts: createMod('TS', true),   // TS 厂商handler失败
+        ef: createMod('EF', false),
+        df: createMod('DF', false),
+        zs: createMod('ZS', false),
+      });
+
+      var result = await mqtt._processTopics('face/device1/event/recognition', {
+        cmd: 'reportVisitRecord',
+        param: { CustomID: 'test_user' },
+      });
+
+      // TS失败但其他4个厂商都被调用了
+      expect(called.length).toBe(4);
+      expect(called).toContain('DA');
+      expect(called).toContain('EF');
+      expect(called).toContain('DF');
+      expect(called).toContain('ZS');
+      expect(called).not.toContain('TS');
+      // 有返回结果
+      expect(result.result).toBeDefined();
+    });
+
+    test('全部厂商handler失败应返回空结果', async () => {
+      var createMod = (name) => ({
+        config: {
+          name,
+          state: 1,
+          topic: ['face/+/status'],
+        },
+        call: jest.fn((method) => {
+          if (method === 'handle') {
+            return Promise.reject(new Error(name + ' failed'));
+          }
+          return Promise.resolve();
+        }),
+      });
+
+      mockGetMods.mockReturnValue({
+        da: createMod('DA'),
+        ts: createMod('TS'),
+      });
+
+      var result = await mqtt._processTopics('face/device1/status', {});
+
+      // 所有mod都失败，result应为undefined
+      expect(result.result).toBeUndefined();
+      expect(result.topic).toBeDefined();
+    });
+  });
+});