@eohjsc/react-native-smart-city 0.7.27 → 0.7.31

package/src/screens/Device/__test__/DeviceDetail-zigbee.test.js

@@ -0,0 +1,451 @@
+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';
+import { act, create } from 'react-test-renderer';
+
+import QualityIndicatorItem from '../../../commons/Device/WaterQualitySensor/QualityIndicatorsItem';
+import { API } from '../../../configs';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import { mqttClientsPool } from '../../../hooks/useMqtt';
+import { unwatchMultiDataChips, watchMultiConfigs } from '../../../iot/Monitor';
+import { setConfigGlobalState } from '../../../iot/states';
+import api from '../../../utils/Apis/axios';
+import {
+  configDataFactory,
+  gatewayDataFactory,
+} from '../../../utils/FactoryGateway';
+import DeviceDetail from '../detail';
+
+const mock = new MockAdapter(api.axiosInstance);
+
+jest.mock('../../../iot/Monitor', () => {
+  return {
+    ...jest.requireActual('../../../iot/Monitor'),
+    watchMultiConfigs: jest.fn(),
+    unwatchMultiDataChips: jest.fn(),
+  };
+});
+
+let store = mockSCStore({});
+
+const mockAxios = (
+  responseDisplay,
+  responseDisplayValueV2,
+  responseRemoteControl = {}
+) => {
+  mock.onGet(API.DEVICE.DISPLAY(1)).reply(200, responseDisplay);
+  mock
+    .onGet(API.DEVICE.REMOTE_CONTROL_OPTIONS(1))
+    .reply(200, responseRemoteControl);
+  mock
+    .onGet(API.DEVICE.DISPLAY_VALUES_V2(1))
+    .reply(200, responseDisplayValueV2);
+};
+
+const navContextValue = {
+  isFocused: () => false,
+  addListener: jest.fn(() => jest.fn()),
+};
+const wrapComponent = (state, account, route) => (
+  <SCProvider initState={state}>
+    <NavigationContext.Provider
+      value={{
+        ...navContextValue,
+        isFocused: () => true,
+      }}
+    >
+      <DeviceDetail account={account} route={route} />
+    </NavigationContext.Provider>
+  </SCProvider>
+);
+
+const mockAlertShow = jest.fn();
+Alert.alert = mockAlertShow;
+
+describe('test DeviceDetail', () => {
+  let tree;
+  let route;
+  let account;
+  let gatewayData;
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitData: {
+          id: 1,
+          name: 'Unit name',
+          address: '298 Dien Bien Phu',
+          remote_control_options: {
+            googlehome: [
+              {
+                config_maps: [],
+                auth: {},
+                chip_id: 1,
+              },
+            ],
+          },
+        },
+        station: {
+          id: 2,
+          name: 'Station name',
+        },
+        sensorData: {
+          id: 1,
+          is_managed_by_backend: true,
+          station: { id: 2, name: 'Station name' },
+          name: 'Sensor name',
+          chip_id: 7689,
+        },
+        title: 'Button',
+      },
+    };
+    account = {
+      token: 'abc',
+    };
+    jest.useFakeTimers();
+    mock.reset();
+    watchMultiConfigs.mockClear();
+    unwatchMultiDataChips.mockClear();
+    AsyncStorage.clear();
+    mqttClientsPool.clear();
+    act(() => {
+      setConfigGlobalState('configValues', {});
+    });
+    gatewayData = JSON.parse(JSON.stringify(gatewayDataFactory));
+    mock.onGet(API.CHIP.SHARED_CONFIGURATION).reply(200, []);
+  });
+
+  const _receiveDataOnDeviceDetail = async (widgetConfigs, topic, message) => {
+    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
+
+    const responseDisplay = {
+      items: [
+        {
+          id: 1,
+          order: 0,
+          template: 'value',
+          type: 'value',
+          configuration: {
+            template: 'simple_list',
+            configs: widgetConfigs,
+          },
+        },
+      ],
+    };
+
+    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 client = mqtt.connect();
+    await act(async () => {
+      await client.trigger('message', topic, JSON.stringify(message), 'packet');
+    });
+
+    const valueBox = instance.findAllByType(QualityIndicatorItem);
+    return valueBox;
+  };
+
+  // ZIGBEE
+  const testZigbee = async (expect1, expect2, extra = {}) => {
+    const valueBoxs = await _receiveDataOnDeviceDetail(
+      [{ id: 111 }, { id: 222 }],
+      'zigbee/0x00158d00022fd3c6/data',
+      {
+        type: 'zigbee_data',
+        data: { temperature_measured: 36 },
+        ...extra,
+      }
+    );
+    expect(valueBoxs[0].props.value).toEqual(expect1);
+    expect(valueBoxs[1].props.value).toEqual(expect2);
+  };
+
+  it('should render device detail, zigbee call updateGlobalValue', async () => {
+    await testZigbee(36, '--');
+  });
+
+  it('should render device detail, zigbee call updateGlobalValue with past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: { value: 0, last_updated: moment(1672531200000) },
+      });
+    });
+    await testZigbee(0, '--', { time: 1672531199 });
+  });
+
+  it('should render device detail, zigbee call updateGlobalValue with future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: { value: 0, last_updated: moment(1672531200000) },
+      });
+    });
+    await testZigbee(36, '--', { time: 1672531201 });
+  });
+
+  it('should render device detail, zigbee with edge past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+      });
+    });
+    await testZigbee(0, '--', { time: 1672531200.123455 });
+  });
+
+  it('should render device detail, zigbee with edge future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: {
+          value: 0,
+          last_updated: moment(1672531200123),
+          last_updated_micro: 456,
+        },
+      });
+    });
+    await testZigbee(36, '--', { time: 1672531200.123457 });
+  });
+
+  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('--');
+  });
+
+  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('--', '--');
+  });
+
+  const _watchDataChipsOnDeviceDetail = async (
+    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_zigbee_data: {
+          '0x00158d00022fd3c6': {
+            type: 'zigbee_data',
+            data: {
+              temperature_measured: 36,
+            },
+            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: 111 }, { id: 222 }],
+          },
+        },
+      ],
+    };
+
+    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(36, '--');
+  });
+
+  it('should render device detail, watch data chips call updateGlobalValue with past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(0, '--');
+  });
+
+  it('should render device detail, watch data chips call updateGlobalValue with future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(36, '--');
+  });
+
+  it('should render device detail, watch data chips with edge past last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.12346Z'),
+          last_updated_micro: 460,
+        },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(0, '--', '2025-09-09T12:00:00.12345Z');
+  });
+
+  it('should render device detail, watch data chips with edge future last_updated', async () => {
+    act(() => {
+      setConfigGlobalState('configValues', {
+        111: {
+          value: 0,
+          last_updated: moment('2025-09-09T12:00:00.12344Z'),
+          last_updated_micro: 440,
+        },
+      });
+    });
+    await _watchDataChipsOnDeviceDetail(36, '--', '2025-09-09T12:00:00.12345Z');
+  });
+});