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.
This commit is contained in:
tgiachi 2026-11-12 15:05:42 +01:00
commit c3edc564f4
2 changed files with 160 additions and 0 deletions

View file

@ -0,0 +1,92 @@
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' })
})

View file

@ -0,0 +1,68 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { api } from './client'
import type { components } from './schema'
export type Provider = components['schemas']['Provider']
export type ProviderName = Provider['name']
export type ProviderTest = components['schemas']['ProviderTest']
export type ProviderPurge = components['schemas']['ProviderPurge']
export type LidarrOptions = components['schemas']['LidarrOptions']
export type LidarrOffers = components['schemas']['LidarrOffers']
/**
* What `PUT /providers/{name}` takes: any of these, and what is left out is kept. (The generated type of the
* body is an "at least one of" that the generator cannot express, so the fields are listed here.)
*/
export interface ProviderChanges {
enabled?: boolean
/** Write-only. An empty one clears the key, and turns off a provider that needs one. */
api_key?: string
contact?: string
/** Only Lidarr. An empty one clears the address and turns Lidarr off. */
url?: string
/** Only Lidarr. Replaces all its options at once. */
lidarr?: LidarrOptions
}
const PROVIDERS = ['providers']
/** Every external provider with whether it is on and what it would send. The key is never in the answer. */
export function useProviders() {
return useQuery({
queryKey: PROVIDERS,
queryFn: () => api.get<{ providers: Provider[] }>('/providers'),
select: (data) => data.providers,
})
}
/**
* Changes a provider: only the fields given are sent and the rest is kept. An `api_key` is write-only; it
* stays in the mutation's variables until `reset()` is called, so whoever sends one resets the mutation.
*/
export function useUpdateProvider() {
const client = useQueryClient()
return useMutation({
mutationFn: ({ name, ...changes }: { name: ProviderName } & ProviderChanges) => api.put<Provider>(`/providers/${name}`, changes),
onSuccess: () => client.invalidateQueries({ queryKey: PROVIDERS }),
})
}
/** Asks the provider one cheap question with the stored key. A "no" is an answer (`ok` false), not an error. */
export function useTestProvider() {
return useMutation({ mutationFn: (name: ProviderName) => api.post<ProviderTest>(`/providers/${name}/test`) })
}
/** Removes everything a provider told Sonda, and says how much that was. The provider is not switched off. */
export function usePurgeProvider() {
return useMutation({ mutationFn: (name: ProviderName) => api.del<ProviderPurge>(`/providers/${name}/data`) })
}
/** What Lidarr offers to choose from. It is asked only when `enabled`: it contacts the admin's own Lidarr. */
export function useLidarrOffers(enabled: boolean) {
return useQuery({
queryKey: [...PROVIDERS, 'lidarr', 'options'],
enabled,
retry: false,
queryFn: () => api.get<LidarrOffers>('/providers/lidarr/options'),
})
}