@applicaster/quick-brick-player 16.0.0-rc.9 → 16.0.0-rc.91

package/src/Player/AudioLayer/__tests__/playerActions.test.ts

@@ -0,0 +1,369 @@
+import { playerManager } from "@applicaster/zapp-react-native-utils/appUtils";
+import {
+  actionExecutor,
+  ActionResult,
+} from "@applicaster/zapp-react-native-utils/actionsExecutor/ActionExecutor";
+import { uiActionsRegistry } from "@applicaster/zapp-react-native-utils/uiActionsRegistrator";
+import { modalOrchestrator } from "@applicaster/zapp-react-native-utils/modalState/ModalOrchestrator";
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { firstValueFrom } from "rxjs";
+
+import {
+  PLAYER_ACTION_IDENTIFIERS,
+  PLAYER_ACTION_TYPES,
+  registerPlayerActions,
+} from "../playerActions";
+import { SpeedController } from "../SpeedManager";
+import { SleepTimerController } from "../SleepTimerManager";
+
+jest.mock("../../Const/sleepTimerOptions", () => ({
+  getSleepTimerOptions: (offLabel: string, sleepTimerValue: number | null) => [
+    sleepTimerValue ? { label: offLabel, value: 0 } : null,
+    { label: "5 minutes", value: 5 },
+    { label: "15 minutes", value: 15 },
+  ],
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/appUtils", () => ({
+  playerManager: {
+    getActivePlayer: jest.fn(),
+  },
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/modalState/ModalOrchestrator",
+  () => ({
+    modalOrchestrator: {
+      close: jest.fn(),
+      stackSize: 0,
+    },
+  })
+);
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+    },
+  })
+);
+
+describe("playerActions", () => {
+  const openedSheets: ActionType[] = [];
+
+  let player: {
+    getConfig: () => Record<string, string>;
+    setPlaybackRate: jest.Mock;
+    startSleepTimer: jest.Mock;
+    cancelSleepTimer: jest.Mock;
+  };
+
+  let speedController: SpeedController;
+  let sleepController: SleepTimerController;
+  let unregisterPlayerActions: () => void;
+
+  beforeEach(() => {
+    openedSheets.length = 0;
+    jest.clearAllMocks();
+    (localStorage.setItem as jest.Mock).mockResolvedValue(undefined);
+    (localStorage.removeItem as jest.Mock).mockResolvedValue(undefined);
+
+    player = {
+      getConfig: () => ({
+        playback_speed_title: "Playback Speed",
+        playback_sleep_title: "Sleep Timer",
+        playback_sleep_off_label: "Off",
+        sleep_timer: "sleep_timer",
+        sleep_timer_active: "sleep_timer_active",
+        speed_1: "speed_1_asset_uri",
+        speed_1_5: "speed_1_5_asset_uri",
+      }),
+      setPlaybackRate: jest.fn(),
+      startSleepTimer: jest.fn(),
+      cancelSleepTimer: jest.fn(),
+    };
+
+    (playerManager.getActivePlayer as jest.Mock).mockReturnValue(player);
+    speedController = new SpeedController(player as any);
+    sleepController = new SleepTimerController(player as any);
+
+    [
+      "openBottomSheet",
+      PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+      PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+      PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+    ].forEach((type) => actionExecutor.unregisterAction(type));
+
+    actionExecutor.registerAction("openBottomSheet", async (action) => {
+      openedSheets.push(action);
+
+      return ActionResult.Success;
+    });
+
+    unregisterPlayerActions = registerPlayerActions({
+      speedController,
+      sleepController,
+    });
+  });
+
+  afterEach(() => {
+    unregisterPlayerActions?.();
+  });
+
+  it("does not register actions until a player controller is provided", async () => {
+    unregisterPlayerActions();
+    unregisterPlayerActions = registerPlayerActions({});
+
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      options: { value: 1.5, dismissSheet: true },
+    });
+
+    expect(result).toBeUndefined();
+    expect(player.setPlaybackRate).not.toHaveBeenCalled();
+
+    expect(
+      uiActionsRegistry.getAction(PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED)
+    ).toBeUndefined();
+
+    expect(
+      uiActionsRegistry.getAction(PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER)
+    ).toBeUndefined();
+  });
+
+  it("unregisters player actions when the player goes away", async () => {
+    unregisterPlayerActions();
+
+    expect(
+      uiActionsRegistry.getAction(PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED)
+    ).toBeUndefined();
+
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      options: { value: 1.5 },
+    });
+
+    expect(result).toBeUndefined();
+    expect(player.setPlaybackRate).not.toHaveBeenCalled();
+  });
+
+  it("opens playback speed through openBottomSheet with the current speed selected", async () => {
+    await speedController.setPlaybackSpeed({
+      asset: "speed_1",
+      value: 1,
+    });
+
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.OPEN_PLAYBACK_SPEED,
+    });
+
+    expect(result).toBe(ActionResult.Success);
+
+    const sheet = openedSheets[0];
+
+    expect(sheet.options.replace).toBe(true);
+    expect(sheet.options.header.title).toBe("Playback Speed");
+    expect(sheet.options.content.role).toBe("collection_selector");
+    expect(sheet.options.content.behavior.currentSelection).toEqual(["1"]);
+
+    expect(sheet.options.content.items.map((item) => item.title)).toEqual([
+      "0.8x",
+      "1x",
+      "1.2x",
+      "1.5x",
+      "2x",
+    ]);
+
+    expect(
+      sheet.options.content.items[0].extensions.tap_actions.actions[0].options
+        .dismissSheet
+    ).toBe(true);
+  });
+
+  it("opens sleep timer with the ticking countdown header", async () => {
+    const timerDate = Date.now() + 15 * 60 * 1000;
+
+    await sleepController.setSleepTimer(
+      { label: "15 minutes", value: 15 },
+      timerDate
+    );
+
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.OPEN_SLEEP_TIMER,
+    });
+
+    expect(result).toBe(ActionResult.Success);
+
+    const sheet = openedSheets[0];
+
+    expect(sheet.options.replace).toBe(true);
+    expect(sheet.options.header.title).toBe("Sleep Timer");
+    expect(sheet.options.header.subtitle).toBeUndefined();
+    expect(sheet.options.content.behavior.currentSelection).toEqual(["15"]);
+
+    expect(
+      sheet.options.content.items[0].extensions.tap_actions.actions[0].type
+    ).toBe(PLAYER_ACTION_TYPES.SET_SLEEP_TIMER);
+  });
+
+  it("setPlaybackSpeed applies the rate and closes the sheet when opened from the picker", async () => {
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      options: { value: 1.5, dismissSheet: true },
+    });
+
+    expect(result).toBe(ActionResult.Success);
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+    expect(localStorage.setItem).toHaveBeenCalled();
+    expect(modalOrchestrator.close).toHaveBeenCalled();
+  });
+
+  it("setSleepTimer starts the timer, writes storage, and closes the sheet", async () => {
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+      options: { value: 15, label: "15 minutes", dismissSheet: true },
+    });
+
+    expect(result).toBe(ActionResult.Success);
+    expect(player.startSleepTimer).toHaveBeenCalled();
+    expect(localStorage.setItem).toHaveBeenCalled();
+    expect(modalOrchestrator.close).toHaveBeenCalled();
+    expect(sleepController.currentState.timer.value).toBe(15);
+  });
+
+  it("setSleepTimer with value 0 cancels the timer", async () => {
+    await sleepController.setSleepTimer({
+      label: "15 minutes",
+      value: 15,
+    });
+
+    player.cancelSleepTimer.mockClear();
+    (localStorage.removeItem as jest.Mock).mockClear();
+    (modalOrchestrator.close as jest.Mock).mockClear();
+
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+      options: { value: 0, label: "Off", dismissSheet: true },
+    });
+
+    expect(result).toBe(ActionResult.Success);
+    expect(player.cancelSleepTimer).toHaveBeenCalled();
+    expect(localStorage.removeItem).toHaveBeenCalled();
+    expect(sleepController.currentState.timer.value).toBe(0);
+    expect(modalOrchestrator.close).toHaveBeenCalled();
+  });
+
+  it.each([undefined, "foo"])(
+    "rejects invalid setPlaybackSpeed value %p",
+    async (value) => {
+      player.setPlaybackRate.mockClear();
+      (localStorage.setItem as jest.Mock).mockClear();
+
+      const result = await actionExecutor.handleAction({
+        type: PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+        options: { value, dismissSheet: true },
+      });
+
+      expect(result).toBe(ActionResult.Error);
+      expect(player.setPlaybackRate).not.toHaveBeenCalled();
+      expect(localStorage.setItem).not.toHaveBeenCalled();
+      expect(modalOrchestrator.close).not.toHaveBeenCalled();
+    }
+  );
+
+  it.each([undefined, "foo"])(
+    "rejects invalid setSleepTimer value %p",
+    async (value) => {
+      const result = await actionExecutor.handleAction({
+        type: PLAYER_ACTION_TYPES.SET_SLEEP_TIMER,
+        options: { value, dismissSheet: true },
+      });
+
+      expect(result).toBe(ActionResult.Error);
+      expect(player.startSleepTimer).not.toHaveBeenCalled();
+      expect(localStorage.setItem).not.toHaveBeenCalled();
+      expect(modalOrchestrator.close).not.toHaveBeenCalled();
+    }
+  );
+
+  it("does not close an unrelated sheet when setPlaybackSpeed is invoked standalone", async () => {
+    const result = await actionExecutor.handleAction({
+      type: PLAYER_ACTION_TYPES.SET_PLAYBACK_SPEED,
+      options: { value: 1.5 },
+    });
+
+    expect(result).toBe(ActionResult.Success);
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+    expect(modalOrchestrator.close).not.toHaveBeenCalled();
+  });
+
+  it("initialEntryState for sleep-timer reflects an active timer", async () => {
+    await sleepController.setSleepTimer({
+      label: "15 minutes",
+      value: 15,
+    });
+
+    const action = uiActionsRegistry.getAction(
+      PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER
+    );
+
+    expect(action.initialEntryState({} as ZappEntry)).toMatchObject({
+      state: 1,
+      asset: "sleep_timer_active",
+      label: "Sleep Timer",
+    });
+
+    const observed = await firstValueFrom(
+      action.observeEntryState({} as ZappEntry)
+    );
+
+    expect(observed).toMatchObject({
+      state: 1,
+      asset: "sleep_timer_active",
+    });
+  });
+
+  it("initialEntryState for playback-speed uses the current speed icon asset", async () => {
+    const action = uiActionsRegistry.getAction(
+      PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED
+    );
+
+    expect(action.initialEntryState({} as ZappEntry)).toMatchObject({
+      label: "Playback Speed",
+      asset: "speed_1_asset_uri",
+    });
+
+    await speedController.setPlaybackSpeed({
+      asset: "speed_1_5",
+      value: 1.5,
+    });
+
+    const observed = await firstValueFrom(
+      action.observeEntryState({} as ZappEntry)
+    );
+
+    expect(observed).toMatchObject({
+      label: "Playback Speed",
+      asset: "speed_1_5_asset_uri",
+    });
+  });
+
+  it("registers UI action identifiers that open the matching sheets", async () => {
+    await uiActionsRegistry
+      .getAction(PLAYER_ACTION_IDENTIFIERS.PLAYBACK_SPEED)
+      .invokeAction({} as ZappEntry);
+
+    await uiActionsRegistry
+      .getAction(PLAYER_ACTION_IDENTIFIERS.SLEEP_TIMER)
+      .invokeAction({} as ZappEntry);
+
+    expect(openedSheets.map((action) => action.options.header.title)).toEqual([
+      "Playback Speed",
+      "Sleep Timer",
+    ]);
+  });
+});