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

package/src/screens/Device/__test__/mqttDetail.test.js

@@ -1,4 +1,5 @@
 import { NavigationContext } from '@react-navigation/native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import MockAdapter from 'axios-mock-adapter';
 import mqtt from 'precompiled-mqtt/dist/mqtt.browser';
 import React from 'react';
@@ -106,6 +107,7 @@ describe('test DeviceDetail', () => {
     jest.useFakeTimers();
     mock.reset();
     watchMultiConfigs.mockClear();
+    AsyncStorage.clear();
     setConfigGlobalState('configValues', {});
     gatewayData = JSON.parse(JSON.stringify(gatewayDataFactory));
   });
@@ -270,134 +272,223 @@ describe('test DeviceDetail', () => {
     expect(watchMultiConfigs).not.toHaveBeenCalled();
   });
 
-  it('should render device detail, modbus not call updateGlobalValue, configs is empty', async () => {
-    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
+  // MODBUS
+  const testModbus = async (data, expect1, expect2) => {
     const valueBoxs = await _receiveDataOnDeviceDetail(
       [{ id: 128323 }, { id: 128324 }],
       `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00010002',
-      }
+      { data }
     );
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+  };
+
+  it('should render device detail, modbus not call updateGlobalValue, configs is empty', async () => {
+    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
+    await testModbus('00010002', '--', '--');
   });
 
   it('should render device detail, modbus not call updateGlobalValue, sensors is empty', async () => {
     gatewayData.sensors = [];
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00010002',
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testModbus('00010002', '--', '--');
   });
 
   it('should render device detail, modbus call updateGlobalValue, modbus_gateway is empty', async () => {
     gatewayData.modbus_gateway = null;
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00012',
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testModbus('00012', '--', '--');
   });
 
   it('should render device detail, modbus call updateGlobalValue, func 1', async () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].func = 1;
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00012',
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(0.2);
+    await testModbus('00012', 0.1, 0.2);
   });
 
   it('should render device detail, modbus call updateGlobalValue, int_all exceed 32767', async () => {
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001F000',
-      }
+    await testModbus('0001F000', 0.1, -409.6);
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, filter zero', async () => {
+    gatewayData.sensors[1].configs[0].active_filter = 'zero';
+    await testModbus('00000002', '--', 0.2);
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, filter in range', async () => {
+    gatewayData.sensors[1].configs[0].active_filter = 'range';
+    gatewayData.sensors[1].configs[0].high_level = 0.5;
+    await testModbus('00040002', 0.4, 0.2);
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, filter out range', async () => {
+    gatewayData.sensors[1].configs[0].active_filter = 'range';
+    gatewayData.sensors[1].configs[0].high_level = 0.3;
+    await testModbus('00040002', '--', 0.2);
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, with offset', async () => {
+    gatewayData.sensors[1].configs[0].ai_trans_offset_value = '1.000';
+    await testModbus('00010002', 1.1, 0.2);
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, with average sample first time', async () => {
+    const cacheKey = `last_values_${gatewayData.sensors[1].configs[0].id}`;
+    gatewayData.sensors[1].configs[0].decimal_behind = 2;
+    gatewayData.sensors[1].configs[0].ai_trans_average_sample = 2;
+    await testModbus('00010002', 0.1, 0.2);
+    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(cacheKey, '[0.1]');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, with average sample', async () => {
+    const cacheKey = `last_values_${gatewayData.sensors[1].configs[0].id}`;
+    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
+    gatewayData.sensors[1].configs[0].decimal_behind = 2;
+    gatewayData.sensors[1].configs[0].ai_trans_average_sample = 2;
+    await testModbus('00010002', 0.15, 0.2); // (0.1 + 0.2) / 2 = 0.15
+    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
+      cacheKey,
+      '[0.15,0.2]'
+    );
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, with offset and average sample', async () => {
+    const cacheKey = `last_values_${gatewayData.sensors[1].configs[0].id}`;
+    await AsyncStorage.setItem(cacheKey, '[0.2, 0.3, 0.4, 0.5]');
+    gatewayData.sensors[1].configs[0].decimal_behind = 2;
+    gatewayData.sensors[1].configs[0].ai_trans_average_sample = 2;
+    gatewayData.sensors[1].configs[0].ai_trans_offset_value = '1.000';
+    await testModbus('00010002', 0.65, 0.2); // (0.2 + 0.1 + 1) / 2 = 0.65
+    expect(AsyncStorage.setItem).toHaveBeenLastCalledWith(
+      cacheKey,
+      '[0.65,0.2]'
     );
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(-409.6);
   });
 
-  it('should render device detail, modbus call updateGlobalValue, uint_32', async () => {
-    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'uint_32';
+  const dataConverterWrongData = async (transformer) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001CCDDBBAA',
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(343708356.1);
-  });
+    await testModbus('0001P1234567', 0.1, '--');
+  };
 
-  it('should render device detail, modbus call updateGlobalValue, float_cdba', async () => {
-    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'float_cdba';
+  const dataConverterUint32 = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '000101234567',
-      }
-    );
+    await testModbus(`0001${data}`, 0.1, 405923122.0);
+  };
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_abcd', async () => {
+    await dataConverterUint32('uint_32_abcd', 'F1F2F3F4');
+  });
 
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(369.6);
+  it('should render device detail, modbus call updateGlobalValue, uint_32_abcd, data not hex format', async () => {
+    await dataConverterWrongData('uint_32_abcd');
   });
 
-  it('should render device detail, modbus call updateGlobalValue, float_cdba, data not hex format', async () => {
-    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'float_cdba';
+  it('should render device detail, modbus call updateGlobalValue, uint_32_dcba', async () => {
+    await dataConverterUint32('uint_32_dcba', 'F4F3F2F1');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_dcba, data not hex format', async () => {
+    await dataConverterWrongData('uint_32_dcba');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_badc', async () => {
+    await dataConverterUint32('uint_32_badc', 'F2F1F4F3');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_badc, data not hex format', async () => {
+    await dataConverterWrongData('uint_32_badc');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_cdab', async () => {
+    await dataConverterUint32('uint_32_cdab', 'F3F4F1F2');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, uint_32_cdab, data not hex format', async () => {
+    await dataConverterWrongData('uint_32_cdab');
+  });
+
+  const dataConverterInt32 = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001P1234567',
-      }
-    );
+    await testModbus(`0001${data}`, 0.1, -23573607.6);
+  };
 
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual('--');
+  it('should render device detail, modbus call updateGlobalValue, int_32_abcd', async () => {
+    await dataConverterInt32('int_32_abcd', 'F1F2F3F4');
   });
 
-  it('should render device detail, modbus call updateGlobalValue, float_abcd, data not hex format', async () => {
-    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'float_abcd';
+  it('should render device detail, modbus call updateGlobalValue, int_32_abcd, data not hex format', async () => {
+    await dataConverterWrongData('int_32_abcd');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_dcba', async () => {
+    await dataConverterInt32('int_32_dcba', 'F4F3F2F1');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_dcba, data not hex format', async () => {
+    await dataConverterWrongData('int_32_dcba');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_badc', async () => {
+    await dataConverterInt32('int_32_badc', 'F2F1F4F3');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_badc, data not hex format', async () => {
+    await dataConverterWrongData('int_32_badc');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_cdab', async () => {
+    await dataConverterInt32('int_32_cdab', 'F3F4F1F2');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, int_32_cdab, data not hex format', async () => {
+    await dataConverterWrongData('int_32_cdab');
+  });
+
+  const dataConverterFloat = async (transformer, data) => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = transformer;
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
+    gatewayData.sensors[1].configs[1].decimal_behind = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001P5670123', // reverse for simple
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testModbus(`0001${data}`, 0.1, 2.76);
+  };
+
+  it('should render device detail, modbus call updateGlobalValue, float_abcd', async () => {
+    await dataConverterFloat('float_abcd', '41DCCCCD');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_abcd, data not hex format', async () => {
+    await dataConverterWrongData('float_abcd');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_dcba', async () => {
+    await dataConverterFloat('float_dcba', 'CDCCDC41');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_dcba, data not hex format', async () => {
+    await dataConverterWrongData('float_dcba');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_badc', async () => {
+    await dataConverterFloat('float_badc', 'DC41CDCC');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_badc, data not hex format', async () => {
+    await dataConverterWrongData('float_badc');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_cdab', async () => {
+    await dataConverterFloat('float_cdab', 'CCCD41DC');
+  });
+
+  it('should render device detail, modbus call updateGlobalValue, float_cdab, data not hex format', async () => {
+    await dataConverterWrongData('float_cdab');
   });
 
   it('should render device detail, modbus call updateGlobalValue, int_first4', async () => {
@@ -405,32 +496,15 @@ describe('test DeviceDetail', () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001CCDDBBAA',
-      }
-    );
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(5244.5);
+    await testModbus('0001CCDDBBAA', 0.1, 5244.5);
   });
 
-  test('should render device detail, modbus call updateGlobalValue, int_last4', async () => {
+  it('should render device detail, modbus call updateGlobalValue, int_last4', async () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'int_last4';
     gatewayData.modbus_gateway.sensors[0].configs[1].len = 2;
     gatewayData.modbus_gateway.sensors[0].configs[1].len2 = 2;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '0001CCDDBBAA',
-      }
-    );
-
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(4804.2);
+    await testModbus('0001CCDDBBAA', 0.1, 4804.2);
   });
 
   it('should render device detail, modbus call updateGlobalValue, convert_ai', async () => {
@@ -440,16 +514,7 @@ describe('test DeviceDetail', () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_min_value = 0;
     gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_max_value = 100;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00010FFF',
-      }
-    );
-
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual(10);
+    await testModbus('00010FFF', 0.1, 10);
   });
 
   it('should render device detail, modbus call updateGlobalValue, convert_ai min_raw same max_raw', async () => {
@@ -459,90 +524,112 @@ describe('test DeviceDetail', () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_min_value = 0;
     gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_max_value = 100;
 
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00010FFF',
-      }
-    );
+    await testModbus('00010FFF', 0.1, '--');
+  });
 
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual('--');
+  it('should render device detail, modbus call updateGlobalValue, convert_ai negative value', async () => {
+    gatewayData.modbus_gateway.sensors[0].configs[1].transformer = 'convert_ai';
+    gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_min_raw_in = 0;
+    gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_max_raw_in = 4000;
+    gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_min_value = -200;
+    gatewayData.modbus_gateway.sensors[0].configs[1].ai_trans_max_value = -100;
+
+    await testModbus('000107D0', 0.1, -15);
   });
 
   it('should render device detail, modbus call updateGlobalValue, transformer not supported', async () => {
     gatewayData.modbus_gateway.sensors[0].configs[1].transformer =
       'WRONG_TRANSFORMER';
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128323 }, { id: 128324 }],
-      `eoh/chip/${gatewayData.code}/data`,
-      {
-        data: '00012',
-      }
-    );
 
-    expect(valueBoxs[0].props.value).toEqual(0.1);
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testModbus('00012', 0.1, '--');
   });
 
-  // // ARDUINO PIN
-  it('should render device detail, arduino pin call updateGlobalValue', async () => {
+  // ARDUINO PIN
+  const testArduinoPin = async (url, data, expect1, expect2) => {
     const valueBoxs = await _receiveDataOnDeviceDetail(
       [{ id: 128282 }, { id: 128324 }],
-      'config/128282/value/',
-      {
-        v: 10,
-      }
+      url,
+      data
     );
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+  };
 
-    expect(valueBoxs[0].props.value).toEqual(10);
-    expect(valueBoxs[1].props.value).toEqual('--');
+  it('should render device detail, arduino pin call updateGlobalValue', async () => {
+    await testArduinoPin('config/128282/value/', { v: 10 }, 10, '--');
   });
 
-  it('arduino pin submit data type string updateGlobalValue', async () => {
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128282 }, { id: 128324 }],
-      'config/128282/value/',
-      {
-        v: 'on',
-      }
+  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 }, '--', '--');
+  });
+
+  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, '--');
+  });
+
+  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 }, '--', '--');
+  });
+
+  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, '--');
+  });
+
+  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]');
+  });
+
+  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]'
     );
+  });
 
-    expect(valueBoxs[0].props.value).toEqual('on');
-    expect(valueBoxs[1].props.value).toEqual('--');
+  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]'
+    );
+  });
+
+  it('arduino pin submit data type string updateGlobalValue', async () => {
+    await testArduinoPin('config/128282/value/', { v: 'on' }, 'on', '--');
   });
 
   it('should render device detail, arduino pin not call updateGlobalValue, configs is empty', async () => {
     gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128282 }, { id: 128324 }],
-      'config/128282/value/',
-      {
-        v: 10,
-      }
-    );
-
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testArduinoPin('config/128282/value/', { v: 10 }, '--', '--');
   });
 
   it('should render device detail, arduino pin not call updateGlobalValue, sensors is empty', async () => {
     gatewayData.sensors = [];
-    const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 128282 }, { id: 128324 }],
-      'config/128282/value/',
-      {
-        v: 10,
-      }
-    );
-
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+    await testArduinoPin('config/128282/value/', { v: 10 }, '--', '--');
   });
 
   // ZIGBEE
-  it('should render device detail, zigbee call updateGlobalValue', async () => {
+  const testZigbee = async (expect1, expect2) => {
     const valueBoxs = await _receiveDataOnDeviceDetail(
       [{ id: 111 }, { id: 222 }],
       'zigbee/0x00158d00022fd3c6/data/',
@@ -550,50 +637,184 @@ describe('test DeviceDetail', () => {
         data: { temperature_measured: 36 },
       }
     );
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+  };
 
-    expect(valueBoxs[0].props.value).toEqual(36);
-    expect(valueBoxs[1].props.value).toEqual('--');
+  it('should render device detail, zigbee call updateGlobalValue', async () => {
+    await testZigbee(36, '--');
   });
 
-  it('should render device detail, zigbee not call updateGlobalValue, configs is empty', async () => {
-    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
+  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: 36 },
+        data: { temperature_measured: 0 },
       }
     );
-
     expect(valueBoxs[0].props.value).toEqual('--');
     expect(valueBoxs[1].props.value).toEqual('--');
   });
 
+  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, '--');
+  });
+
+  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('--', '--');
+  });
+
+  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, '--');
+  });
+
+  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]');
+  });
+
+  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]'
+    );
+  });
+
+  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]'
+    );
+  });
+
+  it('should render device detail, zigbee not call updateGlobalValue, configs is empty', async () => {
+    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
+    await testZigbee('--', '--');
+  });
+
   it('should render device detail, zigbee not call updateGlobalValue, sensors is empty', async () => {
     gatewayData.sensors = [];
+    await testZigbee('--', '--');
+  });
+
+  it('should render device detail, zigbee not call updateGlobalValue, zigbee_gateway is empty', async () => {
+    gatewayData.zigbee_gateway = null;
+    await testZigbee('--', '--');
+  });
+
+  // Third Party
+  const testThirdParty = async (expect1, expect2) => {
     const valueBoxs = await _receiveDataOnDeviceDetail(
-      [{ id: 111 }, { id: 222 }],
-      'zigbee/0x00158d00022fd3c6/data/',
+      [{ id: 37 }, { id: 38 }],
+      'third_party/0x00158d00022fd388/data/',
       {
-        data: { temperature_measured: 36 },
+        led: 1,
       }
     );
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+  };
 
-    expect(valueBoxs[0].props.value).toEqual('--');
-    expect(valueBoxs[1].props.value).toEqual('--');
+  it('should render device detail, Third Party call updateGlobalValue', async () => {
+    await testThirdParty(1, '--');
   });
 
-  it('should render device detail, zigbee not call updateGlobalValue, zigbee_gateway is empty', async () => {
-    gatewayData.zigbee_gateway = null;
+  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: 111 }, { id: 222 }],
-      'zigbee/0x00158d00022fd3c6/data/',
+      [{ id: 37 }, { id: 38 }],
+      'third_party/0x00158d00022fd388/data/',
       {
-        data: { temperature_measured: 36 },
+        led: 0,
       }
     );
-
     expect(valueBoxs[0].props.value).toEqual('--');
     expect(valueBoxs[1].props.value).toEqual('--');
   });
+
+  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, '--');
+  });
+
+  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('--', '--');
+  });
+
+  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, '--');
+  });
+
+  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]');
+  });
+
+  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]'
+    );
+  });
+
+  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, Third Party not call updateGlobalValue, configs is empty', async () => {
+    gatewayData.sensors = [{ id: configDataFactory.sensor, configs: [] }];
+    await testThirdParty('--', '--');
+  });
+
+  it('should render device detail, Third Party not call updateGlobalValue, sensors is empty', async () => {
+    gatewayData.sensors = [];
+    await testThirdParty('--', '--');
+  });
+
+  it('should render device detail, Third Party not call updateGlobalValue, third_party_gateway is empty', async () => {
+    gatewayData.third_party_gateway = null;
+    await testThirdParty('--', '--');
+  });
 });