@eohjsc/react-native-smart-city 0.3.30 → 0.3.33

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

@@ -0,0 +1,191 @@
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+import RenameNewDevices from '../RenameNewDevices';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import AccessibilityLabel from '../../../configs/AccessibilityLabel';
+import Text from '../../../commons/Text';
+import _TextInput from '../../../commons/Form/TextInput';
+import { TouchableOpacity } from 'react-native';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <RenameNewDevices route={route} />
+  </SCProvider>
+);
+
+const mock = new MockAdapter(api.axiosInstance);
+
+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,
+    }),
+  };
+});
+
+describe('Test rename new devices', () => {
+  let tree;
+  let route;
+
+  afterEach(() => {
+    mockedNavigate.mockClear();
+    mock.reset();
+  });
+
+  beforeEach(() => {
+    route = {
+      params: {
+        unitId: 1,
+        stationId: 2,
+        chipId: 3,
+        qrData: {},
+      },
+    };
+  });
+
+  test('rendering base', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel ===
+          `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-chip`
+      )
+    ).toHaveLength(0);
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel ===
+            `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-chip-name` &&
+          el.type === Text
+      )
+    ).toHaveLength(1);
+    expect(mock.history.get).toHaveLength(1);
+  });
+
+  test('rendering sensor', async () => {
+    mock.onGet().reply(200, {
+      id: 1,
+      name: 'chip',
+      can_rename: true,
+      sensors: [
+        {
+          id: 1,
+          name: 'sensor',
+          end_devices: [
+            {
+              id: 1,
+              name: 'end_device',
+            },
+          ],
+        },
+      ],
+    });
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel?.indexOf(
+            `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-sensor`
+          ) === 0 && el.type === _TextInput
+      )
+    ).toHaveLength(1);
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel?.indexOf(
+            `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-end_device`
+          ) === 0 && el.type === _TextInput
+      )
+    ).toHaveLength(1);
+  });
+
+  test('render rename chip', async () => {
+    mock.onGet().reply(200, {
+      can_rename: true,
+    });
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel ===
+            `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-chip` &&
+          el.type === _TextInput
+      )
+    ).toHaveLength(1);
+    expect(
+      instance.findAll(
+        (el) =>
+          el.props.accessibilityLabel ===
+            `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-chip-name` &&
+          el.type === Text
+      )
+    ).toHaveLength(0);
+    expect(mock.history.get).toHaveLength(1);
+  });
+
+  test('update name', async () => {
+    mock.onGet().reply(200, {
+      id: 1,
+      can_rename: true,
+    });
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const chipNameField = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          `${AccessibilityLabel.CONNECTED_DEVICE_RENAME_DEVICE}-chip` &&
+        el.type === _TextInput
+    );
+    await act(async () => {
+      chipNameField.props.onChange('new name');
+    });
+
+    const doneButton = instance.find(
+      (el) =>
+        el.props.accessibilityLabel === AccessibilityLabel.BUTTON_DONE &&
+        el.type === TouchableOpacity
+    );
+
+    await act(async () => {
+      doneButton.props.onPress();
+    });
+
+    expect(mock.history.post).toHaveLength(1);
+    expect(mock.history.post[0].data).toEqual(
+      JSON.stringify({
+        id: 1,
+        can_rename: true,
+        name: 'new name',
+      })
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import ScanGatewayQR from '../ScanGatewayQR';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import QRScan from '../../ScanChipQR/components/QRScan';
+import Toast from 'react-native-toast-message';
+import { getTranslate } from '../../../utils/I18n';
+import Routes from '../../../utils/Route';
+
+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({})}>
+    <ScanGatewayQR route={route} />
+  </SCProvider>
+);
+
+describe('test scan gateway device QR', () => {
+  let tree;
+
+  test('render scan gateway device', async () => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScanComponents = instance.findAllByType(QRScan);
+    expect(qrScanComponents).toHaveLength(1);
+  });
+
+  const scanQRCode = async (data) => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScan = instance.findByType(QRScan);
+    act(() => {
+      qrScan.props.onScan(JSON.stringify(data), jest.fn());
+    });
+  };
+
+  test('on scan wrong QR code', async () => {
+    await scanQRCode({ imei: 'SAMSUNG-xxx' });
+    expect(Toast.show).toBeCalledWith({
+      type: 'error',
+      position: 'bottom',
+      text1: getTranslate('en', 'wrong_qr_format'),
+      visibilityTime: 1000,
+    });
+  });
+
+  test('on scan correct QR code', async () => {
+    await scanQRCode({ imei: 'LITE-xxx' }, jest.fn());
+    expect(mockedNavigate).toHaveBeenCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ShareWifiPassword);
+  });
+});

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

@@ -0,0 +1,75 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import ScanModbusQR from '../ScanModbusQR';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import QRScan from '../../ScanChipQR/components/QRScan';
+import Toast from 'react-native-toast-message';
+import { getTranslate } from '../../../utils/I18n';
+import Routes from '../../../utils/Route';
+
+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({})}>
+    <ScanModbusQR route={route} />
+  </SCProvider>
+);
+
+describe('test scan modbus QR', () => {
+  let tree;
+
+  test('render scan modbus device', async () => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScanComponents = instance.findAllByType(QRScan);
+    expect(qrScanComponents).toHaveLength(1);
+  });
+
+  const scanQRCode = async (data) => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScan = instance.findByType(QRScan);
+    act(() => {
+      qrScan.props.onScan(JSON.stringify(data), jest.fn());
+    });
+  };
+
+  test('on scan wrong QR code', async () => {
+    await scanQRCode({ imei: 'SAMSUNG-xxx' });
+    expect(Toast.show).toBeCalledWith({
+      type: 'error',
+      position: 'bottom',
+      text1: getTranslate('en', 'wrong_qr_format'),
+      visibilityTime: 1000,
+    });
+  });
+
+  test('on scan correct QR code', async () => {
+    await scanQRCode({ imei: 'SENSOR-xxx' }, jest.fn());
+    expect(mockedNavigate).toHaveBeenCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(
+      Routes.ConnectingModbusDevice
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import ScanWifiDeviceQR from '../ScanWifiDeviceQR';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import QRScan from '../../ScanChipQR/components/QRScan';
+import Toast from 'react-native-toast-message';
+import { getTranslate } from '../../../utils/I18n';
+import Routes from '../../../utils/Route';
+
+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({})}>
+    <ScanWifiDeviceQR route={route} />
+  </SCProvider>
+);
+
+describe('test scan wifi device QR', () => {
+  let tree;
+
+  test('render scan wifi device', async () => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScanComponents = instance.findAllByType(QRScan);
+    expect(qrScanComponents).toHaveLength(1);
+  });
+
+  const scanQRCode = async (data) => {
+    const route = { params: {} };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+
+    const instance = tree.root;
+    const qrScan = instance.findByType(QRScan);
+    act(() => {
+      qrScan.props.onScan(JSON.stringify(data), jest.fn());
+    });
+  };
+
+  test('on scan wrong QR code', async () => {
+    await scanQRCode({ imei: 'SAMSUNG-xxx' });
+    expect(Toast.show).toBeCalledWith({
+      type: 'error',
+      position: 'bottom',
+      text1: getTranslate('en', 'wrong_qr_format'),
+      visibilityTime: 1000,
+    });
+  });
+
+  test('on scan correct QR code', async () => {
+    await scanQRCode({ imei: 'ROBOT-xxx' }, jest.fn());
+    expect(mockedNavigate).toHaveBeenCalled();
+    expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ShareWifiPassword);
+  });
+});

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

@@ -0,0 +1,47 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+
+import SelectDeviceSubUnit from '../SelectDeviceSubUnit';
+import { ViewButtonBottom } from '../../../commons';
+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,
+    }),
+    useIsFocused: () => ({}),
+  };
+});
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <SelectDeviceSubUnit route={route} />
+  </SCProvider>
+);
+
+describe('Test SelectSubUnit', () => {
+  beforeEach(() => {
+    mockedNavigate.mockClear();
+    mockedGoBack.mockClear();
+  });
+  let tree;
+
+  test('test ViewButtonBottom onRightClick', async () => {
+    const route = { params: { addType: 'AddNewGateway' } };
+    await act(async () => {
+      tree = renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const viewButtonBottom = instance.findByType(ViewButtonBottom);
+    act(() => {
+      viewButtonBottom.props.onRightClick();
+    });
+    expect(mockedNavigate).toHaveBeenCalled();
+  });
+});

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,
+    });
+  });
+});