@applicaster/zapp-react-native-ui-components 13.0.0-alpha.5771418585 → 13.0.0-alpha.5790181722

package/Components/ScreenResolver/__tests__/screenResolver.test.js

@@ -1,161 +1,180 @@
 import React from "react";
 import { View } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { renderWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
+
 const pluginConfiguration = { foo: "bar" };
 
-const ScreenType1 = jest.fn(() => <View />);
-const ScreenType2 = jest.fn(() => <View />);
-const PlayerController = jest.fn(() => <View />);
+const MockModuleView = (testID) => {
+  // eslint-disable-next-line react/display-name
+  return function (props) {
+    return <View testID={testID} {...props} />;
+  };
+};
+
+const ScreenType1 = MockModuleView("screen_type_1");
+const ScreenType2 = MockModuleView("screen_type_2");
+const PlayerController = MockModuleView("player_controller");
 
 const mockScreenType3 = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_type_3"),
   name: "ScreenType3",
   type: "screen_type_3",
   configuration: pluginConfiguration,
 };
 
 const mockScreenType4 = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_type_4"),
   name: "ScreenType4",
   type: "screen_type_4",
 };
 
 const mockPlayerPlugin = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("player_plugin"),
   name: "playerPlugin",
   type: "player",
 };
 
 const mockScreenPlugin = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("screen_plugin"),
   type: "general",
   name: "Screen plugin",
   identifier: "screen-plugin",
 };
 
 const mockPluginWithConfig = {
-  module: jest.fn(() => <View />),
+  module: MockModuleView("plugin_with_config"),
   type: "general",
   name: "Plugin with config",
   identifier: "plugin-with-config",
   configuration: pluginConfiguration,
 };
 
-const components = { ScreenType1, ScreenType2, PlayerController };
-
-const mockWithAnalytics = {
-  sendOnClickEvent: jest.fn(),
-  sendMenuClickEvent: jest.fn(),
-  sendMenuToggleEvent: jest.fn(),
-  sendBackButtonClickEvent: jest.fn(),
-  sendOnNavItemClickEvent: jest.fn(),
-  sendHeaderClickEvent: jest.fn(),
-  sendHardwareBackButtonClickEvent: jest.fn(),
-  sendScreenEvent: jest.fn(),
+const mockComponents = { ScreenType1, ScreenType2, PlayerController };
+
+const mockState = {
+  components: mockComponents,
+  plugins: [
+    mockScreenType3,
+    mockScreenType4,
+    mockPlayerPlugin,
+    mockScreenPlugin,
+    mockPluginWithConfig,
+  ],
+  rivers: {
+    A1234: {},
+  },
 };
 
-const mockUsePickFromState = jest.fn(() => {
-  return {
-    components,
-    plugins: {
-      ScreenType3: mockScreenType3,
-      ScreenType4: mockScreenType4,
-      playerPlugin: mockPlayerPlugin,
-      ScreenPlugin: mockScreenPlugin,
-      PluginWithConfig: mockPluginWithConfig,
-    },
-  };
-});
-
-jest.mock("@applicaster/zapp-react-native-utils/analyticsUtils", () => ({
-  useAnalytics: jest.fn().mockReturnValue(mockWithAnalytics),
-}));
+jest.mock(
+  "@applicaster/zapp-react-native-utils/analyticsUtils/helpers/hooks",
+  () => ({
+    useScreenAnalytics: jest.fn(),
+  })
+);
 
-jest.mock("@applicaster/zapp-react-native-redux/hooks", () => ({
-  usePickFromState: mockUsePickFromState,
-}));
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation",
+  () => ({
+    useNavigation: jest.fn(() => ({
+      closeVideoModal: jest.fn(),
+      videoModalState: {
+        mode: "test",
+      },
+    })),
+  })
+);
 
-const mockUseScreenAnalytics = jest.fn();
+jest.mock(
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useRoute",
+  () => ({
+    useRoute: jest.fn(() => ({ screenId: "1234" })),
+  })
+);
 
 jest.mock(
-  "@applicaster/zapp-react-native-utils/analyticsUtils/helpers/hooks",
+  "@applicaster/zapp-react-native-utils/reactHooks/navigation/useIsScreenActive",
   () => ({
-    useScreenAnalytics: mockUseScreenAnalytics,
+    useIsScreenActive: () => ({
+      isScreenActive: true,
+    }),
   })
 );
 
-jest.mock("react-redux", () => ({
-  ...jest.requireActual("react-redux"),
-  useDispatch: jest.fn(() => () => {}),
-}));
+jest.mock("../../PlayerContainer", () => {
+  const { View } = jest.requireActual("react-native");
 
-jest.mock("@applicaster/zapp-react-native-utils/reactHooks", () => ({
-  useNavigation: jest.fn(() => ({
-    videoModalState: {
-      mode: "test",
-    },
-  })),
-  useRoute: jest.fn(() => ({ screenId: "1234" })),
-}));
+  return {
+    PlayerContainer: (props) => (
+      <View {...props}>
+        <props.Player />
+      </View>
+    ),
+  };
+});
 
-const { ScreenResolverComponent: ScreenResolver } = require("..");
+const getWrapper = (screenId, screenType, screenData) => {
+  const ScreenResolver = require("../").ScreenResolverComponent;
 
-const getWrapper = (screenId, screenType, screenData) =>
-  shallow(
+  return renderWithProviders(
     <ScreenResolver
       {...{
         screenId,
         screenType,
         screenData,
       }}
-    />
+    />,
+    mockState
   );
+};
 
 describe("<ScreenResolver />", () => {
   it("renders correctly", () => {
     const wrapper = getWrapper("1234", "screen_type_1", {});
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.getByTestId("screen_type_1")).toBeDefined();
   });
 
   it("picks screen from plugins if it exists", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", {});
 
-    expect(wrapper.find(mockScreenType3.module)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_type_3")).toBeDefined();
   });
 
   it("picks the screen from its identifier if it exists", () => {
     const wrapper = getWrapper("A1234", "screen-plugin", {});
 
-    expect(wrapper.find(mockScreenPlugin.module)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_plugin")).toBeDefined();
   });
 
   it("picks screen from components if it doesn't exist in plugins", () => {
     const wrapper = getWrapper("A1234", "screen_type_2", {});
 
-    expect(wrapper.find(ScreenType2)).toHaveProperty("length", 1);
+    expect(wrapper.getByTestId("screen_type_2")).toBeDefined();
   });
 
   it("renders the screen and passes screenId & locationState as props", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", "foo");
 
-    const screenWrapper = wrapper.find(mockScreenType3.module);
+    const screenWrapper = wrapper.getByTestId("screen_type_3");
 
-    expect(screenWrapper.prop("screenId")).toEqual("A1234");
-    expect(screenWrapper.prop("screenData")).toEqual("foo");
+    expect(screenWrapper.props).toMatchObject({
+      screenId: "A1234",
+      screenData: "foo",
+    });
   });
 
   it("renders null if the screen is not found", () => {
     const wrapper = getWrapper(null, "screen_type_5", {});
 
-    expect(wrapper.getElement()).toBe(null);
+    expect(wrapper.queryAllByTestId("screen_type_5")).toBeEmpty();
   });
 
   it("injects the plugin configuration if it exists", () => {
     const wrapper = getWrapper("A1234", "plugin-with-config", {});
 
-    expect(wrapper.find(mockPluginWithConfig.module).props()).toHaveProperty(
+    const screenWrapper = wrapper.getByTestId("plugin_with_config");
+
+    expect(screenWrapper.props).toHaveProperty(
       "configuration",
       expect.objectContaining(pluginConfiguration)
     );
@@ -164,7 +183,9 @@ describe("<ScreenResolver />", () => {
   it("injects the plugin configuration if it exists, even when plugin is resolved by type", () => {
     const wrapper = getWrapper("A1234", "screen_type_3", {});
 
-    expect(wrapper.find(mockScreenType3.module).props()).toHaveProperty(
+    const screenWrapper = wrapper.getByTestId("screen_type_3");
+
+    expect(screenWrapper.props).toHaveProperty(
       "configuration",
       expect.objectContaining(pluginConfiguration)
     );
@@ -172,6 +193,6 @@ describe("<ScreenResolver />", () => {
 
   it("wraps the player with the playerController component when the screenType is playable", () => {
     const wrapper = getWrapper("A1234", "playable", {});
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.getByTestId("player_plugin")).toBeDefined();
   });
 });

package/Components/TrackedView/index.tsx

@@ -12,6 +12,7 @@ type TrackedViewProps = {
   onPositionUpdated: (props: { rect?: Record<string, number> }) => void;
   testId?: string | undefined;
   groupId?: string;
+  clipThreshold?: number;
 };
 
 export const TrackedView = memo(function TrackedView(props: TrackedViewProps) {

package/Components/Transitioner/AnimationManager.js

@@ -2,21 +2,21 @@ import { Animated } from "react-native";
 
 import { NAV_ACTION_PUSH, NAV_ACTION_BACK } from "./Transitioner";
 
-type TransitionConfig = {
-  duration: number;
-  easing: any;
-  from: {
-    style: any;
-  };
-  to: {
-    style: any;
-  };
-};
+// type TransitionConfig = {
+//   duration: number;
+//   easing: any;
+//   from: {
+//     style: any;
+//   };
+//   to: {
+//     style: any;
+//   };
+// };
 
-type Props = {
-  transitionConfig: TransitionConfig;
-  contentStyle: { [string]: any };
-};
+// type Props = {
+//   transitionConfig: TransitionConfig;
+//   contentStyle: { [string]: any };
+// };
 
 /**
  * Manages animation for the Transitioner,
@@ -25,7 +25,7 @@ type Props = {
  * which must have a proper structure, see types above ^.
  */
 export class AnimationManager {
-  constructor(props: Props) {
+  constructor(props) {
     this.animatedValue = new Animated.Value(0.0);
 
     this.config = props.transitionConfig(

package/Components/Transitioner/__tests__/Scene.test.js

@@ -1,6 +1,7 @@
 import React from "react";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
+
+import { Scene } from "../Scene";
 
 const overlayStyle = { opacity: 1 };
 const contentStyle = { paddingBottom: 49 };
@@ -23,28 +24,38 @@ jest.mock(
   })
 );
 
-const { Scene } = require("../Scene");
+jest.mock("../../../Contexts/PathnameContext", () => ({
+  PathnameContext: jest.requireActual("react").createContext({ pathname: "" }),
+}));
 
-const wrapper = shallow(
-  <Scene
-    style={style}
-    overlayStyle={overlayStyle}
-    contentStyle={contentStyle}
-  />
-);
+jest.mock("../../../Contexts/ScreenDataContext", () => ({
+  ScreenDataContext: jest.requireActual("react").createContext({}),
+}));
+
+jest.mock("../../../Contexts/ScreenContext", () => ({
+  ScreenContextProvider: jest.requireActual("react-native").View,
+}));
 
 describe("<Scene />", () => {
+  const wrapper = render(
+    <Scene
+      style={style}
+      overlayStyle={overlayStyle}
+      contentStyle={contentStyle}
+    />
+  );
+
   it("renders correctly", () => {
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 
   // skipped - this isn't a very useful test, and it doesn't work as it used to on the new version of RN
   it.skip("renders children surrounded by AnimatedComponent", () => {
-    expect(shallowToJson(wrapper).type).toEqual("AnimatedComponent");
+    expect(wrapper.toJSON()).toEqual("AnimatedComponent");
   });
 
   it("renders the overlay while animating", () => {
-    const wrapperWithOverlay = shallow(
+    const wrapperWithOverlay = render(
       <Scene
         style={style}
         overlayStyle={overlayStyle}
@@ -53,6 +64,6 @@ describe("<Scene />", () => {
       />
     );
 
-    expect(shallowToJson(wrapperWithOverlay)).toMatchSnapshot();
+    expect(wrapperWithOverlay.toJSON).toMatchSnapshot();
   });
 });

package/Components/Transitioner/__tests__/__snapshots__/Scene.test.js.snap

@@ -1,79 +1,23 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`<Scene /> renders correctly 1`] = `
-<CurrentScreenContextProvider
-  contentStyle={
-    {
-      "paddingBottom": 49,
-    }
-  }
-  overlayStyle={
-    {
-      "opacity": 1,
-    }
-  }
-  style={
-    {
-      "flex": 1,
-    }
-  }
->
-  <SceneComponent
-    contentStyle={
-      {
-        "paddingBottom": 49,
-      }
-    }
-    overlayStyle={
-      {
-        "opacity": 1,
-      }
-    }
+<View>
+  <View
+    collapsable={false}
+    pointerEvents="auto"
     style={
       {
         "flex": 1,
-      }
-    }
-  />
-</CurrentScreenContextProvider>
-`;
-
-exports[`<Scene /> renders the overlay while animating 1`] = `
-<CurrentScreenContextProvider
-  animating={true}
-  contentStyle={
-    {
-      "paddingBottom": 49,
-    }
-  }
-  overlayStyle={
-    {
-      "opacity": 1,
-    }
-  }
-  style={
-    {
-      "flex": 1,
-    }
-  }
->
-  <SceneComponent
-    animating={true}
-    contentStyle={
-      {
+        "fontScale": 2,
+        "height": 1334,
         "paddingBottom": 49,
-      }
-    }
-    overlayStyle={
-      {
-        "opacity": 1,
-      }
-    }
-    style={
-      {
-        "flex": 1,
+        "scale": 2,
+        "statusBarHeight": null,
+        "width": 750,
       }
     }
   />
-</CurrentScreenContextProvider>
+</View>
 `;
+
+exports[`<Scene /> renders the overlay while animating 1`] = `[Function]`;

package/Components/Transitioner/__tests__/__snapshots__/transitioner.test.js.snap

@@ -9,7 +9,7 @@ exports[`<TransitionerComponent /> renders correctly 1`] = `
     }
   }
 >
-  <SceneComponent
+  <View
     isActive={true}
     screenUniqueId="mocked-uuid"
     style={{}}
@@ -23,6 +23,6 @@ exports[`<TransitionerComponent /> renders correctly 1`] = `
         children
       </Text>
     </View>
-  </SceneComponent>
+  </View>
 </View>
 `;

package/Components/Transitioner/__tests__/transitioner.test.js

@@ -1,9 +1,18 @@
 import React from "react";
 import { Text, View } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
 
 import { TransitionerComponent } from "../Transitioner";
+import { render } from "@testing-library/react-native";
+
+jest.mock("../Scene", () => {
+  const View = jest.requireActual("react-native").View;
+
+  return {
+    Scene(props) {
+      return <View {...props} />;
+    },
+  };
+});
 
 const children = (
   <View foo="bar">
@@ -33,12 +42,12 @@ jest.mock("uuid");
 
 describe("<TransitionerComponent />", () => {
   it("renders correctly", () => {
-    const wrapper = shallow(
+    const wrapper = render(
       <TransitionerComponent {...transitionerComponentProps}>
         {children}
       </TransitionerComponent>
     );
 
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    expect(wrapper.toJSON()).toMatchSnapshot();
   });
 });

package/Components/VideoLive/PlayerLiveImageComponent.tsx

@@ -32,6 +32,9 @@ const { log_error, log_debug } = loggerLiveImageComponent;
 const isMeasurement = (item: ZappEntry) =>
   isString(item.id) && item.id.startsWith("pre-measurement-");
 
+// Pixels by which the view can slightly extend outside the viewport and still be considered fully visible.
+const CLIP_THRESHOLD = 10;
+
 type Props = {
   item: ZappEntry;
   style: Record<string, any>;
@@ -328,6 +331,7 @@ const PlayerLiveImageComponent = (props: Props) => {
     <TrackedView
       testId={`tracked-view-${playerId}-${item.title}`}
       onPositionUpdated={onPositionUpdated}
+      clipThreshold={CLIP_THRESHOLD}
     >
       <View ref={trackViewRef}>
         {isVideoMode ? (

package/Components/VideoLive/__tests__/__snapshots__/PlayerLiveImageComponent.test.tsx.snap

@@ -2,6 +2,7 @@
 
 exports[`PlayerLiveImageComponent should render correctly with default props 1`] = `
 <TrackedView
+  clipThreshold={10}
   onPositionUpdated={[Function]}
   testId="tracked-view-player1-Test"
 >

package/Components/VideoModal/ModalAnimation/AnimatedPlayerModalWrapper.tsx

@@ -46,7 +46,7 @@ export const AnimatedPlayerModalWrapper = (props: Props) => {
 
   React.useEffect(() => {
     (playerAnimationState === PlayerAnimationStateEnum.minimize ||
-      playerAnimationState === PlayerAnimationStateEnum.maximaze) &&
+      playerAnimationState === PlayerAnimationStateEnum.maximize) &&
       setStartComponentsAnimation(true);
   }, [playerAnimationState]);