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

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

@@ -1,8 +1,7 @@
 import React from 'react';
 import { FlatList } 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 HanetCameraDetail from '../Detail';
@@ -10,9 +9,6 @@ import CheckinHeader from '../components/CheckinHeader';
 import moment from 'moment';
 import { TESTID } from '../../../configs/Constants';
 import Calendar from '../../../commons/Calendar';
-import api from '../../../utils/Apis/axios';
-import { API } from '../../../configs';
-import { MenuActionMore } from '../../../commons';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -20,19 +16,6 @@ const wrapComponent = (route) => (
   </SCProvider>
 );
 
-const mock = new MockAdapter(api.axiosInstance);
-
-const mockNavigate = jest.fn();
-jest.mock('@react-navigation/native', () => {
-  return {
-    ...jest.requireActual('@react-navigation/native'),
-    useRoute: jest.fn(),
-    useNavigation: () => ({
-      navigate: mockNavigate,
-    }),
-  };
-});
-
 jest.mock('react', () => {
   return {
     ...jest.requireActual('react'),
@@ -40,11 +23,14 @@ jest.mock('react', () => {
   };
 });
 
+jest.mock('axios');
+
 describe('Test HanetCameraDetail', () => {
   Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
   let tree, route, responseDisplay, responseCheckin;
 
   beforeEach(() => {
+    axios.get.mockClear();
     route = {
       params: {
         unit: {
@@ -101,14 +87,20 @@ describe('Test HanetCameraDetail', () => {
   });
 
   test('Test render HanetCameraDetail', async () => {
-    mock.onGet(API.DEVICE.DISPLAY(1)).reply(200, responseDisplay.data);
-    mock.onGet(API.CAMERA.HANET.CHECKIN(2)).reply(200, responseCheckin.data);
+    axios.get.mockImplementationOnce(async () => {
+      return responseDisplay;
+    });
+    axios.get.mockImplementationOnce(async () => {
+      return responseCheckin;
+    });
     await act(async () => {
       tree = await create(wrapComponent(route));
     });
     const instance = tree.root;
+    expect(axios.get).toHaveBeenCalledTimes(2);
     const flatLists = instance.findAllByType(FlatList);
     expect(flatLists).toHaveLength(1);
+
     const textCountMember = instance.find(
       (el) => el.props.testID === TESTID.TEXT_COUNT_MEMBER
     );
@@ -117,33 +109,50 @@ describe('Test HanetCameraDetail', () => {
     );
     expect(textCountMember.props.children).toBe(1);
     expect(textCountStranger.props.children).toBe(1);
-    const MenuActionMores = instance.findByType(MenuActionMore);
-    await MenuActionMores.props.onItemClick({ data: 'test' });
-    expect(mockNavigate).toBeCalled();
   });
 
   test('Test change date', async () => {
-    mock.onGet(API.DEVICE.DISPLAY(1)).reply(200, responseDisplay.data);
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1)).reply(200, responseCheckin.data);
+    axios.get.mockImplementationOnce(async () => {
+      return responseDisplay;
+    });
+    axios.get.mockImplementationOnce(async () => {
+      return responseCheckin;
+    });
     await act(async () => {
       tree = await create(wrapComponent(route));
     });
     const instance = tree.root;
+    expect(axios.get).toHaveBeenCalledTimes(2);
+    axios.get.mockClear();
+
     const checkinHeader = instance.findByType(CheckinHeader);
+
     // press arrow left
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1)).reply(200, responseCheckin.data);
+    axios.get.mockImplementationOnce(async () => {
+      return responseCheckin;
+    });
     await act(async () => {
       await checkinHeader.props.onPickPreviousDate();
     });
     expect(checkinHeader.props.date.format('DD/MM/YYYY')).toBe(
       moment().add(-1, 'days').format('DD/MM/YYYY')
     );
+    expect(axios.get).toHaveBeenCalledTimes(1);
+    axios.get.mockClear();
+
+    // press arrow right
+    axios.get.mockImplementationOnce(async () => {
+      return responseCheckin;
+    });
     await act(async () => {
       await checkinHeader.props.onPickNextDate();
     });
     expect(checkinHeader.props.date.format('DD/MM/YYYY')).toBe(
       moment().format('DD/MM/YYYY')
     );
+    expect(axios.get).toHaveBeenCalledTimes(1);
+    axios.get.mockClear();
+
     // press arrow right
     await act(async () => {
       await checkinHeader.props.onPickNextDate();
@@ -151,6 +160,9 @@ describe('Test HanetCameraDetail', () => {
     expect(checkinHeader.props.date.format('DD/MM/YYYY')).toBe(
       moment().format('DD/MM/YYYY')
     ); // no change
+    expect(axios.get).toHaveBeenCalledTimes(0);
+    axios.get.mockClear();
+
     // open calendar
     await act(async () => {
       await checkinHeader.props.setShowCalendar();
@@ -159,12 +171,15 @@ describe('Test HanetCameraDetail', () => {
     expect(calendar.props.isVisible).toBe(true);
 
     // choose date on calendar
-    mock.onGet(API.CAMERA.HANET.CHECKIN(1)).reply(200, responseCheckin.data);
+    axios.get.mockImplementationOnce(async () => {
+      return responseCheckin;
+    });
     await act(async () => {
       await calendar.props.onConfirm(moment().add(-1, 'days'));
     });
     expect(checkinHeader.props.date.format('DD/MM/YYYY')).toBe(
       moment().add(-1, 'days').format('DD/MM/YYYY')
     );
+    expect(axios.get).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -1,8 +1,7 @@
 import React from 'react';
 import { FlatList } 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 HanetManageAccess from '../ManageAccess';
@@ -10,10 +9,6 @@ import BottomSheet from '../../../commons/BottomSheet';
 import { TESTID } from '../../../configs/Constants';
 import Routes from '../../../utils/Route';
 import ImagePicker from 'react-native-image-crop-picker';
-import api from '../../../utils/Apis/axios';
-import { API } from '../../../configs';
-
-const mock = new MockAdapter(api.axiosInstance);
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -39,11 +34,14 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
+jest.mock('axios');
+
 describe('Test HanetManageAccess', () => {
   let tree, route, response;
 
   beforeEach(() => {
     mockedNavigate.mockClear();
+    axios.get.mockClear();
     route = {
       params: {
         hanetPlace: {
@@ -72,8 +70,7 @@ describe('Test HanetManageAccess', () => {
         ],
       },
     };
-
-    mock.onGet(API.CAMERA.HANET.PLACE_MEMBERS(1)).reply(200, response.data);
+    axios.get.mockImplementationOnce(async () => response);
     await act(async () => {
       tree = await create(wrapComponent(route));
     });

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