@eohjsc/react-native-smart-city 0.7.26 → 0.7.30

package/src/screens/Device/__test__/{mqttDetail.test.js → DeviceDetail-modbus.test.js}

@@ -1,6 +1,7 @@
 import { NavigationContext } from '@react-navigation/native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import MockAdapter from 'axios-mock-adapter';
+import moment from 'moment';
 import mqtt from 'precompiled-mqtt/dist/mqtt.browser';
 import React from 'react';
 import { Alert } from 'react-native';
@@ -10,7 +11,8 @@ import QualityIndicatorItem from '../../../commons/Device/WaterQualitySensor/Qua
 import { API } from '../../../configs';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
-import { watchMultiConfigs } from '../../../iot/Monitor';
+import { mqttClientsPool } from '../../../hooks/useMqtt';
+import { unwatchMultiDataChips, watchMultiConfigs } from '../../../iot/Monitor';
 import { setConfigGlobalState } from '../../../iot/states';
 import api from '../../../utils/Apis/axios';
 import {
@@ -25,6 +27,7 @@ jest.mock('../../../iot/Monitor', () => {
   return {
     ...jest.requireActual('../../../iot/Monitor'),
     watchMultiConfigs: jest.fn(),
+    unwatchMultiDataChips: jest.fn(),
   };
 });
 
@@ -107,96 +110,14 @@ describe('test DeviceDetail', () => {
     jest.useFakeTimers();
     mock.reset();
     watchMultiConfigs.mockClear();
+    unwatchMultiDataChips.mockClear();
     AsyncStorage.clear();
-    setConfigGlobalState('configValues', {});
-    gatewayData = JSON.parse(JSON.stringify(gatewayDataFactory));
-  });
-
-  it('should render device detail, connect will call subscribe', async () => {
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    const client = mqtt.connect();
-    await act(async () => {
-      await create(
-        wrapComponent(store, account, {
-          ...route,
-          params: { ...route.params },
-        })
-      );
-    });
-    await act(async () => {
-      client.trigger('connect');
-    });
-
-    expect(client.subscribe).toHaveBeenCalledWith(
-      `eoh/chip/${gatewayData.code}/#`
-    );
-  });
-
-  it('should render device detail, mqtt_server will not call mqtt connect', async () => {
-    gatewayData.mqtt_server = null;
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    const mockMqttConnect = jest.spyOn(mqtt, 'connect');
-    await act(async () => {
-      await create(
-        wrapComponent(store, account, {
-          ...route,
-          params: { ...route.params },
-        })
-      );
-    });
-    expect(mockMqttConnect).not.toHaveBeenCalled();
-  });
-
-  it('should render device detail, allow_frontend_connect is false will not call mqtt connect', async () => {
-    gatewayData.mqtt_server = {
-      host: 'example.cloudmqtt.com',
-      allow_frontend_connect: false,
-    };
-
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    const mockMqttConnect = jest.spyOn(mqtt, 'connect');
-
-    await act(async () => {
-      await create(
-        wrapComponent(store, account, {
-          ...route,
-          params: { ...route.params },
-        })
-      );
-    });
-    expect(mockMqttConnect).not.toHaveBeenCalled();
-  });
-
-  it('should render device detail, call mqtt connect', async () => {
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    const mockMqttConnect = jest.spyOn(mqtt, 'connect');
-    await act(async () => {
-      await create(
-        wrapComponent(store, account, {
-          ...route,
-          params: { ...route.params },
-        })
-      );
-    });
-    expect(mockMqttConnect).toHaveBeenCalledTimes(1);
-  });
-
-  it('should render device detail, unmount will call mqtt end', async () => {
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    await act(async () => {
-      tree = await create(
-        wrapComponent(store, account, {
-          ...route,
-          params: { ...route.params, unitId: 1 },
-        })
-      );
-    });
-
-    const client = mqtt.connect();
-    await act(async () => {
-      tree.unmount();
+    mqttClientsPool.clear();
+    act(() => {
+      setConfigGlobalState('configValues', {});
     });
-    expect(client.end).toHaveBeenCalled();
+    gatewayData = JSON.parse(JSON.stringify(gatewayDataFactory));
+    mock.onGet(API.CHIP.SHARED_CONFIGURATION).reply(200, []);
   });
 
   const _receiveDataOnDeviceDetail = async (widgetConfigs, topic, message) => {
@@ -251,38 +172,73 @@ describe('test DeviceDetail', () => {
     return valueBox;
   };
 
-  it('should render device detail, config use mqtt will not call watch config', async () => {
-    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
-    mock.onGet(API.DEVICE.DISPLAY(1)).reply(200, [
-      {
-        id: 0,
-        order: 0,
-        template: 'value',
-        type: 'value',
-        configuration: {
-          template: 'simple_list',
-          configs: [
-            {
-              id: 128282, // mqtt config
-            },
-          ],
-        },
-      },
-    ]);
-    expect(watchMultiConfigs).not.toHaveBeenCalled();
-  });
-
   // MODBUS
-  const testModbus = async (data, expect1, expect2) => {
+  const testModbus = async (data, expect1, expect2, extra = {}) => {
     const valueBoxs = await _receiveDataOnDeviceDetail(
       [{ id: 128323 }, { id: 128324 }],
       `eoh/chip/${gatewayData.code}/data`,
-      { data }
+      { data, ...extra }
     );
     expect(valueBoxs[0].props.value).toEqual(expect1);
     expect(valueBoxs[1].props.value).toEqual(expect2);
   };
 
+  it('should render device detail, modbus call updateGlobalValue with past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: { value: 0, last_updated: moment(1672531200000) },
+        128324: { value: 0, last_updated: moment(1672531200000) },
+      });
+    });
+    await testModbus('00010002', 0, 0, { time: 1672531199 });
+  });
+
+  it('should render device detail, modbus call updateGlobalValue with future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: { value: 0, last_updated: moment(1672531200000) },
+        128324: { value: 0, last_updated: moment(1672531200000) },
+      });
+    });
+    await testModbus('00010002', 0.1, 0.2, { time: 1672531201 });
+  });
+
+  it('should render device detail, modbus with edge past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+        128324: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+      });
+    });
+    await testModbus('00010002', 0, 0, { time: 1672531200.123455 });
+  });
+
+  it('should render device detail, modbus with edge future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+        128324: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+      });
+    });
+    await testModbus('00010002', 0.1, 0.2, { time: 1672531200.123457 });
+  });
+
   it('should render device detail, modbus not call updateGlobalValue, configs is empty', async () => {
     gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
     await testModbus('00010002', '--', '--');
@@ -544,277 +500,288 @@ describe('test DeviceDetail', () => {
     await testModbus('00012', 0.1, '--');
   });
 
-  // ARDUINO PIN
-  const testArduinoPin = async (url, data, expect1, expect2) => {
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128282 }, { id: 128324 }],
-      url,
-      data
-    );
-    expect(valueBoxs[0].props.value).toEqual(expect1);
-    expect(valueBoxs[1].props.value).toEqual(expect2);
+  const dataConverterWrongData64 = async (transformer) => {
+    gatewayData.mqtt_server.is_wss = false;
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len = 4;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 4;
+
+    await testModbus('0001P123456712345678', 0.1, '--');
   };
 
-  it('should render device detail, arduino pin call updateGlobalValue', async () => {
-    await testArduinoPin('config/128282/value/', { v: 10 }, 10, '--');
-  });
+  const dataConverterUint64 = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len = 4;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 4;
 
-  it('should render device detail, arduino pin call updateGlobalValue, filter zero', async () => {
-    gatewayData.sensors[0].configs[0].active_filter = 'zero';
-    await testArduinoPin('config/128282/value/', { v: 0 }, '--', '--');
-  });
+    await testModbus(`0001${data}`, 0.1, 122454561422327.6);
+  };
 
-  it('should render device detail, arduino pin call updateGlobalValue, filter in range', async () => {
-    gatewayData.sensors[0].configs[0].active_filter = 'range';
-    gatewayData.sensors[0].configs[0].high_level = 11;
-    await testArduinoPin('config/128282/value/', { v: 10 }, 10, '--');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_abcd', async () => {
+    await dataConverterUint64('uint_64_abcd', '000459b7be58d7ac');
   });
 
-  it('should render device detail, arduino pin call updateGlobalValue, filter out range', async () => {
-    gatewayData.sensors[0].configs[0].active_filter = 'range';
-    gatewayData.sensors[0].configs[0].high_level = 10;
-    await testArduinoPin('config/128282/value/', { v: 11 }, '--', '--');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_abcd, data not hex format', async () => {
+    await dataConverterWrongData64('uint_64_abcd');
   });
 
-  it('should render device detail, arduino pin call updateGlobalValue, with offset', async () => {
-    gatewayData.sensors[0].configs[0].ai_trans_offset_value = '1.000';
-    await testArduinoPin('config/128282/value/', { v: 10 }, 11, '--');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_dcba', async () => {
+    await dataConverterUint64('uint_64_dcba', 'acd758beb7590400');
   });
 
-  it('should render device detail, arduino pin call updateGlobalValue, with average sample first time', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[0].configs[0].id}`;
-    gatewayData.sensors[0].configs[0].decimal_behind = 2;
-    gatewayData.sensors[0].configs[0].ai_trans_average_sample = 2;
-    await testArduinoPin('config/128282/value/', { v: 10 }, 10, '--');
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(cacheKey, '[10]');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_dcba, data not hex format', async () => {
+    await dataConverterWrongData64('uint_64_dcba');
   });
 
-  it('should render device detail, arduino pin call updateGlobalValue, with average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[0].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[0].configs[0].decimal_behind = 2;
-    gatewayData.sensors[0].configs[0].ai_trans_average_sample = 2;
-    await testArduinoPin('config/128282/value/', { v: 10 }, 5.1, '--'); // (10 + 0.2) / 2 = 5.1
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[5.1,0.2]'
-    );
+  test('should render device detail, modbus call updateGlobalValue, uint_64_badc', async () => {
+    await dataConverterUint64('uint_64_badc', '0400b75958beacd7');
   });
 
-  it('should render device detail, arduino pin call updateGlobalValue, with offset and average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[0].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[0].configs[0].decimal_behind = 2;
-    gatewayData.sensors[0].configs[0].ai_trans_average_sample = 2;
-    gatewayData.sensors[0].configs[0].ai_trans_offset_value = '1.000';
-    await testArduinoPin('config/128282/value/', { v: 10 }, 5.6, '--'); // (10 + 1 + 0.2) / 2 = 5.6
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[5.6,0.2]'
-    );
+  test('should render device detail, modbus call updateGlobalValue, uint_64_badc, data not hex format', async () => {
+    await dataConverterWrongData64('uint_64_badc');
   });
 
-  it('arduino pin submit data type string updateGlobalValue', async () => {
-    await testArduinoPin('config/128282/value/', { v: 'on' }, 'on', '--');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_cdab', async () => {
+    await dataConverterUint64('uint_64_cdab', 'd7acbe5859b70004');
   });
 
-  it('should render device detail, arduino pin not call updateGlobalValue, configs is empty', async () => {
-    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
-    await testArduinoPin('config/128282/value/', { v: 10 }, '--', '--');
+  test('should render device detail, modbus call updateGlobalValue, uint_64_cdab, data not hex format', async () => {
+    await dataConverterWrongData64('uint_64_cdab');
   });
 
-  it('should render device detail, arduino pin not call updateGlobalValue, sensors is empty', async () => {
-    gatewayData.sensors = [];
-    await testArduinoPin('config/128282/value/', { v: 10 }, '--', '--');
-  });
+  const dataConverterInt64 = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len = 4;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 4;
 
-  // ZIGBEE
-  const testZigbee = async (expect1, expect2) => {
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 111 }, { id: 222 }],
-      'zigbee/0x00158d00022fd3c6/data/',
-      {
-        data: { temperature_measured: 36 },
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(expect1);
-    expect(valueBoxs[1].props.value).toEqual(expect2);
+    await testModbus(`0001${data}`, 0.1, -122454561422327.6);
   };
 
-  it('should render device detail, zigbee call updateGlobalValue', async () => {
-    await testZigbee(36, '--');
+  test('should render device detail, modbus call updateGlobalValue, int_64_abcd', async () => {
+    await dataConverterInt64('int_64_abcd', 'fffba64841a72854');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, filter zero', async () => {
-    gatewayData.sensors[2].configs[0].active_filter = 'zero';
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 111 }, { id: 222 }],
-      'zigbee/0x00158d00022fd3c6/data/',
-      {
-        data: { temperature_measured: 0 },
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+  test('should render device detail, modbus call updateGlobalValue, int_64_abcd, data not hex format', async () => {
+    await dataConverterWrongData64('int_64_abcd');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, filter in range', async () => {
-    gatewayData.sensors[2].configs[0].active_filter = 'range';
-    gatewayData.sensors[2].configs[0].high_level = 37;
-    await testZigbee(36, '--');
+  test('should render device detail, modbus call updateGlobalValue, int_64_dcba', async () => {
+    await dataConverterInt64('int_64_dcba', '5428a74148a6fbff');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, filter out range', async () => {
-    gatewayData.sensors[2].configs[0].active_filter = 'range';
-    gatewayData.sensors[2].configs[0].high_level = 35;
-    await testZigbee('--', '--');
+  test('should render device detail, modbus call updateGlobalValue, int_64_dcba, data not hex format', async () => {
+    await dataConverterWrongData64('int_64_dcba');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, with offset', async () => {
-    gatewayData.sensors[2].configs[0].ai_trans_offset_value = '1.000';
-    await testZigbee(37, '--');
+  test('should render device detail, modbus call updateGlobalValue, int_64_badc', async () => {
+    await dataConverterInt64('int_64_badc', 'fbff48a6a7415428');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, with average sample first time', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[2].configs[0].id}`;
-    gatewayData.sensors[2].configs[0].decimal_behind = 2;
-    gatewayData.sensors[2].configs[0].ai_trans_average_sample = 2;
-    await testZigbee(36, '--');
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(cacheKey, '[36]');
+  test('should render device detail, modbus call updateGlobalValue, int_64_badc, data not hex format', async () => {
+    await dataConverterWrongData64('int_64_badc');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, with average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[2].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[2].configs[0].decimal_behind = 2;
-    gatewayData.sensors[2].configs[0].ai_trans_average_sample = 2;
-    await testZigbee(18.1, '--'); // (36 + 0.2) / 2 = 18.1
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[18.1,0.2]'
-    );
+  test('should render device detail, modbus call updateGlobalValue, int_64_cdab', async () => {
+    await dataConverterInt64('int_64_cdab', '285441a7a648fffb');
   });
 
-  it('should render device detail, zigbee call updateGlobalValue, with offset and average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[2].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[2].configs[0].decimal_behind = 2;
-    gatewayData.sensors[2].configs[0].ai_trans_average_sample = 2;
-    gatewayData.sensors[2].configs[0].ai_trans_offset_value = '1.000';
-    await testZigbee(18.6, '--'); // (36 + 1 + 0.2) / 2 = 5.6
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[18.6,0.2]'
-    );
+  test('should render device detail, modbus call updateGlobalValue, int_64_cdab, data not hex format', async () => {
+    await dataConverterWrongData64('int_64_cdab');
   });
 
-  it('should render device detail, zigbee not call updateGlobalValue, configs is empty', async () => {
-    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
-    await testZigbee('--', '--');
-  });
+  const dataConverterDouble = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len = 4;
+    gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 4;
+    gatewayData.sensors[1].configs[1].decimal_behind = 2;
 
-  it('should render device detail, zigbee not call updateGlobalValue, sensors is empty', async () => {
-    gatewayData.sensors = [];
-    await testZigbee('--', '--');
-  });
+    await testModbus(`0001${data}`, 0.1, 2.76);
+  };
 
-  it('should render device detail, zigbee not call updateGlobalValue, zigbee_gateway is empty', async () => {
-    gatewayData.zigbee_gateway = null;
-    await testZigbee('--', '--');
+  test('should render device detail, modbus call updateGlobalValue, double_abcd', async () => {
+    await dataConverterDouble('double_abcd', '403b99999999999a');
   });
 
-  // Third Party
-  const testThirdParty = async (expect1, expect2) => {
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 37 }, { id: 38 }],
-      'third_party/0x00158d00022fd388/data/',
-      {
-        led: 1,
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(expect1);
-    expect(valueBoxs[1].props.value).toEqual(expect2);
-  };
+  test('should render device detail, modbus call updateGlobalValue, double_abcd, data not hex format', async () => {
+    await dataConverterWrongData64('double_abcd');
+  });
 
-  it('should render device detail, Third Party call updateGlobalValue', async () => {
-    await testThirdParty(1, '--');
+  test('should render device detail, modbus call updateGlobalValue, double_dcba', async () => {
+    await dataConverterDouble('double_dcba', '9a99999999993b40');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, filter zero', async () => {
-    gatewayData.sensors[3].configs[0].active_filter = 'zero';
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 37 }, { id: 38 }],
-      'third_party/0x00158d00022fd388/data/',
-      {
-        led: 0,
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+  test('should render device detail, modbus call updateGlobalValue, double_dcba, data not hex format', async () => {
+    await dataConverterWrongData64('double_dcba');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, filter in range', async () => {
-    gatewayData.sensors[3].configs[0].active_filter = 'range';
-    gatewayData.sensors[3].configs[0].high_level = 2;
-    await testThirdParty(1, '--');
+  test('should render device detail, modbus call updateGlobalValue, double_badc', async () => {
+    await dataConverterDouble('double_badc', '3b40999999999a99');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, filter out range', async () => {
-    gatewayData.sensors[3].configs[0].active_filter = 'range';
-    gatewayData.sensors[3].configs[0].high_level = 0.5;
-    await testThirdParty('--', '--');
+  test('should render device detail, modbus call updateGlobalValue, double_badc, data not hex format', async () => {
+    await dataConverterWrongData64('double_badc');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, with offset', async () => {
-    gatewayData.sensors[3].configs[0].ai_trans_offset_value = '1.000';
-    await testThirdParty(2, '--');
+  test('should render device detail, modbus call updateGlobalValue, double_cdab', async () => {
+    await dataConverterDouble('double_cdab', '999a99999999403b');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, with average sample first time', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[3].configs[0].id}`;
-    gatewayData.sensors[3].configs[0].decimal_behind = 2;
-    gatewayData.sensors[3].configs[0].ai_trans_average_sample = 2;
-    await testThirdParty(1, '--');
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(cacheKey, '[1]');
+  test('should render device detail, modbus call updateGlobalValue, double_cdab, data not hex format', async () => {
+    await dataConverterWrongData64('double_cdab');
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, with average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[3].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[3].configs[0].decimal_behind = 2;
-    gatewayData.sensors[3].configs[0].ai_trans_average_sample = 2;
-    await testThirdParty(0.6, '--'); // (1 + 0.2) / 2 = 0.6
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[0.6,0.2]'
-    );
+  const _watchDataChipsOnDeviceDetail = async (
+    data,
+    expect1,
+    expect2,
+    last_updated = '2025-09-09T12:00:00Z'
+  ) => {
+    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, []);
+    mock.onPost(API.IOT.CHIP_MANAGER.WATCH_DATA_CHIPS()).reply(200, {
+      7689: {
+        last_modbus_data: {
+          data,
+          ack: '11',
+          last_updated,
+        },
+      },
+    });
+    mock.onGet(API.CHIP.SHARED_CONFIGURATION).reply(200, [gatewayData]);
+
+    const responseDisplay = {
+      items: [
+        {
+          id: 1,
+          order: 0,
+          template: 'value',
+          type: 'value',
+          configuration: {
+            template: 'simple_list',
+            configs: [{ id: 128323 }, { id: 128324 }],
+          },
+        },
+      ],
+    };
+
+    const responseRemoteControl = {
+      bluetooth: {
+        address: 'JUvfa06PMDU8Cqlo',
+        password: 'MYcNoskxspWTPsnh',
+      },
+      internet: {},
+    };
+
+    const responseDisplayValueV2 = {
+      configs: [],
+      is_connected: true,
+      last_updated: '2021-01-24T12:00:00.000Z',
+    };
+
+    mockAxios(responseDisplay, responseDisplayValueV2, responseRemoteControl);
+
+    await act(async () => {
+      tree = await create(
+        wrapComponent(store, account, {
+          ...route,
+          params: { ...route.params },
+        })
+      );
+    });
+
+    const instance = tree.root;
+    const valueBoxs = instance.findAllByType(QualityIndicatorItem);
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+
+    expect(
+      mock.history.post.filter(
+        (req) => req.url === API.IOT.CHIP_MANAGER.WATCH_DATA_CHIPS()
+      )
+    ).toHaveLength(1);
+
+    await act(async () => {
+      jest.runOnlyPendingTimers();
+    });
+    expect(
+      mock.history.post.filter(
+        (req) => req.url === API.IOT.CHIP_MANAGER.WATCH_DATA_CHIPS()
+      )
+    ).toHaveLength(2);
+    expect(unwatchMultiDataChips).not.toHaveBeenCalled();
+
+    await act(async () => {
+      await tree.unmount();
+    });
+    expect(unwatchMultiDataChips).toHaveBeenCalledWith([gatewayData.id]);
+  };
+
+  it('should render device detail, watch data chips call updateGlobalValue', async () => {
+    await _watchDataChipsOnDeviceDetail('00010002', 0.1, 0.2);
   });
 
-  it('should render device detail, Third Party call updateGlobalValue, with offset and average sample', async () => {
-    const cacheKey = `last_values_${gatewayData.sensors[3].configs[0].id}`;
-    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
-    gatewayData.sensors[3].configs[0].decimal_behind = 2;
-    gatewayData.sensors[3].configs[0].ai_trans_average_sample = 2;
-    gatewayData.sensors[3].configs[0].ai_trans_offset_value = '1.000';
-    await testThirdParty(1.1, '--'); // (1 + 1 + 0.2) / 2 = 1.1
-    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
-      cacheKey,
-      '[1.1,0.2]'
-    );
+  it('should render device detail, watch data chips call updateGlobalValue with past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+        128324: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail('00010002', 0, 0);
   });
 
-  it('should render device detail, Third Party not call updateGlobalValue, configs is empty', async () => {
-    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
-    await testThirdParty('--', '--');
+  it('should render device detail, watch data chips call updateGlobalValue with future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+        128324: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail('00010002', 0.1, 0.2);
   });
 
-  it('should render device detail, Third Party not call updateGlobalValue, sensors is empty', async () => {
-    gatewayData.sensors = [];
-    await testThirdParty('--', '--');
+  it('should render device detail, watch data chips with edge past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.123457Z'),
+          last_updated_micro: 457,
+        },
+        128324: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.123457Z'),
+          last_updated_micro: 457,
+        },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(
+      '00010002',
+      0,
+      0,
+      '2025-09-09T12:00:00.123456Z'
+    );
   });
 
-  it('should render device detail, Third Party not call updateGlobalValue, third_party_gateway is empty', async () => {
-    gatewayData.third_party_gateway = null;
-    await testThirdParty('--', '--');
+  it('should render device detail, watch data chips with edge future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        128323: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.123455Z'),
+          last_updated_micro: 455,
+        },
+        128324: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.123455Z'),
+          last_updated_micro: 455,
+        },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(
+      '00010002',
+      0.1,
+      0.2,
+      '2025-09-09T12:00:00.123456Z'
+    );
   });
 });