@applicaster/zapp-react-native-utils 16.0.0-rc.9 → 16.0.0-rc.91

package/modalState/__tests__/ContentViewModel.test.ts

@@ -0,0 +1,165 @@
+import { ContentViewModel } from "../ContentViewModel";
+import { loadItemsFromSource } from "../../actionsExecutor/actions/openBottomSheet";
+
+jest.mock("../../actionsExecutor/actions/openBottomSheet", () => ({
+  loadItemsFromSource: jest.fn(),
+}));
+
+describe("ContentViewModel", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should initialize with items and not fetch if itemsUrl is not provided", () => {
+    const content = {
+      title: "Test Menu",
+      items: [{ title: "Item 1" }, { title: "Item 2" }],
+    };
+
+    const viewModel = new ContentViewModel(content);
+
+    expect(viewModel.getState()).toMatchObject({
+      items: content.items,
+      isLoading: false,
+      role: undefined,
+      behavior: undefined,
+    });
+
+    expect(loadItemsFromSource).not.toHaveBeenCalled();
+  });
+
+  it("seeds role and behavior from Content", () => {
+    const viewModel = new ContentViewModel({
+      title: "Playlists",
+      items: [{ title: "A" }],
+      role: "collection_selector",
+      behavior: { selectMode: "multi", currentSelection: ["a"] },
+    });
+
+    expect(viewModel.getState().role).toBe("collection_selector");
+
+    expect(viewModel.getState().behavior).toEqual({
+      selectMode: "multi",
+      currentSelection: ["a"],
+    });
+  });
+
+  it("should trigger fetch on init if items is empty and itemsUrl is present", async () => {
+    const mockItems = [{ title: "Fetched Item" }];
+
+    (loadItemsFromSource as jest.Mock).mockResolvedValueOnce({
+      items: mockItems,
+      role: "collection_selector",
+      behavior: { selectMode: "multi", currentSelection: [] },
+    });
+
+    const content = {
+      title: "Test Menu",
+      items: [],
+      itemsUrl: "http://example.com/items",
+    };
+
+    const viewModel = new ContentViewModel(content);
+
+    // Initial state should be loading
+    expect(viewModel.getState().isLoading).toBe(true);
+
+    // Wait for the asynchronous refetch to complete
+    await new Promise(process.nextTick);
+
+    expect(loadItemsFromSource).toHaveBeenCalledWith(
+      expect.stringMatching(/^http:\/\/example\.com\/items\?_t=\d+$/)
+    );
+
+    expect(viewModel.getState()).toMatchObject({
+      items: mockItems,
+      isLoading: false,
+      role: "collection_selector",
+      behavior: { selectMode: "multi", currentSelection: [] },
+    });
+  });
+
+  it("updates role and behavior on refetch", async () => {
+    (loadItemsFromSource as jest.Mock)
+      .mockResolvedValueOnce({
+        items: [{ title: "First" }],
+        role: "collection_selector",
+        behavior: { selectMode: "multi", currentSelection: [] },
+      })
+      .mockResolvedValueOnce({
+        items: [{ title: "Second", isSelected: true }],
+        role: "collection_selector",
+        behavior: { selectMode: "multi", currentSelection: ["2"] },
+      });
+
+    const viewModel = new ContentViewModel({
+      title: "Test Menu",
+      items: [],
+      itemsUrl: "http://example.com/items",
+    });
+
+    await new Promise(process.nextTick);
+
+    await viewModel.refetch();
+
+    expect(viewModel.getState().items[0].title).toBe("Second");
+    expect(viewModel.getState().behavior?.currentSelection).toEqual(["2"]);
+    expect(viewModel.getState().role).toBe("collection_selector");
+  });
+
+  it("should notify subscribers of state changes", async () => {
+    const mockItems = [{ title: "Fetched Item" }];
+
+    (loadItemsFromSource as jest.Mock).mockResolvedValue({
+      items: mockItems,
+    });
+
+    const content = {
+      title: "Test Menu",
+      items: [],
+      itemsUrl: "http://example.com/items",
+    };
+
+    const viewModel = new ContentViewModel(content);
+
+    // Wait for constructor's refetch to finish
+    await new Promise(process.nextTick);
+
+    const listener = jest.fn();
+    const unsubscribe = viewModel.subscribe(listener);
+
+    await viewModel.refetch();
+
+    expect(listener).toHaveBeenCalled();
+    expect(viewModel.getState().items).toEqual(mockItems);
+
+    unsubscribe();
+    listener.mockClear();
+
+    await viewModel.refetch();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("should handle error states during fetching", async () => {
+    const error = new Error("Network Error");
+    (loadItemsFromSource as jest.Mock).mockRejectedValueOnce(error);
+
+    const content = {
+      title: "Test Menu",
+      items: [],
+      itemsUrl: "http://example.com/items",
+    };
+
+    const viewModel = new ContentViewModel(content);
+
+    await new Promise(process.nextTick);
+
+    expect(viewModel.getState()).toMatchObject({
+      items: [],
+      isLoading: false,
+      error: "Network Error",
+      role: undefined,
+      behavior: undefined,
+    });
+  });
+});

package/modalState/__tests__/EditableCollectionRegistry.test.ts

@@ -0,0 +1,112 @@
+import {
+  EditableCollectionRegistry,
+  resolveEditableCollection,
+} from "../EditableCollectionRegistry";
+import { RemoteEditableCollection } from "../RemoteEditableCollection";
+import { EditableCollection } from "../EditableCollection";
+import { BehaviorSubject } from "rxjs";
+import type { Content, MenuItem } from "../types";
+
+function fakeCollection(): EditableCollection {
+  return {
+    items$: new BehaviorSubject<MenuItem[]>([]).asObservable(),
+    operations: [],
+  };
+}
+
+const refetch = jest.fn().mockResolvedValue(undefined);
+
+describe("EditableCollectionRegistry", () => {
+  beforeEach(() => {
+    // reset the static registry between tests
+    (EditableCollectionRegistry as any).providers = {};
+    jest.clearAllMocks();
+  });
+
+  it("registers and resolves a provider factory (new instance per call)", () => {
+    const instance = fakeCollection();
+    const factory = jest.fn(() => instance);
+    EditableCollectionRegistry.register("@{provider/x}", factory);
+
+    const resolved = EditableCollectionRegistry.getProvider("@{provider/x}");
+
+    expect(resolved).toBe(instance);
+    expect(factory).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns null for an unknown provider token", () => {
+    expect(EditableCollectionRegistry.getProvider("@{provider/missing}")).toBe(
+      null
+    );
+  });
+});
+
+describe("resolveEditableCollection", () => {
+  beforeEach(() => {
+    (EditableCollectionRegistry as any).providers = {};
+    jest.clearAllMocks();
+  });
+
+  it("returns null when there are no dynamicCollection options", () => {
+    const content = { items: [] } as unknown as Content;
+
+    expect(resolveEditableCollection(content, refetch)).toBe(null);
+  });
+
+  it("resolves a local provider by token", () => {
+    const instance = fakeCollection();
+    EditableCollectionRegistry.register("@{provider/queue}", () => instance);
+
+    const content = {
+      items: [],
+      dynamicCollection: {
+        operations: ["remove"],
+        provider: "@{provider/queue}",
+      },
+    } as unknown as Content;
+
+    expect(resolveEditableCollection(content, refetch)).toBe(instance);
+  });
+
+  it("returns null (and does not throw) for an unregistered provider token", () => {
+    const content = {
+      items: [],
+      dynamicCollection: {
+        operations: ["remove"],
+        provider: "@{provider/unregistered}",
+      },
+    } as unknown as Content;
+
+    expect(resolveEditableCollection(content, refetch)).toBe(null);
+  });
+
+  it("builds a RemoteEditableCollection when a postUrl is present", () => {
+    const content = {
+      items: [],
+      dynamicCollection: {
+        operations: ["remove"],
+        postUrl: "https://x/cloud-events",
+      },
+    } as unknown as Content;
+
+    expect(resolveEditableCollection(content, refetch)).toBeInstanceOf(
+      RemoteEditableCollection
+    );
+  });
+
+  it("prefers a provider token over postUrl", () => {
+    const instance = fakeCollection();
+    EditableCollectionRegistry.register("@{provider/queue}", () => instance);
+
+    const content = {
+      items: [],
+      dynamicCollection: {
+        operations: ["remove"],
+        provider: "@{provider/queue}",
+        postUrl: "https://x/cloud-events",
+      },
+    } as unknown as Content;
+
+    expect(resolveEditableCollection(content, refetch)).toBe(instance);
+  });
+});

package/modalState/__tests__/ModalOrchestrator.phase3.test.ts

@@ -0,0 +1,47 @@
+import { modalOrchestrator } from "../ModalOrchestrator";
+import { modalStore } from "../store";
+
+describe("ModalOrchestrator phase 3", () => {
+  beforeEach(() => {
+    modalOrchestrator.close();
+    modalStore.getState().dismissModal();
+  });
+
+  it("does not forward styleVariant", () => {
+    modalOrchestrator.open({
+      content: {
+        title: "Playlists",
+        items: [{ title: "Favorites" }],
+        role: "collection_selector",
+        behavior: { selectMode: "multi", currentSelection: [] },
+      },
+    });
+
+    const props = (modalStore.getState().modalState.screen as any)
+      ?.modalBottomSheetContentProps;
+
+    expect(props.styleVariant).toBeUndefined();
+    expect(props.viewModel).toBeDefined();
+    expect(props.viewModel.getState().role).toBe("collection_selector");
+    expect(props.title).toBe("Playlists");
+  });
+
+  it("forwards header title and subtitle as summary", () => {
+    modalOrchestrator.open({
+      header: {
+        title: "Sleep Timer",
+        subtitle: "remaining",
+      },
+      content: {
+        title: "Sleep Timer",
+        items: [{ id: "5", title: "5 minutes" }],
+      },
+    });
+
+    const props = (modalStore.getState().modalState.screen as any)
+      ?.modalBottomSheetContentProps;
+
+    expect(props.title).toBe("Sleep Timer");
+    expect(props.summary).toBe("remaining");
+  });
+});