@eohjsc/react-native-smart-city 0.3.4 → 0.3.7

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

@@ -1,24 +1,24 @@
+import axios from 'axios';
 import React from 'react';
-import { TouchableOpacity, View } from 'react-native';
-import MockAdapter from 'axios-mock-adapter';
+import { TouchableOpacity } from 'react-native';
 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,23 +54,15 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
-const mockConnectGoogleHome = jest.fn();
-jest.mock('../../../hooks/IoT', () => {
-  return {
-    ...jest.requireActual('../../../hooks/IoT'),
-    useGGHomeConnection: () => ({
-      connectGoogleHome: mockConnectGoogleHome,
-    }),
-  };
-});
-
-jest.mock('react-native-onesignal', () => {
+jest.mock('home-assistant-js-websocket', () => {
   return {
-    setNotificationWillShowInForegroundHandler: jest.fn(),
+    ...jest.requireActual('home-assistant-js-websocket'),
+    createConnection: jest.fn(),
+    getStates: jest.fn(),
   };
 });
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 describe('Test UnitDetail', () => {
   const route = {
@@ -86,110 +78,155 @@ 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 () => {
-    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: [],
+    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',
       },
-      stations: [],
-      user_id: 119,
     });
+  });
 
-    route.params.isSuccessfullyConnected = true;
+  test('fetch unit detail no network then load from cache', async () => {
+    axios.get.mockImplementation((url) => ({
+      status: 200,
+      data: {},
+    }));
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route));
+      await renderer.create(wrapComponent(route, account));
+    });
+
+    axios.get.mockImplementation((url) => {
+      if (url === detailUnitApiUrl) {
+        throw {};
+      }
+      return { status: 200, data: [] };
     });
-    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 () => {
-      refreshControl.props.onRefresh();
+      await renderer.create(wrapComponent(route, account));
     });
-    const instance = tree.root;
-    const PreventAccesss = instance.findByType(PreventAccess);
-    expect(PreventAccesss).toBeDefined();
-  });
 
-  test('fetch unit detail no network then load from cache', async () => {
-    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(500, []);
-    await act(async () => {
-      tree = await renderer.create(wrapComponent(route, account));
+    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
+      headers: {
+        'Cache-Control': 'no-cache',
+      },
     });
-    const instance = tree.root;
-    const PreventAccesss = instance.findByType(PreventAccess);
-    expect(PreventAccesss).toBeDefined();
   });
 
-  test('fetch unit detail error 404', async () => {
-    mock.onGet(API.UNIT.UNIT_DETAIL(1)).reply(404, {});
+  test('fetch unit detail no network and fail load from cache', async () => {
+    axios.get.mockImplementation((url) => {
+      throw {};
+    });
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route));
+      await renderer.create(wrapComponent(route, account));
+    });
+
+    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
+      headers: {
+        'Cache-Control': 'no-cache',
+      },
     });
-    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 () => {
-    mock.onGet(API.UNIT.UNIT_SUMMARY(1)).reply(200);
+    axios.get.mockImplementation((url) => {
+      if (url === summaryUnitApiUrl) {
+        return {
+          status: 200,
+          data: [],
+        };
+      }
+
+      return {
+        status: 200,
+        data: {},
+      };
+    });
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route, account));
+      await renderer.create(wrapComponent(route, account));
     });
-    const instance = tree.root;
-    const PreventAccesss = instance.findByType(PreventAccess);
-    expect(PreventAccesss).toBeDefined();
+
+    expect(axios.get).toHaveBeenCalledWith(summaryUnitApiUrl, {});
   });
 
   test('fetch unit summary has data', async () => {
-    mock.onGet(API.UNIT.UNIT_SUMMARY(1)).reply(200, [{}]);
+    axios.get.mockImplementation((url) => {
+      if (url === summaryUnitApiUrl) {
+        return {
+          status: 200,
+          data: [{}],
+        };
+      }
+
+      return {
+        status: 200,
+        data: {},
+      };
+    });
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route, account));
+      await renderer.create(wrapComponent(route, account));
     });
-    const instance = tree.root;
-    const PreventAccesss = instance.findByType(PreventAccess);
-    expect(PreventAccesss).toBeDefined();
+
+    expect(axios.get).toHaveBeenCalledWith(summaryUnitApiUrl, {});
   });
 
   test('not fetch unit summary if not focus', async () => {
     useIsFocused.mockImplementation(() => false);
-    mock.onGet(summaryUnitApiUrl).reply(200);
+    axios.get.mockImplementation((url) => {
+      if (url === summaryUnitApiUrl) {
+        return {
+          status: 200,
+          data: [{}],
+        };
+      }
+
+      return {
+        status: 200,
+        data: {},
+      };
+    });
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route, account));
+      await renderer.create(wrapComponent(route, account));
+    });
+
+    expect(axios.get).not.toHaveBeenCalledWith(summaryUnitApiUrl, {
+      headers: {
+        'Cache-Control': 'no-cache',
+      },
     });
-    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(refreshControl).toBeDefined();
+    expect(axios.get).toHaveBeenCalledWith(detailUnitApiUrl, {
+      headers: {
+        'Cache-Control': 'no-cache',
+      },
+    });
   });
 
   test('when unit has google home action then connect to google home', async () => {
@@ -204,12 +241,21 @@ 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(mockConnectGoogleHome).toBeCalled();
+
+    expect(createConnection).toHaveBeenCalled();
+    expect(getStates).toHaveBeenCalled();
   });
 
   test('when unit has bluetooth action then scan for devices', async () => {
@@ -287,9 +333,24 @@ describe('Test UnitDetail', () => {
       ],
     };
     jest.useFakeTimers();
-    mock.onGet(summaryUnitApiUrl).reply(200, []);
-    mock.onGet(sensorStatusApiUrl).reply(200, []);
-    mock.onGet(detailUnitApiUrl).reply(200, unitData);
+    axios.get.mockImplementation((url) => {
+      if (url === summaryUnitApiUrl) {
+        return {
+          status: 200,
+          data: [],
+        };
+      } else if (url === sensorStatusApiUrl) {
+        return {
+          status: 200,
+          data: [],
+        };
+      }
+
+      return {
+        status: 200,
+        data: unitData,
+      };
+    });
 
     await act(async () => {
       tree = await renderer.create(
@@ -297,6 +358,9 @@ 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 &&
@@ -315,6 +379,55 @@ 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: [
@@ -346,7 +459,7 @@ describe('Test UnitDetail', () => {
     });
     const instance = tree.root;
     const CameraDeviceViews = instance.findAllByType(CameraDevice);
-    expect(CameraDeviceViews).toHaveLength(0);
+    expect(CameraDeviceViews).toHaveLength(1);
 
     const fullCamera = tree.root.findAll(
       (el) =>
@@ -359,7 +472,6 @@ describe('Test UnitDetail', () => {
     expect(fullView).toHaveLength(1);
     expect(fullView[0].props.isVisible).toEqual(false);
   });
-
   test('onPress subunit camera devices', async () => {
     const unitData = {
       stations: [
@@ -391,20 +503,19 @@ describe('Test UnitDetail', () => {
     });
     const instance = tree.root;
     const CameraDeviceViews = instance.findAllByType(CameraDevice);
-    expect(CameraDeviceViews).toHaveLength(0);
+    expect(CameraDeviceViews).toHaveLength(1);
     const goDetailButton = tree.root.findAll(
       (el) =>
         el.props.testID === TESTID.SUB_UNIT_GO_DETAIL &&
         el.type === TouchableOpacity
     );
 
-    expect(goDetailButton).toHaveLength(1);
+    expect(goDetailButton).toHaveLength(2);
     await act(async () => {
       await goDetailButton[0].props.onPress();
     });
-    expect(mockedNavigate).not.toHaveBeenCalled();
+    expect(mockedNavigate).toHaveBeenCalled();
   });
-
   test('render subunit favorites', async () => {
     const unitData = {
       stations: [
@@ -423,12 +534,7 @@ 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: [
         {
@@ -437,10 +543,10 @@ describe('Test UnitDetail', () => {
         },
       ],
     };
-    route.params.isAddSubUnit = true;
-    route.params.unitData = unitData;
     await act(async () => {
-      tree = await renderer.create(wrapComponent(route, account));
+      tree = await renderer.create(
+        wrapComponent({ params: { ...route.params, unitData } }, account)
+      );
     });
     const instance = tree.root;
     const navBar = instance.find(
@@ -448,14 +554,9 @@ describe('Test UnitDetail', () => {
     );
 
     await act(() => {
-      navBar.props.onSnapToItem({}, 1);
+      navBar.props.onSnapToItem();
     });
 
     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,7 +1,6 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
-import MockAdapter from 'axios-mock-adapter';
-import Toast from 'react-native-toast-message';
+import axios from 'axios';
 
 import { ToastBottomHelper } from '../../../utils/Utils';
 import { TESTID } from '../../../configs/Constants';
@@ -9,11 +8,8 @@ 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';
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 const mockNavigate = jest.fn();
 jest.mock('@react-navigation/native', () => {
@@ -59,6 +55,7 @@ describe('Test Manage Unit', () => {
 
   beforeEach(() => {
     mockNavigate.mockClear();
+    axios.get.mockClear();
   });
 
   const getElement = (instance) => {
@@ -119,28 +116,33 @@ 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}`
     );
-    mock.onPatch(API.UNIT.MANAGE_UNIT(1)).reply(200, {});
+
+    const response = {
+      data: {},
+    };
+    axios.patch.mockImplementation(async () => {
+      return response;
+    });
+
     await act(async () => {
       await inputRename[0].props.onChange('input station');
       await bottomButton.props.onPress();
     });
-    expect(Toast.show).toBeCalledWith({
-      position: 'bottom',
-      text1: getTranslate('en', 'unit_updated_successfully'),
-      text2: undefined,
-      type: 'success',
-      visibilityTime: 1000,
-    });
+
+    expect(axios.patch).toBeCalled();
   });
 
   test('remove Unit success', async () => {
@@ -160,10 +162,23 @@ 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();
   });
 
@@ -185,19 +200,29 @@ describe('Test Manage Unit', () => {
         item.props.testID ===
         `${TESTID.PREFIX.MANAGE_UNIT}${TESTID.VIEW_BUTTON_BOTTOM_RIGHT_BUTTON}`
     );
-    mock.onPatch(API.UNIT.MANAGE_UNIT(1)).reply(200);
+
+    const response = {
+      status: 200,
+      success: true,
+      data: {},
+    };
+
+    axios.patch.mockImplementation(async () => {
+      return response;
+    });
 
     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));
@@ -218,9 +243,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));
@@ -236,7 +261,6 @@ describe('Test Manage Unit', () => {
     });
     expect(mockNavigate).toBeCalled();
   });
-
   test('test onPress goToManageSubUnit', async () => {
     await act(async () => {
       tree = create(wrapComponent(route));