@applicaster/zapp-react-native-utils 12.0.0-alpha.7725319213 → 12.0.0-alpha.7843515010

package/reactHooks/navigation/__tests__/index.test.tsx

@@ -1,12 +1,13 @@
 import React from "react";
 import { PathnameContext } from "@applicaster/zapp-react-native-ui-components/Contexts/PathnameContext";
 import { renderHook } from "@testing-library/react-hooks";
-import { useRoute } from "../index";
+import { isNavBarVisible, useRoute } from "../";
 import { Provider } from "react-redux";
 import configureMockStore from "redux-mock-store";
 import { NavigationContext } from "@applicaster/zapp-react-native-ui-components/Contexts/NavigationContext";
 import { ZappHookModalContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
-import { ROUTE_TYPES } from "../../../navigationUtils/routeTypes";
+import { ROUTE_TYPES } from "@applicaster/zapp-react-native-utils/navigationUtils/routeTypes";
+import { ScreenDataContext } from "@applicaster/zapp-react-native-ui-components/Contexts/ScreenDataContext";
 
 const plugins = [];
 
@@ -45,26 +46,24 @@ const videoItem = {
   type: { value: "video" },
 };
 
-const modalItem = {
-  id: "modal-1",
-};
+const mockGetStackForPathname = jest.fn().mockReturnValue(homeStack);
 
 const mainStackNavigator = {
-  getStackForPathname: jest.fn().mockReturnValue(homeStack),
-  modalState: {},
+  getStackForPathname: mockGetStackForPathname,
+  getModalState: () => {},
   videoModalState: {},
+  canGoBack: jest.fn(),
 };
 
-const videoModalNavigator = {
-  ...mainStackNavigator,
-  videoModalState: { item: videoItem },
+const _createWrapper = (Wrapper, props) => {
+  return function CreatedWrapper({ children }: any) {
+    return <Wrapper {...props}>{children}</Wrapper>;
+  };
 };
 
-const modalNavigator = {
+const videoModalNavigator = {
   ...mainStackNavigator,
-  modalState: {
-    screen: modalItem,
-  },
+  videoModalState: { item: videoItem },
 };
 
 const hookModalNavigator = {
@@ -86,7 +85,6 @@ const hookModalContextState = {
   resetState: jest.fn(),
 };
 
-const modalPathname = `${ROUTE_TYPES.MODAL}/${modalItem.id}`;
 const hooksModalPathname = `${ROUTE_TYPES.HOOKS_MODAL}/${hookModalContextState.state.screenData.payload.id}`;
 const videoModalPathname = `${ROUTE_TYPES.VIDEO_MODAL}/${videoModalNavigator.videoModalState.item.id}`;
 const mockStore = configureMockStore();
@@ -97,13 +95,21 @@ const store = mockStore({
   contentTypes,
 });
 
-const mainStackWrapper = ({ children }) => (
+const mainStackWrapper = ({
+  children,
+  navigator = {},
+  pathname = homeStack.route,
+}) => (
   <Provider store={store}>
-    <NavigationContext.Provider value={mainStackNavigator}>
-      <PathnameContext.Provider value={homeStack.route}>
-        {children}
-      </PathnameContext.Provider>
-    </NavigationContext.Provider>
+    <ScreenDataContext.Provider value={homeStack.state}>
+      <NavigationContext.Provider
+        value={{ ...mainStackNavigator, ...navigator, currentRoute: pathname }}
+      >
+        <PathnameContext.Provider value={pathname}>
+          {children}
+        </PathnameContext.Provider>
+      </NavigationContext.Provider>
+    </ScreenDataContext.Provider>
   </Provider>
 );
 
@@ -117,16 +123,6 @@ const videoModalWrapper = ({ children }) => (
   </Provider>
 );
 
-const modalWrapper = ({ children }) => (
-  <Provider store={store}>
-    <NavigationContext.Provider value={modalNavigator}>
-      <PathnameContext.Provider value={modalPathname}>
-        {children}
-      </PathnameContext.Provider>
-    </NavigationContext.Provider>
-  </Provider>
-);
-
 const hookModalWrapper = ({ children }) => (
   <Provider store={store}>
     <ZappHookModalContext.ReactContext.Provider value={hookModalContextState}>
@@ -139,88 +135,251 @@ const hookModalWrapper = ({ children }) => (
   </Provider>
 );
 
-describe("useRoute", () => {
-  describe("Main stack components", () => {
-    it("should return a correct pathname", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: mainStackWrapper,
+jest.mock("../../../modalState", () => ({
+  useModalStore: jest.fn(),
+}));
+
+describe("navigation", () => {
+  describe("useRoute", () => {
+    describe("Main stack components", () => {
+      it("should return a correct pathname", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: mainStackWrapper,
+        });
+
+        expect(result.current.pathname).toEqual(homeStack.route);
       });
 
-      expect(result.current.pathname).toEqual(homeStack.route);
+      it("should return correct screenData information", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: mainStackWrapper,
+        });
+
+        expect(result.current.screenData.id).toEqual(entry.id);
+
+        expect(result.current.screenData.targetScreen.id).toEqual(screen.id);
+      });
     });
 
-    it("should return correct screenData information", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: mainStackWrapper,
+    describe("Hook modal components", () => {
+      it("should return a correct pathname", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: hookModalWrapper,
+        });
+
+        expect(result.current.pathname).toEqual(hooksModalPathname);
       });
 
-      expect(result.current.screenData.id).toEqual(entry.id);
+      it("should return correct screenData information", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: hookModalWrapper,
+        });
 
-      expect(result.current.screenData.targetScreen.id).toEqual(screen.id);
+        expect(result.current.screenData.id).toEqual(
+          hookModalContextState.state.screenData.payload.id
+        );
+      });
     });
-  });
 
-  describe("Hook modal components", () => {
-    it("should return a correct pathname", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: hookModalWrapper,
+    describe("Video modal components", () => {
+      it("should return a correct pathname", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: videoModalWrapper,
+        });
+
+        expect(result.current.pathname).toEqual(videoModalPathname);
       });
 
-      expect(result.current.pathname).toEqual(hooksModalPathname);
-    });
+      it("should return correct screenData information", () => {
+        const { result } = renderHook(() => useRoute(), {
+          wrapper: videoModalWrapper,
+        });
+
+        expect(result.current.screenData.id).toEqual(
+          videoModalNavigator.videoModalState.item.id
+        );
 
-    it("should return correct screenData information", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: hookModalWrapper,
+        expect(result.current.screenData.targetScreen.id).toEqual(
+          rivers["river-player"].id
+        );
       });
+    });
+  });
 
-      expect(result.current.screenData.id).toEqual(
-        hookModalContextState.state.screenData.payload.id
+  describe("isNavBarVisible", () => {
+    it("returns false when the route is a player route", () => {
+      const navBarVisible = isNavBarVisible(
+        "/playable/some_vod_item",
+        {} as ZappRiver,
+        false,
+        false
       );
+
+      expect(navBarVisible).toBe(false);
     });
-  });
 
-  describe("Video modal components", () => {
-    it("should return a correct pathname", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: videoModalWrapper,
-      });
+    it("returns false when the next screen is the QB search screen", () => {
+      const navBarVisible = isNavBarVisible(
+        "/river/A1234",
+        {
+          type: "qb_search_screen",
+        } as any,
+        false,
+        false
+      );
 
-      expect(result.current.pathname).toEqual(videoModalPathname);
+      expect(navBarVisible).toBe(false);
     });
 
-    it("should return correct screenData information", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: videoModalWrapper,
+    describe("when screen is a hook", () => {
+      it("returns true if the `showNavBar` flag is set to true", () => {
+        const navBarVisible = isNavBarVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                showNavBar: true,
+              },
+            },
+          } as any,
+          false,
+          false
+        );
+
+        expect(navBarVisible).toBe(true);
+      });
+
+      it("returns true if presentFullScreen flag is set to false", () => {
+        const navBarVisible = isNavBarVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                presentFullScreen: false,
+              },
+            },
+          } as any,
+          false,
+          false
+        );
+
+        expect(navBarVisible).toBe(true);
       });
 
-      expect(result.current.screenData.id).toEqual(
-        videoModalNavigator.videoModalState.item.id
+      it("returns false if presentFullScreen flag is set to true", () => {
+        const navBarVisible = isNavBarVisible(
+          "",
+          {
+            hookPlugin: {
+              module: {
+                presentFullScreen: true,
+              },
+            },
+          } as any,
+          false,
+          false
+        );
+
+        expect(navBarVisible).toBe(false);
+      });
+    });
+
+    it("returns false if the screen's general settings allow screen presentation", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        {
+          general: {
+            allow_screen_plugin_presentation: true,
+          },
+        } as any,
+        false,
+        false
+      );
+
+      expect(navBarVisible).toBe(false);
+    });
+
+    it("returns false if the screen's general settings hide app nav bar", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        {
+          general: {
+            hide_app_nav_bar: true,
+          },
+        } as any,
+        false,
+        false
       );
 
-      expect(result.current.screenData.targetScreen.id).toEqual(
-        rivers["river-player"].id
+      expect(navBarVisible).toBe(false);
+    });
+
+    it("returns false if it's secondary nav bar and hide_secondary_level_menu is true", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        {
+          navigations: [
+            {
+              styles: {
+                hide_secondary_level_menu: true,
+              },
+            },
+          ],
+        } as any,
+        false,
+        true
       );
+
+      expect(navBarVisible).toBe(false);
     });
-  });
 
-  describe("Modal components", () => {
-    it("should return a correct pathname", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: modalWrapper,
-      });
+    it("returns true if it's secondary nav bar and hide_secondary_level_menu is false", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        {
+          navigations: [
+            {
+              styles: {
+                hide_secondary_level_menu: false,
+              },
+            },
+          ],
+        } as any,
+        true,
+        false
+      );
 
-      expect(result.current.pathname).toEqual(modalPathname);
+      expect(navBarVisible).toBe(true);
     });
 
-    it("should return correct screenData information", () => {
-      const { result } = renderHook(() => useRoute(), {
-        wrapper: modalWrapper,
-      });
+    it("returns true if it's first level menu and hide_secondary_level_menu is true", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        {
+          navigations: [
+            {
+              styles: {
+                hide_secondary_level_menu: true,
+              },
+            },
+          ],
+        } as any,
+        true,
+        false
+      );
 
-      expect(result.current.screenData.id).toEqual(
-        modalNavigator.modalState.screen.id
+      expect(navBarVisible).toBe(true);
+    });
+
+    it("returns true otherwise", () => {
+      const navBarVisible = isNavBarVisible(
+        "",
+        { navigations: [] } as any,
+        true,
+        true
       );
+
+      expect(navBarVisible).toBe(true);
     });
   });
 });