@applicaster/quick-brick-core 13.0.0-alpha.4863201005 → 13.0.0-alpha.4951885994

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/remoteContextReloader/__tests__/remoteContextReloader.test.js

@@ -1,7 +1,6 @@
 import * as React from "react";
 import { View, Text } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render } from "@testing-library/react-native";
 
 import { remoteContextReloader } from "../index";
 import * as ContextReloader from "../getRemoteContextData";
@@ -25,19 +24,21 @@ const dispatch = jest.fn();
 
 describe("remoteContextReloader", () => {
   const WrappedComponent = remoteContextReloader(Component);
+  let rendered;
+
+  beforeEach(() => {
+    rendered = render(
+      <WrappedComponent {...{ appSettings, plugins, dispatch }} />
+    );
+  });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it("adds a componentDidMount method", () => {
-    const wrapper = shallow(
-      <WrappedComponent {...{ appSettings, plugins, dispatch }} />
-    );
-
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-    expect(wrapper.instance()).toHaveProperty("componentDidMount");
-    expect(wrapper.instance().componentDidMount).toBeFunction();
+  it("calls componentDidMount and renders correctly", () => {
+    const { getByText } = rendered;
+    expect(getByText("I'm a component")).toBeTruthy();
   });
 
   describe("when in __DEV__", () => {
@@ -47,11 +48,6 @@ describe("remoteContextReloader", () => {
     });
 
     it("doesn't invoke the context reloader", () => {
-      const wrapper = shallow(
-        <WrappedComponent {...{ appSettings, plugins, dispatch }} />
-      );
-
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
       expect(spy).not.toHaveBeenCalled();
     });
   });
@@ -62,12 +58,6 @@ describe("remoteContextReloader", () => {
     });
 
     it("invokes the context reloader", () => {
-      const wrapper = shallow(
-        <WrappedComponent {...{ appSettings, plugins, dispatch }} />
-      );
-
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-
       expect(spy).toHaveBeenCalledWith(
         dispatch,
         appSettings.runtimeConfigurationUrls,

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/createZappApp/__tests__/__snapshots__/createZappApp.test.js.snap

@@ -1,132 +1,9 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`createZappApp has a <Provider /> component with an initialized store 1`] = `
-{
-  "appData": {
-    "countryLocale": "GB",
-    "languageLocale": "en",
-    "layoutVersion": "v1",
-    "quickBrickEvent": [MockFunction],
-  },
-  "appSettings": {
-    "runtimeConfigurationUrls": {},
-  },
-  "appState": {
-    "appLaunched": false,
-    "appReady": false,
-    "appState": {
-      "currentState": null,
-      "eventType": null,
-      "isAvailable": null,
-      "nextState": null,
-    },
-  },
-  "cellStyles": {},
-  "components": {
-    "AppContainer": [Function],
-    "ContentScreen": [Function],
-    "HookRenderer": [Function],
-    "ModalComponent": [Function],
-    "PlayerContainer": {
-      "$$typeof": Symbol(react.memo),
-      "WrappedComponent": {
-        "$$typeof": Symbol(react.memo),
-        "compare": null,
-        "type": [Function],
-      },
-      "compare": null,
-      "type": [Function],
-    },
-    "QBImage": [Function],
-    "River": {
-      "$$typeof": Symbol(react.memo),
-      "WrappedComponent": [Function],
-      "compare": null,
-      "type": [Function],
-    },
-    "TextInputTv": {
-      "$$typeof": Symbol(react.forward_ref),
-      "render": [Function],
-    },
-    "Touchable": [Function],
-  },
-  "contentTypes": null,
-  "localizations": {},
-  "pipesEndpoints": null,
-  "pluginConfigurations": {
-    "pc1": {
-      "configuration_json": null,
-      "plugin": {
-        "api": {},
-        "identifier": "pc1",
-      },
-    },
-    "pc2": {
-      "configuration_json": {
-        "foo": "bar",
-      },
-      "plugin": {
-        "api": {},
-        "identifier": "pc2",
-      },
-    },
-  },
-  "plugins": [
-    {
-      "configuration": null,
-      "identifier": "pc1",
-      "module": [MockFunction],
-      "name": "Plugin1",
-      "type": "general",
-    },
-    {
-      "configuration": {
-        "foo": "bar",
-      },
-      "identifier": "pc2",
-      "module": [MockFunction],
-      "name": "Plugin2",
-      "type": "general",
-    },
-  ],
-  "presetsMapping": {},
-  "remoteConfigurations": {
-    "localizations": {},
-  },
-  "rivers": {},
-  "styles": {},
-  "zappPipes": {},
-}
-`;
-
 exports[`createZappApp renders the provided React App 1`] = `
-<Provider
-  store={
-    {
-      "@@observable": [Function],
-      "dispatch": [Function],
-      "getState": [Function],
-      "replaceReducer": [Function],
-      "subscribe": [Function],
-    }
-  }
->
-  <EmptyZappApp />
-</Provider>
-`;
-
-exports[`createZappApp returns a react component 1`] = `
-<Provider
-  store={
-    {
-      "@@observable": [Function],
-      "dispatch": [Function],
-      "getState": [Function],
-      "replaceReducer": [Function],
-      "subscribe": [Function],
-    }
-  }
->
-  <EmptyZappApp />
-</Provider>
+<View>
+  <Text>
+    Welcome to the QuickBrick App
+  </Text>
+</View>
 `;

package/createZappApp/__tests__/createZappApp.test.js

@@ -1,7 +1,6 @@
 import * as React from "react";
 import { View, Text } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
+import { render, screen } from "@testing-library/react-native";
 import QuickBrickComponents from "@applicaster/zapp-react-native-ui-components";
 import { Provider } from "react-redux";
 
@@ -77,27 +76,17 @@ jest.mock("@applicaster/zapp-react-native-bridge/QuickBrick", () => ({
 }));
 
 describe("createZappApp", () => {
-  it("returns a react component", () => {
-    const ZappApp = createZappApp({});
-    const wrapper = shallow(<ZappApp />);
-
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-  });
-
   it("renders the provided React App", () => {
     const ZappApp = createZappApp({ App });
-    const wrapper = shallow(<ZappApp />);
-
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    render(<ZappApp />);
+    expect(screen.toJSON()).toMatchSnapshot();
   });
 
-  it("has a <Provider /> component with an initialized store", () => {
+  it("has a Provider component with an initialized store", () => {
     const ZappApp = createZappApp(zappAppConfig);
-    const wrapper = shallow(<ZappApp />);
-
-    const providerNode = wrapper.find(Provider);
-    const store = providerNode.prop("store");
-    expect(providerNode.length).toBe(1);
+    const { UNSAFE_root } = render(<ZappApp />);
+    const providerInstance = UNSAFE_root.findByType(Provider);
+    const store = providerInstance.props.store;
 
     expect(store).toEqual(
       expect.objectContaining({
@@ -108,8 +97,6 @@ describe("createZappApp", () => {
       })
     );
 
-    expect(store.getState()).toMatchSnapshot();
-
     expect(store.getState()).toEqual(
       expect.objectContaining({
         styles: expect.any(Object),

package/defaults/__tests__/defaults.test.js

@@ -1,11 +1,10 @@
 import React from "react";
+import { render } from "@testing-library/react-native";
 import { EmptyZappApp } from "../index";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
 
 describe("<EmptyZappApp />", () => {
   it("renders correctly", () => {
-    const wrapper = shallow(<EmptyZappApp />);
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
+    const { toJSON } = render(<EmptyZappApp />);
+    expect(toJSON()).toMatchSnapshot();
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-core",
-  "version": "13.0.0-alpha.4863201005",
+  "version": "13.0.0-alpha.4951885994",
   "description": "Core package for Applicaster's Quick Brick App",
   "main": "index.js",
   "types": "index.d.ts",
@@ -29,13 +29,13 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "13.0.0-alpha.4863201005",
-    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.4863201005",
-    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.4863201005",
+    "@applicaster/applicaster-types": "13.0.0-alpha.4951885994",
+    "@applicaster/quick-brick-core-plugins": "13.0.0-alpha.4951885994",
+    "@applicaster/zapp-pipes-v2-client": "13.0.0-alpha.4951885994",
+    "@applicaster/zapp-react-native-bridge": "13.0.0-alpha.4951885994",
+    "@applicaster/zapp-react-native-redux": "13.0.0-alpha.4951885994",
+    "@applicaster/zapp-react-native-ui-components": "13.0.0-alpha.4951885994",
+    "@applicaster/zapp-react-native-utils": "13.0.0-alpha.4951885994",
     "atob": "^2.1.2",
     "axios": "^0.28.0",
     "btoa": "^1.2.1",
@@ -57,10 +57,9 @@
     "@applicaster/zapp-react-native-tvos-ui-components": "*",
     "@babel/runtime": "*",
     "@react-native-community/netinfo": "*",
-    "@types/node": "*",
     "immer": "*",
-    "react": "17.0.2",
-    "react-native": "0.68.6",
+    "react": "*",
+    "react-native": "*",
     "react-native-fs": "*",
     "react-native-gesture-handler": "*",
     "react-native-linear-gradient": "*",
@@ -73,8 +72,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/DeepLinking/URLSchemeListener/__tests__/URLSchemeListenerTest.js

@@ -1,177 +0,0 @@
-import * as React from "react";
-import { View, Text } from "react-native";
-import { shallow } from "enzyme";
-import { shallowToJson } from "enzyme-to-json";
-
-import { URLSchemeListener } from "../index";
-
-const URL = "url";
-
-const TestComponent = () => (
-  <View>
-    <Text>I'm a test component</Text>
-  </View>
-);
-
-const ReactNative = require("react-native");
-const { Linking } = ReactNative;
-
-const navigator = {
-  push: jest.fn(),
-  replace: jest.fn(),
-};
-
-jest.spyOn(console, "warn").mockImplementation(() => jest.fn());
-
-function clearMocks() {
-  navigator.push.mockClear();
-  navigator.replace.mockClear();
-  console.warn.mockClear(); // eslint-disable-line no-console
-  Linking.__resetListeners();
-  Linking.__clearInitialURL();
-  Linking.addEventListener.mockClear();
-  Linking.removeEventListener.mockClear();
-  Linking.getInitialURL.mockClear();
-  Linking.openURL.mockClear();
-}
-
-describe("URLSchemeHandler", () => {
-  const getWrapper = (props) =>
-    shallow(
-      <URLSchemeListener navigator={navigator} {...props}>
-        <TestComponent />
-      </URLSchemeListener>
-    );
-
-  beforeEach(clearMocks);
-
-  it("renders correctly", () => {
-    const wrapper = getWrapper();
-    expect(shallowToJson(wrapper)).toMatchSnapshot();
-  });
-
-  describe("linking registration", () => {
-    beforeEach(clearMocks);
-
-    it("registers the listener when the component mounts", () => {
-      const wrapper = getWrapper();
-      const instance = wrapper.instance();
-
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-
-      expect(Linking.addEventListener).toHaveBeenCalledWith(
-        URL,
-        instance.handleOpenUrl
-      );
-    });
-
-    it("unregisters the listener when the component unmounts", () => {
-      const wrapper = getWrapper();
-      const instance = wrapper.instance();
-      wrapper.unmount();
-
-      expect(Linking.removeEventListener).toHaveBeenCalledWith(
-        URL,
-        instance.handleOpenUrl
-      );
-    });
-  });
-
-  describe("initial url", () => {
-    beforeEach(clearMocks);
-
-    it("tries to get the initial url", () => {
-      const listenerSpy = jest.fn();
-      const wrapper = getWrapper({ listenerSpy });
-
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-      expect(listenerSpy).toHaveBeenCalledWith("getInitialURL");
-      expect(Linking.getInitialURL).toHaveBeenCalled();
-    });
-
-    it("gets the initial url and redirect to it if it exists", async () => {
-      const listenerSpy = jest.fn();
-      const url = "http://foo.com";
-      Linking.__setInitialURL(url);
-
-      const wrapper = getWrapper({ listenerSpy });
-      const instance = wrapper.instance();
-
-      await instance.componentDidMount();
-
-      expect(listenerSpy).toHaveBeenCalledWith("getInitialURL");
-
-      expect(navigator.replace).toHaveBeenCalledWith(
-        expect.objectContaining({ url })
-      );
-    });
-
-    it("doesn't try to navigate if there is no initial url", async () => {
-      const listenerSpy = jest.fn();
-
-      const wrapper = getWrapper({ listenerSpy });
-      const instance = wrapper.instance();
-      jest.spyOn(instance, "handleOpenUrlError");
-
-      await instance.componentDidMount();
-
-      expect(listenerSpy).toHaveBeenCalledWith("getInitialURL");
-      expect(listenerSpy).not.toHaveBeenCalledWith("canOpenURL");
-      expect(navigator.replace).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("url scheme handler", () => {
-    beforeEach(clearMocks);
-
-    it("invokes the listener when a url is triggered", () => {
-      const listenerSpy = jest.fn();
-      const wrapper = getWrapper({ listenerSpy });
-      const url = "http://foo.com";
-
-      Linking.__callUrl(url);
-
-      expect(shallowToJson(wrapper)).toMatchSnapshot();
-
-      expect(listenerSpy).toHaveBeenCalledWith(
-        "handleOpenUrl",
-        expect.objectContaining({ url })
-      );
-    });
-
-    it("invokes the navigator if a url is triggered and the url is valid", async () => {
-      const listenerSpy = jest.fn();
-      const wrapper = getWrapper({ listenerSpy });
-      const instance = wrapper.instance();
-      const spy = jest.spyOn(instance, "handleOpenUrl");
-      const url = "http://foo.com";
-
-      Linking.__callUrl(url);
-
-      await spy;
-
-      expect(navigator.replace).toHaveBeenCalledWith(
-        expect.objectContaining({ url })
-      );
-    });
-
-    it("doesn't invoke the navigator if a url is triggered and the url is undefined", async () => {
-      const listenerSpy = jest.fn();
-      const wrapper = getWrapper({ listenerSpy });
-      const instance = wrapper.instance();
-      const spy = jest.spyOn(instance, "handleOpenUrl");
-      const url = undefined; // eslint-disable no-undefined
-
-      Linking.__callUrl(url);
-
-      await spy;
-
-      expect(listenerSpy).toHaveBeenCalledWith(
-        "handleOpenUrl",
-        expect.objectContaining({ url })
-      );
-
-      expect(navigator.replace).not.toHaveBeenCalled();
-    });
-  });
-});