@applicaster/quick-brick-core 13.0.0-alpha.7223526501 → 13.0.0-alpha.7586259907

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,
+      });
+    });
+  });
+});

package/App/ErrorBoundary/index.tsx

@@ -1,42 +1,66 @@
 import * as React from "react";
+import pick from "lodash/pick";
 
 import { coreLogger } from "@applicaster/zapp-react-native-utils/logger";
 import { ErrorScreen } from "@applicaster/zapp-react-native-ui-components/Components/ErrorScreen";
 
+import { useErrorStore } from "./store";
+import * as QuickBrickManager from "@applicaster/zapp-react-native-bridge/QuickBrick";
+
 const errorBoundaryLogger = coreLogger.addSubsystem("react_error-boundary");
 
 type Props = {
   children: React.ReactNode;
+  recoverable?: boolean;
 };
 
-type State = {
-  hasError: boolean;
-  error?: Error;
-  info?: string;
+type ErrorBoundaryContentProps = {
+  children: React.ReactNode;
 };
 
-export class ErrorBoundary extends React.Component<Props, State> {
-  state: State = {
-    hasError: false,
-    error: undefined,
-  };
+const restartApp = () => {
+  QuickBrickManager.sendQuickBrickEvent(
+    QuickBrickManager.QUICK_BRICK_EVENTS.FORCE_APP_RELOAD
+  );
+};
 
-  componentDidCatch(error, info) {
-    errorBoundaryLogger.error({ error, data: info, message: error.message });
-    this.setState({ hasError: true, error, info });
+const restartButton = {
+  text: "Restart the app",
+  onPress: restartApp,
+};
+
+const buttons = [restartButton];
+
+const ErrorBoundaryContent: React.FC<ErrorBoundaryContentProps> = ({
+  children,
+}) => {
+  const { hasError, dismissError, info } = pick(
+    useErrorStore((state) => state),
+    ["hasError", "dismissError", "info"]
+  );
+
+  if (hasError) {
+    return (
+      <ErrorScreen
+        dismissError={dismissError}
+        message={info}
+        buttons={buttons}
+      />
+    );
   }
 
-  dismissError = () => {
-    this.setState({ hasError: false });
-  };
+  return <>{children}</>;
+};
 
-  render() {
-    const { hasError } = this.state as State;
+export class ErrorBoundary extends React.Component<Props> {
+  componentDidCatch(error, info) {
+    errorBoundaryLogger.error({ error, data: info, message: error.message });
+    const { recoverable = true } = this.props;
 
-    if (hasError) {
-      return <ErrorScreen dismissError={this.dismissError} />;
-    }
+    useErrorStore.getState().setError(error, info, recoverable);
+  }
 
-    return this.props.children;
+  render() {
+    return <ErrorBoundaryContent>{this.props.children}</ErrorBoundaryContent>;
   }
 }

package/App/ErrorBoundary/store.ts

@@ -0,0 +1,26 @@
+import { create } from "zustand";
+
+type ErrorState = {
+  hasError: boolean;
+  error?: Error;
+  info?: string;
+  recoverable: boolean;
+  setError: (error: Error, info: string, recoverable?: boolean) => void;
+  dismissError: () => void;
+};
+
+export const useErrorStore = create<ErrorState>((set) => ({
+  hasError: false,
+  error: undefined,
+  info: undefined,
+  recoverable: true,
+  setError: (error: Error, info: string, recoverable = true) =>
+    set({ hasError: true, error, info, recoverable }),
+  dismissError: () =>
+    set({
+      hasError: false,
+      error: undefined,
+      info: undefined,
+      recoverable: true,
+    }),
+}));

package/App/NavigationProvider/NavigationProvider.tsx

@@ -423,7 +423,7 @@ export function NavigationProvider({ children }: Props) {
     closeLoadingOverlay();
   };
 
-  const handleHookCancel = ({ hookPlugin, callback }, dispose) => {
+  const handleHookCancel = ({ hookPlugin, callback, abort }, dispose) => {
     dispose();
     setStartUpHooks(false);
 
@@ -431,10 +431,12 @@ export function NavigationProvider({ children }: Props) {
       callback();
     }
 
-    if (hookPlugin.isModalHook()) {
-      navigator.dismissModal();
-    } else {
-      goBack(true, true);
+    if (!abort) {
+      if (hookPlugin.isModalHook()) {
+        navigator.dismissModal();
+      } else {
+        goBack(true, true);
+      }
     }
 
     closeLoadingOverlay();

package/App/NetworkStatusProvider/utils.ts

@@ -1,4 +1,3 @@
-/// <reference types="@types/tizen-tv-webapis" />
 import * as R from "ramda";
 
 import { NetInfoState } from "@react-native-community/netinfo";

package/App/appLifeCycleManager/__tests__/appLifeCycleManager.test.tsx

@@ -0,0 +1,146 @@
+import * as React from "react";
+import { View, Text } from "react-native";
+import { render, waitFor } from "@testing-library/react-native";
+import thunk from "redux-thunk";
+import configureStore from "redux-mock-store";
+
+let mocked_items: Record<string, any> = {};
+
+import { appLifeCycleManager } from "../";
+
+const mock_actions = {};
+
+jest.mock("@applicaster/zapp-react-native-redux/AppData", () => ({
+  loadAppData: jest.fn(() => () => Promise.resolve()),
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/actions", () => ({
+  useActions: jest.fn(() => ({ actions: mock_actions })),
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getAllItems: jest.fn(() => Promise.resolve(mocked_items)),
+      setItem: jest.fn((key, value) => {
+        mocked_items[key] = JSON.stringify(value);
+
+        return Promise.resolve(true);
+      }),
+      getItem: jest.fn((key) => {
+        if (mocked_items[key]) {
+          if (typeof mocked_items[key] === "string") {
+            return Promise.resolve(JSON.parse(mocked_items[key]));
+          } else {
+            return Promise.resolve(mocked_items[key]);
+          }
+        } else {
+          return Promise.resolve([]);
+        }
+      }),
+      __reset() {
+        mocked_items = {};
+      },
+    },
+  })
+);
+
+const Component = () => (
+  <View>
+    <Text>I'm a component</Text>
+  </View>
+);
+
+const QuickBrickManager = {
+  sendQuickBrickEvent: jest.fn(),
+};
+
+const LOADING_ERROR = new Error("loading failed");
+
+const appLoader = jest.fn((_dispatch, _getState) => {
+  if (_getState().shouldFail) return Promise.reject(LOADING_ERROR);
+
+  return Promise.resolve();
+});
+
+const store = configureStore([thunk])({});
+const dispatch = store.dispatch;
+
+const state = {
+  rivers: {},
+  plugins: {},
+  appSettings: { runtimeConfigurationUrls: { rivers: "http://rivers.url" } },
+};
+
+const QUICK_BRICK_READY_EVENT = "quickBrickReady";
+
+describe("appLifeCycleManager", () => {
+  const decorator = appLifeCycleManager(appLoader, QuickBrickManager);
+  const DecoratedComponent = decorator(Component);
+
+  beforeEach(() => {
+    appLoader.mockClear();
+    QuickBrickManager.sendQuickBrickEvent.mockClear();
+  });
+
+  it("returns a function to decorate a component", () => {
+    expect(decorator).toBeDefined();
+  });
+
+  it("runs the loaders, then sends quickBrickReady event", async () => {
+    const testCallback = jest.fn(() => {});
+
+    render(
+      <DecoratedComponent
+        dispatch={dispatch}
+        {...state}
+        testCallback={testCallback}
+      />
+    );
+
+    await waitFor(() => {
+      return expect(testCallback).toHaveBeenCalled();
+    });
+
+    const actions = store.getActions();
+
+    expect(actions[0]).toMatchObject({ type: "SET_APP_READY" });
+
+    expect(QuickBrickManager.sendQuickBrickEvent).toHaveBeenCalledWith(
+      QUICK_BRICK_READY_EVENT
+    );
+
+    expect(appLoader).toHaveBeenCalled();
+  });
+
+  it("sends the quickBrickReady event when a loader doesn't resolves", async () => {
+    const testCallback = jest.fn(() => {});
+
+    render(
+      <DecoratedComponent
+        dispatch={dispatch}
+        {...state}
+        shouldFail
+        testCallback={testCallback}
+      />
+    );
+
+    const actions = store.getActions();
+
+    await waitFor(() => {
+      return expect(testCallback).toHaveBeenCalled();
+    });
+
+    expect(actions[0]).toMatchObject({ type: "SET_APP_READY" });
+    expect(actions[1]).toMatchObject({ type: "SET_APP_LAUNCHED" });
+
+    expect(QuickBrickManager.sendQuickBrickEvent).toHaveBeenCalledWith(
+      QUICK_BRICK_READY_EVENT
+    );
+
+    expect(testCallback).toHaveBeenCalled();
+
+    expect(appLoader).toHaveBeenCalled();
+  });
+});

package/App/appLifeCycleManager/index.tsx

@@ -182,13 +182,13 @@ export function appLifeCycleManager(appLoader, QuickBrickManager) {
             data: { error },
           });
         }
-
-        makeAppReady();
-        checkStoredContextKeys();
       };
 
       React.useLayoutEffect(() => {
-        prepareApp();
+        prepareApp().then(() => {
+          makeAppReady();
+          checkStoredContextKeys();
+        });
       }, []);
 
       return <Component {...props} />;

package/App/index.tsx

@@ -72,11 +72,11 @@ const App = ({
                 </SplashLoader>
                 <ModalProvider />
               </URLSchemeListener>
-              <LogicAggregatorContainer
-                components={[InteractionManager, ApplyScreenHooks]}
-              />
               <LoadingOverlay />
             </ErrorBoundary>
+            <LogicAggregatorContainer
+              components={[InteractionManager, ApplyScreenHooks]}
+            />
           </AppContainer>
         </SafeAreaProvider>
       </ThemeManager>

package/App/remoteContextReloader/getRemoteContextData/getNativeRemoteContextData.ts

@@ -1,4 +1,5 @@
 import * as R from "ramda";
+import isEmpty from "lodash/isEmpty";
 import { Dimensions, NativeModules } from "react-native";
 import { loadAppContextData } from "@applicaster/zapp-react-native-redux";
 import { isTablet } from "@applicaster/zapp-react-native-utils/reactHooks";
@@ -10,6 +11,7 @@ import { logger } from "@applicaster/zapp-react-native-utils/logger";
 import { ACTIVE_LAYOUT_ID_STORAGE_KEY } from "../consts";
 const { AppLoaderBridge } = NativeModules;
 import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { useErrorStore } from "../../ErrorBoundary/store";
 
 export async function getNativeRemoteContextData(
   dispatch,
@@ -58,6 +60,18 @@ export async function getNativeRemoteContextData(
 
   const layout = await getPromiseForType("layout");
 
+  const layoutLoadingErrorMessage = "Failed to load layout data";
+
+  if (isEmpty(layout)) {
+    useErrorStore
+      .getState()
+      .setError(
+        new Error(layoutLoadingErrorMessage),
+        layoutLoadingErrorMessage,
+        false
+      );
+  }
+
   const apiVersion = layout?.layout?.["api_version"]; // Taken from remote configuration
 
   dispatch(appDataActions.merge({ layoutVersion: apiVersion || "v1" }));

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "13.0.0-alpha.7223526501",
+  "version": "13.0.0-alpha.7586259907",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
-    "test": "jest -w=2",
     "build": "echo 'skipping ts build for core packages'"
   },
   "repository": {
@@ -29,13 +28,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.7223526501",
-    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.7223526501",
-    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.7223526501",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.7223526501",
-    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.7223526501",
-    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.7223526501",
-    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.7223526501",
+    "@applicaster/applicaster-types": "13.0.0-alpha.7586259907",
+    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.7586259907",
+    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.7586259907",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.7586259907",
+    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.7586259907",
+    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.7586259907",
+    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.7586259907",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",
@@ -57,7 +56,6 @@
     "@applicaster/zapp-react-native-tvos-ui-components": "*",
     "@babel/runtime": "*",
     "@react-native-community/netinfo": "*",
-    "@types/node": "*",
     "immer": "*",
     "react": "*",
     "react-native": "*",
@@ -73,8 +71,6 @@
     "zustand": "*"
   },
   "devDependencies": {
-    "@types/react-native": "0.69.6",
-    "@types/tizen-tv-webapis": "^2.0.1",
     "nock": "^10.0.0",
     "redux-mock-store": "^1.5.3"
   },

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

@@ -1,55 +0,0 @@
-import React from "react";
-import { View, Text } from "react-native";
-import { render } from "@testing-library/react-native";
-
-import { ErrorBoundary } from "../index";
-
-const TestComponent = ({ error }: { error: any }) => {
-  if (error) {
-    throw new Error("error !!");
-  }
-
-  return (
-    <View>
-      <Text>all is good</Text>
-    </View>
-  );
-};
-
-describe("<ErrorBoundary />", () => {
-  describe("when there is no error", () => {
-    it("renders correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent />
-        </ErrorBoundary>
-      );
-
-      expect(getByText("all is good")).toBeTruthy();
-    });
-  });
-
-  describe("When an error is caught", () => {
-    const _consoleLog = console.log;
-
-    beforeAll(() => {
-      console.log = jest.fn();
-    });
-
-    afterAll(() => {
-      console.log = _consoleLog;
-    });
-
-    it("renders error state correctly", () => {
-      const { getByText } = render(
-        <ErrorBoundary>
-          <TestComponent error />
-        </ErrorBoundary>
-      );
-
-      // Note: You'll need to verify what your ErrorBoundary actually renders in error state
-      // This is just an example assertion:
-      expect(getByText(/error/i)).toBeTruthy();
-    });
-  });
-});

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

@@ -1,30 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`appLifeCycleManager runs the loaders, then sends quickBrickReady event 1`] = `
-<View>
-  <Text>
-    I'm a component
-  </Text>
-</View>
-`;
-
-exports[`appLifeCycleManager sends the quickBrickReady event when a loader doesn't resolves 1`] = `
-<View>
-  <Text>
-    I'm a component
-  </Text>
-</View>
-`;
-
-exports[`appLifeCycleManager sends the quickBrickReady event when a loader doesn't resolves 2`] = `
-[
-  [
-    {
-      "data": {
-        "error": [Error: loading failed],
-      },
-      "message": "AppLifeCycleManager: A loading operation failed: loading failed",
-    },
-  ],
-]
-`;

package/App/appLifeCycleManager/__tests__/appLifeCycleManager.test.js

@@ -1,134 +0,0 @@
-import * as React from "react";
-import { View, Text } from "react-native";
-import { create, act } from "react-test-renderer";
-
-const Component = () => (
-  <View>
-    <Text>I'm a component</Text>
-  </View>
-);
-
-const mockLogger = {
-  warning: jest.fn(),
-  log: jest.fn(),
-  debug: jest.fn(),
-  info: jest.fn(),
-};
-
-jest.mock("../../logger", () => ({
-  coreAppLogger: {
-    addSubsystem: jest.fn(() => mockLogger),
-  },
-}));
-
-const QuickBrickManager = {
-  sendQuickBrickEvent: jest.fn(),
-};
-
-const LOADING_ERROR = new Error("loading failed");
-
-const appLoader = jest.fn((_dispatch, _getState) => {
-  if (_getState().shouldFail) return Promise.reject(LOADING_ERROR);
-
-  return Promise.resolve();
-});
-
-const dispatch = jest.fn();
-
-const state = {
-  rivers: {},
-  plugins: {},
-  appSettings: { runtimeConfigurationUrls: { rivers: "http://rivers.url" } },
-};
-
-const QUICK_BRICK_READY_EVENT = "quickBrickReady";
-
-const actions = {};
-
-jest.doMock("@applicaster/zapp-react-native-utils/reactHooks/actions", () => ({
-  useActions: jest.fn(() => ({ actions })),
-}));
-
-const { appLifeCycleManager } = require("../index");
-
-describe("appLifeCycleManager", () => {
-  const decorator = appLifeCycleManager(appLoader, QuickBrickManager);
-
-  beforeEach(() => {
-    mockLogger.warning.mockClear();
-    appLoader.mockClear();
-    QuickBrickManager.sendQuickBrickEvent.mockClear();
-    dispatch.mockClear();
-  });
-
-  it("returns a function to decorate a component", () => {
-    expect(decorator).toBeFunction();
-  });
-
-  it("runs the loaders, then sends quickBrickReady event", (done) => {
-    const DecoratedComponent = decorator(Component);
-
-    let wrapper;
-
-    const testCallback = () => {
-      expect(dispatch).toHaveBeenCalledWith(
-        expect.objectContaining({ type: "SET_APP_READY" })
-      );
-
-      expect(QuickBrickManager.sendQuickBrickEvent).toHaveBeenCalledWith(
-        QUICK_BRICK_READY_EVENT
-      );
-
-      done();
-    };
-
-    act(() => {
-      wrapper = create(
-        <DecoratedComponent
-          dispatch={dispatch}
-          {...state}
-          testCallback={testCallback}
-        />
-      );
-    });
-
-    expect(wrapper.toJSON()).toMatchSnapshot();
-    expect(appLoader).toHaveBeenCalled();
-    expect.assertions(4);
-  });
-
-  it("sends the quickBrickReady event when a loader doesn't resolves", (done) => {
-    const DecoratedComponent = decorator(Component);
-
-    let wrapper;
-
-    const testCallback = () => {
-      expect(dispatch).toHaveBeenCalledWith(
-        expect.objectContaining({ type: "SET_APP_READY" })
-      );
-
-      expect(QuickBrickManager.sendQuickBrickEvent).toHaveBeenCalledWith(
-        QUICK_BRICK_READY_EVENT
-      );
-
-      expect(mockLogger.warning.mock.calls).toMatchSnapshot();
-
-      done();
-    };
-
-    act(() => {
-      wrapper = create(
-        <DecoratedComponent
-          dispatch={dispatch}
-          {...state}
-          shouldFail
-          testCallback={testCallback}
-        />
-      );
-    });
-
-    expect(wrapper.toJSON()).toMatchSnapshot();
-    expect(appLoader).toHaveBeenCalled();
-    expect.assertions(5);
-  });
-});