@applicaster/zapp-react-native-utils 16.0.0-alpha.1836140445 → 16.0.0-alpha.1852433906

package/actionsExecutor/__tests__/ActionExecutor.test.ts

@@ -0,0 +1,71 @@
+import { ActionExecutor, ActionResult } from "../ActionExecutor";
+
+jest.mock("../../logger", () => ({
+  createLogger: () => ({
+    log_error: jest.fn(),
+    log_debug: jest.fn(),
+    log_info: jest.fn(),
+  }),
+}));
+
+describe("handleActions", () => {
+  const executor = () => {
+    const ran: string[] = [];
+    const actionExecutor = new ActionExecutor();
+
+    const register = (type: string, result?: ActionResult) =>
+      actionExecutor.registerAction(type, async () => {
+        ran.push(type);
+
+        return result as ActionResult;
+      });
+
+    register("ok", ActionResult.Success);
+    register("fails", ActionResult.Error);
+    register("cancels", ActionResult.Cancel);
+    register("recover", ActionResult.Success);
+    register("after", ActionResult.Success);
+
+    return { actionExecutor, ran };
+  };
+
+  // Everything after a failed step was written for a state that never
+  // happened: the event was refused, the screen never opened.
+  it("stops when an action fails", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "fails" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["fails"]);
+    expect(result).toBe(ActionResult.Error);
+  });
+
+  it("still stops on a cancel", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "cancels" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["cancels"]);
+    expect(result).toBe(ActionResult.Cancel);
+  });
+
+  // An action nobody registered never ran, which is a misconfigured feed
+  // rather than a step that failed. It is stepped over, as it always was.
+  it("steps over an action with no handler", async () => {
+    const { actionExecutor, ran } = executor();
+
+    const result = await actionExecutor.handleActions([
+      { type: "nobody-registered-this" },
+      { type: "after" },
+    ]);
+
+    expect(ran).toEqual(["after"]);
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/__tests__/StorageActions.test.ts

@@ -0,0 +1,98 @@
+import { ActionResult } from "../ActionExecutor";
+import { localStorageToggleFlag } from "../StorageActions";
+import { TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT } from "../consts";
+import { postEvent } from "../../reactHooks/useSubscriberFor";
+
+jest.mock("../ActionExecutorContext", () => ({
+  log_error: jest.fn(),
+  log_info: jest.fn(),
+}));
+
+jest.mock("../../reactHooks/useSubscriberFor", () => ({
+  postEvent: jest.fn(),
+}));
+
+// In-memory stand-in for the storage-backed provider; the limit check under
+// test lives in storageToggleFlag, not in the provider.
+const mockStore: Record<string, string[]> = {};
+
+jest.mock("../../storage/StorageMultiSelectProvider", () => ({
+  StorageMultiSelectProvider: {
+    getProvider: (keyNamespace: string) => ({
+      getSelectedAsync: async () => [...(mockStore[keyNamespace] ?? [])],
+      addItem: async (item: string) => {
+        mockStore[keyNamespace] = [...(mockStore[keyNamespace] ?? []), item];
+      },
+      removeItem: async (item: string) => {
+        mockStore[keyNamespace] = (mockStore[keyNamespace] ?? []).filter(
+          (it) => it !== item
+        );
+      },
+    }),
+  },
+}));
+
+const KEY = "user_preferences.teams";
+
+// Entries of a team selection feed with explicit tap actions
+// (localStorageToggleFlag with key and selector).
+const teamEntry = (n: number) =>
+  ({
+    id: `team-${n}`,
+    title: `Team ${n}`,
+    type: { value: "action" },
+    extensions: { tag: `TEAM ${n}` },
+  }) as unknown as ZappEntry;
+
+const tapAction = (extraOptions = {}) =>
+  ({
+    type: "localStorageToggleFlag",
+    options: { key: KEY, selector: "extensions.tag", ...extraOptions },
+  }) as unknown as ActionType;
+
+const tapTeams = async (count: number, extraOptions = {}) => {
+  const results: ActionResult[] = [];
+
+  for (let n = 1; n <= count; n++) {
+    results.push(
+      await localStorageToggleFlag(
+        { entry: teamEntry(n) },
+        tapAction(extraOptions)
+      )
+    );
+  }
+
+  return results;
+};
+
+describe("localStorageToggleFlag max_items", () => {
+  beforeEach(() => {
+    delete mockStore[KEY];
+    jest.clearAllMocks();
+  });
+
+  it("blocks the 11th team when max_items is in the action options", async () => {
+    const results = await tapTeams(11, { max_items: "10" });
+
+    expect(results.slice(0, 10)).toEqual(Array(10).fill(ActionResult.Success));
+    expect(results[10]).toBe(ActionResult.Cancel);
+    expect(mockStore[KEY]).toHaveLength(10);
+
+    expect(postEvent).toHaveBeenCalledWith(
+      TOGGLE_FLAG_MAX_ITEMS_REACHED_EVENT,
+      [expect.objectContaining({ maxItems: "10", tag: "TEAM 11" })]
+    );
+  });
+
+  it("still lets a selected team be removed at the limit", async () => {
+    await tapTeams(10, { max_items: "10" });
+
+    const result = await localStorageToggleFlag(
+      { entry: teamEntry(1) },
+      tapAction({ max_items: "10" })
+    );
+
+    expect(result).toBe(ActionResult.Success);
+    expect(mockStore[KEY]).toHaveLength(9);
+  });
+});

package/actionsExecutor/__tests__/feedDecorator.test.ts

@@ -0,0 +1,91 @@
+import { decorateFeed } from "../feedDecorator";
+
+const preferenceFeed = (selectMode: string) =>
+  ({
+    id: "agree-component",
+    title: "I agree to the terms",
+    type: { value: "feed" },
+    extensions: {
+      role: "preference_editor",
+      preference_editor_options: {
+        key: "agree",
+        scope: "screen",
+        select_mode: selectMode,
+      },
+    },
+    entry: [
+      {
+        id: "I agree to the terms-agree",
+        title: "I agree to the terms",
+        type: { value: "action" },
+        extensions: { tag: "true" },
+      },
+    ],
+  }) as unknown as ZappFeed;
+
+describe("decorateFeed", () => {
+  it("decorates single select feeds with screenSetVariable", () => {
+    const decorated = decorateFeed(preferenceFeed("single"));
+
+    expect(decorated.extensions.behavior).toEqual(
+      expect.objectContaining({
+        select_mode: "single",
+        current_selection: "@{screen/agree}",
+      })
+    );
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenSetVariable"
+    );
+  });
+
+  it("decorates multi select feeds with screenToggleFlag", () => {
+    const decorated = decorateFeed(preferenceFeed("multi"));
+
+    expect(decorated.extensions.behavior.select_mode).toBe("multi");
+
+    expect(decorated.entry[0].extensions.tap_actions.actions[0].type).toBe(
+      "screenToggleFlag"
+    );
+  });
+
+  it("leaves a feed without the preference_editor role untouched", () => {
+    const feed = preferenceFeed("single");
+    feed.extensions.role = undefined;
+
+    const decorated = decorateFeed(feed);
+
+    expect(decorated.extensions.behavior).toBeUndefined();
+    expect(decorated.entry[0].extensions.tap_actions).toBeUndefined();
+  });
+});
+
+describe("decorateFeed max_items", () => {
+  const toggleAction = (feed: ZappFeed) =>
+    decorateFeed(feed).entry[0].extensions.tap_actions.actions[0];
+
+  it.each([
+    ["screen", "screenToggleFlag"],
+    ["session", "sessionStorageToggleFlag"],
+    ["ctx", "localStorageToggleFlag"],
+  ])("passes max_items to the %s toggle action", (scope, type) => {
+    const feed = preferenceFeed("multi");
+    feed.extensions.preference_editor_options.scope = scope;
+    feed.extensions.preference_editor_options.max_items = "10";
+
+    const toggle = toggleAction(feed);
+
+    expect(toggle.type).toBe(type);
+    expect(toggle.options).toEqual({ key: "agree", max_items: 10 });
+  });
+
+  it.each([undefined, 0, "0", "ten", -1])(
+    "does not set a limit for max_items %p",
+    (maxItems) => {
+      const feed = preferenceFeed("multi");
+      feed.extensions.preference_editor_options.max_items = maxItems;
+
+      expect(toggleAction(feed).options).toEqual({ key: "agree" });
+    }
+  );
+});

package/actionsExecutor/__tests__/screenToggleFlag.test.ts

@@ -0,0 +1,90 @@
+import { ActionExecutor, ActionResult } from "../ActionExecutor";
+import { screenToggleFlagAction } from "../actions/screenToggleFlag";
+
+jest.mock("../ActionExecutorContext", () => ({
+  log_error: jest.fn(),
+  log_info: jest.fn(),
+}));
+
+jest.mock("../StorageActions", () => ({
+  onMaxTagsReached: jest.fn(),
+}));
+
+// not used here, but it pulls the native bridge logger in at import time
+jest.mock("../../storage/ScreenSingleValueProvider", () => ({}));
+
+jest.mock("../../logger", () => ({
+  createLogger: () => ({
+    log_error: jest.fn(),
+    log_debug: jest.fn(),
+    log_info: jest.fn(),
+  }),
+}));
+
+const mockSelected: string[] = [];
+
+jest.mock("../../storage/ScreenStateMultiSelectProvider", () => ({
+  ScreenMultiSelectProvider: {
+    getProvider: () => ({
+      getSelectedAsync: async () => [...mockSelected],
+      addItem: async (item: string) => {
+        mockSelected.push(item);
+      },
+      removeItem: async (item: string) => {
+        mockSelected.splice(mockSelected.indexOf(item), 1);
+      },
+    }),
+  },
+}));
+
+const toggleAction = (options = {}) =>
+  ({
+    type: "screenToggleFlag",
+    options: { key: "teams", selector: "extensions.tag", ...options },
+  }) as unknown as ActionType;
+
+const context = (tag: string) => ({
+  screenRoute: "/screen",
+  screenStateStore: {},
+  entry: { id: tag, extensions: { tag } },
+});
+
+describe("screenToggleFlagAction at the max_items limit", () => {
+  beforeEach(() => {
+    mockSelected.length = 0;
+  });
+
+  it("returns the cancellation so the chained actions do not run", async () => {
+    const afterToggle = jest.fn();
+    const executor = new ActionExecutor();
+
+    executor.registerAction("screenToggleFlag", screenToggleFlagAction);
+
+    executor.registerAction("sendCloudEvent", async () => {
+      afterToggle();
+
+      return ActionResult.Success;
+    });
+
+    mockSelected.push("A", "B");
+
+    const result = await executor.handleActions(
+      [toggleAction({ max_items: 2 }), { type: "sendCloudEvent" }],
+      context("C") as never
+    );
+
+    expect(result).toBe(ActionResult.Cancel);
+    expect(afterToggle).not.toHaveBeenCalled();
+    expect(mockSelected).toEqual(["A", "B"]);
+  });
+
+  it("lets the chain continue below the limit", async () => {
+    const result = await screenToggleFlagAction(
+      toggleAction({ max_items: 2 }),
+      context("A") as never
+    );
+
+    expect(result).toBe(ActionResult.Success);
+    expect(mockSelected).toEqual(["A"]);
+  });
+});

package/actionsExecutor/actions/__tests__/dismissBottomSheet.test.ts

@@ -0,0 +1,25 @@
+import { dismissBottomSheetAction } from "../dismissBottomSheet";
+import { dismissModal } from "../../../modalState";
+import { ActionResult } from "../../ActionExecutor";
+
+jest.mock("../../../modalState", () => ({
+  dismissModal: jest.fn(),
+  modalOrchestrator: {
+    close: jest.fn(),
+  },
+}));
+
+describe("dismissBottomSheetAction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("calls dismissModal and returns ActionResult.Success", async () => {
+    const result = await dismissBottomSheetAction({
+      type: "dismissBottomSheet",
+    });
+
+    expect(dismissModal).toHaveBeenCalledTimes(1);
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/goBack.test.ts

@@ -0,0 +1,62 @@
+import { createGoBackAction } from "../goBack";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator(canGoBack = true) {
+  return {
+    goBack: jest.fn(),
+    canGoBack: jest.fn().mockReturnValue(canGoBack),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goBack", () => {
+  it("goes back with fallbackToHome enabled when no options are provided", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoBackAction(navigator)({ type: "goBack" });
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("forwards backToTop", async () => {
+    const navigator = createNavigator();
+
+    const action = {
+      type: "goBack",
+      options: { backToTop: true },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(true, false, true);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("goes back without falling back to home when the stack allows it", async () => {
+    const navigator = createNavigator(true);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).toHaveBeenCalledWith(false, false, false);
+    expect(result).toBe(ActionResult.Success);
+  });
+
+  it("does nothing when there is nothing to go back to and fallbackToHome is off", async () => {
+    const navigator = createNavigator(false);
+
+    const action = {
+      type: "goBack",
+      options: { fallbackToHome: false },
+    };
+
+    const result = await createGoBackAction(navigator)(action);
+
+    expect(navigator.goBack).not.toHaveBeenCalled();
+    expect(result).toBe(ActionResult.Error);
+  });
+});

package/actionsExecutor/actions/__tests__/goHome.test.ts

@@ -0,0 +1,19 @@
+import { createGoHomeAction } from "../goHome";
+import { ActionResult } from "../../ActionExecutor";
+
+function createNavigator() {
+  return {
+    goHome: jest.fn(),
+  } as unknown as QuickBrickAppNavigator;
+}
+
+describe("goHome", () => {
+  it("navigates to the home screen", async () => {
+    const navigator = createNavigator();
+
+    const result = await createGoHomeAction(navigator)({ type: "goHome" });
+
+    expect(navigator.goHome).toHaveBeenCalledWith();
+    expect(result).toBe(ActionResult.Success);
+  });
+});

package/actionsExecutor/actions/__tests__/loadItemsFromSource.test.ts

@@ -0,0 +1,88 @@
+import { loadItemsFromSource } from "../openBottomSheet";
+
+const mockCall = jest.fn();
+
+jest.mock("@applicaster/zapp-pipes-v2-client", () => ({
+  RequestBuilder: jest.fn().mockImplementation(() => ({
+    setEntryContext: jest.fn().mockReturnThis(),
+    setScreenContext: jest.fn().mockReturnThis(),
+    setUrl: jest.fn().mockReturnThis(),
+    buildAxiosRequest: jest.fn().mockResolvedValue(undefined),
+    call: (...args: any[]) => mockCall(...args),
+  })),
+  PipesClientResponseHelper: jest.fn().mockImplementation(() => ({
+    error: null,
+  })),
+}));
+
+describe("loadItemsFromSource", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns items plus role and behavior from feed.extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "a", title: "Playlist A", media_group: [] }],
+        extensions: {
+          role: "collection_selector",
+          behavior: {
+            select_mode: "multi",
+            current_selection: ["a"],
+            selector: "extensions.tag",
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.role).toBe("collection_selector");
+
+    expect(result.behavior).toEqual({
+      selectMode: "multi",
+      currentSelection: ["a"],
+      selector: "extensions.tag",
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].isSelected).toBe(true);
+    expect(result.items[0].title).toBe("Playlist A");
+  });
+
+  it("returns undefined role/behavior when feed has no extensions", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [{ id: "1", title: "Plain", media_group: [] }],
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/plain");
+
+    expect(result.role).toBeUndefined();
+    expect(result.behavior).toBeUndefined();
+    expect(result.items).toHaveLength(1);
+  });
+
+  it("preserves events in dynamic_collection_options", async () => {
+    mockCall.mockResolvedValueOnce({
+      response: {
+        entry: [],
+        extensions: {
+          dynamic_collection_options: {
+            operations: "add,remove",
+            events: {
+              add: [{ type: "showTextInput", options: {} }],
+            },
+          },
+        },
+      },
+    });
+
+    const result = await loadItemsFromSource("https://example.com/feed");
+
+    expect(result.dynamicCollection?.events).toEqual({
+      add: [{ type: "showTextInput", options: {} }],
+    });
+  });
+});