@applicaster/quick-brick-core 15.0.0-rc.99 → 15.1.0-alpha.9834630500

package/App/ActionSetters/index.ts

@@ -21,8 +21,7 @@ const warnUndefinedContext = (context) =>
   });
 
 type Subscription = {
-  [x: string]: (() => any) | string;
-  pluginId?: string;
+  [x: string]: () => any;
 };
 
 const getModuleContext = R.path(["module", "context"]);
@@ -30,7 +29,7 @@ const getModuleContext = R.path(["module", "context"]);
 const getContexts = R.compose(
   R.map((action) => {
     const item = getModuleContext(action);
-    item.pluginId = action.name;
+    item["pluginId"] = action.name;
 
     return item;
   }),
@@ -47,10 +46,10 @@ const useSubscribeToActionProviders = () => {
   }, [actionContext]);
 
   const subscriptions = getContexts(actionContext.actions).map((context) => {
-    const subscription = React.useContext<Subscription>(context);
+    const subscription = React.useContext<{}>(context);
 
     if (subscription) {
-      subscription.pluginId = context.pluginId;
+      subscription["pluginId"] = context.pluginId;
 
       return subscription;
     } else {

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

@@ -1,13 +1,14 @@
 /* eslint-disable max-len */
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
 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 { waitFor, cleanup, renderHook } from "@testing-library/react-native";
 import nock from "nock";
+import * as R from "ramda";
 import React from "react";
-import { mergeDeepRight } from "ramda";
+import { Provider } from "react-redux";
+import configureStore from "redux-mock-store";
 import * as helpers from "../../../helpers";
-import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
-
 import {
   noTargetScreenError,
   resolveError,
@@ -23,7 +24,6 @@ const rivers: Record<string, Partial<ZappRiver>> = {
     home: true,
   },
   B0987: {
-    type: "any",
     id: "B0987",
   },
   C5678: {
@@ -42,7 +42,7 @@ const contentTypes: ZappContentTypes = {
 const endpoint = "http://feed.com";
 
 const pipesEndpoints: ZappPipesEndpoints = {
-  [endpoint]: {
+  [`${endpoint}`]: {
     context_keys: [],
     context_obj: [],
   },
@@ -55,6 +55,7 @@ const navigator = {
   goHome: jest.fn(),
 } as any;
 
+const mockStore = configureStore();
 jest.spyOn(useNavigationHooks, "useNavigation").mockReturnValue(navigator);
 
 const helperSpy = jest.spyOn(helpers, "handlePresentNavigation");
@@ -79,17 +80,31 @@ jest.mock("../../../logger", () => ({
 // to use import instead of require it's required to use jest.mock above
 const { useOpenSchemeHandler } = require("../useOpenSchemeHandler");
 
-const mockStoreObj = { rivers, contentTypes, pipesEndpoints, appData };
+const getWrapper = (storeProps = {}) => {
+  const store = mockStore(
+    R.mergeDeepRight(
+      { rivers, contentTypes, pipesEndpoints, appData },
+      storeProps
+    )
+  );
+
+  appStore.set(store);
+
+  const Wrapper = ({ children }: { children: React.ReactChild }) => (
+    /* @ts-ignore */
+    <Provider store={store}>{children}</Provider>
+  );
+
+  return Wrapper;
+};
+
+const testHook = async ({ url, query, storeProps = {}, tests }) => {
+  const wrapper = getWrapper(storeProps);
 
-const testHook = async ({ url, query, storeProps = {}, tests }: any) => {
   const callback = jest.fn((fn) => fn(tests));
 
   renderHook(() => useOpenSchemeHandler({ url, query, onFinish: callback }), {
-    wrapper: ({ children }) => (
-      <WrappedWithProviders store={mergeDeepRight(mockStoreObj, storeProps)}>
-        {children}
-      </WrappedWithProviders>
-    ),
+    wrapper,
   });
 
   await waitFor(() => expect(callback).toHaveBeenCalled());

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

@@ -1,14 +1,11 @@
-import * as R from "ramda";
 import axios from "axios";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook, waitFor } from "@testing-library/react-native";
 import { sessionStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/SessionStorage";
 import * as helpers from "../../../helpers";
 import * as feedLoader from "@applicaster/zapp-react-native-utils/reactHooks/feed/useFeedLoader";
 import { WrappedWithProviders } from "@applicaster/zapp-react-native-utils/testUtils";
 import { usePresentSchemeHandler } from "../usePresentSchemeHandler";
 
-import configureStore from "redux-mock-store";
-
 const rivers = {
   A1234: {
     id: "A1234",
@@ -28,8 +25,6 @@ jest.mock(
   })
 );
 
-const mockStore = configureStore();
-
 const helperSpy = jest.spyOn(helpers, "handlePresentNavigation");
 const feedLoaderSpy = jest.spyOn(feedLoader, "useFeedLoader");
 
@@ -179,46 +174,88 @@ describe("usePresentSchemeHandler", () => {
   });
 
   describe("loading new river", () => {
-    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 query = { rivers_configuration_id: "layout-uuid" };
 
-      const query = {
-        rivers_configuration_id: "test",
-      };
+    const baseSessionData = {
+      accountsAccountId: "account-123",
+      bundleIdentifier: "com.example.app",
+      app_family_id: "42",
+      version_name: "1.0.0",
+    };
 
-      const storageSpy = jest.spyOn(sessionStorage, "getAllItems");
-      const axiosGetSpy = jest.spyOn(axios, "get");
+    let storageSpy: jest.SpyInstance;
+    let axiosGetSpy: jest.SpyInstance;
 
-      const getAllItems = jest.fn().mockResolvedValue({
-        accountsAccountId: "accountsAccountId",
-        bundleIdentifier: "bundleIdentifier",
-        app_family_id: "app_family_id",
-        version_name: "version_name",
-        store: "store",
-      });
+    beforeEach(() => {
+      storageSpy = jest.spyOn(sessionStorage, "getAllItems");
+      axiosGetSpy = jest.spyOn(axios, "get");
+      axiosGetSpy.mockResolvedValue({ data: {} });
+    });
 
-      const get = jest.fn().mockResolvedValue({ data: "url" });
+    afterEach(() => {
+      storageSpy.mockRestore();
+      axiosGetSpy.mockRestore();
+    });
 
-      storageSpy.mockImplementation(getAllItems);
-      axiosGetSpy.mockImplementation(get);
+    it("fetches the rivers, cell styles and presets mapping URLs", async () => {
+      storageSpy.mockResolvedValue({ ...baseSessionData, store: "store" });
 
       renderHook(() => usePresentSchemeHandler({ query, url: "", onFinish }), {
-        wrapper,
+        wrapper: WrappedWithProviders,
       });
 
-      return () => {
-        const actions = store.getActions();
-
-        expect(
-          actions?.find(R.propEq("type", "SET_APP_NOT_READY"))
-        ).toBeDefined();
+      await waitFor(() => {
+        expect(axiosGetSpy).toHaveBeenCalledWith(
+          expect.stringContaining("/layouts/layout-uuid.json")
+        );
+      });
+    });
 
-        expect(actions?.find(R.propEq("type", "SET_APP_READY"))).toBeDefined();
+    describe("WEB_STORE_PLATFORM CDN store key mapping", () => {
+      it.each([
+        ["samsung", "samsung_app_store"],
+        ["lg", "lg_content_store"],
+        ["vizio", "vizio_app_store"],
+      ])(
+        'maps store="%s" to "%s" in the rivers URL',
+        async (store, expectedCdnKey) => {
+          storageSpy.mockResolvedValue({ ...baseSessionData, store });
+
+          renderHook(
+            () => usePresentSchemeHandler({ query, url: "", onFinish }),
+            { wrapper: WrappedWithProviders }
+          );
+
+          await waitFor(() => {
+            expect(axiosGetSpy).toHaveBeenCalledWith(
+              expect.stringContaining(`/${expectedCdnKey}/`)
+            );
+          });
+
+          // Confirm the raw store name is NOT used in the URL
+          expect(axiosGetSpy).not.toHaveBeenCalledWith(
+            expect.stringContaining(`/${store}/`)
+          );
+        }
+      );
 
-        expect(navigator.replace).toBeCalledWith({});
-      };
+      it("passes through an unmapped store value unchanged", async () => {
+        storageSpy.mockResolvedValue({
+          ...baseSessionData,
+          store: "apple_tv",
+        });
+
+        renderHook(
+          () => usePresentSchemeHandler({ query, url: "", onFinish }),
+          { wrapper: WrappedWithProviders }
+        );
+
+        await waitFor(() => {
+          expect(axiosGetSpy).toHaveBeenCalledWith(
+            expect.stringContaining("/apple_tv/")
+          );
+        });
+      });
     });
   });
 

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

@@ -1,35 +1,11 @@
 import * as React from "react";
-import { renderHook } from "@testing-library/react-native";
+import { renderHook } from "@testing-library/react-hooks";
 import * as URLHandlersMap from "..";
 
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 
 import { log_warning } from "../../../logger";
-import { handleActionSchemeUrl } from "../useUrlSchemeHandler";
-import { appStore } from "../../../../../../zapp-react-native-redux/AppStore";
-
-type UrlSchemeHandlerArgs = {
-  query: Record<string, unknown>;
-  url: string;
-  onFinish?: (callback: () => void) => void;
-};
-
-type PluginType = "general" | "player";
-
-interface ZappPlugin {
-  urlScheme?: {
-    host: string;
-    handler: (args: UrlSchemeHandlerArgs) => void;
-  };
-}
-
-interface QuickBrickPlugin {
-  module: ZappPlugin;
-  name: string;
-  identifier: string;
-  type: PluginType;
-}
 
 const mockStore = configureStore();
 
@@ -38,222 +14,153 @@ jest.mock("../../../logger", () => ({
   log_warning: jest.fn(),
 }));
 
-const mockHandler = jest.fn(({ onFinish }) => {
-  onFinish?.(() => {});
-});
-
-const mockComplexHandler = jest.fn(({ onFinish }) => {
-  onFinish?.(() => {});
-});
-
-const lambdaPlugin: QuickBrickPlugin = {
-  module: {} as ZappPlugin,
+const lambdaPlugin = {
+  module: jest.fn() as ZappPlugin,
   name: "Lambda plugin",
   identifier: "someplugin",
-  type: "general",
+  type: "general" as PluginType,
 };
 
-const pluginWithHandler: QuickBrickPlugin = {
+const pluginWithHandler = {
   name: "Plugin handling scheme",
   identifier: "plugin-with-handler",
-  type: "general",
+  type: "general" as PluginType,
   module: {
     urlScheme: {
       host: "foo",
-      handler: mockHandler,
-    },
-  },
-};
-
-const pluginWithComplexHandler: QuickBrickPlugin = {
-  name: "Plugin with nested handler",
-  identifier: "plugin-with-nested-handler",
-  type: "general",
-  module: {
-    urlScheme: {
-      host: "complex",
-      handler: mockComplexHandler,
+      handler: jest.fn(({ onFinish }) => {
+        onFinish(() => {});
+      }),
     },
-  },
+  } as ZappPlugin,
 };
 
-const plugins = [lambdaPlugin, pluginWithHandler, pluginWithComplexHandler];
+const plugins: QuickBrickPlugin[] = [lambdaPlugin, pluginWithHandler];
 
 const { useUrlSchemeHandler } = require("../useUrlSchemeHandler");
 
 describe("useUrlSchemeHandler", () => {
-  const store = mockStore({ plugins });
+  // beforeEach(() => {
+  //   log_warning.mockClear();
+  // });
 
-  appStore.set(store);
+  const store = mockStore({ test: "test", plugins });
 
-  const wrapper: React.FC = ({ children }) => (
+  const wrapper: React.FC<any> = ({ children }) => (
     <Provider store={store}>{children}</Provider>
   );
 
-  beforeEach(() => {
-    jest.clearAllMocks();
+  it("calls correct urlScheme handler with query params", () => {
+    const presentSpy = jest.fn();
+    const onFinish = jest.fn();
+    const url = "test://present?foo=bar";
 
-    Object.keys(URLHandlersMap.schemeHandlerHooks).forEach((key) => {
-      delete (URLHandlersMap.schemeHandlerHooks as any)[key];
-    });
+    URLHandlersMap.schemeHandlerHooks.present = presentSpy;
+
+    renderHook(
+      () =>
+        useUrlSchemeHandler({
+          url,
+          onFinish,
+        }),
+      { wrapper }
+    );
+
+    expect(presentSpy).toBeCalledWith({ query: { foo: "bar" }, url, onFinish });
   });
 
-  describe("Basic URL scheme handling", () => {
-    it("handles query params correctly", () => {
-      const testHandler = jest.fn();
-      (URLHandlersMap.schemeHandlerHooks as any).test = testHandler;
-      const testUrl = "test://test?foo=bar";
-
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish: jest.fn(),
-          }),
-        { wrapper }
-      );
-
-      expect(testHandler).toBeCalledWith({
-        query: { foo: "bar" },
-        url: testUrl,
-        onFinish: expect.any(Function),
-      });
+  it("not throws an error and calls onFinish if correct url scheme handler can not be found", () => {
+    const url = "test://nonExistingHost?foo=bar";
+
+    const onFinish = jest.fn((cb) => {
+      cb();
     });
 
-    it("handles missing scheme handlers gracefully", () => {
-      const testUrl = "test://unknown?foo=bar";
-      const finishCallback = jest.fn();
+    renderHook(
+      () =>
+        useUrlSchemeHandler({
+          url,
+          onFinish,
+        }),
+      { wrapper }
+    );
 
-      const onFinish = jest.fn((cb) => {
-        cb();
-        finishCallback();
-      });
+    expect(onFinish).toBeCalled();
 
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish,
-          }),
-        { wrapper }
-      );
+    expect(log_warning).toHaveBeenCalledWith(
+      `unable to resolve ${url}: Non of the installed plugins knows how to handle this urlScheme ${url}`
+    );
+  });
 
-      expect(finishCallback).toBeCalled();
+  it("calls onFinish when the handler does", () => {
+    const url = "test://present?foo=bar";
+    const onFinish = jest.fn();
 
-      expect(log_warning).toBeCalledWith(expect.stringContaining(testUrl));
+    const presentSpy = jest.fn(() => {
+      onFinish();
     });
+
+    URLHandlersMap.schemeHandlerHooks.present = presentSpy;
+
+    renderHook(
+      () =>
+        useUrlSchemeHandler({
+          url,
+          onFinish,
+        }),
+      { wrapper }
+    );
+
+    expect(onFinish).toBeCalled();
   });
 
-  describe("Plugin-based scheme handling", () => {
-    it("resolves and calls plugin handlers", () => {
-      const testUrl = "test://foo?param=test";
-      const onFinish = jest.fn();
-
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish,
-          }),
-        { wrapper }
-      );
-
-      expect(mockHandler).toBeCalledWith({
-        query: { param: "test" },
-        url: testUrl,
-        onFinish,
-      });
-    });
+  it("calls onFinish if handler returns an error", () => {
+    const url = "test://present?foo=bar";
 
-    it("handles complex plugin configurations", () => {
-      const testUrl = "test://complex?param=nested";
-      const onFinish = jest.fn();
-
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish,
-          }),
-        { wrapper }
-      );
-
-      expect(mockComplexHandler).toBeCalledWith({
-        query: { param: "nested" },
-        url: testUrl,
-        onFinish,
-      });
+    const onFinish = jest.fn((cb) => {
+      cb();
     });
 
-    it("ignores plugins without urlScheme", () => {
-      const testUrl = "test://nonexistent?param=value";
-      const finishCallback = jest.fn();
-
-      const onFinish = jest.fn((cb) => {
-        cb();
-        finishCallback();
-      });
-
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish,
-          }),
-        { wrapper }
-      );
-
-      expect(lambdaPlugin.module).not.toHaveProperty("urlScheme");
-      expect(finishCallback).toBeCalled();
+    const presentSpy = jest.fn(() => {
+      throw new Error("error");
     });
-  });
 
-  describe("Action scheme handling", () => {
-    it("handles action schemes using plugins", () => {
-      const testUrl = "test://foo?action=test";
+    URLHandlersMap.schemeHandlerHooks.present = presentSpy;
 
-      handleActionSchemeUrl({
-        url: testUrl,
-        plugins,
-      } as any);
+    renderHook(
+      () =>
+        useUrlSchemeHandler({
+          url,
+          onFinish,
+        }),
+      { wrapper }
+    );
 
-      expect(mockHandler).toBeCalledWith({
-        query: { action: "test" },
-        url: testUrl,
-      });
-    });
+    expect(onFinish).toBeCalled();
 
-    it("throws for unknown action schemes", () => {
-      const testUrl = "test://unknown?action=test";
+    expect(log_warning).toHaveBeenCalledWith(`unable to resolve ${url}: error`);
+  });
+
+  it("finds the plugin for the host", () => {
+    const url = "scheme://foo?whatever=bar";
 
-      expect(() => {
-        handleActionSchemeUrl({
-          url: testUrl,
-          plugins,
-        } as any);
-      }).toThrow(/Non of the installed plugins/);
+    const onFinish = jest.fn((cb) => {
+      cb();
     });
 
-    it("handles malformed URLs gracefully", () => {
-      const testUrl = "invalid-url";
-      const finishCallback = jest.fn();
-
-      const onFinish = jest.fn((cb) => {
-        cb();
-        finishCallback();
-      });
-
-      renderHook(
-        () =>
-          useUrlSchemeHandler({
-            url: testUrl,
-            onFinish,
-          }),
-        { wrapper }
-      );
-
-      expect(log_warning).toBeCalled();
-      expect(finishCallback).toBeCalled();
+    renderHook(
+      () => {
+        useUrlSchemeHandler({ url, onFinish });
+      },
+      { wrapper }
+    );
+
+    expect(pluginWithHandler.module.urlScheme.handler).toBeCalledWith({
+      url,
+      onFinish,
+      query: { whatever: "bar" },
     });
+
+    expect(onFinish).toBeCalled();
   });
 });

package/App/DeepLinking/URLSchemeHandler/SchemeHandlerHooks/useOpenSchemeHandler/index.ts

@@ -1,4 +1,8 @@
-import { useContentTypes } from "@applicaster/zapp-react-native-redux";
+import {
+  useAppSelector,
+  selectContentTypes,
+  selectRivers,
+} from "@applicaster/zapp-react-native-redux";
 import { ZappPipesEntryContext } from "@applicaster/zapp-react-native-ui-components/Contexts";
 import { useNavigation } from "@applicaster/zapp-react-native-utils/reactHooks/navigation";
 import { useEffect } from "react";
@@ -20,7 +24,6 @@ import {
   withInitialPlayerState,
 } from "./utils";
 import { log_warning } from "../../../logger";
-import { useRivers } from "@applicaster/zapp-react-native-utils/reactHooks";
 
 async function handleQuery({
   query,
@@ -98,8 +101,8 @@ async function handleQuery({
 }
 
 export function useOpenSchemeHandler({ query, url, onFinish }) {
-  const rivers = useRivers();
-  const contentTypes = useContentTypes();
+  const rivers = useAppSelector(selectRivers);
+  const contentTypes = useAppSelector(selectContentTypes);
   const navigator = useNavigation();
   const homeId = getHomeScreenId(rivers);
   const homeRoute = `/river/${homeId}`;