@eohjsc/react-native-smart-city 0.3.29 → 0.3.32

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

@@ -0,0 +1,89 @@
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+
+import SelectDeviceType from '../SelectDeviceType';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import Button from '../../../commons/Button';
+import Routes from '../../../utils/Route';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SelectDeviceType route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return { ...jest.requireActual('react'), memo: (x) => x };
+});
+
+const mockedNavigate = jest.fn();
+const mockedGoBack = jest.fn();
+
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+describe('Test select device type', () => {
+  let tree;
+  let route;
+
+  afterEach(() => {
+    mockedNavigate.mockClear();
+  });
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitId: 1,
+        stationId: 1,
+      },
+    };
+  });
+
+  test('render select type', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const buttons = instance.findAllByType(Button);
+    expect(buttons).toHaveLength(4);
+  });
+
+  const selectDeviceType = async (index) => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const buttons = instance.findAllByType(Button);
+    await act(async () => {
+      buttons[index].props.onPress();
+    });
+
+    expect(mockedNavigate).toBeCalled();
+  };
+
+  test('select modbus', async () => {
+    await selectDeviceType(0);
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectModbusGateway);
+  });
+  test('select zigbee', async () => {
+    await selectDeviceType(1);
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.SelectZigbeeGateway);
+  });
+  test('select gateway', async () => {
+    await selectDeviceType(2);
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ScanGatewayQR);
+  });
+  test('select wifi', async () => {
+    await selectDeviceType(3);
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ScanWifiDeviceQR);
+  });
+});

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

@@ -0,0 +1,48 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import SelectDeviceUnit from '../SelectDeviceUnit';
+import AccessibilityLabel from '../../../configs/AccessibilityLabel';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+
+const mockedGoBack = jest.fn();
+const mockedNavigate = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+  };
+});
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SelectDeviceUnit route={route} />
+  </SCProvider>
+);
+
+describe('test single SelectUnit', () => {
+  let tree;
+
+  test('click next', async () => {
+    const route = { params: { addType: 'AddSubUnit' } };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const goBack = instance.find(
+      (item) =>
+        item.props.accessibilityLabel ===
+        `${AccessibilityLabel.PREFIX.SELECT_UNIT}${AccessibilityLabel.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
+    );
+
+    await act(async () => {
+      goBack.props.onPress();
+    });
+    expect(mockedNavigate).toBeCalled();
+  });
+});

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

@@ -0,0 +1,77 @@
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+
+import SelectModbusGateway from '../SelectModbusGateway';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import SelectGateway from '../../../commons/SelectGateway';
+import Routes from '../../../utils/Route';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SelectModbusGateway route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return { ...jest.requireActual('react'), memo: (x) => x };
+});
+
+const mockedNavigate = jest.fn();
+const mockedGoBack = jest.fn();
+
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+describe('Test select modbus gateway', () => {
+  let tree;
+  let route;
+
+  afterEach(() => {
+    mockedNavigate.mockClear();
+  });
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitId: 1,
+        stationId: 2,
+      },
+    };
+  });
+
+  test('render gateway', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SelectGateway);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('select gateway', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const selectGateway = instance.findByType(SelectGateway);
+
+    await act(async () => {
+      selectGateway.props.onPressNext({ id: 3 });
+    });
+
+    expect(mockedNavigate).toBeCalledWith(Routes.ScanModbusQR, {
+      unitId: 1,
+      stationId: 2,
+      chipId: 3,
+    });
+  });
+});

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

@@ -0,0 +1,77 @@
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+
+import SelectZigbeeGateway from '../SelectZigbeeGateway';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import SelectGateway from '../../../commons/SelectGateway';
+import Routes from '../../../utils/Route';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SelectZigbeeGateway route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return { ...jest.requireActual('react'), memo: (x) => x };
+});
+
+const mockedNavigate = jest.fn();
+const mockedGoBack = jest.fn();
+
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+describe('Test select zigbee gateway', () => {
+  let tree;
+  let route;
+
+  afterEach(() => {
+    mockedNavigate.mockClear();
+  });
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitId: 1,
+        stationId: 2,
+      },
+    };
+  });
+
+  test('render gateway', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SelectGateway);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('select gateway', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const selectGateway = instance.findByType(SelectGateway);
+
+    await act(async () => {
+      selectGateway.props.onPressNext({ id: 3 });
+    });
+
+    expect(mockedNavigate).toBeCalledWith(Routes.ConnectingZigbeeDevice, {
+      unitId: 1,
+      stationId: 2,
+      chipId: 3,
+    });
+  });
+});

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

@@ -0,0 +1,294 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import ShareWifiPassword from '../ShareWifiPassword';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import ButtonPopup from '../../../commons/ButtonPopup';
+import TextInputPassword from '../../../commons/Form/TextInputPassword';
+import { Platform, TouchableOpacity } from 'react-native';
+import WifiManager from 'react-native-wifi-reborn';
+import dgram from 'react-native-udp';
+import Routes from '../../../utils/Route';
+import Toast from 'react-native-toast-message';
+
+const mockedGoBack = jest.fn();
+const mockedNavigate = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <ShareWifiPassword route={route} />
+  </SCProvider>
+);
+
+describe('test share wifi password', () => {
+  let tree;
+
+  beforeEach(() => {
+    const socket = dgram.createSocket({});
+    socket.on.mockClear();
+    socket.bind.mockClear();
+    socket.send.mockClear();
+    socket.close.mockClear();
+  });
+
+  test('render share wifi', async () => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const popups = instance.findAllByType(ButtonPopup);
+    expect(popups).toHaveLength(1);
+    const passwordFields = instance.findAllByType(TextInputPassword);
+    expect(passwordFields).toHaveLength(1);
+  });
+
+  test('auto connect to wifi prefix on ios', async () => {
+    Platform.OS = 'ios';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    expect(WifiManager.connectToProtectedSSIDPrefix).toBeCalled();
+    expect(WifiManager.connectToProtectedSSIDPrefix.mock.calls[0][0]).toEqual(
+      'eoh.robot.'
+    );
+    const socket = dgram.createSocket();
+    expect(socket.bind).toBeCalled();
+  });
+
+  test('fail connect to wifi prefix on ios', async () => {
+    Platform.OS = 'ios';
+    const route = { params: { prefix: 'robot' } };
+    WifiManager.connectToProtectedSSIDPrefix.mockImplementationOnce(
+      async () => {
+        throw 'Cannot connect to protected prefix SSID';
+      }
+    );
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const socket = dgram.createSocket();
+    expect(socket.bind).not.toBeCalled();
+  });
+
+  test('auto connect to wifi android', async () => {
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    WifiManager.loadWifiList.mockImplementationOnce(async () => [
+      { SSID: 'random-name' },
+      { SSID: 'eoh.lite.xxx' },
+      { SSID: 'eoh.robot.xxx' },
+    ]);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    expect(WifiManager.connectToProtectedSSID).toBeCalled();
+    expect(WifiManager.connectToProtectedSSID.mock.calls[0][0]).toEqual(
+      'eoh.robot.xxx'
+    );
+    const socket = dgram.createSocket();
+    expect(socket.bind).toBeCalled();
+  });
+
+  test('fail connect to wifi android', async () => {
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    WifiManager.reScanAndLoadWifiList.mockImplementationOnce(async () => [
+      { SSID: 'random-name' },
+      { SSID: 'eoh.lite.xxx' },
+      { SSID: 'eoh.robot.xxx' },
+    ]);
+    WifiManager.connectToProtectedSSID.mockImplementationOnce(async () => {
+      throw 'Cannot connect to wifi';
+    });
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    const socket = dgram.createSocket();
+    expect(socket.bind).not.toBeCalled();
+  });
+
+  test('fail load wifi list android', async () => {
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    WifiManager.reScanAndLoadWifiList.mockImplementationOnce(async () => {
+      throw 'Cannot load wifi list to wifi';
+    });
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    const socket = dgram.createSocket();
+    expect(socket.bind).not.toBeCalled();
+  });
+
+  test('request wifi list from device', async () => {
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    jest.runOnlyPendingTimers();
+    const socket = dgram.createSocket({});
+    expect(socket.send).toBeCalled();
+    const data = JSON.parse(socket.send.mock.calls[0][0]);
+    expect(data.type).toEqual('scan');
+  });
+
+  test('got wifi list from device', async () => {
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    const socket = dgram.createSocket({});
+    expect(socket.on).toBeCalled();
+    expect(socket.on.mock.calls[0][0]).toEqual('message');
+
+    expect(
+      tree.root.findAll((el) => el.type === TouchableOpacity)
+    ).toHaveLength(4);
+
+    await act(async () => {
+      socket.on.mock.calls[0][1](
+        JSON.stringify({
+          wifi: [{ ssid: 'wifi 1' }, { ssid: 'wifi.2' }],
+        })
+      );
+    });
+    // todo Bang should test wifi display
+    expect(socket.close).toBeCalled();
+  });
+
+  test('got error while request wifi list from device', async () => {
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+
+    const socket = dgram.createSocket({});
+    expect(socket.on).toBeCalledTimes(2);
+    expect(socket.on.mock.calls[1][0]).toEqual('error');
+
+    await act(async () => {
+      socket.on.mock.calls[1][1]();
+    });
+    expect(Toast.show).toBeCalled();
+  });
+
+  const sendPasswordToGateway = async () => {
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const popup = tree.root.find((el) => el.type === ButtonPopup);
+
+    const socket = dgram.createSocket({});
+    socket.on.mockClear();
+    socket.close.mockClear();
+    socket.send.mockClear();
+
+    await act(async () => {
+      await popup.props.onPressMain();
+    });
+    jest.runOnlyPendingTimers();
+
+    expect(socket.send).toBeCalled();
+    expect(socket.on).toBeCalled();
+  };
+
+  test('send password to gateway', async () => {
+    await sendPasswordToGateway();
+    const socket = dgram.createSocket({});
+    expect(socket.on.mock.calls[0][0]).toEqual('message');
+    expect(JSON.parse(socket.send.mock.calls[0][0]).type).toEqual('connect');
+  });
+
+  test('error share password to gateway', async () => {
+    await sendPasswordToGateway();
+    const socket = dgram.createSocket({});
+    expect(socket.on.mock.calls[1][0]).toEqual('error');
+
+    await act(async () => {
+      socket.on.mock.calls[1][1]();
+    });
+
+    expect(Toast.show).toBeCalled();
+  });
+
+  const receiveGatewayInfo = async (
+    info = {
+      gateway: {},
+    }
+  ) => {
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+    const route = { params: { prefix: 'robot' } };
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const popup = tree.root.find((el) => el.type === ButtonPopup);
+
+    const socket = dgram.createSocket({});
+    socket.on.mockClear();
+    socket.close.mockClear();
+    socket.send.mockClear();
+
+    await act(async () => {
+      await popup.props.onPressMain();
+    });
+    jest.runOnlyPendingTimers();
+
+    expect(socket.on).toBeCalled();
+    expect(socket.on.mock.calls[0][0]).toEqual('message');
+
+    await act(async () => {
+      socket.on.mock.calls[0][1](JSON.stringify(info));
+    });
+  };
+
+  test('close socket after gateway success connect to wifi', async () => {
+    await receiveGatewayInfo();
+    const socket = dgram.createSocket({});
+    expect(socket.close).toBeCalled();
+  });
+
+  test('not close socket after gateway fail connect to wifi', async () => {
+    await receiveGatewayInfo({});
+    const socket = dgram.createSocket({});
+    expect(socket.close).not.toBeCalled();
+  });
+
+  test('go to connecting after restore wifi', async () => {
+    await receiveGatewayInfo();
+    WifiManager.getCurrentWifiSSID.mockImplementationOnce(
+      async () => 'other-random-name'
+    );
+    jest.runOnlyPendingTimers(); // check SSID interval
+    await new Promise(jest.requireActual('timers').setImmediate);
+    expect(mockedNavigate).toBeCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(
+      Routes.ConnectingWifiDevice
+    );
+  });
+});

package/src/screens/AddNewGateway/hooks/__Tests__/index.test.js

@@ -0,0 +1,27 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import MockAdapter from 'axios-mock-adapter';
+import api from '../../../../utils/Apis/axios';
+import { useConnectGateway } from '..';
+
+import { API } from '../../../../configs';
+
+const mock = new MockAdapter(api.axiosInstance);
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      dangerouslyGetParent: () => ({
+        dangerouslyGetState: jest.fn(),
+      }),
+    }),
+  };
+});
+describe('Test useHomeAssistantConnection', () => {
+  it('test connectGoogleHome all connected', async () => {
+    const { result } = renderHook(() => useConnectGateway(1));
+    await act(async () => {
+      await result.current.onPressDone();
+    });
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(200, {});
+  });
+});

package/src/screens/AddNewGateway/index.js

@@ -7,12 +7,12 @@ import { Colors } from '../../configs';
 import { Section, ViewButtonBottom } from '../../commons';
 import Text from '../../commons/Text';
 import Routes from '../../utils/Route';
-import { TESTID } from '../../configs/Constants';
+import { AccessibilityLabel } from '../../configs/Constants';
 import styles from './AddNewGatewayStyles';
 
 const AddNewGateway = memo(({ route }) => {
   const t = useTranslations();
-  const { unit_id, wifiName, wifiPass, imei } = route.params;
+  const { unit_id, wifiName, wifiPass, imei } = route?.params || {};
   const { navigate, goBack } = useNavigation();
   const [phoneNumber, setPhoneNumber] = useState('');
   const [chipName, setChipName] = useState('');
@@ -55,7 +55,7 @@ const AddNewGateway = memo(({ route }) => {
   return (
     <SafeAreaView style={styles.wrap}>
       <Text
-        testID={TESTID.ADD_NEW_GATEWAY_ADD}
+        accessibilityLabel={AccessibilityLabel.ADD_NEW_GATEWAY_ADD}
         semibold
         size={20}
         color={Colors.Black}
@@ -64,7 +64,7 @@ const AddNewGateway = memo(({ route }) => {
         {t('add_new_gateway')}
       </Text>
       <Text
-        testID={TESTID.ADD_NEW_GATEWAY_THEN_SELECT}
+        accessibilityLabel={AccessibilityLabel.ADD_NEW_GATEWAY_THEN_SELECT}
         size={14}
         color={Colors.Gray8}
         style={styles.textNote}

package/src/screens/AddNewOneTap/__test__/AddNewOneTap.test.js

@@ -4,7 +4,7 @@ import { Platform, TextInput, TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
 
 import AddNewOneTap from '..';
-import { TESTID } from '../../../configs/Constants';
+import { AccessibilityLabel } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import Routes from '../../../utils/Route';
@@ -80,7 +80,8 @@ describe('test AddNewOneTap', () => {
     const instance = tree.root;
     const inputName = instance.findAll(
       (el) =>
-        el.props.testID === TESTID.NAME_YOUR_BUTTON && el.type === TextInput
+        el.props.accessibilityLabel === AccessibilityLabel.NAME_YOUR_BUTTON &&
+        el.type === TextInput
     );
     expect(inputName).toHaveLength(1);
 
@@ -90,7 +91,7 @@ describe('test AddNewOneTap', () => {
 
     const item = instance.findAll(
       (el) =>
-        el.props.testID === TESTID.BOTTOM_VIEW_MAIN &&
+        el.props.accessibilityLabel === AccessibilityLabel.BOTTOM_VIEW_MAIN &&
         el.type === TouchableOpacity
     );
 
@@ -114,7 +115,7 @@ describe('test AddNewOneTap', () => {
 
     const item = tree.root.findAll(
       (el) =>
-        el.props.testID === TESTID.BOTTOM_VIEW_MAIN &&
+        el.props.accessibilityLabel === AccessibilityLabel.BOTTOM_VIEW_MAIN &&
         el.type === TouchableOpacity
     );