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

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

@@ -2,6 +2,7 @@ import React from 'react';
 import { TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
 import Text from '../../../commons/Text';
+import { TESTID } from '../../../configs/Constants';
 import { watchMultiConfigs } from '../../../iot/Monitor';
 import NumberUpDownActionTemplate from '../NumberUpDownActionTemplate';
 
@@ -30,7 +31,7 @@ describe('Test NumberUpDownActionTemplate', () => {
     watchMultiConfigs.mockClear();
     actionGroup = {
       configuration: {
-        keep_track_config: false,
+        allow_config_store_value: false,
         config: 5,
         action_data,
         min_value: 16,
@@ -57,28 +58,10 @@ describe('Test NumberUpDownActionTemplate', () => {
 
     const touchs = instance.findAllByType(TouchableOpacity);
     expect(touchs).toHaveLength(2);
-  });
-
-  test('do action call watchConfigs', async () => {
-    actionGroup.configuration.keep_track_config = true;
-    const mockDoAction = jest.fn();
-    await act(async () => {
-      wrapper = await create(
-        <NumberUpDownActionTemplate
-          actionGroup={actionGroup}
-          doAction={mockDoAction}
-          sensor={{ is_managed_by_backend: true }}
-        />
-      );
-    });
-    const instance = wrapper.root;
-    const touchs = instance.findAllByType(TouchableOpacity);
-    expect(touchs).toHaveLength(2);
 
     await act(async () => {
       await touchs[0].props.onPress();
     });
-
     expect(watchMultiConfigs).toBeCalled();
   });
 
@@ -104,8 +87,9 @@ describe('Test NumberUpDownActionTemplate', () => {
     expect(watchMultiConfigs).not.toBeCalled();
   });
 
-  test('do action not call watchConfigs cause keep track config false', async () => {
+  test('do action watchConfigs cause allow_config_store_value true', async () => {
     const mockDoAction = jest.fn();
+    actionGroup.configuration.allow_config_store_value = true;
     await act(async () => {
       wrapper = await create(
         <NumberUpDownActionTemplate
@@ -123,11 +107,11 @@ describe('Test NumberUpDownActionTemplate', () => {
       await touchs[0].props.onPress();
     });
 
-    expect(watchMultiConfigs).not.toBeCalled();
+    expect(watchMultiConfigs).toBeCalled();
   });
 
   test('action down without config', async () => {
-    actionGroup.configuration.keep_track_config = true;
+    actionGroup.configuration.allow_config_store_value = true;
     actionGroup.configuration.config = undefined;
     const mockDoAction = jest.fn();
     await act(async () => {
@@ -150,8 +134,10 @@ describe('Test NumberUpDownActionTemplate', () => {
     expect(watchMultiConfigs).not.toBeCalled();
   });
 
-  test('action down without keep track config', async () => {
+  test('action down allow_config_store_value true', async () => {
     const mockDoAction = jest.fn();
+    actionGroup.configuration.allow_config_store_value = true;
+    actionGroup.configuration.config = null;
     await act(async () => {
       wrapper = await create(
         <NumberUpDownActionTemplate
@@ -162,19 +148,23 @@ describe('Test NumberUpDownActionTemplate', () => {
       );
     });
     const instance = wrapper.root;
-    const touchs = instance.findAllByType(TouchableOpacity);
-    expect(touchs).toHaveLength(2);
-
+    const touchs = instance.find(
+      (el) =>
+        el.props.testID === TESTID.NUMBER_ACTION_DOWN &&
+        el.type === TouchableOpacity
+    );
     await act(async () => {
-      await touchs[0].props.onPress();
+      await touchs.props.onPress();
     });
 
     const text = instance.findByType(Text);
-    expect(text.props.children).toEqual('24 *C');
+    expect(text.props.children).toEqual('27 *C');
   });
 
-  test('action up without keep track config', async () => {
+  test('action up allow_config_store_value true', async () => {
     const mockDoAction = jest.fn();
+    actionGroup.configuration.allow_config_store_value = true;
+    actionGroup.configuration.config = null;
     await act(async () => {
       wrapper = await create(
         <NumberUpDownActionTemplate
@@ -185,19 +175,21 @@ describe('Test NumberUpDownActionTemplate', () => {
       );
     });
     const instance = wrapper.root;
-    const touchs = instance.findAllByType(TouchableOpacity);
-    expect(touchs).toHaveLength(2);
-
+    const touchs = instance.find(
+      (el) =>
+        el.props.testID === TESTID.NUMBER_ACTION_UP &&
+        el.type === TouchableOpacity
+    );
     await act(async () => {
-      await touchs[1].props.onPress();
+      await touchs.props.onPress();
     });
-
-    const text = instance.findByType(Text);
-    expect(text.props.children).toEqual('26 *C');
+    const text = instance.find(
+      (el) => el.props.testID === 'abcd' && el.type === Text
+    );
+    expect(text.props.children).toEqual('29 *C');
   });
 
-  test('action down with keep track config', async () => {
-    actionGroup.configuration.keep_track_config = true;
+  test('action down with allow_config_store_value false', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
       wrapper = await create(
@@ -209,19 +201,21 @@ describe('Test NumberUpDownActionTemplate', () => {
       );
     });
     const instance = wrapper.root;
-    const touchs = instance.findAllByType(TouchableOpacity);
-    expect(touchs).toHaveLength(2);
+    const touchs = instance.find(
+      (el) =>
+        el.props.testID === TESTID.NUMBER_ACTION_DOWN &&
+        el.type === TouchableOpacity
+    );
 
     await act(async () => {
-      await touchs[0].props.onPress();
+      await touchs.props.onPress();
     });
 
     const text = instance.findByType(Text);
-    expect(text.props.children).toEqual('25 *C'); // TODO should 24, configValues make changes again
+    expect(text.props.children).toEqual('24 *C'); // TODO should 24, configValues make changes again
   });
 
-  test('action up with keep track config', async () => {
-    actionGroup.configuration.keep_track_config = true;
+  test('action up with allow_config_store_value false', async () => {
     const mockDoAction = jest.fn();
     await act(async () => {
       wrapper = await create(
@@ -233,15 +227,18 @@ describe('Test NumberUpDownActionTemplate', () => {
       );
     });
     const instance = wrapper.root;
-    const touchs = instance.findAllByType(TouchableOpacity);
-    expect(touchs).toHaveLength(2);
+    const touchs = instance.find(
+      (el) =>
+        el.props.testID === TESTID.NUMBER_ACTION_UP &&
+        el.type === TouchableOpacity
+    );
 
     await act(async () => {
-      await touchs[1].props.onPress();
+      await touchs.props.onPress();
     });
 
     const text = instance.findByType(Text);
-    expect(text.props.children).toEqual('25 *C'); // TODO should 26, configValues make changes again
+    expect(text.props.children).toEqual('26 *C'); // TODO should 26, configValues make changes again
   });
 
   test('action down limit ', async () => {

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

@@ -0,0 +1,77 @@
+import React from 'react';
+import { TouchableOpacity } from 'react-native';
+import { act, create } from 'react-test-renderer';
+import Text from '../../Text';
+import StatesGridActionTemplate from '../StatesGridActionTemplate';
+
+const mockDoAction = jest.fn();
+const mockActionData = jest.fn();
+
+describe('Test StatesGridActionTemplate', () => {
+  let tree;
+  const actionGroup = {
+    configuration: {
+      options: [
+        {
+          config: true,
+          active: false,
+          text: 'item 1',
+          icon_kit_data: 'icon_kit_data',
+          icon: '123',
+          icon_outlined: 'icon_outlined',
+          action_data: mockActionData,
+        },
+        {
+          config: false,
+          active: true,
+          text: 'item 2',
+          icon_kit_data: 'icon_kit_data',
+          icon: 'icon',
+          icon_outlined: 'icon_outlined',
+          action_data: mockActionData,
+        },
+      ],
+      is_on_value: true,
+    },
+    title: 'Title',
+  };
+  const sensor = {
+    is_managed_by_backend: true,
+    device_type: '',
+    name: 'Sensor name',
+  };
+
+  test('test render without params', async () => {
+    await act(async () => {
+      tree = await create(<StatesGridActionTemplate />);
+    });
+    const instance = tree.root;
+    const Texts = instance.findAllByType(Text);
+    expect(Texts).toHaveLength(1);
+  });
+
+  test('test render with params', async () => {
+    await act(async () => {
+      tree = await create(
+        <StatesGridActionTemplate
+          doAction={mockDoAction}
+          sensor={sensor}
+          actionGroup={actionGroup}
+        />
+      );
+    });
+    const instance = tree.root;
+    const Texts = instance.findAllByType(Text);
+    expect(Texts).toHaveLength(3);
+    const TouchableOpacities = instance.findAllByType(TouchableOpacity);
+    expect(TouchableOpacities).toHaveLength(2);
+    await TouchableOpacities[0].props.onPress();
+    expect(mockDoAction).toBeCalledWith(
+      mockActionData,
+      null,
+      `${sensor.name} ${actionGroup.title.toLowerCase()} ${
+        actionGroup.configuration.options[0].text
+      }`
+    );
+  });
+});

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

@@ -1,8 +1,10 @@
 import React from 'react';
-import { Switch } from 'react-native';
+import { Switch, TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
 import TimerActionTemplate from '../TimerActionTemplate';
 import DateTimePickerModal from 'react-native-modal-datetime-picker';
+import ScrollPicker from 'react-native-wheel-scrollview-picker';
+
 import moment from 'moment';
 import Text from '../../Text';
 import { watchMultiConfigs } from '../../../iot/Monitor';
@@ -15,12 +17,14 @@ jest.mock('../../../iot/states', () => ({
   useConfigGlobalState: () => [{ 5: 18, 6: 30 }, null],
 }));
 
-const wrapComponent = (actionGroup, mockDoAction, is_managed_by_backend) => (
+const mockDoAction = jest.fn();
+
+const wrapComponent = (actionGroup, sensor) => (
   <SCProvider initState={mockSCStore({})}>
     <TimerActionTemplate
       actionGroup={actionGroup}
       doAction={mockDoAction}
-      sensor={{ is_managed_by_backend }}
+      sensor={sensor}
     />
   </SCProvider>
 );
@@ -39,6 +43,7 @@ describe('Test TimerActionTemplate success with config value', () => {
 
   let actionGroup;
   let wrapper;
+  let sensor;
 
   beforeEach(() => {
     watchMultiConfigs.mockClear();
@@ -50,12 +55,24 @@ describe('Test TimerActionTemplate success with config value', () => {
         config_minute: 6,
       },
     };
+    sensor = {
+      is_managed_by_backend: true,
+      device_type: '',
+    };
+  });
+
+  test('render without params', async () => {
+    await act(async () => {
+      wrapper = await create(wrapComponent());
+    });
+    const instance = wrapper.root;
+    const texts = instance.findAllByType(Text);
+    expect(texts).toHaveLength(6);
   });
 
   test('render template', async () => {
-    const mockDoAction = jest.fn();
     await act(async () => {
-      wrapper = await create(wrapComponent(actionGroup, mockDoAction, true));
+      wrapper = await create(wrapComponent(actionGroup, sensor));
     });
     const instance = wrapper.root;
 
@@ -66,11 +83,46 @@ describe('Test TimerActionTemplate success with config value', () => {
 
     const switchButton = instance.findByType(Switch);
     expect(switchButton.props.value).toBeTruthy();
+    await switchButton.props.onValueChange();
+    expect(mockDoAction).toBeCalled();
+
+    const bottomScrollPicker = instance.findByType(ScrollPicker);
+    expect(bottomScrollPicker).toBeDefined();
+    const TouchableOpacities = instance.findAllByType(TouchableOpacity);
+    await TouchableOpacities[0].props.onPress();
 
     const dateTimePicker = instance.findByType(DateTimePickerModal);
-    expect(dateTimePicker.props.isVisible).toBeFalsy();
+    expect(dateTimePicker.props.isVisible).toBeTruthy();
     expect(dateTimePicker.props.date).toEqual(
       moment('18:30', 'HH:mm').valueOf()
     );
   });
+
+  test('render template with config_hour', async () => {
+    actionGroup = {
+      ...actionGroup,
+      configuration: {
+        ...actionGroup.configuration,
+        config_hour: 5,
+        config_minute: null,
+      },
+    };
+    await act(async () => {
+      wrapper = await create(wrapComponent(actionGroup, sensor));
+    });
+    const instance = wrapper.root;
+
+    const bottomScrollPicker = instance.findByType(ScrollPicker);
+    expect(bottomScrollPicker).toBeDefined();
+
+    const dateTimePicker = instance.findByType(DateTimePickerModal);
+    expect(dateTimePicker.props.isVisible).toBeFalsy();
+    await dateTimePicker.props.onConfirm();
+
+    const TouchableOpacities = instance.findAllByType(TouchableOpacity);
+    expect(TouchableOpacities).toHaveLength(3);
+    await TouchableOpacities[0].props.onPress();
+    await TouchableOpacities[2].props.onPress(3);
+    expect(mockDoAction).toBeCalled();
+  });
 });

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

@@ -1,6 +1,7 @@
 import React, { useState } from 'react';
 import { TouchableOpacity } from 'react-native';
 import { act, create } from 'react-test-renderer';
+import { DEVICE_TYPE } from '../../../configs/Constants';
 import TwoButtonTemplate from '../TwoButtonTemplate';
 
 jest.mock('react', () => ({
@@ -31,6 +32,10 @@ describe('Test TwoButtonTemplate', () => {
     key: '5ed1d4dc-a905-47cd-b0c9-f979644bd21a',
   };
 
+  const sensor = {
+    device_type: DEVICE_TYPE.LG_THINQ,
+    is_managed_by_backend: true,
+  };
   const actionGroup = {
     configuration: {
       button1: {
@@ -41,6 +46,9 @@ describe('Test TwoButtonTemplate', () => {
         icon_on: 'poweroff',
         text_on: 'ON',
         config: 621,
+        is_on_value: [true],
+        action_on_data,
+        action_off_data,
       },
       button2: {
         action_off: 'f49e1577-493d-4bae-a9ab-3b0f96a4ec52',
@@ -50,6 +58,9 @@ describe('Test TwoButtonTemplate', () => {
         icon_on: 'caret-right',
         text_on: 'START',
         config: 621,
+        is_on_value: [true],
+        action_on_data,
+        action_off_data,
       },
     },
   };
@@ -102,7 +113,44 @@ describe('Test TwoButtonTemplate', () => {
     const mockDoAction = jest.fn();
     await act(() => {
       wrapper = create(
-        <TwoButtonTemplate actionGroup={actionGroup} doAction={mockDoAction} />
+        <TwoButtonTemplate
+          actionGroup={actionGroup}
+          doAction={mockDoAction}
+          sensor={sensor}
+        />
+      );
+    });
+    const instance = wrapper.root;
+    const touchableOpacities = instance.findAllByType(TouchableOpacity);
+    expect(touchableOpacities.length).toEqual(2);
+    await touchableOpacities[0].props.onPress();
+    await touchableOpacities[1].props.onPress();
+    expect(mockDoAction).toBeCalled();
+  });
+
+  test('render TouchableOpacity TwoButtonTemplate without is_on_value', async () => {
+    const mockDoAction = jest.fn();
+    let new_actionGroup = {
+      ...actionGroup,
+      configuration: {
+        ...actionGroup.configuration,
+        button1: {
+          ...actionGroup.configuration.button1,
+          is_on_value: null,
+        },
+        button2: {
+          ...actionGroup.configuration.button2,
+          is_on_value: null,
+        },
+      },
+    };
+    await act(() => {
+      wrapper = create(
+        <TwoButtonTemplate
+          actionGroup={new_actionGroup}
+          doAction={mockDoAction}
+          sensor={sensor}
+        />
       );
     });
     const instance = wrapper.root;

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

@@ -356,8 +356,8 @@ describe('Test ActionGroup', () => {
         text_format: '{number} *C',
       },
     };
-    await act(() => {
-      wrapper = renderer.create(
+    await act(async () => {
+      wrapper = await renderer.create(
         wrapComponent(actionGroup, mockDoAction, sensor)
       );
     });
@@ -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);
+  });
+});