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

import { beforeEach, describe, expect, it, vi } from 'vitest';
import { setStoredApiKey } from './auth';
import { ApiError, request, requestWithMeta } from './client';

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

  it('omits the API key header for read requests', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(
      new Response(JSON.stringify([{ id: 1, number: '1', name: 'News' }]), {
        headers: { 'Content-Type': 'application/json' },
        status: 200
      })
    );
    setStoredApiKey('write-secret');

    await request('/api/channels');

    expect(fetchMock).toHaveBeenCalledWith(
      '/api/channels',
      expect.objectContaining({
        headers: expect.not.objectContaining({ 'X-Api-Key': 'write-secret' })
      })
    );
  });

  it('adds the API key header for mutating requests', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(new Response(null, { status: 204 }));
    setStoredApiKey('write-secret');

    await request('/api/channels/1', { method: 'DELETE' });

    expect(fetchMock).toHaveBeenCalledWith(
      '/api/channels/1',
      expect.objectContaining({
        headers: expect.objectContaining({ 'X-Api-Key': 'write-secret' }),
        method: 'DELETE'
      })
    );
  });

  it('throws an ApiError with problem details for non-OK responses', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(
      new Response(JSON.stringify({ status: 422, title: 'Validation failed', detail: 'Number exists' }), {
        headers: { 'Content-Type': 'application/json' },
        status: 422
      })
    );

    await expect(request('/api/channels', { method: 'POST', body: { name: 'News' } })).rejects.toMatchObject({
      detail: 'Number exists',
      message: 'Validation failed',
      status: 422
    } satisfies Partial<ApiError>);
  });

  it('returns undefined for successful responses without a JSON body', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(new Response(null, { status: 200 }));

    await expect(request('/api/channels', { method: 'POST' })).resolves.toBeUndefined();
  });

  it('reads problem details from application/problem+json responses', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(
      new Response(JSON.stringify({ status: 401, title: 'Unauthorized', detail: 'A valid API key is required for write requests.' }), {
        headers: { 'Content-Type': 'application/problem+json' },
        status: 401
      })
    );

    await expect(request('/api/channels', { method: 'POST' })).rejects.toMatchObject({
      detail: 'A valid API key is required for write requests.',
      message: 'Unauthorized',
      status: 401
    } satisfies Partial<ApiError>);
  });

  it('does not add a duplicate JSON content type when callers provide lowercase content-type', async () => {
    const fetchMock = vi.spyOn(window, 'fetch').mockResolvedValue(new Response(null, { status: 204 }));

    await request('/api/channels', {
      body: { name: 'News' },
      headers: { 'content-type': 'application/merge-patch+json' },
      method: 'PATCH'
    });

    expect(fetchMock).toHaveBeenCalledWith(
      '/api/channels',
      expect.objectContaining({
        headers: expect.not.objectContaining({ 'Content-Type': 'application/json' })
      })
    );
  });

  it('requestWithMeta returns the response ETag alongside the parsed body', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(
      new Response(JSON.stringify([{ id: 1 }]), {
        headers: { ETag: '"7"', 'Content-Type': 'application/json' },
        status: 200
      })
    );

    const result = await requestWithMeta<{ id: number }[]>('/api/blocks/1/items');

    expect(result.etag).toBe('"7"');
    expect(result.data).toEqual([{ id: 1 }]);
  });

  it('requestWithMeta returns a null ETag when the response has none', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(
      new Response(JSON.stringify({ ok: true }), {
        headers: { 'Content-Type': 'application/json' },
        status: 200
      })
    );

    const result = await requestWithMeta('/api/blocks/1/items');

    expect(result.etag).toBeNull();
  });

  it('requestWithMeta surfaces the ETag on a 204 (no body) response', async () => {
    vi.spyOn(window, 'fetch').mockResolvedValue(new Response(null, { headers: { ETag: '"3"' }, status: 204 }));

    const result = await requestWithMeta('/api/blocks/1', { method: 'PUT' });

    expect(result.data).toBeUndefined();
    expect(result.etag).toBe('"3"');
  });
});