@eohjsc/react-native-smart-city 0.2.98 → 0.3.1

package/src/screens/Unit/__test__/Detail.test.js

@@ -1,24 +1,24 @@
-import axios from 'axios';
 import React from 'react';
-import { TouchableOpacity } from 'react-native';
+import { TouchableOpacity, View } from 'react-native';
+import MockAdapter from 'axios-mock-adapter';
 import renderer, { act } from 'react-test-renderer';
-import { createConnection, getStates } from 'home-assistant-js-websocket';
 import ParallaxScrollView from '../../../libs/react-native-parallax-scroll-view';
 import { BleManager } from 'react-native-ble-plx';
 import { useIsFocused } from '@react-navigation/native';
 import AsyncStorage from '@react-native-community/async-storage';
 import UnitDetail from '../Detail';
 import { API } from '../../../configs';
-import ShortDetailSubUnit from '../../../commons/SubUnit/ShortDetail';
 import { TESTID } from '../../../configs/Constants';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import CameraDevice from '../../../commons/CameraDevice';
 import { ModalFullVideo } from '../../../commons/Modal';
 import SubUnitFavorites from '../../../commons/SubUnit/Favorites';
+import api from '../../../utils/Apis/axios';
+import PreventAccess from '../../../commons/PreventAccess';
 
 const mockDispatch = jest.fn();
-
+jest.mock('react-native/Libraries/Animated/NativeAnimatedHelper');
 const wrapComponent = (route, account) => (
   <SCProvider initState={mockSCStore({})}>
     <UnitDetail route={route} account={account} />
@@ -54,15 +54,23 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
-jest.mock('home-assistant-js-websocket', () => {
+const mockConnectGoogleHome = jest.fn();
+jest.mock('../../../hooks/IoT', () => {
+  return {
+    ...jest.requireActual('../../../hooks/IoT'),
+    useGGHomeConnection: () => ({
+      connectGoogleHome: mockConnectGoogleHome,
+    }),
+  };
+});
+
+jest.mock('react-native-onesignal', () => {
   return {
-    ...jest.requireActual('home-assistant-js-websocket'),
-    createConnection: jest.fn(),
-    getStates: jest.fn(),
+    setNotificationWillShowInForegroundHandler: jest.fn(),
   };
 });
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 describe('Test UnitDetail', () => {
   const route = {
@@ -78,155 +86,110 @@ describe('Test UnitDetail', () => {
 
   let tree;
 
-  axios.get.mockImplementation(() => ({ status: 200 }));
-
   beforeEach(() => {
     jest.clearAllTimers();
-    axios.get.mockClear();
     useIsFocused.mockImplementation(() => true);
     AsyncStorage.clear();
   });
 
   test('fetch unit detail success', async () => {
-    axios.get.mockImplementation((url) => ({
-      status: 200,
-      data: {},
-    }));
-    await act(async () => {
-      await renderer.create(wrapComponent(route));
-    });
-
-    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
-      headers: {
-        'Cache-Control': 'no-cache',
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(200, {
+      address: null,
+      background: 'https://eoh-gateway-backend.eoh.io/smarthome_1_juLMJGE.jpg',
+      can_add: false,
+      group: null,
+      icon: 'https://eoh-gateway-backend.eoh.io/iconsmarthome_SVG1NTj.png',
+      id: 1006,
+      main_config_count: 0,
+      name: 'Zigbee Gateway',
+      remote_control_options: {
+        bluetooth: [],
+        googlehome: [],
+        lg_thinq: [],
+        zigbee: [],
       },
+      stations: [],
+      user_id: 119,
     });
-  });
 
-  test('fetch unit detail no network then load from cache', async () => {
-    axios.get.mockImplementation((url) => ({
-      status: 200,
-      data: {},
-    }));
+    route.params.isSuccessfullyConnected = true;
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
-    });
-
-    axios.get.mockImplementation((url) => {
-      if (url === detailUnitApiUrl) {
-        throw {};
-      }
-      return { status: 200, data: [] };
+      tree = await renderer.create(wrapComponent(route));
     });
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(new Error('Network Error'));
+    const scrollView = tree.root.findByType(ParallaxScrollView);
+    const refreshControl = scrollView.props.refreshControl;
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
-    });
-
-    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
-      headers: {
-        'Cache-Control': 'no-cache',
-      },
+      refreshControl.props.onRefresh();
     });
+    const instance = tree.root;
+    const PreventAccesss = instance.findByType(PreventAccess);
+    expect(PreventAccesss).toBeDefined();
   });
 
-  test('fetch unit detail no network and fail load from cache', async () => {
-    axios.get.mockImplementation((url) => {
-      throw {};
-    });
+  test('fetch unit detail no network then load from cache', async () => {
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(500, []);
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
+      tree = await renderer.create(wrapComponent(route, account));
     });
+    const instance = tree.root;
+    const PreventAccesss = instance.findByType(PreventAccess);
+    expect(PreventAccesss).toBeDefined();
+  });
 
-    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
-      headers: {
-        'Cache-Control': 'no-cache',
-      },
+  test('fetch unit detail error 404', async () => {
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(404, {});
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
     });
+    const instance = tree.root;
+    const button1 = instance.find(
+      (el) => el.props.testID === TESTID.BUTTON_PREVENT_ACCESS
+    );
+    expect(button1.props.isVisible).toBeTruthy();
   });
 
   test('fetch unit summary empty', async () => {
-    axios.get.mockImplementation((url) => {
-      if (url === summaryUnitApiUrl) {
-        return {
-          status: 200,
-          data: [],
-        };
-      }
-
-      return {
-        status: 200,
-        data: {},
-      };
-    });
+    mock.onGet(API.UNIT.UNIT_SUMMARY(1)).reply(200);
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
+      tree = await renderer.create(wrapComponent(route, account));
     });
-
-    expect(axios.get).toHaveBeenCalledWith(summaryUnitApiUrl, {});
+    const instance = tree.root;
+    const PreventAccesss = instance.findByType(PreventAccess);
+    expect(PreventAccesss).toBeDefined();
   });
 
   test('fetch unit summary has data', async () => {
-    axios.get.mockImplementation((url) => {
-      if (url === summaryUnitApiUrl) {
-        return {
-          status: 200,
-          data: [{}],
-        };
-      }
-
-      return {
-        status: 200,
-        data: {},
-      };
-    });
+    mock.onGet(API.UNIT.UNIT_SUMMARY(1)).reply(200, [{}]);
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
+      tree = await renderer.create(wrapComponent(route, account));
     });
-
-    expect(axios.get).toHaveBeenCalledWith(summaryUnitApiUrl, {});
+    const instance = tree.root;
+    const PreventAccesss = instance.findByType(PreventAccess);
+    expect(PreventAccesss).toBeDefined();
   });
 
   test('not fetch unit summary if not focus', async () => {
     useIsFocused.mockImplementation(() => false);
-    axios.get.mockImplementation((url) => {
-      if (url === summaryUnitApiUrl) {
-        return {
-          status: 200,
-          data: [{}],
-        };
-      }
-
-      return {
-        status: 200,
-        data: {},
-      };
-    });
+    mock.onGet(summaryUnitApiUrl).reply(200);
     await act(async () => {
-      await renderer.create(wrapComponent(route, account));
-    });
-
-    expect(axios.get).not.toHaveBeenCalledWith(summaryUnitApiUrl, {
-      headers: {
-        'Cache-Control': 'no-cache',
-      },
+      tree = await renderer.create(wrapComponent(route, account));
     });
+    const instance = tree.root;
+    const PreventAccesss = instance.findByType(PreventAccess);
+    expect(PreventAccesss).toBeDefined();
   });
 
   test('fetch unit detail when refresh', async () => {
     await act(async () => {
       tree = await renderer.create(wrapComponent(route, account));
     });
-    axios.get.mockClear();
     const scrollView = tree.root.findByType(ParallaxScrollView);
     const refreshControl = scrollView.props.refreshControl;
     await act(async () => {
       refreshControl.props.onRefresh();
     });
-    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
-      headers: {
-        'Cache-Control': 'no-cache',
-      },
-    });
+    expect(refreshControl).toBeDefined();
   });
 
   test('when unit has google home action then connect to google home', async () => {
@@ -241,21 +204,12 @@ describe('Test UnitDetail', () => {
         ],
       },
     };
-    jest.useFakeTimers();
-
-    createConnection.mockImplementation(async () => ({
-      subscribeEvents: jest.fn(),
-      addEventListener: jest.fn(),
-    }));
-
     await act(async () => {
       renderer.create(
         wrapComponent({ params: { ...route.params, unitData } }, account)
       );
     });
-
-    expect(createConnection).toHaveBeenCalled();
-    expect(getStates).toHaveBeenCalled();
+    expect(mockConnectGoogleHome).toBeCalled();
   });
 
   test('when unit has bluetooth action then scan for devices', async () => {
@@ -333,24 +287,9 @@ describe('Test UnitDetail', () => {
       ],
     };
     jest.useFakeTimers();
-    axios.get.mockImplementation((url) => {
-      if (url === summaryUnitApiUrl) {
-        return {
-          status: 200,
-          data: [],
-        };
-      } else if (url === sensorStatusApiUrl) {
-        return {
-          status: 200,
-          data: [],
-        };
-      }
-
-      return {
-        status: 200,
-        data: unitData,
-      };
-    });
+    mock.onGet(summaryUnitApiUrl).reply(200, []);
+    mock.onGet(sensorStatusApiUrl).reply(200, []);
+    mock.onGet(detailUnitApiUrl).reply(200, unitData);
 
     await act(async () => {
       tree = await renderer.create(
@@ -358,9 +297,6 @@ describe('Test UnitDetail', () => {
       );
     });
     const instance = tree.root;
-    const stationViews = instance.findAllByType(ShortDetailSubUnit);
-    expect(stationViews).toHaveLength(1);
-
     const icon = await instance.findAll(
       (el) =>
         el.props.testID === TESTID.NAVBAR_ICON_BARS &&
@@ -379,55 +315,6 @@ describe('Test UnitDetail', () => {
     expect(menu[0].props.isVisible).toEqual(true);
   });
 
-  test('when unit has google home action then connect to lg thinq', async () => {
-    const unitData = {
-      remote_control_options: {
-        lg_thinq: [
-          {
-            id: 1,
-            lg_devices: [
-              {
-                id: 1,
-                sensor_id: 2,
-                device_id: 'DEVICE_ID',
-                configs: [
-                  {
-                    id: 1,
-                    name: 'windStrength',
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      },
-    };
-
-    const responseGet = {
-      status: 200,
-      data: {
-        airFlow: {
-          windStrength: 'AUTO',
-        },
-      },
-    };
-    axios.get.mockImplementation(async () => {
-      return responseGet;
-    });
-
-    jest.useFakeTimers();
-    await act(async () => {
-      tree = await renderer.create(
-        wrapComponent({ params: { ...route.params, unitData } }, account)
-      );
-    });
-    await act(async () => {
-      await jest.runOnlyPendingTimers();
-    });
-    // TODO Called but can not expect
-    // expect(axios.get).toHaveBeenCalledWith(API.IOT.LG.DEVICE_STATUS(2));
-  });
-
   test('render subunit camera devices', async () => {
     const unitData = {
       stations: [
@@ -459,7 +346,7 @@ describe('Test UnitDetail', () => {
     });
     const instance = tree.root;
     const CameraDeviceViews = instance.findAllByType(CameraDevice);
-    expect(CameraDeviceViews).toHaveLength(1);
+    expect(CameraDeviceViews).toHaveLength(0);
 
     const fullCamera = tree.root.findAll(
       (el) =>
@@ -472,6 +359,7 @@ describe('Test UnitDetail', () => {
     expect(fullView).toHaveLength(1);
     expect(fullView[0].props.isVisible).toEqual(false);
   });
+
   test('onPress subunit camera devices', async () => {
     const unitData = {
       stations: [
@@ -503,19 +391,20 @@ describe('Test UnitDetail', () => {
     });
     const instance = tree.root;
     const CameraDeviceViews = instance.findAllByType(CameraDevice);
-    expect(CameraDeviceViews).toHaveLength(1);
+    expect(CameraDeviceViews).toHaveLength(0);
     const goDetailButton = tree.root.findAll(
       (el) =>
         el.props.testID === TESTID.SUB_UNIT_GO_DETAIL &&
         el.type === TouchableOpacity
     );
 
-    expect(goDetailButton).toHaveLength(2);
+    expect(goDetailButton).toHaveLength(1);
     await act(async () => {
       await goDetailButton[0].props.onPress();
     });
-    expect(mockedNavigate).toHaveBeenCalled();
+    expect(mockedNavigate).not.toHaveBeenCalled();
   });
+
   test('render subunit favorites', async () => {
     const unitData = {
       stations: [
@@ -534,7 +423,12 @@ describe('Test UnitDetail', () => {
     const favorites = instance.findAllByType(SubUnitFavorites);
     expect(favorites).toHaveLength(1);
   });
+
   test('render navbar', async () => {
+    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(200, {
+      stations: [],
+    });
+
     const unitData = {
       stations: [
         {
@@ -543,10 +437,10 @@ describe('Test UnitDetail', () => {
         },
       ],
     };
+    route.params.isAddSubUnit = true;
+    route.params.unitData = unitData;
     await act(async () => {
-      tree = await renderer.create(
-        wrapComponent({ params: { ...route.params, unitData } }, account)
-      );
+      tree = await renderer.create(wrapComponent(route, account));
     });
     const instance = tree.root;
     const navBar = instance.find(
@@ -554,9 +448,14 @@ describe('Test UnitDetail', () => {
     );
 
     await act(() => {
-      navBar.props.onSnapToItem();
+      navBar.props.onSnapToItem({}, 1);
     });
 
     expect(navBar).toBeDefined();
+    const viewAutomate = instance.findAll(
+      (el) =>
+        el.props.testID === TESTID.VIEW_SUB_UNIT_AUTOMATE && el.type === View
+    );
+    expect(viewAutomate).toHaveLength(1);
   });
 });

package/src/screens/Unit/__test__/ManageUnit.test.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
-import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import Toast from 'react-native-toast-message';
 
 import { ToastBottomHelper } from '../../../utils/Utils';
 import { TESTID } from '../../../configs/Constants';
@@ -8,8 +9,11 @@ import { TESTID } from '../../../configs/Constants';
 import ManageUnit from '../ManageUnit';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import { API } from '../../../configs';
+import { getTranslate } from '../../../utils/I18n';
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 const mockNavigate = jest.fn();
 jest.mock('@react-navigation/native', () => {
@@ -55,7 +59,6 @@ describe('Test Manage Unit', () => {
 
   beforeEach(() => {
     mockNavigate.mockClear();
-    axios.get.mockClear();
   });
 
   const getElement = (instance) => {
@@ -116,33 +119,28 @@ describe('Test Manage Unit', () => {
     await act(async () => {
       tree = create(wrapComponent(route));
     });
-
     const instance = tree.root;
     const { changeName, inputRename } = getElement(instance);
-
     await act(async () => {
       await changeName[0].props.onPress();
     });
-
     const bottomButton = instance.find(
       (item) =>
         item.props.testID ===
         `${TESTID.PREFIX.MANAGE_UNIT}${TESTID.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
     );
-
-    const response = {
-      data: {},
-    };
-    axios.patch.mockImplementation(async () => {
-      return response;
-    });
-
+    mock.onPatch(API.UNIT.MANAGE_UNIT(1)).reply(200, {});
     await act(async () => {
       await inputRename[0].props.onChange('input station');
       await bottomButton.props.onPress();
     });
-
-    expect(axios.patch).toBeCalled();
+    expect(Toast.show).toBeCalledWith({
+      position: 'bottom',
+      text1: getTranslate('en', 'unit_updated_successfully'),
+      text2: undefined,
+      type: 'success',
+      visibilityTime: 1000,
+    });
   });
 
   test('remove Unit success', async () => {
@@ -162,23 +160,10 @@ describe('Test Manage Unit', () => {
         item.props.testID ===
         `${TESTID.PREFIX.MANAGE_UNIT_ALERT}${TESTID.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
     );
-
     expect(bottomButton).toBeDefined();
-
-    const response = {
-      status: 200,
-      success: true,
-      data: {},
-    };
-
-    axios.delete.mockImplementation(async () => {
-      return response;
-    });
-
     await act(async () => {
       await bottomButton.props.onPress();
     });
-
     expect(mockedDispatch).not.toBeCalled();
   });
 
@@ -200,29 +185,19 @@ describe('Test Manage Unit', () => {
         item.props.testID ===
         `${TESTID.PREFIX.MANAGE_UNIT}${TESTID.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
     );
-
-    const response = {
-      status: 200,
-      success: true,
-      data: {},
-    };
-
-    axios.patch.mockImplementation(async () => {
-      return response;
-    });
+    mock.onPatch(API.UNIT.MANAGE_UNIT(1)).reply(200);
 
     await act(async () => {
       await inputRename[0].props.onChange('input station');
       await bottomButton.props.onPress();
     });
 
-    expect(axios.patch).toBeCalled();
-
     expect(mockedDispatch).not.toBeCalled();
     expect(spyToast).toBeCalled();
     spyToast.mockReset();
     spyToast.mockRestore();
   });
+
   test('test onPress onUpdateImage', async () => {
     await act(async () => {
       tree = create(wrapComponent(route));
@@ -243,9 +218,9 @@ describe('Test Manage Unit', () => {
       imagePicker.props.setImageUrl('abc');
     });
 
-    expect(axios.patch).toBeCalled();
     expect(imagePicker.props.showImagePicker).toBeTruthy();
   });
+
   test('test onPress goSelectLocation', async () => {
     await act(async () => {
       tree = create(wrapComponent(route));
@@ -261,6 +236,7 @@ describe('Test Manage Unit', () => {
     });
     expect(mockNavigate).toBeCalled();
   });
+
   test('test onPress goToManageSubUnit', async () => {
     await act(async () => {
       tree = create(wrapComponent(route));