ersatztv/web/src/api/rerunCollections.test.ts

import { beforeEach, describe, expect, it, vi } from 'vitest';
import {
  createRerunCollection,
  deleteRerunCollection,
  getRerunCollection,
  getRerunCollections,
  messageFromRerunCollectionError,
  updateRerunCollection
} from './rerunCollections';
import { ApiError } from './client';

function jsonResponse(body: unknown, status = 200): Response {
  return new Response(JSON.stringify(body), {
    headers: { 'Content-Type': 'application/json' },
    status
  });
}

function noContent(): Response {
  return new Response(null, { status: 204 });
}

describe('rerunCollections api client', () => {
  beforeEach(() => {
    window.localStorage.clear();
    vi.restoreAllMocks();
  });

  it('getRerunCollections maps paging params into the query string', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ page: [], totalCount: 0 }));

    await getRerunCollections({ pageNum: 1, pageSize: 50, query: 'noir' });

    const url = new URL(String(fetchMock.mock.calls[0][0]), 'http://localhost');
    expect(url.pathname).toBe('/api/rerun-collections');
    expect(url.searchParams.get('pageNum')).toBe('1');
    expect(url.searchParams.get('pageSize')).toBe('50');
    expect(url.searchParams.get('query')).toBe('noir');
  });

  it('getRerunCollections with no params hits the bare endpoint', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ page: [], totalCount: 0 }));

    await getRerunCollections();

    expect(fetchMock).toHaveBeenCalledWith('/api/rerun-collections', expect.objectContaining({ method: 'GET' }));
  });

  it('getRerunCollection fetches a single rerun collection by id', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(
      jsonResponse({
        collectionType: 'Collection',
        firstRunPlaybackOrder: 'Chronological',
        id: 3,
        name: 'Reruns',
        rerunPlaybackOrder: 'Shuffle',
        selectedId: 8,
        selectedName: 'Favorites'
      })
    );

    await expect(getRerunCollection(3)).resolves.toMatchObject({ id: 3, selectedName: 'Favorites' });
    expect(fetchMock).toHaveBeenCalledWith('/api/rerun-collections/3', expect.objectContaining({ method: 'GET' }));
  });

  it('createRerunCollection POSTs the full tagged-union body', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 12 }, 201));

    const body = {
      collectionType: 'TelevisionShow' as const,
      firstRunPlaybackOrder: 'SeasonEpisode' as const,
      name: 'Nightly',
      rerunPlaybackOrder: 'Chronological' as const,
      selectedId: 42
    };
    await expect(createRerunCollection(body)).resolves.toMatchObject({ id: 12 });

    const [url, init] = fetchMock.mock.calls[0];
    expect(url).toBe('/api/rerun-collections');
    expect(init).toMatchObject({ method: 'POST' });
    expect(JSON.parse(String(init?.body))).toEqual(body);
  });

  it('updateRerunCollection PUTs to the id route', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(jsonResponse({ id: 5 }));

    const body = {
      collectionType: 'MultiCollection' as const,
      firstRunPlaybackOrder: 'Shuffle' as const,
      name: 'Bundle Reruns',
      rerunPlaybackOrder: 'Shuffle' as const,
      selectedId: 99
    };
    await updateRerunCollection(5, body);

    const [url, init] = fetchMock.mock.calls[0];
    expect(url).toBe('/api/rerun-collections/5');
    expect(init).toMatchObject({ method: 'PUT' });
    expect(JSON.parse(String(init?.body))).toEqual(body);
  });

  it('deleteRerunCollection issues a DELETE and resolves on 204', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(noContent());

    await expect(deleteRerunCollection(7)).resolves.toBeUndefined();
    expect(fetchMock).toHaveBeenCalledWith('/api/rerun-collections/7', expect.objectContaining({ method: 'DELETE' }));
  });

  it('messageFromRerunCollectionError narrows ApiError, Error, and unknown', () => {
    expect(messageFromRerunCollectionError(new ApiError(422, { detail: 'In use', title: 'Unprocessable' }))).toBe('In use');
    expect(messageFromRerunCollectionError(new Error('boom'))).toBe('boom');
    expect(messageFromRerunCollectionError('nope', 'fallback')).toBe('fallback');
  });
});