@applicaster/zapp-react-native-utils 16.0.0-rc.7 → 16.0.0-rc.8

package/appUtils/playerManager/__tests__/playerFactory.test.ts

@@ -0,0 +1,150 @@
+const mockAppStoreGet = jest.fn();
+const mockFindPluginByIdentifier = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: { get: (key: string) => mockAppStoreGet(key) },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
+  findPluginByIdentifier: (id: string, plugins: any) =>
+    mockFindPluginByIdentifier(id, plugins),
+}));
+
+import { PlayerRole } from "../conts";
+import { playerFactory } from "../playerFactory";
+
+const fakeComponent = () => null;
+
+class FakeController {
+  receivedConfig: any;
+  constructor(config: any) {
+    this.receivedConfig = config;
+  }
+}
+
+const baseConfig = {
+  player: {},
+  playerId: "p1",
+  autoplay: false,
+  entry: { id: "entry-1" } as any,
+  muted: false,
+  playerPluginId: "test-plugin",
+  screenConfig: { foo: "bar" },
+  playerRole: PlayerRole.Cell,
+};
+
+const installPluginWithProtocol = (
+  protocolReturn: any | ((screenConfig: any, entry: any) => any)
+) => {
+  const playerProtocol =
+    typeof protocolReturn === "function"
+      ? protocolReturn
+      : () => protocolReturn;
+
+  mockAppStoreGet.mockImplementation((key: string) =>
+    key === "plugins" ? { "test-plugin": {} } : null
+  );
+
+  mockFindPluginByIdentifier.mockReturnValue({
+    module: { playerProtocol },
+  });
+};
+
+describe("playerFactory", () => {
+  beforeEach(() => {
+    mockAppStoreGet.mockReset();
+    mockFindPluginByIdentifier.mockReset();
+  });
+
+  it("resolves with controller and Component when playerProtocol returns synchronously", async () => {
+    installPluginWithProtocol({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    });
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+
+    expect((item?.controller as FakeController).receivedConfig).toBe(
+      baseConfig
+    );
+  });
+
+  it("resolves with controller and Component when playerProtocol returns a Promise (delayed import)", async () => {
+    installPluginWithProtocol(async () => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    const item = await playerFactory(baseConfig);
+
+    expect(item).not.toBeNull();
+    expect(item?.Component).toBe(fakeComponent);
+    expect(item?.controller).toBeInstanceOf(FakeController);
+  });
+
+  it("passes screenConfig and entry through to playerProtocol", async () => {
+    const playerProtocol = jest.fn(() => ({
+      Component: fakeComponent,
+      controllerClass: FakeController,
+    }));
+
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: { playerProtocol } });
+
+    await playerFactory(baseConfig);
+
+    expect(playerProtocol).toHaveBeenCalledWith(
+      baseConfig.screenConfig,
+      baseConfig.entry
+    );
+  });
+
+  it("resolves to null when playerPluginId is missing", async () => {
+    expect(
+      await playerFactory({ ...baseConfig, playerPluginId: "" } as any)
+    ).toBeNull();
+  });
+
+  it("resolves to null when appStore has no plugins", async () => {
+    mockAppStoreGet.mockReturnValue(null);
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when the plugin has no playerProtocol", async () => {
+    mockAppStoreGet.mockImplementation((key: string) =>
+      key === "plugins" ? { "test-plugin": {} } : null
+    );
+
+    mockFindPluginByIdentifier.mockReturnValue({ module: {} });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a Component", async () => {
+    installPluginWithProtocol({ controllerClass: FakeController });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("resolves to null when playerProtocol returns without a controllerClass", async () => {
+    installPluginWithProtocol({ Component: fakeComponent });
+
+    expect(await playerFactory(baseConfig)).toBeNull();
+  });
+
+  it("rejects when playerProtocol throws synchronously", async () => {
+    installPluginWithProtocol(() => {
+      throw new Error("boom");
+    });
+
+    await expect(playerFactory(baseConfig)).rejects.toThrow("boom");
+  });
+});

package/appUtils/playerManager/playerFactory.ts

@@ -19,52 +19,35 @@ type PlayerFactoryProps = {
   playerRole: PlayerRole;
 };
 
-interface PlayerConstructor {
+interface PlayerControllerConstructor {
   new (params: any): Player;
 }
 
-export const playerFactory = (
-  config: PlayerFactoryProps
-): PlayerFactoryItem | null => {
-  const IDENTIFIER = config?.playerPluginId;
+type PlayerProtocol = {
+  Component: any;
+  controllerClass: PlayerControllerConstructor;
+};
 
-  if (!IDENTIFIER) {
-    return null;
-  }
+export const playerFactory = async (
+  config: PlayerFactoryProps
+): Promise<PlayerFactoryItem | null> => {
+  if (!config?.playerPluginId) return null;
 
   const plugins = appStore.get("plugins");
+  if (!plugins) return null;
 
-  if (!plugins) {
-    return null;
-  }
-
-  const playerPlugin = findPluginByIdentifier(IDENTIFIER, plugins);
+  const playerPlugin = findPluginByIdentifier(config.playerPluginId, plugins);
+  if (!playerPlugin?.module?.playerProtocol) return null;
 
-  if (!playerPlugin?.module?.playerProtocol) {
-    return null;
-  }
-
-  const playerProtocol: PlayerConstructor = playerPlugin.module.playerProtocol(
-    config?.screenConfig,
-    config?.entry
-  );
+  const playerProtocol: PlayerProtocol | null =
+    await playerPlugin.module.playerProtocol(config.screenConfig, config.entry);
 
-  const playerView = (playerProtocol as any)?.Component || null;
-
-  if (!playerView) {
+  if (!playerProtocol?.Component || !playerProtocol.controllerClass) {
     return null;
   }
 
-  const Controller = (playerProtocol as any)?.controllerClass || null;
-
-  if (Controller === null) {
-    return null;
-  }
-
-  const controller = new Controller(config);
-
   return {
-    controller,
-    Component: playerView,
+    controller: new playerProtocol.controllerClass(config),
+    Component: playerProtocol.Component,
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-rc.7",
+  "version": "16.0.0-rc.8",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-rc.7",
+    "@applicaster/applicaster-types": "16.0.0-rc.8",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",