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

package/src/commons/ActionGroup/__test__/index.test.js

@@ -464,4 +464,139 @@ describe('Test ActionGroup', () => {
       moment('2021-09-09T10:00:00.000Z').valueOf()
     );
   });
+
+  test('render OnOffSmartLock', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'OnOffSmartLockActionTemplate',
+      title: 'Timer',
+      configuration: {
+        action_off_data: jest.fn(),
+        action_on_data: jest.fn(),
+      },
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(5);
+  });
+
+  test('render OptionsDropdownActionTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'OptionsDropdownActionTemplate',
+      title: 'Timer',
+      configuration: {
+        action_data: jest.fn(),
+        options: [],
+        icon_kit_data: 'icon_kit_data',
+        icon: '',
+        icon_outlined: 'icon_outlined',
+      },
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(7);
+  });
+
+  test('render CurtainButtonTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'curtain_action_template',
+      title: 'Timer',
+      configuration: {},
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(2);
+  });
+
+  test('render SmartTiviActionTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'SmartTiviActionTemplate',
+      title: 'Timer',
+      configuration: {},
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(4);
+  });
+
+  test('render ColorPickerTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'color_picker_template',
+      title: 'Timer',
+      configuration: {},
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(2);
+  });
+
+  test('render SliderRangeTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'slider_range_template',
+      title: 'Timer',
+      configuration: {},
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(4);
+  });
+
+  test('render TwoButtonTemplate', async () => {
+    Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
+    const actionGroup = {
+      template: 'two_button_action_template',
+      title: 'Timer',
+      configuration: {},
+    };
+    const mockDoAction = jest.fn();
+    await act(() => {
+      wrapper = renderer.create(
+        wrapComponent(actionGroup, mockDoAction, sensor)
+      );
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(5);
+  });
 });

package/src/commons/Automate/ItemAutomate.js

@@ -35,9 +35,7 @@ const ItemAutomate = ({
       style={[styles.wrap, isSelected && styles.active]}
     >
       <View style={styles.row}>
-        <View style={styles.wrapIcon}>
-          <Icon />
-        </View>
+        <View style={styles.wrapIcon}>{!!Icon && <Icon />}</View>
         <View style={styles.wrapTitle}>
           <Text type="H4" bold>
             {t(item?.title)}

package/src/commons/Calendar/__test__/Calendar.test.js

@@ -0,0 +1,33 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+import CalendarComponent from '../';
+import { Calendar } from 'react-native-calendars';
+// eslint-disable-next-line no-unused-vars
+import BottomSheet from '../../BottomSheet';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+
+const mockSetState = jest.fn();
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    useState: jest.fn((init) => [init, mockSetState]),
+  };
+});
+const wrapComponent = (route, navigation) => (
+  <SCProvider initState={mockSCStore({})}>
+    <CalendarComponent route={route} />
+  </SCProvider>
+);
+describe('Test Calendar component', () => {
+  let tree;
+
+  test('create Calendar', () => {
+    act(() => {
+      tree = renderer.create(wrapComponent());
+    });
+    const instance = tree.root;
+    const calendar = instance.findAllByType(Calendar);
+    expect(calendar).toHaveLength(1);
+  });
+});

package/src/commons/Connecting/__test__/Connecting.test.js

@@ -5,13 +5,19 @@ import Text from '../../Text';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 
-const wrapComponent = (route) => (
+const wrapComponent = (route, isLoading, isConnect, isPercentConnect) => (
   <SCProvider initState={mockSCStore({})}>
-    <Connecting route={route} />
+    <Connecting
+      route={route}
+      isLoading={isLoading}
+      isConnect={isConnect}
+      isPercentConnect={isPercentConnect}
+    />
   </SCProvider>
 );
 describe('Test Connecting', () => {
   let tree;
+
   test('create Connecting', () => {
     act(() => {
       tree = renderer.create(wrapComponent());
@@ -20,4 +26,15 @@ describe('Test Connecting', () => {
     const text = instance.findAllByType(Text);
     expect(text).toHaveLength(4);
   });
+
+  test('isLoading = true', () => {
+    jest.useFakeTimers();
+    act(() => {
+      tree = renderer.create(wrapComponent({}, true));
+    });
+    jest.runAllTimers();
+    const instance = tree.root;
+    const text = instance.findAllByType(Text);
+    expect(text).toHaveLength(4);
+  });
 });

package/src/commons/ConnectingProcess/__test__/Connecting.test.js

@@ -1,18 +1,35 @@
 import React from 'react';
 import renderer, { act } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
+
 import ConnectingProcess from '../index';
 import { SafeAreaView } from 'react-native';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
+import api from '../../../utils/Apis/axios';
+import { API } from '../../../configs';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
     <ConnectingProcess route={route} />
   </SCProvider>
 );
+
+const mock = new MockAdapter(api.axiosInstance);
+
 describe('Test ConnectingProcess', () => {
   let tree;
-  test('create ConnectingProcess', () => {
+
+  test('render without params', () => {
+    act(() => {
+      tree = renderer.create(wrapComponent({}));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = SENSOR call api success', async () => {
     const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
     const devicePrefixName = 'SENSOR';
     const gateway = { id: 1, name: 'gateway' };
@@ -20,8 +37,124 @@ describe('Test ConnectingProcess', () => {
     const route = {
       params: { scan_sensor_data, gateway, station, devicePrefixName },
     };
-    act(() => {
-      tree = renderer.create(wrapComponent(route));
+    mock.onPost(API.SUB_UNIT.SENSOR_SCAN(1)).reply(200);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = SENSOR call api fail', async () => {
+    const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
+    const devicePrefixName = 'SENSOR';
+    const gateway = { id: 1, name: 'gateway' };
+    const station = { id: 1, icon_kit: 'a', name: 'station' };
+    const route = {
+      params: { scan_sensor_data, gateway, station, devicePrefixName },
+    };
+    mock.onPost(API.SUB_UNIT.SENSOR_SCAN(1)).reply(400);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = ROBOT call api success', async () => {
+    const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
+    const devicePrefixName = 'ROBOT';
+    const gateway = { id: 1, name: 'gateway' };
+    const station = { id: 1, icon_kit: 'a', name: 'station' };
+    const route = {
+      params: {
+        scan_sensor_data,
+        gateway,
+        station,
+        devicePrefixName,
+        unit_id: 1,
+        unit: {
+          id: 1,
+        },
+      },
+    };
+    mock.onPost(API.UNIT.CHIP_SCAN(1)).reply(200);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = ROBOT call api fail', async () => {
+    const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
+    const devicePrefixName = 'ROBOT';
+    const gateway = { id: 1, name: 'gateway' };
+    const station = { id: 1, icon_kit: 'a', name: 'station' };
+    const route = {
+      params: {
+        scan_sensor_data,
+        gateway,
+        station,
+        devicePrefixName,
+        unit_id: 1,
+        unit: {
+          id: 1,
+        },
+      },
+    };
+    mock.onPost(API.UNIT.CHIP_SCAN(1)).reply(400);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = LITE call api success', async () => {
+    const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
+    const devicePrefixName = 'LITE';
+    const gateway = { id: 1, name: 'gateway' };
+    const station = { id: 1, icon_kit: 'a', name: 'station' };
+    const route = {
+      params: {
+        scan_sensor_data,
+        gateway,
+        station,
+        devicePrefixName,
+        unit_id: 1,
+      },
+    };
+    mock.onPost(API.UNIT.ADD_GATEWAY(1)).reply(200);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const safeAreaView = instance.findAllByType(SafeAreaView);
+    expect(safeAreaView).toHaveLength(1);
+  });
+
+  test('create ConnectingProcess with devicePrefixName = LITE call api fail', async () => {
+    const scan_sensor_data = { imei: 'SENSOR-afasdfas' };
+    const devicePrefixName = 'LITE';
+    const gateway = { id: 1, name: 'gateway' };
+    const station = { id: 1, icon_kit: 'a', name: 'station' };
+    const route = {
+      params: {
+        scan_sensor_data,
+        gateway,
+        station,
+        devicePrefixName,
+        unit_id: 1,
+      },
+    };
+    mock.onPost(API.UNIT.ADD_GATEWAY(1)).reply(400);
+    await act(async () => {
+      tree = await renderer.create(wrapComponent(route));
     });
     const instance = tree.root;
     const safeAreaView = instance.findAllByType(SafeAreaView);

package/src/commons/ConnectingProcess/index.js

@@ -28,7 +28,7 @@ const ConnectingProcess = ({ route }) => {
     wifi_ssid,
     wifi_pass,
     chip_id,
-  } = route.params;
+  } = route.params || {};
   const [isLoading, setIsLoading] = useState(true);
   const [sensor, setSensor] = useState(null);
   const user = useSCContextSelector((state) => state?.auth?.account?.user);

package/src/commons/Dashboard/MyPinnedSharedUnit/__test__/MyPinnedSharedUnit.test.js

@@ -1,5 +1,6 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
+import MockAdapter from 'axios-mock-adapter';
 
 import MyPinnedSharedUnit from '../index';
 import { Text } from 'react-native';
@@ -9,9 +10,9 @@ import { mockSCStore } from '../../../../context/mockStore';
 import { TESTID } from '../../../../configs/Constants';
 import { API } from '../../../../configs';
 import { TouchableOpacity } from 'react-native';
-import axios from 'axios';
+import api from '../../../../utils/Apis/axios';
 
-jest.mock('axios');
+const mock = new MockAdapter(api.axiosInstance);
 
 const mockedNavigate = jest.fn();
 jest.mock('@react-navigation/native', () => {
@@ -32,21 +33,14 @@ const wrapComponent = (route) => (
 
 describe('Test MyPinnedSharedUnit', () => {
   let tree;
-  afterEach(() => {
-    axios.get.mockClear();
-  });
 
   test('create', async () => {
-    const response = {
-      status: 200,
-      data: [{ id: 1 }],
-    };
-    axios.get.mockImplementation(async () => {
-      return response;
-    });
+    mock.onGet(API.UNIT.SHARED_UNITS()).reply(200, [{ id: 1 }]);
+
     await act(async () => {
       tree = await create(wrapComponent());
     });
+
     const instance = tree.root;
     const texts = instance.findAllByType(Text);
     expect(texts).toHaveLength(4);
@@ -65,6 +59,15 @@ describe('Test MyPinnedSharedUnit', () => {
       goToAllSharedUnits.props.onPress();
     });
     expect(mockedNavigate).toHaveBeenCalled();
-    expect(axios.get).toHaveBeenCalledWith(API.UNIT.SHARED_UNITS(), {});
+  });
+
+  test('render without item', async () => {
+    mock.onGet(API.UNIT.SHARED_UNITS()).reply(400, []);
+    await act(async () => {
+      tree = await create(wrapComponent());
+    });
+    const instance = tree.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(4);
   });
 });

package/src/commons/Dashboard/MyPinnedSharedUnit/index.js

@@ -60,7 +60,7 @@ const MyPinnedSharedUnit = () => {
         {sharedUnits &&
           Boolean(sharedUnits.length) &&
           sharedUnits
-            .filter((sharedUnit) => sharedUnit.is_pin)
+            .filter((sharedUnit) => sharedUnit?.is_pin)
             .map((item, index) => (
               <View key={item.id}>
                 <SharedUnit

package/src/commons/Dashboard/MyUnit/__test__/MyUnit.test.js

@@ -4,9 +4,7 @@ import MyUnit from '..';
 import { TESTID } from '../../../../configs/Constants';
 import { SCProvider } from '../../../../context';
 import { mockSCStore } from '../../../../context/mockStore';
-import axios from 'axios';
 
-jest.mock('axios');
 const mockedNavigate = jest.fn();
 const mockUseIsFocused = jest.fn();
 const mockedDispatch = jest.fn();
@@ -36,9 +34,6 @@ const wrapComponent = () => (
 
 describe('Test MyUnit', () => {
   let tree;
-  beforeEach(() => {
-    axios.get.mockClear();
-  });
   const getElement = (instance) => {
     const goToDetail = instance.findAll(
       (item) => item.props.testID === TESTID.MY_UNIT_GO_TO_DETAIL

package/src/commons/Device/Hanet/ItemHanetDevice.test.js

@@ -0,0 +1,58 @@
+import React from 'react';
+import { TouchableWithoutFeedback } from 'react-native';
+import renderer, { act } from 'react-test-renderer';
+import ItemHanetDevice from './ItemHanetDevice';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+
+const wrapComponent = (props) => (
+  <SCProvider initState={mockSCStore({})}>
+    <ItemHanetDevice {...props} />
+  </SCProvider>
+);
+
+const mockNavigate = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockNavigate,
+    }),
+  };
+});
+
+describe('Test ItemHanetDevice', () => {
+  let tree, props;
+
+  beforeEach(() => {
+    props = {
+      svgMain: 'icon',
+      title: 'title',
+      sensor: {},
+      unit: {},
+      station: {},
+    };
+  });
+
+  test('render ItemHanetDevice', () => {
+    act(() => {
+      tree = renderer.create(wrapComponent(props));
+    });
+    const instance = tree.root;
+    const touches = instance.findAllByType(TouchableWithoutFeedback);
+    act(() => {
+      tree = touches[0].props.onPress();
+    });
+    expect(mockNavigate).toBeCalled();
+  });
+
+  test('render ItemHanetDevice sensor has icon', () => {
+    props.sensor.icon_kit = 'icon';
+    act(() => {
+      tree = renderer.create(wrapComponent(props));
+    });
+    const instance = tree.root;
+    const touches = instance.findAllByType(TouchableWithoutFeedback);
+    expect(touches.length).toBeGreaterThan(0);
+  });
+});

package/src/commons/Device/LinearChart.js

@@ -52,6 +52,21 @@ const chartOptions = {
       format: '{value:%d.%m %H:%M}',
     },
   },
+  legend: {
+    useHTML: true,
+    labelFormatter: function () {
+      if (this.visible) {
+        return (
+          '<span style="color:#333333;font-weight:bold">' +
+          this.name +
+          '</span>'
+        );
+      }
+      return (
+        '<span style="color:#cccccc;font-weight:bold">' + this.name + '</span>'
+      );
+    },
+  },
 };
 
 function LinearChart({ datas }) {