@eohjsc/react-native-smart-city 0.2.86 → 0.2.89

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

@@ -0,0 +1,133 @@
+import React from 'react';
+import { TouchableOpacity } from 'react-native';
+import { create, act } from 'react-test-renderer';
+import axios from 'axios';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import HanetCaptureFaceID from '../CaptureFaceID';
+import { RNCamera } from 'react-native-camera';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <HanetCaptureFaceID route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+  };
+});
+
+const mockedNavigate = jest.fn();
+const mockedGoBack = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+  };
+});
+
+jest.mock('axios');
+
+const mockSetAvatar = jest.fn();
+describe('Test HanetCaptureFaceID', () => {
+  let tree, route;
+
+  beforeEach(() => {
+    mockedNavigate.mockClear();
+    mockedGoBack.mockClear();
+    mockSetAvatar.mockClear();
+    axios.patch.mockClear();
+    route = {
+      params: {
+        title: 'title',
+        hanetPlace: {
+          place_id: 1,
+        },
+        hanetMember: {
+          id: 1,
+          alias_id: 1,
+          name: 'name',
+          avatar_uri: 'uri',
+        },
+        setMemberAvatar: mockSetAvatar,
+        isAddNewMember: false,
+      },
+    };
+  });
+
+  const captureFaceID = async (instance) => {
+    let touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+    const camera = instance.findByType(RNCamera);
+    expect(camera).toBeDefined();
+
+    // capture
+    touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+
+    // resume capture
+    touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[2].props.onPress();
+    });
+
+    // capture
+    touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+  };
+
+  test('Test update face id', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    // capture face id
+    await captureFaceID(instance);
+
+    axios.patch.mockImplementationOnce(async () => ({
+      status: 200,
+      data: {
+        avatar_uri: 'avatar_uri',
+      },
+    }));
+
+    // continue
+    let touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+    expect(axios.patch).toHaveBeenCalled();
+    expect(mockSetAvatar).toHaveBeenCalled();
+    expect(mockedGoBack).toHaveBeenCalled();
+  });
+
+  test('Test set face id for new member', async () => {
+    route.params.isAddNewMember = true;
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    await captureFaceID(instance);
+
+    // continue
+    let touches = instance.findAllByType(TouchableOpacity);
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+    expect(mockedNavigate).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,185 @@
+import React from 'react';
+import { FlatList } from 'react-native';
+import { create, act } from 'react-test-renderer';
+import axios from 'axios';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import HanetCameraDetail from '../Detail';
+import CheckinHeader from '../components/CheckinHeader';
+import moment from 'moment';
+import { TESTID } from '../../../configs/Constants';
+import Calendar from '../../../commons/Calendar';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <HanetCameraDetail route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+  };
+});
+
+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: {
+          user_id: 1,
+        },
+        sensor: {
+          id: 1,
+        },
+        title: 'title',
+      },
+    };
+    responseDisplay = {
+      status: 200,
+      data: {
+        items: [
+          {
+            type: 'hanet_camera',
+            configuration: {
+              device_id: 2,
+              place: {
+                place_id: 3,
+              },
+            },
+          },
+        ],
+      },
+    };
+    responseCheckin = {
+      status: 200,
+      data: {
+        count: 2,
+        count_member: 1,
+        count_stranger: 1,
+        results: [
+          {
+            id: 1,
+            person_name: 'name 1',
+            person_type: 'EMPLOYEE',
+            detected_image_uri: 'uri',
+            detected_mask: 'MASK_OFF',
+            created_at: moment(),
+          },
+          {
+            id: 2,
+            person_name: 'name 2',
+            person_type: 'STRANGER',
+            detected_image_uri: 'uri',
+            detected_mask: 'MASK_ON',
+            created_at: moment(),
+          },
+        ],
+      },
+    };
+  });
+
+  test('Test render HanetCameraDetail', async () => {
+    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
+    );
+    const textCountStranger = instance.find(
+      (el) => el.props.testID === TESTID.TEXT_COUNT_STRANGER
+    );
+    expect(textCountMember.props.children).toBe(1);
+    expect(textCountStranger.props.children).toBe(1);
+  });
+
+  test('Test change date', async () => {
+    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
+    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();
+    });
+    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();
+    });
+    const calendar = instance.findByType(Calendar);
+    expect(calendar.props.isVisible).toBe(true);
+
+    // choose date on calendar
+    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

@@ -0,0 +1,152 @@
+import React from 'react';
+import { FlatList } from 'react-native';
+import { create, act } from 'react-test-renderer';
+import axios from 'axios';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import HanetManageAccess from '../ManageAccess';
+import BottomSheet from '../../../commons/BottomSheet';
+import { TESTID } from '../../../configs/Constants';
+import Routes from '../../../utils/Route';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <HanetManageAccess route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+  };
+});
+
+const mockedNavigate = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+jest.mock('axios');
+
+describe('Test HanetManageAccess', () => {
+  let tree, route, response;
+
+  beforeEach(() => {
+    mockedNavigate.mockClear();
+    axios.get.mockClear();
+    route = {
+      params: {
+        hanetPlace: {
+          place_id: 1,
+        },
+      },
+    };
+  });
+
+  test('Test render', async () => {
+    response = {
+      status: 200,
+      data: {
+        count: 2,
+        results: [
+          {
+            id: 1,
+            name: 'name 1',
+            avatar_uri: 'uri 1',
+          },
+          {
+            id: 2,
+            name: 'name 2',
+            avatar_uri: 'uri 2',
+          },
+        ],
+      },
+    };
+    axios.get.mockImplementationOnce(async () => response);
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const flatlists = instance.findAllByType(FlatList);
+    expect(flatlists).toHaveLength(1);
+
+    const touches = instance.findAll(
+      (el) => el.props.testID === TESTID.ROW_HANET_MANAGE_ACCESS
+    );
+    act(() => {
+      touches[0].props.onPress();
+    });
+    expect(mockedNavigate).toBeCalled();
+  });
+
+  const chooseAddMemberOption = async (instance, index) => {
+    const buttonAddNew = instance.find(
+      (el) => el.props.testID === TESTID.HANET_MANAGE_ACCESS_ADD_BUTTON
+    );
+    await act(async () => {
+      await buttonAddNew.props.onPress();
+    });
+    const option = instance.find(
+      (el) => el.props.testID === `${TESTID.HANET_ADD_MEMBER_OPTION}_${index}`
+    );
+    await act(async () => {
+      await option.props.onPress();
+    });
+  };
+
+  test('Test add new member capture face id', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const bottomSheet = instance.findByType(BottomSheet);
+
+    await chooseAddMemberOption(instance, 0);
+
+    expect(bottomSheet.props.isVisible).toBe(false);
+    expect(mockedNavigate).toBeCalledWith(Routes.HanetCaptureFaceID, {
+      title: 'Add new member',
+      hanetPlace: {
+        place_id: 1,
+      },
+      hanetMember: {
+        alias_id: null,
+        name: null,
+      },
+      isAddNewMember: true,
+    });
+  });
+
+  test('Test add new member choose file', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const bottomSheet = instance.findByType(BottomSheet);
+
+    await chooseAddMemberOption(instance, 1);
+
+    expect(bottomSheet.props.isVisible).toBe(false);
+    expect(mockedNavigate).toBeCalledWith(Routes.HanetMemberInfo, {
+      hanetPlace: {
+        place_id: 1,
+      },
+      hanetMember: {
+        alias_id: null,
+        name: null,
+        avatar_uri:
+          'file:///data/user/0/com.eohjsc.eohmobile/cache/Camera/80fbbd4b-926d-425f-a081-e21b13f2f7d0.jpg',
+      },
+      isAddNewMember: true,
+    });
+  });
+});

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

@@ -0,0 +1,178 @@
+import React from 'react';
+import { TouchableOpacity } from 'react-native';
+import { create, act } from 'react-test-renderer';
+import axios from 'axios';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import HanetMemberInfo from '../MemberInfo';
+import { AlertAction } from '../../../commons';
+import TextInput from '../../../commons/Form/TextInput';
+import BottomButtonView from '../../../commons/BottomButtonView';
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <HanetMemberInfo route={route} />
+  </SCProvider>
+);
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+  };
+});
+
+const mockedNavigate = jest.fn();
+const mockedGoBack = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => true,
+  };
+});
+
+jest.mock('axios');
+
+describe('Test HanetMemberInfo', () => {
+  let tree, route;
+
+  beforeEach(() => {
+    mockedNavigate.mockClear();
+    mockedGoBack.mockClear();
+    axios.post.mockClear();
+    axios.patch.mockClear();
+    axios.delete.mockClear();
+    route = {
+      params: {
+        hanetPlace: {
+          place_id: 1,
+        },
+        hanetMember: {
+          id: 1,
+          alias_id: 1,
+          name: 'name',
+          avatar_uri: 'uri',
+        },
+        isAddNewMember: false,
+      },
+    };
+  });
+
+  test('Test rename member', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const touches = instance.findAllByType(TouchableOpacity);
+    expect(touches).toHaveLength(5);
+    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);
+
+    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(axios.patch).toHaveBeenCalled();
+  });
+
+  test('Test remove member', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const touches = instance.findAllByType(TouchableOpacity);
+    expect(touches).toHaveLength(5);
+    const alertAction = instance.findByType(AlertAction);
+
+    // open alert action
+    await act(async () => {
+      await touches[3].props.onPress();
+    });
+    expect(alertAction.props.visible).toBe(true);
+
+    axios.delete.mockImplementationOnce(async () => ({ status: 200 }));
+
+    // press remove
+    await act(async () => {
+      await alertAction.props.rightButtonClick();
+    });
+
+    expect(axios.delete).toHaveBeenCalled();
+    expect(mockedGoBack).toHaveBeenCalled();
+  });
+
+  test('Test navigate CaptureFaceID', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const touches = instance.findAllByType(TouchableOpacity);
+    expect(touches).toHaveLength(5);
+
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+    expect(mockedNavigate).toBeCalled();
+  });
+
+  test('Test register new member', async () => {
+    route.params.hanetMember = {
+      alias_id: null,
+      name: null,
+      avatar_uri: 'avatar_uri',
+    };
+    route.params.isAddNewMember = true;
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+
+    const touches = instance.findAllByType(TouchableOpacity);
+    expect(touches).toHaveLength(5);
+
+    // press set face id
+    await act(async () => {
+      await touches[1].props.onPress();
+    });
+    expect(mockedNavigate).toBeCalled();
+
+    // open alert action
+    const alertAction = instance.findByType(AlertAction);
+    await act(async () => {
+      await touches[2].props.onPress();
+    });
+    expect(alertAction.props.visible).toBe(true);
+
+    // change name and press rename
+    const textInput = instance.findByType(TextInput);
+    await act(async () => {
+      await textInput.props.onChange('new name');
+      await alertAction.props.rightButtonClick();
+    });
+    expect(axios.post).not.toBeCalled();
+
+    // finish
+    const bottomButton = instance.findByType(BottomButtonView);
+    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/CheckinHeader.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import { View, TouchableOpacity, Image } from 'react-native';
+import Text from '../../../commons/Text';
+import { Images, Colors } from '../../../configs';
+import styles from '../styles/checkinHeaderStyles';
+import CalendarSvg from '../../../../assets/images/Common/Calendar.svg';
+
+const CheckinHeader = ({
+  date,
+  onPickPreviousDate,
+  onPickNextDate,
+  setShowCalendar,
+}) => {
+  return (
+    <View style={styles.wrap}>
+      <Text type="H3" color={Colors.Gray9} bold>
+        {'Check in'}
+      </Text>
+      <View style={styles.row}>
+        <TouchableOpacity onPress={onPickPreviousDate}>
+          <Image source={Images.arrowLeft} />
+        </TouchableOpacity>
+        <TouchableOpacity onPress={setShowCalendar} style={styles.wrapDate}>
+          <Text color={Colors.Gray9} style={styles.marginRight10}>
+            {date.format('DD/MM/YYYY')}
+          </Text>
+          <CalendarSvg color={Colors.Primary} />
+        </TouchableOpacity>
+        <TouchableOpacity onPress={onPickNextDate}>
+          <Image source={Images.arrowLeft} style={styles.arrowRight} />
+        </TouchableOpacity>
+      </View>
+    </View>
+  );
+};
+
+export default CheckinHeader;