@applicaster/quick-brick-core 13.0.0-alpha.3454305619 → 13.0.0-alpha.3496266611

package/App/ActionsProvider/__tests__/__snapshots__/ActionsProvider.test.js.snap

@@ -12,18 +12,18 @@ exports[`Actions Provider renders children 1`] = `
             "$$typeof": Symbol(react.context),
             "Consumer": {
               "$$typeof": Symbol(react.context),
+              "_calculateChangedBits": null,
               "_context": [Circular],
             },
             "Provider": {
               "$$typeof": Symbol(react.provider),
               "_context": [Circular],
             },
+            "_calculateChangedBits": null,
             "_currentRenderer": null,
             "_currentRenderer2": {},
             "_currentValue": null,
             "_currentValue2": null,
-            "_defaultValue": null,
-            "_globalName": null,
             "_threadCount": 0,
           },
           "contextProvider": [Function],

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/__tests__/useOpenSchemeHandler.test.tsx

@@ -16,7 +16,7 @@ import {
 } from "../useOpenSchemeHandler/const";
 import { withInitialPlayerState } from "../useOpenSchemeHandler/utils";
 
-import { log_warning } from "../../../logger";
+const { log_warning } = require("../../../logger");
 
 const rivers: Record<string, Partial<ZappRiver>> = {
   A1234: {
@@ -53,10 +53,13 @@ const navigator = {
   replace: jest.fn(),
   push: jest.fn(),
   goHome: jest.fn(),
-} as any;
+};
 
 const mockStore = configureStore();
-jest.spyOn(useNavigationHooks, "useNavigation").mockReturnValue(navigator);
+
+jest
+  .spyOn(useNavigationHooks, "useNavigation")
+  .mockImplementation(() => navigator);
 
 const helperSpy = jest.spyOn(helpers, "handlePresentNavigation");
 const feedLoaderSpy = jest.spyOn(feedLoader, "useFeedLoader");
@@ -69,7 +72,7 @@ jest.doMock("@applicaster/zapp-react-native-ui-components/Contexts", () => ({
   },
 }));
 
-jest.mock("../../../logger", () => ({
+jest.doMock("../../../logger", () => ({
   log_info: jest.fn(),
   log_error: jest.fn(),
   log_warning: jest.fn(),
@@ -77,6 +80,10 @@ jest.mock("../../../logger", () => ({
   log_debug: jest.fn(),
 }));
 
+jest.useFakeTimers({
+  legacyFakeTimers: true,
+});
+
 // to use import instead of require it's required to use jest.mock above
 const { useOpenSchemeHandler } = require("../useOpenSchemeHandler");
 
@@ -185,6 +192,7 @@ describe("useOpenSchemeHandler", () => {
     it("doesn't log a warning", async () => {
       const tests = () => {
         expect(log_warning).not.toHaveBeenCalled();
+        expect.assertions(1);
       };
 
       await testHook({ url, query, tests });

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/__tests__/usePresentSchemeHandler.test.tsx

@@ -1,13 +1,14 @@
+import * as React from "react";
 import * as R from "ramda";
 import axios from "axios";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
+import * as zappRedux from "@applicaster/zapp-react-native-redux";
 import * as helpers from "../../../helpers";
 import * as feedLoader from "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedLoader";
 import * as useNavigationHooks from "@applicaster/zapp-react-native-utils/reactHooks/navigation/useNavigation";
-import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
-import { usePresentSchemeHandler } from "../usePresentSchemeHandler";
 
+import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
 const rivers = {
@@ -19,22 +20,23 @@ const rivers = {
 const navigator = {
   currentRoute: "/river/A1234",
   replace: jest.fn(),
-  goHome: jest.fn(),
-} as any;
+};
 
 const mockStore = configureStore();
 
-jest.spyOn(useNavigationHooks, "useNavigation").mockReturnValue(navigator);
+jest
+  .spyOn(useNavigationHooks, "useNavigation")
+  .mockImplementation(() => navigator);
 
 const helperSpy = jest.spyOn(helpers, "handlePresentNavigation");
 const feedLoaderSpy = jest.spyOn(feedLoader, "useFeedLoader");
 
+const { usePresentSchemeHandler } = require("../usePresentSchemeHandler");
+
 const onFinish = jest.fn((cb) => {
   cb();
 });
 
-jest.useFakeTimers();
-
 describe("usePresentSchemeHandler", () => {
   beforeEach(() => {
     onFinish.mockClear();
@@ -42,7 +44,11 @@ describe("usePresentSchemeHandler", () => {
     navigator.replace.mockClear();
   });
 
-  const store = { test: "test", rivers };
+  const store = mockStore({ test: "test", rivers });
+
+  const wrapper: React.FC<any> = ({ children }) => (
+    <Provider store={store}>{children}</Provider>
+  );
 
   describe("loading link url", () => {
     const query = { link_url: "http://applicaster.com" };
@@ -53,11 +59,10 @@ describe("usePresentSchemeHandler", () => {
 
     it("opens the link entry", () => {
       renderHook(() => usePresentSchemeHandler({ query, url, onFinish }), {
-        wrapper: WrappedWithProviders,
-        initialProps: { store },
+        wrapper,
       });
 
-      expect(onFinish).toHaveBeenCalled();
+      expect(onFinish).toBeCalled();
 
       expect(helperSpy).toBeCalledWith(
         expect.objectContaining({
@@ -91,8 +96,7 @@ describe("usePresentSchemeHandler", () => {
             onFinish,
           }),
         {
-          wrapper: WrappedWithProviders,
-          initialProps: { store },
+          wrapper,
         }
       );
 
@@ -119,8 +123,7 @@ describe("usePresentSchemeHandler", () => {
       )}&show_nav_bar=true`;
 
       renderHook(() => usePresentSchemeHandler({ query, url, onFinish }), {
-        wrapper: WrappedWithProviders,
-        initialProps: { store },
+        wrapper,
       });
 
       expect(onFinish).toBeCalled();
@@ -152,22 +155,22 @@ describe("usePresentSchemeHandler", () => {
       )}&screen_id=${screen_id}`;
 
       renderHook(() => usePresentSchemeHandler({ query, url, onFinish }), {
-        wrapper: WrappedWithProviders,
-        initialProps: { store },
+        wrapper,
       });
 
       expect(onFinish).toBeCalled();
 
-      expect(helperSpy).toHaveBeenCalledWith(
+      expect(helperSpy).toBeCalledWith(
         expect.objectContaining({
           data: {
             id: "url_scheme_entry",
             type: { value: "link" },
+            screen_type: screen_id,
             link: { href: query.link_url, type: "text/html" },
             extensions: { showNavBar: false },
           },
-          navigator: expect.anything(),
-          pushScreen: "http://applicaster.com",
+          navigator,
+          pushScreen: expect.anything(),
         })
       );
     });
@@ -177,7 +180,9 @@ describe("usePresentSchemeHandler", () => {
     it("Re-sets app ready state and calls loadAppContextData with new river and cellStyles data", async () => {
       const store = mockStore({ test: "test" });
 
-      const wrapper = WrappedWithProviders;
+      const wrapper: React.FC<any> = ({ children }) => (
+        <Provider store={store}>{children}</Provider>
+      );
 
       const query = {
         rivers_configuration_id: "test",
@@ -185,6 +190,7 @@ describe("usePresentSchemeHandler", () => {
 
       const storageSpy = jest.spyOn(sessionStorage, "getAllItems");
       const axiosGetSpy = jest.spyOn(axios, "get");
+      const zappReduxSpy = jest.spyOn(zappRedux, "loadAppContextData");
 
       const getAllItems = jest.fn().mockResolvedValue({
         accountsAccountId: "accountsAccountId",
@@ -198,6 +204,7 @@ describe("usePresentSchemeHandler", () => {
 
       storageSpy.mockImplementation(getAllItems);
       axiosGetSpy.mockImplementation(get);
+      zappReduxSpy.mockReturnValue(null);
 
       renderHook(() => usePresentSchemeHandler({ query, url: "", onFinish }), {
         wrapper,
@@ -210,6 +217,13 @@ describe("usePresentSchemeHandler", () => {
           actions?.find(R.propEq("type", "SET_APP_NOT_READY"))
         ).toBeDefined();
 
+        expect(actions?.find(R.propEq("type", "SET_APP_READY"))).toBeDefined();
+
+        expect(zappReduxSpy).toBeCalledWith(expect.any(Function), {
+          cellStyles: "url",
+          rivers: "url",
+        });
+
         expect(navigator.replace).toBeCalledWith({});
       };
     });
@@ -247,7 +261,7 @@ describe("usePresentSchemeHandler", () => {
             },
           }),
         {
-          wrapper: WrappedWithProviders,
+          wrapper,
         }
       );
 
@@ -279,7 +293,7 @@ describe("usePresentSchemeHandler", () => {
             },
           }),
         {
-          wrapper: WrappedWithProviders,
+          wrapper,
         }
       );
 
@@ -311,7 +325,7 @@ describe("usePresentSchemeHandler", () => {
             },
           }),
         {
-          wrapper: WrappedWithProviders,
+          wrapper,
         }
       );
 
@@ -343,7 +357,7 @@ describe("usePresentSchemeHandler", () => {
             },
           }),
         {
-          wrapper: WrappedWithProviders,
+          wrapper,
         }
       );
 

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/__tests__/useUrlSchemeHandler.test.tsx

@@ -5,7 +5,7 @@ import * as URLHandlersMap from "..";
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
-import { log_warning } from "../../../logger";
+const { log_warning } = require("../../../logger");
 
 const mockStore = configureStore();
 

package/App/ErrorBoundary/__tests__/errorBoundary.test.jsx

@@ -0,0 +1,232 @@
+import React from "react";
+import { View, Text, TouchableOpacity } from "react-native";
+import { render, fireEvent, act } from "@testing-library/react-native";
+import { useErrorStore } from "../store";
+import { ErrorBoundary } from "../index";
+
+jest.mock(
+  "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen",
+  () => ({
+    // eslint-disable-next-line react/prop-types
+    ErrorScreen: ({ dismissError, message, buttons }) => (
+      <View testID="error-screen">
+        <Text testID="error-message">{message || "Default error message"}</Text>
+        {/* eslint-disable-next-line react/prop-types */}
+        {buttons?.map((button, index) => (
+          <TouchableOpacity
+            key={index}
+            onPress={button.onPress}
+            testID={`button-${index}`}
+          >
+            <Text>{button.text}</Text>
+          </TouchableOpacity>
+        ))}
+
+        {dismissError ? (
+          <TouchableOpacity onPress={dismissError} testID="dismiss-button">
+            <Text>Dismiss Error</Text>
+          </TouchableOpacity>
+        ) : null}
+      </View>
+    ),
+  })
+);
+
+jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
+  sendQuickBrickEvent: jest.fn(),
+  QUICK_BRICK_EVENTS: {
+    FORCE_APP_RELOAD: "force_app_reload",
+  },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/logger", () => ({
+  coreLogger: {
+    addSubsystem: () => ({
+      error: jest.fn(),
+    }),
+  },
+}));
+
+// eslint-disable-next-line react/prop-types
+const TestComponent = ({ error, errorMessage = "error !!" }) => {
+  if (error) {
+    throw new Error(errorMessage);
+  }
+
+  return (
+    <View>
+      <Text>all is good</Text>
+    </View>
+  );
+};
+
+describe("<ErrorBoundary />", () => {
+  // Clear all error states between tests
+  beforeEach(() => {
+    useErrorStore.getState().dismissError();
+  });
+
+  describe("when there is no error", () => {
+    it("renders children correctly", () => {
+      const { getByText } = render(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      expect(getByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("when an error is caught", () => {
+    const _consoleLogs = {
+      error: console.error,
+      log: console.log,
+    };
+
+    beforeAll(() => {
+      console.error = jest.fn();
+      console.log = jest.fn();
+    });
+
+    afterAll(() => {
+      console.error = _consoleLogs.error;
+      console.log = _consoleLogs.log;
+    });
+
+    it("renders error state with default values (recoverable error)", () => {
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(getByTestId("dismiss-button")).toBeTruthy(); // Should be recoverable by default
+    });
+
+    it("handles non-recoverable errors (no dismiss button)", () => {
+      const { getByTestId, queryByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      expect(getByTestId("error-screen")).toBeTruthy();
+      expect(queryByTestId("dismiss-button")).toBeFalsy(); // Should not be recoverable
+    });
+
+    it("shows custom error message from caught error", () => {
+      const customErrorMessage = "Custom error message for testing";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be passed to the ErrorScreen
+      expect(getByTestId("error-message").props.children).toBeTruthy();
+    });
+
+    it("can dismiss the error and restore the UI", () => {
+      // First render with error
+      const { getByTestId, queryByText, rerender } = render(
+        <ErrorBoundary>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Verify error screen is shown
+      expect(getByTestId("error-screen")).toBeTruthy();
+
+      // Dismiss the error
+      fireEvent.press(getByTestId("dismiss-button"));
+
+      // Force rerender to see the change
+      rerender(
+        <ErrorBoundary>
+          <TestComponent />
+        </ErrorBoundary>
+      );
+
+      // Now the regular content should be visible
+      expect(queryByText("all is good")).toBeTruthy();
+    });
+  });
+
+  describe("error store functionality", () => {
+    it("properly sets error state", () => {
+      const error = new Error("Test error");
+      const errorInfo = "Test error info";
+
+      act(() => {
+        useErrorStore.getState().setError(error, errorInfo, true);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(true);
+      expect(state.error).toBe(error);
+      expect(state.info).toBe(errorInfo);
+      expect(state.recoverable).toBe(true);
+    });
+
+    it("properly resets error state", () => {
+      // First set an error
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", true);
+      });
+
+      // Then dismiss it
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.hasError).toBe(false);
+      expect(state.error).toBeUndefined();
+      expect(state.info).toBeUndefined();
+      expect(state.recoverable).toBe(true); // Default value when reset
+    });
+
+    it("remembers recoverable state", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("Test error"), "Info", false);
+      });
+
+      const state = useErrorStore.getState();
+      expect(state.recoverable).toBe(false);
+    });
+  });
+
+  describe("integration with ErrorScreen", () => {
+    it("renders restart app button for non-recoverable errors", () => {
+      const { getAllByTestId } = render(
+        <ErrorBoundary recoverable={false}>
+          <TestComponent error />
+        </ErrorBoundary>
+      );
+
+      // Should have the restart app button
+      const buttons = getAllByTestId(/button-/);
+      expect(buttons.length).toBeGreaterThan(0);
+    });
+
+    it("passes error info to the ErrorScreen component", () => {
+      const customErrorMessage = "Very specific error message";
+
+      const { getByTestId } = render(
+        <ErrorBoundary>
+          <TestComponent error errorMessage={customErrorMessage} />
+        </ErrorBoundary>
+      );
+
+      // The error info should be visible in the UI
+      expect(getByTestId("error-message")).toBeTruthy();
+    });
+  });
+});

package/App/ErrorBoundary/__tests__/store.test.js

@@ -0,0 +1,143 @@
+import { act, renderHook } from "@testing-library/react-hooks";
+import { useErrorStore } from "../store";
+
+describe("Error Store", () => {
+  beforeEach(() => {
+    act(() => {
+      useErrorStore.getState().dismissError();
+    });
+  });
+
+  describe("Initial state", () => {
+    it("should have correct default values", () => {
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("setError action", () => {
+    it("should set error state with provided values", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = true;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: testError,
+        info: testInfo,
+        recoverable: isRecoverable,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+
+    it("should set non-recoverable error when specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+      const isRecoverable = false;
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo, isRecoverable);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: false,
+      });
+    });
+
+    it("should default to recoverable error when not specified", () => {
+      const testError = new Error("Test error");
+      const testInfo = "Test error info";
+
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, testInfo);
+      });
+
+      expect(result.current).toMatchObject({
+        recoverable: true,
+      });
+    });
+  });
+
+  describe("dismissError action", () => {
+    it("should reset error state to defaults", () => {
+      const testError = new Error("Test error");
+      const { result } = renderHook(() => useErrorStore());
+
+      act(() => {
+        result.current.setError(testError, "info", false);
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        recoverable: false,
+      });
+
+      act(() => {
+        result.current.dismissError();
+      });
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+        error: undefined,
+        info: undefined,
+        recoverable: true,
+        setError: expect.any(Function),
+        dismissError: expect.any(Function),
+      });
+    });
+  });
+
+  describe("Direct store access via API", () => {
+    it("should allow direct access to store outside React components", () => {
+      act(() => {
+        useErrorStore
+          .getState()
+          .setError(new Error("API error"), "API info", false);
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: true,
+        error: expect.objectContaining({ message: "API error" }),
+        info: "API info",
+        recoverable: false,
+      });
+    });
+
+    it("should allow clearing errors via API", () => {
+      act(() => {
+        useErrorStore.getState().setError(new Error("API error"), "API info");
+      });
+
+      act(() => {
+        useErrorStore.getState().dismissError();
+      });
+
+      const { result } = renderHook(() => useErrorStore());
+
+      expect(result.current).toMatchObject({
+        hasError: false,
+      });
+    });
+  });
+});