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

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

@@ -0,0 +1,529 @@
+import { appStore } from "@applicaster/zapp-react-native-redux/AppStore";
+import { findPluginByIdentifier } from "@applicaster/zapp-react-native-utils/pluginUtils";
+import { loadFeedEntry } from "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils";
+import {
+  PlaylistNavigationController,
+  RESTART_THRESHOLD_SECONDS,
+} from "../PlaylistNavigationController";
+
+jest.mock("@applicaster/zapp-react-native-redux/AppStore", () => ({
+  appStore: {
+    get: jest.fn(),
+  },
+}));
+
+jest.mock("@applicaster/zapp-react-native-utils/pluginUtils", () => ({
+  findPluginByIdentifier: jest.fn(),
+}));
+
+jest.mock(
+  "@applicaster/zapp-react-native-utils/appUtils/playerManager/OverlayObserver/utils",
+  () => ({
+    loadFeedEntry: jest.fn(),
+  })
+);
+
+const appStoreMock = appStore as unknown as { get: jest.Mock };
+const findPluginByIdentifierMock = findPluginByIdentifier as jest.Mock;
+const loadFeedEntryMock = loadFeedEntry as jest.Mock;
+
+const NEXT_URL = "https://feeds/next.json";
+const PREV_URL = "https://feeds/prev.json";
+
+const entryWith = (extensions: Record<string, unknown>): ZappEntry =>
+  ({
+    id: "current",
+    title: "Current Track",
+    type: { value: "audio" },
+    extensions,
+  }) as ZappEntry;
+
+const stateAt = (
+  currentTime: number,
+  seekableDuration = 600
+): QuickBrickPlayer.PlayerState =>
+  ({ currentTime, seekableDuration }) as QuickBrickPlayer.PlayerState;
+
+const NOT_SEEKABLE = 0;
+
+describe("PlaylistNavigationController", () => {
+  let player: { seekTo: jest.Mock };
+  let navigator: { replaceTop: jest.Mock };
+  let mockQueueManager: any;
+
+  beforeEach(() => {
+    player = { seekTo: jest.fn() };
+    navigator = { replaceTop: jest.fn() };
+    loadFeedEntryMock.mockReset();
+
+    mockQueueManager = {
+      isInitialized: jest.fn().mockReturnValue(false),
+      instance: {
+        getUpcomingQueue: jest.fn().mockResolvedValue([]),
+        getHistoryQueue: jest.fn().mockResolvedValue([]),
+        addListener: jest.fn().mockReturnValue(jest.fn()),
+      },
+    };
+
+    appStoreMock.get.mockReturnValue([]);
+    findPluginByIdentifierMock.mockReturnValue(null);
+  });
+
+  describe("static URL feeds (no queue)", () => {
+    it("reports both directions available when both static extensions are present", async () => {
+      const entry = entryWith({
+        play_next_feed_url: NEXT_URL,
+        play_previous_feed_url: PREV_URL,
+      });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0),
+      });
+
+      await controller.recalculate();
+
+      expect(controller.hasNext$.getValue()).toBe(true);
+      expect(controller.hasPrevious$.getValue()).toBe(true);
+
+      controller.destroy();
+    });
+
+    it("keeps previous available at head of chain when track is seekable", async () => {
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0),
+      });
+
+      await controller.recalculate();
+
+      expect(controller.hasNext$.getValue()).toBe(true);
+      expect(controller.hasPrevious$.getValue()).toBe(true);
+
+      controller.destroy();
+    });
+
+    it("reports no previous when track is not seekable and has no previous extension", async () => {
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0, NOT_SEEKABLE),
+      });
+
+      await controller.recalculate();
+
+      expect(controller.hasNext$.getValue()).toBe(true);
+      expect(controller.hasPrevious$.getValue()).toBe(false);
+
+      controller.destroy();
+    });
+
+    it("fetches and plays next remote feed entry on goNext", async () => {
+      const target = { id: "next-track", title: "Next" } as ZappEntry;
+      loadFeedEntryMock.mockResolvedValue(target);
+
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0),
+      });
+
+      await controller.goNext();
+
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(NEXT_URL, entry);
+      expect(navigator.replaceTop).toHaveBeenCalledWith(target);
+
+      controller.destroy();
+    });
+
+    it("restarts playback when currentTime > RESTART_THRESHOLD_SECONDS", async () => {
+      const entry = entryWith({ play_previous_feed_url: PREV_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(RESTART_THRESHOLD_SECONDS + 1),
+      });
+
+      await controller.goPrevious();
+
+      expect(player.seekTo).toHaveBeenCalledWith(0);
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+      expect(navigator.replaceTop).not.toHaveBeenCalled();
+
+      controller.destroy();
+    });
+
+    it("fetches and plays previous remote feed entry when currentTime <= RESTART_THRESHOLD_SECONDS", async () => {
+      const target = { id: "prev-track", title: "Previous" } as ZappEntry;
+      loadFeedEntryMock.mockResolvedValue(target);
+
+      const entry = entryWith({ play_previous_feed_url: PREV_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      await controller.goPrevious();
+
+      expect(player.seekTo).not.toHaveBeenCalled();
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(PREV_URL, entry);
+      expect(navigator.replaceTop).toHaveBeenCalledWith(target);
+
+      controller.destroy();
+    });
+  });
+
+  describe("queue navigation (QueueManager active)", () => {
+    let queueListener: () => void;
+
+    beforeEach(() => {
+      mockQueueManager.isInitialized.mockReturnValue(true);
+
+      mockQueueManager.instance.addListener.mockImplementation(
+        (cb: () => void) => {
+          queueListener = cb;
+
+          return jest.fn();
+        }
+      );
+
+      findPluginByIdentifierMock.mockReturnValue({
+        module: { QueueManager: mockQueueManager },
+      });
+    });
+
+    it("reports availability based on upcoming and history queues", async () => {
+      const upcomingItem = { id: "next_in_queue" } as ZappEntry;
+      const historyItem = { id: "prev_in_queue" } as ZappEntry;
+
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([
+        upcomingItem,
+      ]);
+
+      mockQueueManager.instance.getHistoryQueue.mockResolvedValue([
+        historyItem,
+      ]);
+
+      const controller = new PlaylistNavigationController({
+        entry: entryWith({}),
+        player,
+        navigator,
+        playerState: stateAt(0, NOT_SEEKABLE),
+      });
+
+      await controller.recalculate();
+
+      expect(controller.hasNext$.getValue()).toBe(true);
+      expect(controller.hasPrevious$.getValue()).toBe(true);
+
+      controller.destroy();
+    });
+
+    it("navigates directly to upcoming item on goNext without Pipes roundtrip", async () => {
+      const nextQueueItem = {
+        id: "queue_item_2",
+        title: "Second Track",
+      } as ZappEntry;
+
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([
+        nextQueueItem,
+      ]);
+
+      const controller = new PlaylistNavigationController({
+        entry: entryWith({}),
+        player,
+        navigator,
+        playerState: stateAt(0),
+      });
+
+      await controller.goNext();
+
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+      expect(navigator.replaceTop).toHaveBeenCalledWith(nextQueueItem);
+
+      controller.destroy();
+    });
+
+    it("navigates directly to history item on goPrevious without Pipes roundtrip when <= 3s", async () => {
+      const prevQueueItem = {
+        id: "queue_item_0",
+        title: "Zero Track",
+      } as ZappEntry;
+
+      mockQueueManager.instance.getHistoryQueue.mockResolvedValue([
+        prevQueueItem,
+      ]);
+
+      const controller = new PlaylistNavigationController({
+        entry: entryWith({}),
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      await controller.goPrevious();
+
+      expect(player.seekTo).not.toHaveBeenCalled();
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+      expect(navigator.replaceTop).toHaveBeenCalledWith(prevQueueItem);
+
+      controller.destroy();
+    });
+
+    it("recalculates streams when QueueManager listener fires", async () => {
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([]);
+      mockQueueManager.instance.getHistoryQueue.mockResolvedValue([]);
+
+      const controller = new PlaylistNavigationController({
+        entry: entryWith({}),
+        player,
+        navigator,
+        playerState: stateAt(0, NOT_SEEKABLE),
+      });
+
+      await controller.recalculate();
+      expect(controller.hasNext$.getValue()).toBe(false);
+
+      // Simulate item enqueued
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([
+        { id: "new_item" },
+      ]);
+
+      queueListener();
+
+      // Wait a tick for async recalculate
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(controller.hasNext$.getValue()).toBe(true);
+
+      controller.destroy();
+    });
+
+    it("prevents duplicate navigation calls while in-flight", async () => {
+      const target = { id: "next-track" } as ZappEntry;
+      let resolvePromise: (value: ZappEntry) => void;
+
+      loadFeedEntryMock.mockReturnValue(
+        new Promise((resolve) => {
+          resolvePromise = resolve;
+        })
+      );
+
+      const entry = entryWith({ play_next_feed_url: NEXT_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0),
+      });
+
+      // First tap starts flight
+      const firstTap = controller.goNext();
+      // Second tap while in-flight
+      const secondTap = controller.goNext();
+
+      resolvePromise!(target);
+      await Promise.all([firstTap, secondTap]);
+
+      expect(loadFeedEntryMock).toHaveBeenCalledTimes(1);
+      expect(navigator.replaceTop).toHaveBeenCalledTimes(1);
+
+      controller.destroy();
+    });
+
+    it("prevents duplicate goPrevious calls while in-flight", async () => {
+      const target = { id: "prev-track" } as ZappEntry;
+      let resolvePromise: (value: ZappEntry) => void;
+
+      loadFeedEntryMock.mockReturnValue(
+        new Promise((resolve) => {
+          resolvePromise = resolve;
+        })
+      );
+
+      const entry = entryWith({ play_previous_feed_url: PREV_URL });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      const firstTap = controller.goPrevious();
+      const secondTap = controller.goPrevious();
+
+      resolvePromise!(target);
+      await Promise.all([firstTap, secondTap]);
+
+      expect(loadFeedEntryMock).toHaveBeenCalledTimes(1);
+      expect(navigator.replaceTop).toHaveBeenCalledTimes(1);
+
+      controller.destroy();
+    });
+
+    it("prioritizes static feed URLs when entry is not from queue", async () => {
+      const queueNextItem = { id: "queue_next" } as ZappEntry;
+      const queuePrevItem = { id: "queue_prev" } as ZappEntry;
+      const staticNextTarget = { id: "static_next" } as ZappEntry;
+      const staticPrevTarget = { id: "static_prev" } as ZappEntry;
+
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([
+        queueNextItem,
+      ]);
+
+      mockQueueManager.instance.getHistoryQueue.mockResolvedValue([
+        queuePrevItem,
+      ]);
+
+      loadFeedEntryMock.mockImplementation((url) =>
+        Promise.resolve(url === NEXT_URL ? staticNextTarget : staticPrevTarget)
+      );
+
+      const entry = entryWith({
+        play_next_feed_url: NEXT_URL,
+        play_previous_feed_url: PREV_URL,
+      });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      await controller.goNext();
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(NEXT_URL, entry);
+      expect(navigator.replaceTop).toHaveBeenCalledWith(staticNextTarget);
+
+      await controller.goPrevious();
+      expect(loadFeedEntryMock).toHaveBeenCalledWith(PREV_URL, entry);
+      expect(navigator.replaceTop).toHaveBeenCalledWith(staticPrevTarget);
+
+      controller.destroy();
+    });
+
+    it("prioritizes queue navigation when entry is from queue (has queueItemId)", async () => {
+      const queueNextItem = { id: "queue_next" } as ZappEntry;
+      const queuePrevItem = { id: "queue_prev" } as ZappEntry;
+
+      mockQueueManager.instance.getUpcomingQueue.mockResolvedValue([
+        queueNextItem,
+      ]);
+
+      mockQueueManager.instance.getHistoryQueue.mockResolvedValue([
+        queuePrevItem,
+      ]);
+
+      const entry = entryWith({
+        queueItemId: "current_queue_slot",
+        play_next_feed_url: NEXT_URL,
+        play_previous_feed_url: PREV_URL,
+      });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      await controller.goNext();
+      expect(loadFeedEntryMock).not.toHaveBeenCalled();
+      expect(navigator.replaceTop).toHaveBeenCalledWith(queueNextItem);
+
+      await controller.goPrevious();
+      expect(navigator.replaceTop).toHaveBeenCalledWith(queuePrevItem);
+
+      controller.destroy();
+    });
+
+    it("ignores stale recalculate resolution when newer recalculate was called", async () => {
+      let resolveFirst: (val: any) => void;
+
+      const firstPromise = new Promise<{
+        upcoming: ZappEntry[];
+        history: ZappEntry[];
+      }>((resolve) => {
+        resolveFirst = resolve;
+      });
+
+      const entry = entryWith({});
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(0, NOT_SEEKABLE),
+      });
+
+      // Override getUpcomingQueue to control resolution order
+      mockQueueManager.instance.getUpcomingQueue
+        .mockReturnValueOnce(firstPromise.then((d) => d.upcoming))
+        .mockResolvedValueOnce([{ id: "second_call_item" }]);
+
+      // First recalculate (will hang until resolveFirst)
+      const recalc1 = controller.recalculate();
+
+      // Second recalculate resolves immediately with hasNext = true
+      const recalc2 = controller.recalculate();
+      await recalc2;
+      expect(controller.hasNext$.getValue()).toBe(true);
+
+      // Now resolve first with empty array; should NOT overwrite hasNext$ to false
+      resolveFirst!({ upcoming: [], history: [] });
+      await recalc1;
+      expect(controller.hasNext$.getValue()).toBe(true);
+
+      controller.destroy();
+    });
+
+    it("does not navigate if controller is destroyed while resolving feed entry", async () => {
+      let resolvePromise: (value: ZappEntry) => void;
+
+      loadFeedEntryMock.mockReturnValue(
+        new Promise((resolve) => {
+          resolvePromise = resolve;
+        })
+      );
+
+      const entry = entryWith({
+        play_next_feed_url: NEXT_URL,
+        play_previous_feed_url: PREV_URL,
+      });
+
+      const controller = new PlaylistNavigationController({
+        entry,
+        player,
+        navigator,
+        playerState: stateAt(1),
+      });
+
+      const goNextPromise = controller.goNext();
+      controller.destroy();
+
+      resolvePromise!({ id: "target" } as ZappEntry);
+      await goNextPromise;
+
+      expect(navigator.replaceTop).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,78 @@
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { SLEEP_TIMER_OFF, SleepTimerController } from "../SleepTimerManager";
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+    },
+  })
+);
+
+describe("SleepTimerController", () => {
+  const player = {
+    startSleepTimer: jest.fn(),
+    cancelSleepTimer: jest.fn(),
+  };
+
+  let sleepController: SleepTimerController;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (localStorage.setItem as jest.Mock).mockResolvedValue(undefined);
+    (localStorage.removeItem as jest.Mock).mockResolvedValue(undefined);
+    (localStorage.getItem as jest.Mock).mockResolvedValue(undefined);
+    sleepController = new SleepTimerController(player as any);
+  });
+
+  it("starts from the off state", () => {
+    expect(sleepController.currentState.timer).toEqual(SLEEP_TIMER_OFF);
+  });
+
+  it("starts a sleep timer on the constructed player", async () => {
+    await sleepController.setSleepTimer({
+      label: "15 minutes",
+      value: 15,
+    });
+
+    expect(player.cancelSleepTimer).toHaveBeenCalled();
+    expect(player.startSleepTimer).toHaveBeenCalled();
+    expect(sleepController.currentState.timer.value).toBe(15);
+  });
+
+  it("loadSleep restores an unexpired timer", async () => {
+    const futureSleepDate = Date.now() + 60 * 1000;
+
+    (localStorage.getItem as jest.Mock).mockResolvedValue({
+      label: "15 minutes",
+      value: 15,
+      futureSleepDate,
+    });
+
+    player.startSleepTimer.mockClear();
+
+    await sleepController.loadSleep();
+
+    expect(player.startSleepTimer).toHaveBeenCalledWith(futureSleepDate);
+    expect(sleepController.currentState.timer.value).toBe(15);
+  });
+
+  it("loadSleep drops an expired timer without starting a native timer", async () => {
+    (localStorage.getItem as jest.Mock).mockResolvedValue({
+      label: "15 minutes",
+      value: 15,
+      futureSleepDate: Date.now() - 1000,
+    });
+
+    player.startSleepTimer.mockClear();
+
+    await sleepController.loadSleep();
+
+    expect(player.startSleepTimer).not.toHaveBeenCalled();
+    expect(localStorage.removeItem).toHaveBeenCalled();
+    expect(sleepController.currentState.timer).toEqual(SLEEP_TIMER_OFF);
+  });
+});

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

@@ -0,0 +1,57 @@
+import { localStorage } from "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage";
+import { DEFAULT_SPEED, SpeedController } from "../SpeedManager";
+
+jest.mock(
+  "@applicaster/zapp-react-native-bridge/ZappStorage/LocalStorage",
+  () => ({
+    localStorage: {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn(),
+    },
+  })
+);
+
+describe("SpeedController", () => {
+  const player = { setPlaybackRate: jest.fn() };
+  let speedController: SpeedController;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (localStorage.setItem as jest.Mock).mockResolvedValue(undefined);
+    (localStorage.getItem as jest.Mock).mockResolvedValue(undefined);
+    speedController = new SpeedController(player as any);
+  });
+
+  it("requires a player in the constructor", () => {
+    expect(speedController.currentSpeed).toEqual(DEFAULT_SPEED);
+  });
+
+  it("applies playback speed on the constructed player", async () => {
+    await speedController.setPlaybackSpeed({
+      asset: "speed_1_5",
+      value: 1.5,
+    });
+
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+
+    expect(speedController.currentSpeed).toEqual({
+      asset: "speed_1_5",
+      value: 1.5,
+    });
+  });
+
+  it("loadSpeed restores a stored rate onto the player", async () => {
+    (localStorage.getItem as jest.Mock).mockResolvedValue({
+      asset: "speed_1_5",
+      value: 1.5,
+    });
+
+    player.setPlaybackRate.mockClear();
+
+    await speedController.loadSpeed();
+
+    expect(player.setPlaybackRate).toHaveBeenCalledWith(1.5);
+    expect(speedController.currentSpeed.value).toBe(1.5);
+  });
+});