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

package/src/screens/HanetCamera/__test__/MemberInfo.test.js

@@ -1,8 +1,7 @@
 import React from 'react';
 import { TouchableOpacity } from 'react-native';
 import { create, act } from 'react-test-renderer';
-import MockAdapter from 'axios-mock-adapter';
-
+import axios from 'axios';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import HanetMemberInfo from '../MemberInfo';
@@ -11,8 +10,6 @@ import TextInput from '../../../commons/Form/TextInput';
 import BottomButtonView from '../../../commons/BottomButtonView';
 import BottomSheet from '../../../commons/BottomSheet';
 import { TESTID } from '../../../configs/Constants';
-import api from '../../../utils/Apis/axios';
-import { API } from '../../../configs';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -40,7 +37,7 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 describe('Test HanetMemberInfo', () => {
   let tree, route;
@@ -48,6 +45,9 @@ describe('Test HanetMemberInfo', () => {
   beforeEach(() => {
     mockedNavigate.mockClear();
     mockedGoBack.mockClear();
+    axios.post.mockClear();
+    axios.patch.mockClear();
+    axios.delete.mockClear();
     route = {
       params: {
         hanetPlace: {
@@ -72,18 +72,23 @@ describe('Test HanetMemberInfo', () => {
     const touches = instance.findAllByType(TouchableOpacity);
     expect(touches).toHaveLength(7);
     const alertAction = instance.findByType(AlertAction);
+
     // open alert action
     await act(async () => {
       await touches[2].props.onPress();
     });
+    expect(alertAction.props.visible).toBe(true);
+
     const textInput = instance.findByType(TextInput);
-    mock.onPatch(API.CAMERA.HANET.RENAME_MEMBER(1, 1)).reply(200);
+
+    axios.patch.mockImplementationOnce(async () => ({ status: 200 }));
+
     // change name and press rename
     await act(async () => {
       await textInput.props.onChange('new name');
       await alertAction.props.rightButtonClick();
     });
-    expect(alertAction.props.visible).toBe(false);
+    expect(axios.patch).toHaveBeenCalled();
   });
 
   test('Test remove member', async () => {
@@ -100,11 +105,15 @@ describe('Test HanetMemberInfo', () => {
       await touches[3].props.onPress();
     });
     expect(alertAction.props.visible).toBe(true);
-    mock.onDelete(API.CAMERA.HANET.REMOVE_MEMBER(1, 1)).reply(200);
+
+    axios.delete.mockImplementationOnce(async () => ({ status: 200 }));
+
     // press remove
     await act(async () => {
       await alertAction.props.rightButtonClick();
     });
+
+    expect(axios.delete).toHaveBeenCalled();
     expect(mockedGoBack).toHaveBeenCalled();
   });
 
@@ -144,14 +153,24 @@ describe('Test HanetMemberInfo', () => {
     const instance = tree.root;
     const touches = instance.findAllByType(TouchableOpacity);
     expect(touches).toHaveLength(7);
+
     await act(async () => {
       await touches[1].props.onPress();
     });
+
     const bottomSheet = instance.findByType(BottomSheet);
     expect(bottomSheet.props.isVisible).toBe(true);
-    mock.onPatch(API.CAMERA.HANET.UPDATE_FACE_ID(1, 1)).reply(200);
+
+    axios.patch.mockImplementationOnce(async () => ({
+      status: 200,
+      data: {
+        avatar_uri: 'uri',
+      },
+    }));
     await chooseSetFaceIDOption(instance, 1);
+
     expect(bottomSheet.props.isVisible).toBe(false);
+    expect(axios.patch).toBeCalled(); // call api update face id
   });
 
   test('Test register new member', async () => {
@@ -177,6 +196,7 @@ describe('Test HanetMemberInfo', () => {
     expect(bottomSheet.props.isVisible).toBe(true);
 
     await chooseSetFaceIDOption(instance, 1);
+    expect(axios.patch).not.toBeCalled(); // not call api
 
     // open alert action
     const alertAction = instance.findByType(AlertAction);
@@ -191,13 +211,15 @@ describe('Test HanetMemberInfo', () => {
       await textInput.props.onChange('new name');
       await alertAction.props.rightButtonClick();
     });
+    expect(axios.post).not.toBeCalled();
 
     // finish
     const bottomButton = instance.findByType(BottomButtonView);
-    mock.onPost(API.CAMERA.HANET.REGISTER(1)).reply(200);
+    axios.post.mockImplementationOnce(async () => ({ status: 200 }));
     await act(async () => {
       await bottomButton.props.onPressMain();
     });
+    expect(axios.post).toBeCalled();
     expect(mockedNavigate).toBeCalled();
   });
 });

package/src/screens/HanetCamera/components/RequestFaceIDPopup.js

@@ -31,7 +31,7 @@ const RequestFaceIDPopup = ({
       text: t('pick_available_image_from_your_phone'),
       onChoose: async () => {
         setHide();
-        const pickerOptions = {
+        const options = {
           mediaType: 'photo',
           compressImageMaxHeight: 1280,
           compressImageMaxWidth: 738,
@@ -39,9 +39,8 @@ const RequestFaceIDPopup = ({
           forceJpg: true,
         };
         try {
-          const result = await ImagePicker.openPicker(pickerOptions);
+          const result = await ImagePicker.openPicker(options);
           onChooseFile && onChooseFile(result);
-          // eslint-disable-next-line no-empty
         } catch (e) {}
       },
     },

package/src/screens/HanetCamera/hooks/__test__/useHanetCheckinData.test.js

@@ -1,17 +1,16 @@
 import { act, renderHook } from '@testing-library/react-hooks';
 import { useHanetCheckinData } from '../index';
-import MockAdapter from 'axios-mock-adapter';
+import axios from 'axios';
 import moment from 'moment';
-import api from '../../../../utils/Apis/axios';
-import { API } from '../../../../configs';
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 describe('Test useHanetCheckinData', () => {
   let props, data;
 
   beforeEach(() => {
     Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    axios.get.mockClear();
     props = {
       device_id: 1,
       place: {
@@ -52,20 +51,40 @@ describe('Test useHanetCheckinData', () => {
 
   test('Test onRefresh', async () => {
     const { result } = renderHook(() => useHanetCheckinData(props));
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1)).reply(200, data);
+    axios.get.mockImplementationOnce(() => ({
+      status: 200,
+      data: data,
+    }));
     await act(async () => {
       await result.current.onRefresh();
     });
-    expect(result.current.countMember).toBe(data.count_member);
+    expect(axios.get).toHaveBeenCalled();
   });
 
-  test('Test render without props', async () => {
-    const { result } = renderHook(() => useHanetCheckinData());
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1)).reply(200, data);
+  test('Test onLoadMore', async () => {
+    const { result } = renderHook(() => useHanetCheckinData(props));
+    axios.get.mockImplementationOnce(() => ({
+      status: 200,
+      data: data,
+    }));
     await act(async () => {
-      await result.current.onRefresh();
+      await result.current.onLoadMore();
+    });
+    expect(axios.get).toHaveBeenCalled();
+
+    axios.get.mockClear();
+
+    await act(async () => {
+      await result.current.onLoadMore();
+    });
+    expect(axios.get).toHaveBeenCalledTimes(0);
+  });
+
+  test('Test onMomentumScrollBegin', async () => {
+    const { result } = renderHook(() => useHanetCheckinData(props));
+    await act(async () => {
+      await result.current.onMomentumScrollBegin();
     });
-    expect(result.current.refreshing).toBeFalsy();
   });
 
   test('Test onReceiveNewCheckinData', async () => {
@@ -82,9 +101,9 @@ describe('Test useHanetCheckinData', () => {
     await act(async () => {
       await result.current.onReceiveNewCheckinData(newData);
     });
-    expect(result.current.checkinData).toHaveLength(3);
+    expect(result.current.checkinData).toHaveLength(1);
     expect(result.current.countMember).toBe(1);
-    expect(result.current.countStranger).toBe(1);
+    expect(result.current.countStranger).not.toBe(1);
 
     const newData2 = {
       id: 2,
@@ -97,7 +116,7 @@ describe('Test useHanetCheckinData', () => {
     await act(async () => {
       await result.current.onReceiveNewCheckinData(newData2);
     });
-    expect(result.current.checkinData).toHaveLength(3);
+    expect(result.current.checkinData).toHaveLength(2);
     expect(result.current.countMember).toBe(1);
     expect(result.current.countStranger).toBe(1);
 
@@ -113,7 +132,7 @@ describe('Test useHanetCheckinData', () => {
       await result.current.onReceiveNewCheckinData(newData3);
     });
     // no change
-    expect(result.current.checkinData).toHaveLength(3);
+    expect(result.current.checkinData).toHaveLength(2);
     expect(result.current.countMember).toBe(1);
     expect(result.current.countStranger).toBe(1);
 
@@ -122,35 +141,8 @@ describe('Test useHanetCheckinData', () => {
       await result.current.onReceiveNewCheckinData(newData2);
     });
     // no change
-    expect(result.current.checkinData).toHaveLength(3);
+    expect(result.current.checkinData).toHaveLength(2);
     expect(result.current.countMember).toBe(1);
     expect(result.current.countStranger).toBe(1);
   });
-
-  test('Test onLoadMore', async () => {
-    const { result } = renderHook(() => useHanetCheckinData(props));
-    mock
-      .onGet(API.CAMERA.HANET.CHECKIN(1))
-      .reply(200, { ...data, count_member: 20 });
-    await act(async () => {
-      await result.current.onLoadMore();
-    });
-    expect(result.current.countMember).toBe(20);
-  });
-
-  test('Test onMomentumScrollBegin', async () => {
-    const { result } = renderHook(() => useHanetCheckinData(props));
-    await act(async () => {
-      await result.current.onMomentumScrollBegin();
-    });
-  });
-
-  test('Test onChangeDate', async () => {
-    const { result } = renderHook(() => useHanetCheckinData(props));
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1, moment())).reply(200, data);
-    await act(async () => {
-      await result.current.onChangeDate(moment());
-    });
-    expect(result.current.countMember).toBe(data.count_member);
-  });
 });

package/src/screens/HanetCamera/hooks/__test__/useHanetPlaceMembers.test.js

@@ -1,15 +1,14 @@
 import { act, renderHook } from '@testing-library/react-hooks';
 import { useHanetPlaceMembers } from '../index';
-import MockAdapter from 'axios-mock-adapter';
-import api from '../../../../utils/Apis/axios';
-import { API } from '../../../../configs';
+import axios from 'axios';
 
-const mock = new MockAdapter(api.axiosInstance);
+jest.mock('axios');
 
 describe('Test useHanetPlaceMembers', () => {
   let props, data;
 
   beforeEach(() => {
+    axios.get.mockClear();
     props = {
       place: {
         place_id: 2,
@@ -34,20 +33,33 @@ describe('Test useHanetPlaceMembers', () => {
 
   test('Test onRefresh', async () => {
     const { result } = renderHook(() => useHanetPlaceMembers(props));
-    mock.onGet(API.CAMERA.HANET.PLACE_MEMBERS(1)).reply(200, data);
+    axios.get.mockImplementationOnce(() => ({
+      status: 200,
+      data: data,
+    }));
     await act(async () => {
       await result.current.onRefresh();
     });
-    expect(result.current.loadingMore).toBe(false);
+    expect(axios.get).toHaveBeenCalled();
   });
 
   test('Test onLoadMore', async () => {
-    const { result } = renderHook(() => useHanetPlaceMembers());
-    mock.onGet(API.CAMERA.HANET.PLACE_MEMBERS(1)).reply(200, data);
+    const { result } = renderHook(() => useHanetPlaceMembers(props));
+    axios.get.mockImplementationOnce(() => ({
+      status: 200,
+      data: data,
+    }));
+    await act(async () => {
+      await result.current.onLoadMore();
+    });
+    expect(axios.get).toHaveBeenCalled();
+
+    axios.get.mockClear();
+
     await act(async () => {
       await result.current.onLoadMore();
     });
-    expect(result.current.loadingMore).toBe(false);
+    expect(axios.get).toHaveBeenCalledTimes(0);
   });
 
   test('Test onMomentumScrollBegin', async () => {
@@ -55,6 +67,5 @@ describe('Test useHanetPlaceMembers', () => {
     await act(async () => {
       await result.current.onMomentumScrollBegin();
     });
-    expect(result.current.loadingMore).toBe(false);
   });
 });

package/src/screens/HanetCamera/hooks/useHanetCheckinData.js

@@ -16,13 +16,13 @@ const useHanetCheckinData = (hanetCamera) => {
   const [loadingMore, setLoadingMore] = useState(false);
   const [canLoadMore, setCanLoadMore] = useState(true);
 
-  const fetchData = async (selectedPage, selectedDate) => {
+  const fetchData = async (page, date) => {
     if (!hanetCamera) {
       return;
     }
-    setPage(selectedPage);
-    setDate(selectedDate);
-    if (selectedPage === 1) {
+    setPage(page);
+    setDate(date);
+    if (page === 1) {
       setRefreshing(true);
     } else {
       if (!canLoadMore) {
@@ -32,8 +32,8 @@ const useHanetCheckinData = (hanetCamera) => {
     }
 
     const params = new URLSearchParams();
-    params.append('page', selectedPage);
-    params.append('date', selectedDate.format('YYYY-MM-DD'));
+    params.append('page', page);
+    params.append('date', date.format('YYYY-MM-DD'));
     const { success, data } = await axiosGet(
       API.CAMERA.HANET.CHECKIN(hanetCamera.device_id),
       {
@@ -43,17 +43,17 @@ const useHanetCheckinData = (hanetCamera) => {
     if (success && data) {
       setCountMember(data.count_member);
       setCountStranger(data.count_stranger);
-      if (selectedPage === 1) {
+      if (page === 1) {
         setCheckinData(data.results || []);
       } else {
-        setCanLoadMore(selectedPage < Math.ceil(data.count / 20));
+        setCanLoadMore(page < Math.ceil(data.count / 20));
         setCheckinData((prevData) =>
           _.uniqBy(prevData.concat(data.results || []), 'id')
         );
       }
     }
 
-    if (selectedPage === 1) {
+    if (page === 1) {
       setRefreshing(false);
     } else {
       setLoadingMore(false);
@@ -75,8 +75,8 @@ const useHanetCheckinData = (hanetCamera) => {
   const onMomentumScrollBegin = () =>
     (onEndReachedCalledDuringMomentum = false);
 
-  const onChangeDate = (selectedDate) => {
-    fetchData(page, selectedDate);
+  const onChangeDate = (date) => {
+    fetchData(page, date);
   };
 
   const onReceiveNewCheckinData = (data) => {

package/src/screens/HanetCamera/hooks/useHanetPlaceMembers.js

@@ -13,12 +13,12 @@ const useHanetPlaceMembers = (place) => {
   const [loadingMore, setLoadingMore] = useState(false);
   const [canLoadMore, setCanLoadMore] = useState(true);
 
-  const fetchData = async (selectedPage) => {
+  const fetchData = async (page) => {
     if (!place) {
       return;
     }
-    setPage(selectedPage);
-    if (selectedPage === 1) {
+    setPage(page);
+    if (page === 1) {
       setRefreshing(true);
     } else {
       if (!canLoadMore) {
@@ -28,23 +28,23 @@ const useHanetPlaceMembers = (place) => {
     }
 
     const params = new URLSearchParams();
-    params.append('page', selectedPage);
-    const { success, data: membersData } = await axiosGet(
+    params.append('page', page);
+    const { success, data } = await axiosGet(
       API.CAMERA.HANET.PLACE_MEMBERS(place.place_id),
       {
         params,
       }
     );
-    if (success && membersData) {
-      if (selectedPage === 1) {
-        setData(membersData.results || []);
+    if (success && data) {
+      if (page === 1) {
+        setData(data.results || []);
       } else {
-        setCanLoadMore(selectedPage < Math.ceil(membersData.count / 20));
-        setData((prevData) => prevData.concat(membersData.results || []));
+        setCanLoadMore(page < Math.ceil(data.count / 20));
+        setData((prevData) => prevData.concat(data.results || []));
       }
     }
 
-    if (selectedPage === 1) {
+    if (page === 1) {
       setRefreshing(false);
     } else {
       setLoadingMore(false);

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

@@ -1,18 +1,14 @@
 import React from 'react';
 import { create, act } from 'react-test-renderer';
-import MockAdapter from 'axios-mock-adapter';
 
 import ManageAccessScreen from '../index';
 import { HeaderCustom } from '../../../commons/Header';
+import axios from 'axios';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import { ScrollView } from 'react-native';
 import { RowItem } from '../../../commons/RowItem';
 import Routes from '../../../utils/Route';
-import api from '../../../utils/Apis/axios';
-import { API } from '../../../configs';
-
-const mock = new MockAdapter(api.axiosInstance);
 
 const mockUseIsFocused = jest.fn();
 const mockedNavigate = jest.fn();
@@ -35,6 +31,8 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
+jest.mock('axios');
+
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
     <ManageAccessScreen route={route} />
@@ -46,6 +44,7 @@ describe('Test Manage Access', () => {
   let route;
 
   beforeEach(() => {
+    axios.get.mockClear();
     mockedNavigate.mockClear();
     route = {
       params: {
@@ -60,25 +59,27 @@ describe('Test Manage Access', () => {
       },
     };
   });
-
   it('render Manage Access', async () => {
     mockUseIsFocused.mockImplementation(() => true);
-    mock.onGet(API.UNIT.MANAGE_ACCESS(1)).reply(200, [
-      {
-        id: 1,
-        user: {
+    const response = {
+      status: 200,
+      data: [
+        {
           id: 1,
-          name: 'jason',
-          phone_number: '0984524544',
-          email: '123@gmail.com',
+          user: {
+            id: 1,
+            name: 'jason',
+            phone_number: '0984524544',
+            email: '123@gmail.com',
+          },
+          access_schedule: 'always',
+          schedule: 'Always',
         },
-        access_schedule: 'always',
-        schedule: 'Always',
-      },
-      {
-        id: 2,
-      },
-    ]);
+      ],
+    };
+    axios.get.mockImplementation(async () => {
+      return response;
+    });
     await act(async () => {
       tree = await create(wrapComponent(route));
     });
@@ -88,7 +89,7 @@ describe('Test Manage Access', () => {
     expect(header).toHaveLength(1);
     expect(scrollView).toHaveLength(1);
     const memberButton = instance.findAllByType(RowItem);
-    expect(memberButton).toHaveLength(2);
+    expect(memberButton).toHaveLength(1);
     await act(async () => {
       await memberButton[0].props.onPress();
     });
@@ -96,16 +97,4 @@ describe('Test Manage Access', () => {
       id: 1,
     });
   });
-
-  it('render Manage Access without params', async () => {
-    mockUseIsFocused.mockImplementation(() => false);
-    await act(async () => {
-      tree = await create(wrapComponent({}));
-    });
-    const instance = tree.root;
-    const header = instance.findAllByType(HeaderCustom);
-    const scrollView = instance.findAllByType(ScrollView);
-    expect(header).toHaveLength(1);
-    expect(scrollView).toHaveLength(1);
-  });
 });

package/src/screens/ManageAccess/hooks/__test__/useManageAccess.test.js

@@ -1,10 +1,7 @@
 import { act, renderHook } from '@testing-library/react-hooks';
-import MockAdapter from 'axios-mock-adapter';
 import useManageAccess from '../index';
+import axios from 'axios';
 import API from '../../../../configs/API';
-import api from '../../../../utils/Apis/axios';
-
-const mock = new MockAdapter(api.axiosInstance);
 
 jest.mock('react', () => {
   return {
@@ -13,7 +10,15 @@ jest.mock('react', () => {
   };
 });
 
+jest.mock('axios');
+
 describe('Test Use Manage Access', () => {
+  beforeEach(() => {
+    axios.get.mockClear();
+  });
+  afterEach(() => {
+    axios.get.mockClear();
+  });
   const unit = { id: 1, name: 'unit name' };
   const sensor = {
     id: 1,
@@ -25,53 +30,49 @@ describe('Test Use Manage Access', () => {
 
   it('Test fetch data', () => {
     const { result } = renderHook(() => useManageAccess(unit, sensor));
-    mock.onGet(API.UNIT.MANAGE_ACCESS(unit.id)).reply(200, [
-      {
-        id: 1,
-        user: {
+    axios.get.mockImplementation(() => ({
+      status: 200,
+      data: [
+        {
           id: 1,
-          name: 'jason',
-          phone_number: '0984524544',
-          email: '123@gmail.com',
+          user: {
+            id: 1,
+            name: 'jason',
+            phone_number: '0984524544',
+            email: '123@gmail.com',
+          },
+          access_schedule: 'always',
+          schedule: 'Always',
         },
-        access_schedule: 'always',
-        schedule: 'Always',
-      },
-      {
-        id: 2,
-        user: {
-          id: 1,
-          name: 'mike',
-          phone_number: '0984524144',
-          email: '1235@gmail.com',
+        {
+          id: 2,
+          user: {
+            id: 1,
+            name: 'mike',
+            phone_number: '0984524144',
+            email: '1235@gmail.com',
+          },
+          access_schedule: 'recurring',
+          schedule: 'M/T 02:40 - 08:40 AM',
         },
-        access_schedule: 'recurring',
-        schedule: 'M/T 02:40 - 08:40 AM',
-      },
-      {
-        id: 3,
-        user: {
-          id: 1,
-          name: 'david',
-          phone_number: '0984524541',
-          email: '1234@gmail.com',
+        {
+          id: 3,
+          user: {
+            id: 1,
+            name: 'david',
+            phone_number: '0984524541',
+            email: '1234@gmail.com',
+          },
+          access_schedule: 'temporary',
+          schedule: '02:40 09/08/2020 - 08:40 09/10/2020',
         },
-        access_schedule: 'temporary',
-        schedule: '02:40 09/08/2020 - 08:40 09/10/2020',
-      },
-    ]);
+      ],
+    }));
     act(() => {
       result.current.onRefresh();
     });
-    expect(result.current.isLoading).toBe(true);
-  });
-
-  it('Test get manage access failure', () => {
-    const { result } = renderHook(() => useManageAccess(unit, sensor));
-    mock.onGet(API.UNIT.MANAGE_ACCESS(unit.id)).reply(400, []);
-    act(() => {
-      result.current.onRefresh();
+    expect(axios.get).toHaveBeenCalledWith(API.UNIT.MANAGE_ACCESS(unit.id), {
+      params: { sensor_id: sensor.id },
     });
-    expect(result.current.data).toEqual([]);
   });
 });