@eohjsc/react-native-smart-city 0.2.99 → 0.3.2

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

@@ -1,12 +1,15 @@
-import axios from 'axios';
-import { API } from '../../../configs';
 import React from 'react';
-import renderer, { act } from 'react-test-renderer';
+import { act, create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+
+import { API } from '../../../configs';
 import UnitDetail from '../Detail';
-import { useIsFocused } from '@react-navigation/native';
-import AsyncStorage from '@react-native-community/async-storage';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import NavBar from '../../../commons/NavBar';
+
+const mock = new MockAdapter(api.axiosInstance);
 
 const mockDispatch = jest.fn();
 
@@ -21,11 +24,11 @@ jest.mock('react-redux', () => ({
 
 jest.mock('../../../iot/RemoteControl/GoogleHome', () => ({
   ...jest.requireActual('../../../iot/RemoteControl/GoogleHome'),
-  googleHomeConnect: jest.fn(() => false),
+  googleHomeConnect: jest.fn(async () => ({
+    [1]: {},
+  })),
 }));
 
-jest.mock('axios');
-
 jest.mock('@react-native-community/netinfo', () => {
   return {
     useNetInfo: () => {
@@ -36,6 +39,12 @@ jest.mock('@react-native-community/netinfo', () => {
   };
 });
 
+jest.mock('react-native-onesignal', () => {
+  return {
+    setNotificationWillShowInForegroundHandler: jest.fn(),
+  };
+});
+
 const wrapComponent = (route, unitData, account) => (
   <SCProvider initState={mockSCStore({})}>
     <UnitDetail
@@ -46,6 +55,7 @@ const wrapComponent = (route, unitData, account) => (
 );
 
 describe('Test UnitDetail google home disconnect', () => {
+  let tree;
   const route = {
     params: {
       unitId: 1,
@@ -53,15 +63,6 @@ describe('Test UnitDetail google home disconnect', () => {
   };
   const account = {};
 
-  axios.get.mockImplementation(() => ({ status: 200 }));
-
-  beforeEach(() => {
-    jest.clearAllTimers();
-    axios.get.mockClear();
-    useIsFocused.mockImplementation(() => true);
-    AsyncStorage.clear();
-  });
-
   test('when unit has google home disconnect call api check send email', async () => {
     const unitData = {
       remote_control_options: {
@@ -76,18 +77,12 @@ describe('Test UnitDetail google home disconnect', () => {
         ],
       },
     };
-    jest.useFakeTimers();
-
-    await act(async () => {
-      await renderer.create(wrapComponent(route, unitData, account));
+    mock.onGet(API.GOOGLE_HOME.CHECK_SEND_EMAIL()).reply(200);
+    await act(() => {
+      tree = create(wrapComponent(route, unitData, account));
     });
-
-    expect(axios.post).toHaveBeenCalledWith(
-      API.GOOGLE_HOME.CHECK_SEND_EMAIL(),
-      {
-        chip_id: 1,
-        is_connected: false,
-      }
-    );
+    const instance = tree.root;
+    const NavBars = instance.findAllByType(NavBar);
+    expect(NavBars).toHaveLength(0);
   });
 });

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

@@ -1,11 +1,14 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+import MapView from 'react-native-maps';
+
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import ChooseLocation from '../ChooseLocation';
-import axios from 'axios';
-import { API, SCConfig } from '../../../configs';
+import { API } from '../../../configs';
 import BottomButtonView from '../../../commons/BottomButtonView';
+import api from '../../../utils/Apis/axios';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -43,7 +46,7 @@ jest.mock('react-native-maps', () => {
   };
 });
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 describe('Test ChooseLocation', () => {
   let tree;
@@ -52,7 +55,6 @@ describe('Test ChooseLocation', () => {
   const mockSetLocation = jest.fn();
 
   beforeAll(() => {
-    axios.get.mockClear();
     route = {
       params: {
         location: {
@@ -65,6 +67,24 @@ describe('Test ChooseLocation', () => {
     };
   });
 
+  test('test render without location', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent({}));
+    });
+    const instance = tree.root;
+    const buttonBottom = instance.findByType(BottomButtonView);
+    expect(buttonBottom).toBeDefined();
+    await act(async () => {
+      await buttonBottom.props.onPressMain();
+    });
+    const MapViews = instance.findByType(MapView);
+    await MapViews.props.onRegionChangeComplete({
+      latitude: 1,
+      longitude: 1,
+    });
+    expect(mockSetLocation).not.toBeCalled();
+  });
+
   test('test done choose location', async () => {
     await act(async () => {
       tree = await create(wrapComponent(route));
@@ -88,19 +108,12 @@ describe('Test ChooseLocation', () => {
         ],
       },
     };
-    axios.get.mockImplementation(async () => response);
+    mock
+      .onGet(API.EXTERNAL.GOOGLE_MAP.GET_LOCATION_FROM_LAT_LNG)
+      .reply(200, response.data);
     await act(async () => {
       await buttonBottom.props.onPressMain();
     });
-    expect(axios.get).toBeCalledWith(
-      API.EXTERNAL.GOOGLE_MAP.GET_LOCATION_FROM_LAT_LNG,
-      {
-        params: {
-          latlng: '10,10',
-          key: SCConfig.GOOGLE_MAP_API_KEY,
-        },
-      }
-    );
     expect(mockSetAddress).toBeCalledWith('address');
     expect(mockSetLocation).toBeCalledWith({
       description: 'address',

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