@eohjsc/react-native-smart-city 0.7.8 → 0.7.9

package/src/screens/AddNewGateway/__test__/ScanDeviceLocal.test.js

@@ -0,0 +1,475 @@
+import React from 'react';
+import MockAdapter from 'axios-mock-adapter';
+import { FlatList, TouchableOpacity, ActivityIndicator } from 'react-native';
+import renderer, { act } from 'react-test-renderer';
+import { useNavigation } from '@react-navigation/native';
+import Zeroconf from 'react-native-zeroconf';
+
+import { ViewButtonBottom, HeaderCustom } from '../../../commons';
+import { DEVICE_TYPE } from '../../../configs/Constants';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import ScanDeviceLocal from '../ScanDeviceLocal';
+import { ToastBottomHelper } from '../../../utils/Utils';
+import { getTranslate } from '../../../utils/I18n';
+import Routes from '../../../utils/Route';
+
+import { API as DEVICEAPI } from '../configs/API';
+import { api as deviceApi } from '../hooks/useConnectDevice';
+
+import { API } from '../../../configs';
+import api from '../../../utils/Apis/axios';
+
+jest.mock('react-native-zeroconf', () => jest.fn());
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <ScanDeviceLocal route={route} />
+  </SCProvider>
+);
+
+const mock = new MockAdapter(api.axiosInstance);
+const mockDeviceApi = new MockAdapter(deviceApi.axiosInstance);
+
+describe('test ScanDeviceLocal', () => {
+  let tree;
+  const mockedNavigate = useNavigation().navigate;
+  const mockedGoBack = useNavigation().goBack;
+  const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+
+  const zeroconfMock = {
+    on: jest.fn(),
+    scan: jest.fn(),
+    stop: jest.fn(),
+  };
+
+  beforeEach(() => {
+    Zeroconf.mockImplementation(() => zeroconfMock);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const resolveDeviceAndPress = async (instance, resolvedDevice) => {
+    mock.onGet(API.DEV_MODE.CHIP_QR_CODE.DETAIL_BY_SECRET()).reply(200, {
+      host: 'mqtt.example.com',
+      port: 1883,
+      secret: '123456',
+    });
+    mockDeviceApi.onGet(DEVICEAPI.BOARD.DETAIL()).reply(200, {
+      name: resolvedDevice.name,
+      type: resolvedDevice.type,
+      secret: '123456',
+    });
+    mockDeviceApi.onPost(DEVICEAPI.BOARD.CONFIG()).reply(200, {
+      status: 'success',
+    });
+
+    const resolvedCallback = zeroconfMock.on.mock.calls.find(
+      (call) => call[0] === 'resolved'
+    )[1];
+    await act(async () => {
+      await resolvedCallback(resolvedDevice);
+    });
+
+    const flatList = instance.findByType(FlatList);
+    expect(flatList.props.data).toEqual([resolvedDevice]);
+    await act(async () => {
+      await flatList.props.renderItem({ item: resolvedDevice });
+    });
+
+    // Select first device
+    const touchable = flatList.findAllByType(TouchableOpacity);
+    expect(touchable).toHaveLength(1);
+    await act(async () => {
+      await touchable[0].props.onPress();
+    });
+
+    // Click connect button
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    expect(viewButtonBottom.props.rightDisabled).toBeFalsy();
+    await act(async () => {
+      await viewButtonBottom.props.onRightClick();
+    });
+
+    expect(deviceApi.baseURL).toBe(`http://${resolvedDevice.host}/api`);
+
+    expect(zeroconfMock.on).toHaveBeenCalledWith(
+      'resolved',
+      expect.any(Function)
+    );
+    expect(zeroconfMock.on).toHaveBeenCalledWith(
+      'remove',
+      expect.any(Function)
+    );
+    expect(zeroconfMock.on).toHaveBeenCalledWith('error', expect.any(Function));
+    expect(zeroconfMock.scan).toHaveBeenCalledWith('plugandplay', 'tcp');
+  };
+
+  it('test connect gateway and navigate', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Gateway 1',
+      type: 'gateway',
+    };
+
+    await resolveDeviceAndPress(instance, resolvedDevice);
+
+    expect(mockedNavigate).toHaveBeenCalledWith(Routes.ConnectingWifiDevice, {
+      unit: 1,
+      subUnit: undefined,
+      addDeviceType: 'gateway',
+      qrData: {
+        host: 'mqtt.example.com',
+        port: 1883,
+        secret: '123456',
+      },
+      gateway: {
+        name: 'Gateway 1',
+        type: 'gateway',
+        secret: '123456',
+      },
+      code: expect.any(String),
+    });
+  });
+
+  it('test connect device with subunit and navigate', async () => {
+    const route = { params: { unit: 1, subUnit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Device 1',
+      type: 'end_device',
+    };
+
+    await resolveDeviceAndPress(instance, resolvedDevice);
+
+    expect(mockedNavigate).toHaveBeenCalledWith(Routes.ConnectingWifiDevice, {
+      unit: 1,
+      subUnit: 1,
+      addDeviceType: 'end_device',
+      qrData: {
+        host: 'mqtt.example.com',
+        port: 1883,
+        secret: '123456',
+      },
+      gateway: {
+        name: 'Device 1',
+        type: 'end_device',
+        secret: '123456',
+      },
+      code: expect.any(String),
+    });
+  });
+
+  it('test connect device without subunit and navigate', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Device 1',
+      type: 'end_device',
+    };
+
+    await resolveDeviceAndPress(instance, resolvedDevice);
+
+    expect(mockedNavigate).toHaveBeenCalledWith(Routes.SelectDeviceSubUnit, {
+      unit: 1,
+      deviceType: DEVICE_TYPE.SCAN_DEVICE,
+      qrData: {
+        host: 'mqtt.example.com',
+        port: 1883,
+        secret: '123456',
+      },
+      gateway: {
+        name: 'Device 1',
+        type: 'end_device',
+        secret: '123456',
+      },
+      code: expect.any(String),
+    });
+  });
+
+  it('test handle go back', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const headerCustom = instance.findByType(HeaderCustom);
+    await act(async () => {
+      await headerCustom.props.onGoBack();
+    });
+    expect(mockedGoBack).toHaveBeenCalled();
+  });
+
+  it('test disable connect button when fetch device info error', async () => {
+    mockDeviceApi.onGet(DEVICEAPI.BOARD.DETAIL()).networkError();
+
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Device 1',
+      type: 'end_device',
+    };
+
+    const resolvedCallback = zeroconfMock.on.mock.calls.find(
+      (call) => call[0] === 'resolved'
+    )[1];
+    await act(async () => {
+      await resolvedCallback(resolvedDevice);
+    });
+
+    const flatList = instance.findByType(FlatList);
+    expect(flatList.props.data).toEqual([resolvedDevice]);
+    await act(async () => {
+      await flatList.props.renderItem({ item: resolvedDevice });
+    });
+
+    // Select first device
+    const touchable = flatList.findAllByType(TouchableOpacity);
+    expect(touchable).toHaveLength(1);
+    await act(async () => {
+      await touchable[0].props.onPress();
+    });
+
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    expect(viewButtonBottom.props.rightDisabled).toBeTruthy();
+  });
+
+  it('test handle connecting device error', async () => {
+    mockDeviceApi.onPost(DEVICEAPI.BOARD.CONFIG()).reply(400, {
+      status: 'error',
+      message: 'Invalid token',
+    });
+
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    await act(async () => {
+      await viewButtonBottom.props.onRightClick();
+    });
+    expect(spyToastError).toHaveBeenCalledWith(
+      getTranslate('en', 'error_sending_data_to_wifi_device')
+    );
+  });
+
+  it('test handle zeroconf.on error', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    expect(zeroconfMock.scan).toHaveBeenCalledTimes(1);
+    expect(zeroconfMock.stop).not.toHaveBeenCalled();
+    const errorCallback = zeroconfMock.on.mock.calls.find(
+      (call) => call[0] === 'error'
+    )[1];
+    await act(async () => {
+      await errorCallback();
+    });
+    expect(zeroconfMock.scan).toHaveBeenCalledTimes(2);
+    expect(zeroconfMock.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it('test call zeroconf.stop in cleanup function when unmount', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    expect(zeroconfMock.scan).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      tree.unmount();
+    });
+    expect(zeroconfMock.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it('test handle zeroconf throw scan error', async () => {
+    Zeroconf.mockImplementation(() => {
+      throw new Error('Scan error');
+    });
+
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    expect(zeroconfMock.on).not.toHaveBeenCalled();
+    expect(zeroconfMock.scan).not.toHaveBeenCalled();
+    expect(zeroconfMock.stop).not.toHaveBeenCalled();
+  });
+
+  it('test handle zeroconf throw scan error and cleanup function when unmount', async () => {
+    Zeroconf.mockImplementation(() => {
+      throw new Error('Scan error');
+    });
+
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    expect(zeroconfMock.on).not.toHaveBeenCalled();
+    expect(zeroconfMock.scan).not.toHaveBeenCalled();
+    expect(zeroconfMock.stop).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree.unmount();
+    });
+    expect(zeroconfMock.stop).not.toHaveBeenCalled();
+  });
+
+  it('test handleGoBack stops zeroconf and navigates back', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const headerCustom = instance.findByType(HeaderCustom);
+    await act(async () => {
+      await headerCustom.props.onGoBack();
+    });
+
+    expect(zeroconfMock.stop).toHaveBeenCalledTimes(1);
+    expect(mockedGoBack).toHaveBeenCalled();
+  });
+
+  it('test handleGoBack when zeroconf throw scan error', async () => {
+    Zeroconf.mockImplementation(() => {
+      throw new Error('Scan error');
+    });
+
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const headerCustom = instance.findByType(HeaderCustom);
+    await act(async () => {
+      await headerCustom.props.onGoBack();
+    });
+
+    expect(zeroconfMock.stop).not.toHaveBeenCalled();
+    expect(mockedGoBack).toHaveBeenCalled();
+  });
+
+  it('test renders loading indicator when device list is empty', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const activityIndicator = instance.findByType(ActivityIndicator);
+    expect(activityIndicator).toBeTruthy();
+  });
+
+  it('test renders device list when devices are available', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Device 1',
+      type: 'end_device',
+    };
+
+    const resolvedCallback = zeroconfMock.on.mock.calls.find(
+      (call) => call[0] === 'resolved'
+    )[1];
+    await act(async () => {
+      await resolvedCallback(resolvedDevice);
+    });
+
+    await resolveDeviceAndPress(instance, resolvedDevice);
+
+    const flatList = instance.findByType(FlatList);
+    expect(flatList.props.data).toEqual([resolvedDevice]);
+  });
+
+  it('test renders device list when zeroconf.on remove', async () => {
+    const route = { params: { unit: 1 } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const resolvedDevice = {
+      host: 'host-1.lan',
+      name: 'Device 1',
+      type: 'end_device',
+    };
+
+    await resolveDeviceAndPress(instance, resolvedDevice);
+
+    const removeCallback = zeroconfMock.on.mock.calls.find(
+      (call) => call[0] === 'remove'
+    )[1];
+
+    // Remove device not in the list
+    await act(async () => {
+      await removeCallback('Device 2');
+    });
+
+    const flatList = instance.findByType(FlatList);
+    expect(flatList.props.data).toEqual([resolvedDevice]);
+
+    // Remove device in the list
+    await act(async () => {
+      await removeCallback('Device 1');
+    });
+
+    const flatListAfter = instance.findAllByType(FlatList);
+    expect(flatListAfter.length).toBe(0);
+
+    const activityIndicator = instance.findByType(ActivityIndicator);
+    expect(activityIndicator).toBeTruthy();
+  });
+
+  it('test when params is null', async () => {
+    const route = {};
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+
+    const headerCustom = instance.findByType(HeaderCustom);
+    expect(headerCustom).toBeTruthy();
+
+    const activityIndicator = instance.findByType(ActivityIndicator);
+    expect(activityIndicator).toBeTruthy();
+  });
+});

package/src/screens/AddNewGateway/__test__/SelectDeviceType.test.js

@@ -51,7 +51,7 @@ describe('Test select device type', () => {
         el.type === TouchableOpacity &&
         el.props.accessibilityLabel === AccessibilityLabel.ITEM_DEVICE_TYPE
     );
-    expect(deviceTypeItems).toHaveLength(4);
+    expect(deviceTypeItems).toHaveLength(5);
   });
 
   it('render select type with station', async () => {
@@ -73,7 +73,7 @@ describe('Test select device type', () => {
         el.type === TouchableOpacity &&
         el.props.accessibilityLabel === AccessibilityLabel.ITEM_DEVICE_TYPE
     );
-    expect(deviceTypeItems).toHaveLength(3);
+    expect(deviceTypeItems).toHaveLength(4);
   });
 
   const selectDeviceType = async (index, storeData = {}) => {

package/src/screens/AddNewGateway/configs/API.js

@@ -0,0 +1,8 @@
+// API endpoint for interfacing with the chip
+export const API = {
+  BOARD: {
+    DETAIL: () => '/board_info.json',
+    SCAN_WIFI: () => '/wifi_scan.json',
+    CONFIG: () => '/config',
+  },
+};

package/src/screens/AddNewGateway/hooks/useConnectDevice.js

@@ -0,0 +1,59 @@
+import { create } from 'apisauce';
+import { useState, useCallback, useEffect } from 'react';
+
+import { API } from '../configs/API';
+
+export const api = create({
+  timeout: 10000,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+export const useConnectDevice = (host) => {
+  const [deviceInfo, setDeviceInfo] = useState();
+  const [listWiFiDevice, setListWiFiDevice] = useState([]);
+  const [lastError, setLastError] = useState();
+
+  useEffect(() => {
+    api.baseURL = `http://${host}/api`;
+  }, [host]);
+
+  const parseResponse = (response, setInfo) => {
+    if (response.data?.status === 'error') {
+      setLastError(response.data?.message);
+      return false;
+    }
+    if (!response.ok) {
+      setLastError(response.problem);
+      return false;
+    }
+    setInfo && setInfo(response.data);
+    return true;
+  };
+
+  const fetchDeviceInfo = useCallback(async () => {
+    const response = await api.get(API.BOARD.DETAIL());
+    return parseResponse(response, setDeviceInfo);
+  }, []);
+
+  const fetchListWiFiDevice = useCallback(async () => {
+    const response = await api.get(API.BOARD.SCAN_WIFI());
+    return parseResponse(response, setListWiFiDevice);
+  }, []);
+
+  const sendConfigToDevice = useCallback(async (config) => {
+    const response = await api.post(API.BOARD.CONFIG(), config);
+    return parseResponse(response);
+  }, []);
+
+  return {
+    deviceInfo,
+    listWiFiDevice,
+    lastError,
+
+    fetchDeviceInfo,
+    fetchListWiFiDevice,
+    sendConfigToDevice,
+  };
+};

package/src/screens/AllGateway/GatewayInfo/__test__/index.test.js

@@ -1,7 +1,7 @@
 import { useRoute } from '@react-navigation/native';
 import MockAdapter from 'axios-mock-adapter';
 import React from 'react';
-import { FlatList } from 'react-native';
+import { FlatList, TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
 
 import GatewayInfo from '..';
@@ -12,6 +12,8 @@ import API from '../../../../configs/API';
 import { AccessibilityLabel } from '../../../../configs/Constants';
 import { SCProvider } from '../../../../context';
 import { mockSCStore } from '../../../../context/mockStore';
+import { ToastBottomHelper } from '../../../../utils/Utils';
+import { getTranslate } from '../../../../utils/I18n';
 import t from '../../../../hooks/Common/useTranslations';
 import api from '../../../../utils/Apis/axios';
 import Routes from '../../../../utils/Route';
@@ -37,6 +39,9 @@ const buttonDelete = (instance) => {
 
 describe('Test GatewayInfo', () => {
   let tree;
+
+  const spyToastError = jest.spyOn(ToastBottomHelper, 'error');
+
   beforeEach(() => {
     useRoute.mockReturnValue({
       params: {
@@ -47,6 +52,7 @@ describe('Test GatewayInfo', () => {
 
   afterEach(() => {
     mock.reset();
+    spyToastError.mockClear();
   });
 
   it('test render GatewayInfo', async () => {
@@ -134,4 +140,55 @@ describe('Test GatewayInfo', () => {
     });
     expect(modal.props.isVisible).toBeFalsy();
   });
+
+  it('test press change wifi when gateway connected', async () => {
+    const mockResponse = {
+      id: 1,
+      name: 'device 1',
+      arduino_gateway: 1,
+      modbus_gateway: 1,
+      zigbee_gateway: 1,
+      is_connected: true,
+    };
+    mock.onGet(API.DEV_MODE.GATEWAY.DETAIL(1)).reply(200, mockResponse);
+
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+
+    const instance = tree.root;
+    const connectWifi = instance.find(
+      (el) =>
+        el.props.accessibilityLabel === AccessibilityLabel.CHANGE_WIFI &&
+        el.type === TouchableOpacity
+    );
+
+    await act(async () => {
+      await connectWifi.props.onPress();
+    });
+
+    expect(global.mockedNavigate).toHaveBeenCalledWith(Routes.GatewayWifi, {
+      gateway: mockResponse,
+    });
+  });
+
+  it('test press change wifi when gateway not connected', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+
+    const instance = tree.root;
+    const connectWifi = instance.find(
+      (el) =>
+        el.props.accessibilityLabel === AccessibilityLabel.CHANGE_WIFI &&
+        el.type === TouchableOpacity
+    );
+
+    await act(async () => {
+      await connectWifi.props.onPress();
+    });
+    expect(spyToastError).toHaveBeenCalledWith(
+      getTranslate('en', 'gateway_need_to_be_connected')
+    );
+  });
 });

package/src/screens/AllGateway/GatewayInfo/index.js

@@ -35,7 +35,8 @@ const GatewayInfo = () => {
     id,
     date_install = '',
     expired_at = '',
-    firmware = {},
+    info = {},
+    board = '',
     code = '',
     arduino_gateway = undefined,
     modbus_gateway = undefined,
@@ -60,8 +61,8 @@ const GatewayInfo = () => {
     () => [
       {
         id: 1,
-        title: 'system',
-        data: firmware?.board || '--',
+        title: 'board',
+        data: board || '--',
       },
       {
         id: 2,
@@ -96,14 +97,15 @@ const GatewayInfo = () => {
       {
         id: 9,
         title: 'firmware_version',
-        data: firmware?.board || '--',
+        data: info?.firmware_version || '--',
       },
     ],
     [
+      board,
       connection_time,
       date_install,
       expired_at,
-      firmware?.board,
+      info,
       id,
       code,
       wifi_ssid,
@@ -145,7 +147,7 @@ const GatewayInfo = () => {
     <View style={styles.wrap}>
       <Information
         buttonBackStyles={styles.buttonBack}
-        data={gatewayDetail}
+        gatewayDetail={gatewayDetail}
         methodsConnection={methodsConnection}
         listInformation={gatewayInformation}
         handleDeleteGateway={handleDeleteGateway}