jellytau/src/lib/stores/playbackMode.test.ts

// Tests for playback mode store
// TRACES: UR-010 | DR-037
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { get } from "svelte/store";

// Mock Tauri invoke
const mockInvoke = vi.fn();
vi.mock("@tauri-apps/api/core", () => ({
  invoke: (...args: unknown[]) => mockInvoke(...args),
}));

// Mock the sessions store. `selectedSession` is read via svelte's `get()`, which
// calls subscribe and synchronously receives the current value; tests set
// `currentSelectedSession` to control what the store yields.
const mockSelectSession = vi.fn();
let currentSelectedSession: unknown = null;
vi.mock("./sessions", () => ({
  sessions: {
    selectSession: (...args: unknown[]) => mockSelectSession(...args),
  },
  selectedSession: {
    subscribe: vi.fn((callback: (value: unknown) => void) => {
      callback(currentSelectedSession);
      return () => {};
    }),
  },
}));

// Mock auth store
const mockGetHandle = vi.fn(() => "repo-handle-1");
vi.mock("./auth", () => ({
  auth: {
    getRepository: vi.fn(() => ({
      getPlaybackInfo: vi.fn().mockResolvedValue({ streamUrl: "http://test.com/stream" }),
      getImageUrl: vi.fn().mockReturnValue("http://test.com/image"),
      getHandle: () => mockGetHandle(),
    })),
  },
}));

describe("playbackMode store", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    currentSelectedSession = null;
  });

  afterEach(() => {
    vi.restoreAllMocks();
  });

  describe("initial state", () => {
    it("should have idle mode initially", async () => {
      const { playbackMode } = await import("./playbackMode");
      const state = get(playbackMode);

      expect(state.mode).toBe("idle");
      expect(state.remoteSessionId).toBeNull();
      expect(state.isTransferring).toBe(false);
      expect(state.transferError).toBeNull();
    });
  });

  describe("setMode", () => {
    it("should update mode locally", async () => {
      const { playbackMode } = await import("./playbackMode");

      playbackMode.setMode("local");
      let state = get(playbackMode);
      expect(state.mode).toBe("local");

      playbackMode.setMode("remote", "session-123");
      state = get(playbackMode);
      expect(state.mode).toBe("remote");
      expect(state.remoteSessionId).toBe("session-123");
    });
  });

  describe("disconnect", () => {
    it("should notify Rust backend and update local state when disconnecting", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Set up remote mode first
      playbackMode.setMode("remote", "session-123");
      let state = get(playbackMode);
      expect(state.mode).toBe("remote");
      expect(state.remoteSessionId).toBe("session-123");

      // Mock successful Rust call
      mockInvoke.mockResolvedValueOnce(undefined);

      // Call disconnect
      await playbackMode.disconnect();

      // Verify Rust backend was notified with correct mode (mode is now an object with type field)
      expect(mockInvoke).toHaveBeenCalledWith("playback_mode_set", {
        mode: { type: "idle" },
      });

      // Verify sessions.selectSession was called with null
      expect(mockSelectSession).toHaveBeenCalledWith(null);

      // Verify local state updated
      state = get(playbackMode);
      expect(state.mode).toBe("idle");
      expect(state.remoteSessionId).toBeNull();
      expect(state.transferError).toBeNull();
    });

    it("should do nothing if not in remote mode", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Ensure we're in idle mode
      playbackMode.setMode("idle");
      const state = get(playbackMode);
      expect(state.mode).toBe("idle");

      // Call disconnect
      await playbackMode.disconnect();

      // Verify Rust backend was NOT called
      expect(mockInvoke).not.toHaveBeenCalled();
      expect(mockSelectSession).not.toHaveBeenCalled();
    });

    it("should handle errors gracefully", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Set up remote mode first
      playbackMode.setMode("remote", "session-123");

      // Mock failed Rust call
      const error = new Error("Failed to set mode");
      mockInvoke.mockRejectedValueOnce(error);

      // Call disconnect and expect it to throw
      await expect(playbackMode.disconnect()).rejects.toThrow("Failed to set mode");

      // Verify error was stored in state
      const state = get(playbackMode);
      expect(state.transferError).toBe("Failed to set mode");
    });

    it("should clear previous transfer errors on successful disconnect", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Set up remote mode with an existing error
      playbackMode.setMode("remote", "session-123");

      // Manually set an error state (simulating a previous failed operation)
      // We'll use clearError then verify it's cleared on disconnect
      mockInvoke.mockResolvedValueOnce(undefined);

      await playbackMode.disconnect();

      const state = get(playbackMode);
      expect(state.transferError).toBeNull();
    });
  });

  describe("transferToRemote", () => {
    it("should call Rust backend with session ID", async () => {
      const { playbackMode } = await import("./playbackMode");

      mockInvoke.mockResolvedValueOnce(undefined);

      await playbackMode.transferToRemote("session-456");

      expect(mockInvoke).toHaveBeenCalledWith("playback_mode_transfer_to_remote", {
        sessionId: "session-456",
      });
    });

    it("should update local state on success", async () => {
      const { playbackMode } = await import("./playbackMode");

      mockInvoke.mockResolvedValueOnce(undefined);

      await playbackMode.transferToRemote("session-456");

      const state = get(playbackMode);
      expect(state.mode).toBe("remote");
      expect(state.remoteSessionId).toBe("session-456");
      expect(state.isTransferring).toBe(false);
    });

    it("should set isTransferring during transfer", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Create a promise that we can control
      let resolveTransfer: () => void;
      const transferPromise = new Promise<void>((resolve) => {
        resolveTransfer = resolve;
      });
      mockInvoke.mockReturnValueOnce(transferPromise);

      // Start the transfer (don't await)
      const transferPromiseResult = playbackMode.transferToRemote("session-789");

      // Check that isTransferring is true during the transfer
      let state = get(playbackMode);
      expect(state.isTransferring).toBe(true);

      // Resolve the transfer
      resolveTransfer!();
      await transferPromiseResult;

      // Check that isTransferring is false after
      state = get(playbackMode);
      expect(state.isTransferring).toBe(false);
    });
  });

  describe("transferToLocal", () => {
    // 50,000,000 ticks = 5 seconds (10M ticks per second).
    const REMOTE_POSITION_TICKS = 50_000_000;
    const REMOTE_POSITION_SECONDS = 5;

    function setRemoteSessionPlaying() {
      currentSelectedSession = {
        id: "session-123",
        nowPlayingItem: { id: "item-abc", name: "Test Track", runTimeTicks: 1_800_000_000 },
        playState: { positionTicks: REMOTE_POSITION_TICKS },
      };
    }

    it("resumes local playback at the remote position, not from 0", async () => {
      const { playbackMode } = await import("./playbackMode");

      playbackMode.setMode("remote", "session-123");
      setRemoteSessionPlaying();
      mockInvoke.mockResolvedValue(undefined);

      await playbackMode.transferToLocal();

      // Bug 2 guard: the resume position must be passed to play_tracks so the
      // backend seeks at load time. Restarting from 0 means startPosition is missing.
      const playTracksCall = mockInvoke.mock.calls.find((c) => c[0] === "player_play_tracks");
      expect(playTracksCall).toBeDefined();
      expect(playTracksCall![1]).toMatchObject({
        repositoryHandle: "repo-handle-1",
        request: {
          trackIds: ["item-abc"],
          startIndex: 0,
          startPosition: REMOTE_POSITION_SECONDS,
        },
      });
    });

    it("does not issue a separate player_seek (no start-at-0-then-jump race)", async () => {
      const { playbackMode } = await import("./playbackMode");

      playbackMode.setMode("remote", "session-123");
      setRemoteSessionPlaying();
      mockInvoke.mockResolvedValue(undefined);

      await playbackMode.transferToLocal();

      const seekCall = mockInvoke.mock.calls.find((c) => c[0] === "player_seek");
      expect(seekCall).toBeUndefined();
    });

    it("tells Rust to stop the remote session with the current item and position", async () => {
      const { playbackMode } = await import("./playbackMode");

      playbackMode.setMode("remote", "session-123");
      setRemoteSessionPlaying();
      mockInvoke.mockResolvedValue(undefined);

      await playbackMode.transferToLocal();

      expect(mockInvoke).toHaveBeenCalledWith("playback_mode_transfer_to_local", {
        currentItemId: "item-abc",
        positionTicks: REMOTE_POSITION_TICKS,
      });

      const state = get(playbackMode);
      expect(state.mode).toBe("local");
      expect(state.remoteSessionId).toBeNull();
      expect(state.isTransferring).toBe(false);
    });

    it("switches to local without playing media when remote has nothing playing", async () => {
      const { playbackMode } = await import("./playbackMode");

      playbackMode.setMode("remote", "session-123");
      currentSelectedSession = { id: "session-123", nowPlayingItem: null, playState: null };

      await playbackMode.transferToLocal();

      expect(mockInvoke).not.toHaveBeenCalledWith("player_play_tracks", expect.anything());
      const state = get(playbackMode);
      expect(state.mode).toBe("local");
      expect(state.remoteSessionId).toBeNull();
    });
  });

  describe("clearError", () => {
    it("should clear transfer error", async () => {
      const { playbackMode } = await import("./playbackMode");

      // Set up remote mode and simulate a failed transfer to set an error
      playbackMode.setMode("remote", "session-123");
      mockInvoke.mockRejectedValueOnce(new Error("Test error"));

      try {
        await playbackMode.disconnect();
      } catch {
        // Expected to throw
      }

      let state = get(playbackMode);
      expect(state.transferError).toBe("Test error");

      // Clear the error
      playbackMode.clearError();

      state = get(playbackMode);
      expect(state.transferError).toBeNull();
    });
  });

  describe("derived stores", () => {
    it("isRemoteMode should be true when mode is remote", async () => {
      const { playbackMode, isRemoteMode } = await import("./playbackMode");

      playbackMode.setMode("remote", "session-123");

      const isRemote = get(isRemoteMode);
      expect(isRemote).toBe(true);
    });

    it("isLocalMode should be true when mode is local", async () => {
      const { playbackMode, isLocalMode } = await import("./playbackMode");

      playbackMode.setMode("local");

      const isLocal = get(isLocalMode);
      expect(isLocal).toBe(true);
    });

    it("isIdleMode should be true when mode is idle", async () => {
      const { playbackMode, isIdleMode } = await import("./playbackMode");

      playbackMode.setMode("idle");

      const isIdle = get(isIdleMode);
      expect(isIdle).toBe(true);
    });
  });
});