sonda/web/src/api/adminProviders.test.tsx
tgiachi c3edc564f4 feat(web): hooks for the external providers
List them, change one (only the fields given are sent), test a key, remove what a provider gave, and read what Lidarr offers only when asked.
2026-11-12 15:05:42 +01:00

92 lines
4.8 KiB
TypeScript

import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { act, renderHook, waitFor } from '@testing-library/react'
import type { ReactNode } from 'react'
import { expect, test } from 'vitest'
import { apiError, mockFetch } from '@/test/mockFetch'
import { useLidarrOffers, useProviders, usePurgeProvider, useTestProvider, useUpdateProvider } from './adminProviders'
function setup() {
const client = new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } })
const wrapper = ({ children }: { children: ReactNode }) => <QueryClientProvider client={client}>{children}</QueryClientProvider>
return { client, wrapper }
}
const provider = (name: string, over: object = {}) => ({
name,
enabled: false,
needs_api_key: false,
needs_url: false,
has_api_key: false,
contact: '',
url: '',
sends: 'Nothing.',
notes: 'Terms.',
updated_at: null,
...over,
})
test('the providers are listed in the order the server gives them', async () => {
mockFetch({ 'GET /api/v1/providers': () => ({ providers: [provider('lastfm'), provider('musicbrainz')] }) })
const { result } = renderHook(() => useProviders(), { wrapper: setup().wrapper })
await waitFor(() => expect(result.current.data?.map((p) => p.name)).toEqual(['lastfm', 'musicbrainz']))
})
test('an update names the provider, sends only the fields given, and the list is read again', async () => {
let enabled = false
const { calls } = mockFetch({
'GET /api/v1/providers': () => ({ providers: [provider('lastfm', { enabled })] }),
'PUT /api/v1/providers/lastfm': ({ init }) => {
enabled = JSON.parse(String(init.body)).enabled
return provider('lastfm', { enabled })
},
})
const { wrapper } = setup()
const { result } = renderHook(() => ({ list: useProviders(), update: useUpdateProvider() }), { wrapper })
await waitFor(() => expect(result.current.list.data?.[0].enabled).toBe(false))
await act(() => result.current.update.mutateAsync({ name: 'lastfm', enabled: true }))
await waitFor(() => expect(result.current.list.data?.[0].enabled).toBe(true))
expect(JSON.parse(String(calls.find((c) => c.key === 'PUT /api/v1/providers/lastfm')?.init.body))).toEqual({ enabled: true })
})
test('a key is sent as api_key and nothing else with it', async () => {
const { calls } = mockFetch({ 'PUT /api/v1/providers/lastfm': () => provider('lastfm', { has_api_key: true }), 'GET /api/v1/providers': () => ({ providers: [] }) })
const { result } = renderHook(() => useUpdateProvider(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync({ name: 'lastfm', api_key: '0123456789abcdef0123456789abcdef' }))
expect(JSON.parse(String(calls.find((c) => c.key === 'PUT /api/v1/providers/lastfm')?.init.body))).toEqual({
api_key: '0123456789abcdef0123456789abcdef',
})
})
test('a test gives the outcome, which is not an error when the provider says no', async () => {
mockFetch({ 'POST /api/v1/providers/lastfm/test': () => ({ ok: false, status: 'key_refused' }) })
const { result } = renderHook(() => useTestProvider(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync('lastfm'))
await waitFor(() => expect(result.current.data).toEqual({ ok: false, status: 'key_refused' }))
})
test('removing a provider data gives what was removed', async () => {
const counts = { similar_artists: 4, tags: 9, descriptions: 0, images: 0, artists: 2 }
const { calls } = mockFetch({ 'DELETE /api/v1/providers/lastfm/data': () => counts })
const { result } = renderHook(() => usePurgeProvider(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync('lastfm'))
await waitFor(() => expect(result.current.data).toEqual(counts))
expect(calls.map((c) => c.key)).toEqual(['DELETE /api/v1/providers/lastfm/data'])
})
test('what Lidarr offers is asked for only when wanted', async () => {
const offers = { quality_profiles: [{ id: 1, name: 'Any' }], metadata_profiles: [], root_folders: [{ path: '/music', accessible: true }] }
const { calls } = mockFetch({ 'GET /api/v1/providers/lidarr/options': () => offers })
const { wrapper } = setup()
const { result, rerender } = renderHook(({ on }) => useLidarrOffers(on), { wrapper, initialProps: { on: false } })
await new Promise((r) => setTimeout(r, 30))
expect(calls).toHaveLength(0)
rerender({ on: true })
await waitFor(() => expect(result.current.data).toEqual(offers))
})
test('when Lidarr is not set up the offers fail with the error to show', async () => {
mockFetch({ 'GET /api/v1/providers/lidarr/options': () => apiError(409, 'lidarr_not_configured') })
const { result } = renderHook(() => useLidarrOffers(true), { wrapper: setup().wrapper })
await waitFor(() => expect(result.current.isError).toBe(true))
expect(result.current.error).toMatchObject({ status: 409, code: 'lidarr_not_configured' })
})