@applicaster/zapp-react-native-utils 16.0.0-alpha.5439705823 → 16.0.0-alpha.5548956531

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

package/modalState/__tests__/RemoteEditableCollection.test.ts

@@ -0,0 +1,259 @@
+import { RemoteEditableCollection } from "../RemoteEditableCollection";
+import { actionExecutor } from "../../actionsExecutor/ActionExecutor";
+import type { Content, MenuItem } from "../types";
+
+jest.mock("../../actionsExecutor/ActionExecutor", () => ({
+  actionExecutor: { handleAction: jest.fn() },
+  ActionResult: { Success: "success", Error: "error" },
+}));
+
+const handleAction = actionExecutor.handleAction as jest.Mock;
+
+/**
+ * BehaviorSubject emits its current value synchronously on subscribe, so this
+ * returns the latest items snapshot.
+ */
+function currentItems(col: RemoteEditableCollection): MenuItem[] {
+  let items: MenuItem[] = [];
+  const sub = col.items$.subscribe((i) => (items = i));
+  sub.unsubscribe();
+
+  return items;
+}
+
+const removeAction = { type: "sendCloudEvent", options: { foo: "bar" } };
+
+const itemWithRemove: MenuItem = {
+  id: "1",
+  title: "A",
+  entryActions: [{ button: { alias: "remove_item" }, actions: [removeAction] }],
+};
+
+const itemPlain: MenuItem = { id: "2", title: "B" };
+
+function makeCollection(
+  items: MenuItem[],
+  refetch = jest.fn().mockResolvedValue(undefined),
+  operations = ["remove", "reorder"]
+) {
+  const content = {
+    items,
+    dynamicCollection: { operations, postUrl: "https://x/cloud-events" },
+  } as unknown as Content;
+
+  return { col: new RemoteEditableCollection(content, refetch), refetch };
+}
+
+describe("RemoteEditableCollection", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("exposes the declared operations and initial items", () => {
+    const { col } = makeCollection([itemWithRemove, itemPlain]);
+
+    expect(col.operations).toEqual(["remove", "reorder"]);
+    expect(currentItems(col)).toEqual([itemWithRemove, itemPlain]);
+  });
+
+  describe("remove", () => {
+    it("optimistically removes, dispatches the aliased action, then refetches", async () => {
+      handleAction.mockResolvedValue("success");
+      const { col, refetch } = makeCollection([itemWithRemove, itemPlain]);
+
+      await col.remove(0);
+
+      expect(handleAction).toHaveBeenCalledWith(removeAction, {
+        entry: itemWithRemove,
+      });
+
+      expect(refetch).toHaveBeenCalledTimes(1);
+      expect(currentItems(col)).toEqual([itemPlain]);
+    });
+
+    it("rolls back to the snapshot when the action dispatch fails", async () => {
+      handleAction.mockRejectedValue(new Error("network"));
+      const { col, refetch } = makeCollection([itemWithRemove, itemPlain]);
+
+      await col.remove(0);
+
+      // optimistic removal reverted
+      expect(currentItems(col)).toEqual([itemWithRemove, itemPlain]);
+      // refetch never reached on failure
+      expect(refetch).not.toHaveBeenCalled();
+    });
+
+    it("lets the refetched server result replace the optimistic list", async () => {
+      handleAction.mockResolvedValue("success");
+      const serverItems: MenuItem[] = [{ id: "99", title: "server truth" }];
+
+      const refetch = jest.fn();
+      const { col } = makeCollection([itemWithRemove, itemPlain], refetch);
+
+      // Emulate ContentViewModel.refetch pushing authoritative items via sync()
+      refetch.mockImplementation(async () => {
+        col.sync(serverItems);
+      });
+
+      await col.remove(0);
+
+      expect(currentItems(col)).toEqual(serverItems);
+    });
+
+    it("is a no-op for an out-of-range index", async () => {
+      const { col, refetch } = makeCollection([itemWithRemove]);
+
+      await col.remove(5);
+
+      expect(handleAction).not.toHaveBeenCalled();
+      expect(refetch).not.toHaveBeenCalled();
+      expect(currentItems(col)).toEqual([itemWithRemove]);
+    });
+
+    it("skips dispatch (no throw) when no matching alias exists", async () => {
+      const { col, refetch } = makeCollection([itemPlain, itemWithRemove]);
+
+      await col.remove(0); // itemPlain has no entryActions
+
+      expect(handleAction).not.toHaveBeenCalled();
+      // still optimistic-removes and refetches (server is source of truth)
+      expect(refetch).toHaveBeenCalledTimes(1);
+      expect(currentItems(col)).toEqual([itemWithRemove]);
+    });
+  });
+
+  describe("move", () => {
+    it("optimistically reorders and dispatches reorder_item with itemIds", async () => {
+      handleAction.mockResolvedValue("success");
+
+      const itemA: MenuItem = {
+        id: "2",
+        title: "B",
+        entryActions: [
+          { button: { alias: "reorder_item" }, actions: [removeAction] },
+        ],
+      };
+
+      const moved: MenuItem = {
+        id: "3",
+        title: "C",
+        entryActions: [
+          { button: { alias: "reorder_item" }, actions: [removeAction] },
+        ],
+      };
+
+      const { col, refetch } = makeCollection([moved, itemA]);
+
+      await col.move(["2", "3"]);
+
+      expect(currentItems(col)).toEqual([itemA, moved]);
+
+      expect(handleAction).toHaveBeenCalledWith(
+        {
+          ...removeAction,
+          options: {
+            ...removeAction.options,
+            itemIds: ["2", "3"],
+            data: {
+              ...removeAction.options?.data,
+              itemIds: ["2", "3"],
+            },
+          },
+        },
+        { entry: itemA }
+      );
+
+      expect(refetch).toHaveBeenCalledTimes(1);
+    });
+
+    it("rolls back on failure", async () => {
+      handleAction.mockRejectedValue(new Error("nope"));
+
+      const itemA: MenuItem = {
+        id: "2",
+        title: "B",
+        entryActions: [
+          { button: { alias: "reorder_item" }, actions: [removeAction] },
+        ],
+      };
+
+      const moved: MenuItem = {
+        id: "3",
+        title: "C",
+        entryActions: [
+          { button: { alias: "reorder_item" }, actions: [removeAction] },
+        ],
+      };
+
+      const { col } = makeCollection([moved, itemA]);
+
+      await col.move(["2", "3"]);
+
+      expect(currentItems(col)).toEqual([moved, itemA]);
+    });
+
+    it("is a no-op for empty or non-existent IDs", async () => {
+      const { col, refetch } = makeCollection([itemWithRemove, itemPlain]);
+
+      await col.move([]);
+
+      expect(refetch).not.toHaveBeenCalled();
+      expect(currentItems(col)).toEqual([itemWithRemove, itemPlain]);
+    });
+  });
+
+  describe("sync", () => {
+    it("replaces the current items with the provided list", () => {
+      const { col } = makeCollection([itemWithRemove]);
+      const next: MenuItem[] = [{ id: "7", title: "next" }];
+
+      col.sync(next);
+
+      expect(currentItems(col)).toEqual(next);
+    });
+  });
+
+  describe("deleteCollection", () => {
+    it("optimistically clears items and calls refetch", async () => {
+      handleAction.mockResolvedValue("success");
+      const { col, refetch } = makeCollection([itemWithRemove, itemPlain]);
+
+      await col.deleteCollection();
+
+      expect(currentItems(col)).toEqual([]);
+      expect(refetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("add", () => {
+    it("dispatches actions from dynamicCollection.events.add and refetches", async () => {
+      handleAction.mockResolvedValue("success");
+
+      const addAction = {
+        type: "sendCloudEvent",
+        options: {
+          url: "https://x/cloud-events",
+          type: "com.applicaster.collection.create.v1",
+          subject: "create_collection",
+        },
+      };
+
+      const content = {
+        items: [],
+        dynamicCollection: {
+          operations: ["add"],
+          postUrl: "https://x/cloud-events",
+          events: {
+            add: [addAction],
+          },
+        },
+      } as any;
+
+      const refetch = jest.fn().mockResolvedValue(undefined);
+      const col = new RemoteEditableCollection(content, refetch);
+
+      await col.add();
+
+      expect(handleAction).toHaveBeenCalledWith(addAction);
+      expect(refetch).toHaveBeenCalledTimes(1);
+    });
+  });
+});