@eohjsc/react-native-smart-city 0.7.15 → 0.7.17

package/src/screens/Automate/ScriptDetail/__test__/index.test.js

@@ -42,11 +42,16 @@ describe('Test ScriptDetail', () => {
   const mockAddListener = useNavigation().addListener;
   const mockedNavigate = useNavigation().navigate;
   const mockedDispatch = useNavigation().dispatch;
+  const mockedGetState = useNavigation().getState;
+
   beforeEach(() => {
     mockGoBack.mockClear();
     mockAddListener.mockClear();
     mockedNavigate.mockClear();
     mockedDispatch.mockClear();
+    mockedGetState.mockReturnValue({
+      routes: [{ name: 'Home' }],
+    });
     global.mockedNavigate.mockClear();
     mock.reset();
     route = {
@@ -111,6 +116,43 @@ describe('Test ScriptDetail', () => {
     };
   });
 
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  const expectMockedDispatch = (screen, screenParams) => {
+    act(() => {
+      jest.runAllTimers();
+    });
+    expect(mockedDispatch).toHaveBeenCalledWith({
+      type: 'RESET',
+      payload: {
+        index: 2,
+        routes: [
+          {
+            name: 'Home',
+          },
+          {
+            name: Routes.ScriptDetail,
+            params: route.params,
+          },
+          {
+            name: screen,
+            params: screenParams,
+          },
+        ],
+      },
+    });
+    expect(mockedDispatch).toHaveBeenCalledTimes(1);
+    mockedGetState.mockReturnValue({
+      routes: [
+        { name: 'Home' },
+        { name: Routes.ScriptDetail, params: route.params },
+      ],
+    });
+    mockedDispatch.mockClear();
+  };
+
   it('test rename script', async () => {
     await act(async () => {
       tree = await create(wrapComponent(route));
@@ -331,6 +373,7 @@ describe('Test ScriptDetail', () => {
   });
 
   it('test press add action', async () => {
+    jest.useFakeTimers();
     data = [
       {
         id: 1,
@@ -370,56 +413,182 @@ describe('Test ScriptDetail', () => {
           AccessibilityLabel.AUTOMATE_LIST_SCRIPT_ACTION &&
         el.type === TouchableOpacity
     );
-    expect(listScriptActions).toHaveLength(4);
+    expect(listScriptActions).toHaveLength(5);
     await act(async () => {
       await listScriptActions[0].props.onPress();
     });
 
-    expect(global.mockedNavigate).toHaveBeenCalledWith(
-      Routes.SelectControlDevices,
-      {
-        unitId: route.params.preAutomate.unit,
-        automateId: route.params.preAutomate.id,
-        numberActionCanAdd: 2,
-        closeScreen: undefined,
-        routeName: null,
-      }
-    );
-    mockedNavigate.mockClear();
+    expectMockedDispatch(Routes.SelectControlDevices, {
+      unitId: route.params.preAutomate.unit,
+      automateId: route.params.preAutomate.id,
+      numberActionCanAdd: 2,
+      closeScreen: undefined,
+      routeName: null,
+    });
     await act(async () => {
       await listScriptActions[1].props.onPress();
     });
 
-    expect(global.mockedNavigate).toHaveBeenCalledWith(
-      Routes.SetupScriptNotify,
-      {
-        automate: route.params.preAutomate,
-        unitId: route.params.preAutomate.unit,
-      }
-    );
-    mockedNavigate.mockClear();
+    expectMockedDispatch(Routes.SetupScriptNotify, {
+      automate: route.params.preAutomate,
+      unitId: route.params.preAutomate.unit,
+    });
     await act(async () => {
       await listScriptActions[2].props.onPress();
     });
 
-    expect(global.mockedNavigate).toHaveBeenCalledWith(
-      Routes.SetupScriptDelay,
+    expectMockedDispatch(Routes.SetupScriptDelay, {
+      automate: route.params.preAutomate,
+    });
+  });
+
+  it('test press add email and sms', async () => {
+    jest.useFakeTimers();
+    data = [
       {
-        automate: route.params.preAutomate,
-      }
+        id: 1,
+        unit: 1,
+        script_items: null,
+      },
+    ];
+    mock.onGet(API.AUTOMATE.SCRIPT(1)).reply(200, data);
+    const auth = {
+      account: {
+        user: {
+          permissions: {
+            max_actions_per_automation: 2,
+          },
+        },
+      },
+    };
+    await act(async () => {
+      tree = await create(wrapComponent(route, { auth }));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.BUTTON_ADD_SCRIPT_ACTION &&
+        el.type === TouchableOpacity
     );
-    mockedNavigate.mockClear();
+    await act(async () => {
+      await button.props.onPress();
+    });
+    const texts = instance.findByType(AddActionScript);
+    expect(texts.props.isVisible).toBeTruthy();
+
+    const listScriptActions = instance.findAll(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_LIST_SCRIPT_ACTION &&
+        el.type === TouchableOpacity
+    );
+    expect(listScriptActions).toHaveLength(5);
     await act(async () => {
       await listScriptActions[3].props.onPress();
     });
 
-    expect(global.mockedNavigate).toHaveBeenCalledWith(
-      Routes.SetupScriptEmail,
+    expectMockedDispatch(Routes.SetupScriptEmail, {
+      automate: route.params.preAutomate,
+      unitId: route.params.preAutomate.unit,
+    });
+    await act(async () => {
+      await listScriptActions[4].props.onPress();
+    });
+
+    expectMockedDispatch(Routes.SetupScriptSms, {
+      automate: route.params.preAutomate,
+      unitId: route.params.preAutomate.unit,
+    });
+  });
+
+  it('test press add action when has closeScreen is present in stacks', async () => {
+    jest.useFakeTimers();
+    data = [
       {
-        automate: route.params.preAutomate,
-        unitId: route.params.preAutomate.unit,
-      }
+        id: 1,
+        unit: 1,
+        script_items: null,
+      },
+    ];
+    mock.onGet(API.AUTOMATE.SCRIPT(1)).reply(200, data);
+    const auth = {
+      account: {
+        user: {
+          permissions: {
+            max_actions_per_automation: 2,
+          },
+        },
+      },
+    };
+    route.params.closeScreen = Routes.UnitDetail;
+    await act(async () => {
+      tree = await create(wrapComponent(route, { auth }));
+    });
+    const instance = tree.root;
+    const button = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.BUTTON_ADD_SCRIPT_ACTION &&
+        el.type === TouchableOpacity
     );
+    await act(async () => {
+      await button.props.onPress();
+    });
+    const texts = instance.findByType(AddActionScript);
+    expect(texts.props.isVisible).toBeTruthy();
+
+    const listScriptActions = instance.findAll(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_LIST_SCRIPT_ACTION &&
+        el.type === TouchableOpacity
+    );
+    expect(listScriptActions).toHaveLength(5);
+
+    mockedGetState.mockReturnValue({
+      routes: [
+        { name: 'Home' },
+        { name: Routes.UnitDetail, params: { unitId: 1 } },
+        { name: Routes.ScriptDetail, params: route.params },
+      ],
+    });
+    await act(async () => {
+      await listScriptActions[0].props.onPress();
+    });
+    await act(async () => {
+      jest.runAllTimers();
+    });
+    expect(mockedDispatch).toHaveBeenCalledWith({
+      type: 'RESET',
+      payload: {
+        index: 3,
+        routes: [
+          {
+            name: 'Home',
+          },
+          {
+            name: Routes.UnitDetail,
+            params: { unitId: 1 },
+          },
+          {
+            name: Routes.ScriptDetail,
+            params: route.params,
+          },
+          {
+            name: Routes.SelectControlDevices,
+            params: {
+              unitId: route.params.preAutomate.unit,
+              automateId: route.params.preAutomate.id,
+              numberActionCanAdd: 2,
+              closeScreen: undefined,
+              routeName: null,
+            },
+          },
+        ],
+      },
+    });
+    expect(mockedDispatch).toHaveBeenCalledTimes(1);
   });
 
   it('test press disable script', async () => {
@@ -560,6 +729,7 @@ describe('Test ScriptDetail', () => {
   _testGoToActivityLog(3, AUTOMATE_TYPE.VALUE_CHANGE, 'automate', undefined);
 
   it('Test render textCondition value change >', async () => {
+    jest.useFakeTimers();
     const automate = {
       can_edit: true,
       type: AUTOMATE_TYPE.VALUE_CHANGE,
@@ -600,33 +770,10 @@ describe('Test ScriptDetail', () => {
       menuActionMore.props.listMenuItem[2].doAction();
     });
 
-    const mockState = {
-      routes: [{ name: 'Home' }],
-    };
-    const updatedState = mockedDispatch.mock.calls[0][0](mockState);
-    expect(updatedState).toEqual({
-      type: 'RESET',
-      payload: {
-        index: 2,
-        routes: [
-          {
-            name: 'Home',
-          },
-          {
-            name: Routes.ScriptDetail,
-            params: route.params,
-          },
-          {
-            name: Routes.AddUnknownTypeSmart,
-            params: {
-              automate: automate,
-              closeScreen: undefined,
-            },
-          },
-        ],
-      },
+    expectMockedDispatch(Routes.AddUnknownTypeSmart, {
+      automate: automate,
+      closeScreen: undefined,
     });
-    expect(mockedDispatch).toHaveBeenCalledTimes(1);
 
     expect(menuActionMore.props.listMenuItem[0].text).toEqual('Device display');
     await act(async () => {
@@ -742,7 +889,10 @@ describe('Test ScriptDetail', () => {
 
     // beforeRemove test when swipe to back
     const navigation = useNavigation();
-    const beforeRemoveEvent = { preventDefault: jest.fn() };
+    const beforeRemoveEvent = {
+      preventDefault: jest.fn(),
+      data: { action: { type: 'GO_BACK' } },
+    };
     const beforeRemoveListener = navigation.addListener.mock.calls.find(
       ([event]) => event === 'beforeRemove'
     )[1];
@@ -758,6 +908,34 @@ describe('Test ScriptDetail', () => {
     });
   });
 
+  it('test skip block back when navigate on ios', async () => {
+    Platform.OS = 'ios';
+    route.params.closeScreen = Routes.UnitDetail;
+    route.params.preAutomate.unit = 2;
+
+    await act(async () => {
+      await create(wrapComponent(route));
+    });
+
+    // beforeRemove test when navigate
+    const navigation = useNavigation();
+    const beforeRemoveEvent = {
+      preventDefault: jest.fn(),
+      data: { action: { type: 'NAVIGATE' } },
+    };
+    const beforeRemoveListener = navigation.addListener.mock.calls.find(
+      ([event]) => event === 'beforeRemove'
+    )[1];
+
+    await act(async () => {
+      beforeRemoveListener(beforeRemoveEvent);
+    });
+
+    expect(mockAddListener).toHaveBeenCalled();
+    expect(beforeRemoveEvent.preventDefault).not.toHaveBeenCalled();
+    expect(mockedNavigate).not.toHaveBeenCalled();
+  });
+
   it('test navigate to UnitDetail on event hardwareBackPress', async () => {
     Platform.OS = 'android';
     jest.spyOn(BackHandler, 'addEventListener');
@@ -784,4 +962,64 @@ describe('Test ScriptDetail', () => {
       unitId: 2,
     });
   });
+
+  it('test enable local control', async () => {
+    mock.onPost(API.AUTOMATE.ENABLE_LOCAL_CONTROL(1)).reply(200);
+    mock
+      .onGet(API.DEV_MODE.GATEWAY.SHARED())
+      .reply(200, [{ name: 'Chip', id: 1 }]);
+
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const show_local_control = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_SHOW_LOCAL_CONTROL &&
+        el.type === TouchableOpacity
+    );
+    await act(async () => {
+      await show_local_control.props.onPress();
+    });
+    const disable = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_ENABLE_LOCAL_CONTROL &&
+        el.type === TouchableOpacity
+    );
+    await act(async () => {
+      await disable.props.onPress();
+    });
+
+    expect(mock.history.post[0].url).toEqual(
+      API.AUTOMATE.ENABLE_LOCAL_CONTROL(1)
+    );
+  });
+
+  it('test disable local control', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const show_local_control = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_SHOW_LOCAL_CONTROL &&
+        el.type === TouchableOpacity
+    );
+    await act(async () => {
+      await show_local_control.props.onPress();
+    });
+    const disable = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+          AccessibilityLabel.AUTOMATE_DISABLE_LOCAL_CONTROL &&
+        el.type === TouchableOpacity
+    );
+    await act(async () => {
+      await disable.props.onPress();
+    });
+    expect(mock.history.post.length).toBe(0);
+  });
 });