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

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

@@ -0,0 +1,502 @@
+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 { 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, []);
+  });
+
+  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();
+    });
+
+    await act(async () => {
+      jest.runOnlyPendingTimers();
+    });
+    expect(client.end).toHaveBeenCalled();
+  });
+
+  it('test back and render device detail again, unmount 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();
+    });
+    expect(client.end).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree = await create(
+        wrapComponent(store, account, {
+          ...route,
+          params: { ...route.params, unitId: 1 },
+        })
+      );
+    });
+    await act(async () => {
+      tree.unmount();
+    });
+    expect(client.end).not.toHaveBeenCalled();
+
+    await act(async () => {
+      jest.runOnlyPendingTimers();
+    });
+    expect(client.end).toHaveBeenCalled();
+  });
+
+  it('test render multi, unmount call mqtt end', async () => {
+    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [gatewayData]);
+    const tree1 = await act(async () => {
+      return await create(
+        wrapComponent(store, account, {
+          ...route,
+          params: { ...route.params, unitId: 1 },
+        })
+      );
+    });
+    const tree2 = await act(async () => {
+      return await create(
+        wrapComponent(store, account, {
+          ...route,
+          params: { ...route.params, unitId: 1 },
+        })
+      );
+    });
+
+    const client = mqtt.connect();
+    await act(async () => {
+      tree1.unmount();
+    });
+    expect(client.end).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree2.unmount();
+    });
+    expect(client.end).not.toHaveBeenCalled();
+
+    await act(async () => {
+      jest.runOnlyPendingTimers();
+    });
+    expect(client.end).toHaveBeenCalled();
+  });
+
+  const _receiveDataMqtt = 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);
+    expect(valueBox.length).toBe(widgetConfigs.length);
+    return valueBox;
+  };
+
+  test('should render device detail, receive is_online message', async () => {
+    const valueBoxs = await _receiveDataMqtt(
+      [{ id: 2547 }],
+      `eoh/chip/${gatewayData.code}/is_online`,
+      {
+        ol: 1,
+      }
+    );
+    expect(valueBoxs[0].props.value).toEqual(1);
+  });
+
+  test('should render device detail, receive self_sensor message', async () => {
+    const valueBoxs = await _receiveDataMqtt(
+      [
+        { id: 2540 },
+        { id: 2541 },
+        { id: 2542 },
+        { id: 2543 },
+        { id: 2544 },
+        { id: 2545 },
+        { id: 2546 },
+      ],
+      `eoh/chip/${gatewayData.code}/self_sensor`,
+      {
+        temperature: 27.6,
+        volt: 3.3,
+        signal: 100,
+        modbus_fail: 0,
+        modbus_total: 100,
+        internal_temperature: 45,
+        is_battery: 0,
+      }
+    );
+    expect(valueBoxs[0].props.value).toEqual(27.6);
+    expect(valueBoxs[1].props.value).toEqual(3.3);
+    expect(valueBoxs[2].props.value).toEqual(100);
+    expect(valueBoxs[3].props.value).toEqual(0);
+    expect(valueBoxs[4].props.value).toEqual(100);
+    expect(valueBoxs[5].props.value).toEqual(45);
+    expect(valueBoxs[6].props.value).toEqual(0);
+  });
+
+  const _watchDataChipsOnDeviceDetail = async (expects) => {
+    const widgetConfigs = [
+      { id: 2540 },
+      { id: 2541 },
+      { id: 2542 },
+      { id: 2543 },
+      { id: 2544 },
+      { id: 2545 },
+      { id: 2546 },
+    ];
+    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, []);
+    mock.onPost(API.IOT.CHIP_MANAGER.WATCH_DATA_CHIPS()).reply(200, {
+      7689: {
+        last_self_data: {
+          temperature: 27.6,
+          volt: 3.3,
+          signal: 100,
+          modbus_fail: 0,
+          modbus_total: 100,
+          internal_temperature: 45,
+          is_battery: 0,
+          last_updated: '2025-09-09T12:00:00Z',
+        },
+      },
+    });
+    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: 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 valueBoxs = instance.findAllByType(QualityIndicatorItem);
+    for (let i = 0; i < widgetConfigs.length; i++) {
+      expect(valueBoxs[i].props.value).toEqual(expects[i]);
+    }
+
+    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]);
+  };
+
+  test('should render device detail, watch data chips self sensorr', async () => {
+    await _watchDataChipsOnDeviceDetail([27.6, 3.3, 100, 0, 100, 45, 0]);
+  });
+
+  test('should render device detail, watch data chips self sensorr with past last_updated', async () => {
+    setConfigGlobalState('configValues', {
+      2540: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2541: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2542: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2543: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2544: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2545: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+      2546: { value: 0, last_updated: moment('2025-09-09T12:00:01Z') },
+    });
+    await _watchDataChipsOnDeviceDetail([0, 0, 0, 0, 0, 0, 0]);
+  });
+
+  test('should render device detail, watch data chips self sensorr with future last_updated', async () => {
+    setConfigGlobalState('configValues', {
+      2540: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2541: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2542: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2543: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2544: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2545: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+      2546: { value: 0, last_updated: moment('2025-09-09T11:59:59Z') },
+    });
+    await _watchDataChipsOnDeviceDetail([27.6, 3.3, 100, 0, 100, 45, 0]);
+  });
+});

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

@@ -1,5 +1,6 @@
 import { NavigationContext, useNavigation } from '@react-navigation/native';
 import MockAdapter from 'axios-mock-adapter';
+import mqtt from 'precompiled-mqtt/dist/mqtt.browser';
 import React from 'react';
 import { Alert, ScrollView } from 'react-native';
 import { act, create } from 'react-test-renderer';
@@ -14,6 +15,8 @@ import { AccessibilityLabel } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import { useWatchConfigs } from '../../../hooks/IoT';
+import { gatewayDataFactory } from '../../../utils/FactoryGateway';
+import { watchMultiDataChips } from '../../../iot/Monitor';
 import api from '../../../utils/Apis/axios';
 import { getTranslate } from '../../../utils/I18n';
 import Routes from '../../../utils/Route';
@@ -29,6 +32,13 @@ jest.mock('../../../hooks/IoT', () => {
   };
 });
 
+jest.mock('../../../iot/Monitor', () => {
+  return {
+    ...jest.requireActual('../../../iot/Monitor'),
+    watchMultiDataChips: jest.fn(),
+  };
+});
+
 jest.mock('../../../hooks/Common', () => {
   return {
     ...jest.requireActual('../../../hooks/Common'),
@@ -198,6 +208,10 @@ describe('test DeviceDetail', () => {
     useWatchConfigs.mockReset();
   });
 
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
   it('render DeviceDetail render SensorDisplayItem', async () => {
     const responseDisplay = data_sensor_display;
 
@@ -898,7 +912,7 @@ describe('test DeviceDetail', () => {
         el.props.accessibilityLabel === AccessibilityLabel.SENSOR_DISPLAY_ITEM
     );
     expect(sensorDisplayItem.length).toEqual(1);
-    expect(useWatchConfigs).toHaveBeenCalledWith([]);
+    expect(useWatchConfigs).toHaveBeenLastCalledWith([1]);
   });
 
   it('watch action config', async () => {
@@ -926,7 +940,7 @@ describe('test DeviceDetail', () => {
       tree = await create(wrapComponent(store, account, route));
     });
 
-    expect(useWatchConfigs).toHaveBeenCalledWith([]);
+    expect(useWatchConfigs).toHaveBeenLastCalledWith([2]);
   });
 
   it('watch stages grid action config', async () => {
@@ -957,6 +971,50 @@ describe('test DeviceDetail', () => {
       tree = await create(wrapComponent(store, account, route));
     });
 
-    expect(useWatchConfigs).toHaveBeenCalledWith([]);
+    expect(useWatchConfigs).toHaveBeenLastCalledWith([3]);
+  });
+
+  it('test connect mqtt, watch data chips and config', async () => {
+    mock.onGet(API.CHIP.JSON_CONFIGURATION).reply(200, [
+      { ...gatewayDataFactory, id: 1 },
+      { ...gatewayDataFactory, code: 'xxx' },
+    ]);
+    mock.onGet(API.CHIP.SHARED_CONFIGURATION).reply(200, [
+      { ...gatewayDataFactory, id: 1 },
+      { ...gatewayDataFactory, code: 'yyy' },
+    ]);
+    const responseDisplay = {
+      items: [
+        {
+          id: 1,
+          order: 0,
+          template: 'on_off_button_action_template',
+          type: 'on_off_button_action_template',
+          configuration: {
+            config: 2,
+          },
+        },
+      ],
+    };
+    const responseDisplayValueV2 = {
+      configs: [{ id: 2 }],
+      is_connected: true,
+      last_updated: '2021-01-24T12:00:00.000Z',
+    };
+    mockAxios(responseDisplay, responseDisplayValueV2);
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+
+    const client = mqtt.connect();
+    await act(async () => {
+      client.trigger('connect');
+    });
+    expect(client.subscribe).toHaveBeenCalledWith(
+      `eoh/chip/${gatewayDataFactory.code}/#`
+    );
+
+    expect(useWatchConfigs).toHaveBeenLastCalledWith([2]);
+    expect(watchMultiDataChips).toHaveBeenCalledWith([1]);
   });
 });

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

@@ -1,3 +1,4 @@
+import MockAdapter from 'axios-mock-adapter';
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
 
@@ -8,17 +9,28 @@ import ActionGroup from '../../../commons/ActionGroup';
 import MediaPlayerDetail from '../../../commons/MediaPlayerDetail';
 import FlatListItems from '../../../commons/Device/FlatListItems';
 import VisualChart from '../components/VisualChart';
-import SmartIr from '../../SmartIr';
 import FooterInfo from '../../../commons/Device/FooterInfo';
 import Anemometer from '../../../commons/Device/WindSpeed/Anemometer';
 import ProgressBar from '../../../commons/Device/ProgressBar';
 import Compass from '../../../commons/Device/WindDirection/Compass';
 import DeviceAlertStatus from '../../../commons/Device/DeviceAlertStatus';
-import MockAdapter from 'axios-mock-adapter';
-import api from '../../../utils/Apis/axios';
 import CurrentRainSensor from '../../../commons/Device/RainningSensor/CurrentRainSensor';
 import LabelValue from '../../../commons/Device/LabelValue';
 import Text from '../../../commons/Text';
+import SmartIr from '../../SmartIr';
+import api from '../../../utils/Apis/axios';
+
+const mockIncrementReviewTrigger = jest.fn();
+const mockAskReview = jest.fn();
+jest.mock('../../../hooks/Review/useInAppReview', () => {
+  return {
+    __esModule: true,
+    default: jest.fn(() => ({
+      askReview: mockAskReview,
+      incrementReviewTrigger: mockIncrementReviewTrigger,
+    })),
+  };
+});
 
 jest.mock('../../../iot/states', () => ({
   useConfigGlobalState: () => [{}, null],
@@ -35,6 +47,11 @@ const wrapComponent = ({ ...rest }) => (
 
 describe('Test SensorDisplayItem', () => {
   let tree;
+
+  beforeEach(() => {
+    mockIncrementReviewTrigger.mockClear();
+  });
+
   it('render visualChart', async () => {
     const item = {
       id: 10452,
@@ -103,6 +120,14 @@ describe('Test SensorDisplayItem', () => {
     expect(actionGroup).toHaveLength(1);
     const labels = instance.findAllByType(Text);
     expect(labels[0].props.children).toEqual('LED');
+
+    await act(async () => {
+      actionGroup[0].props.doAction(
+        { id: 1, name: 'sensor name' },
+        { key: 'action key' }
+      );
+    });
+    expect(mockIncrementReviewTrigger).toHaveBeenCalled();
   });
 
   it('render camera', async () => {