kmcom-nuxt-layers 6.4.0 → 6.5.0

package/layers/data/metadata/providers/openlibrary/server/utils/metadata-openlibrary/normalise.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, it, vi } from 'vite-plus/test'
-
-import { openLibraryCoverUrl } from './client'
-import {
-  normaliseOpenLibraryEdition,
-  normaliseOpenLibrarySearchDoc,
-  normaliseOpenLibraryWork,
-} from './normalise'
-import type { OpenLibraryEdition, OpenLibrarySearchDoc, OpenLibraryWork } from './types'
-
-// normalise.ts calls openLibraryCoverUrl() as a Nitro auto-import; stub it with the real
-// implementation from client.ts since that function is pure (no $fetch/config involved).
-vi.stubGlobal('openLibraryCoverUrl', openLibraryCoverUrl)
-
-function baseSearchDoc(overrides: Partial<OpenLibrarySearchDoc> = {}): OpenLibrarySearchDoc {
-  return {
-    key: '/works/OL82563W',
-    title: 'Watchmen',
-    ...overrides,
-  }
-}
-
-function baseWork(overrides: Partial<OpenLibraryWork> = {}): OpenLibraryWork {
-  return {
-    key: '/works/OL82563W',
-    title: 'Watchmen',
-    ...overrides,
-  }
-}
-
-function baseEdition(overrides: Partial<OpenLibraryEdition> = {}): OpenLibraryEdition {
-  return {
-    key: '/books/OL456M',
-    title: 'Watchmen',
-    ...overrides,
-  }
-}
-
-describe('normaliseOpenLibrarySearchDoc', () => {
-  it('strips /works/ from the key to derive the id', () => {
-    const record = normaliseOpenLibrarySearchDoc(baseSearchDoc({ key: '/works/OL82563W' }))
-    expect(record.providerId).toBe('OL82563W')
-    expect(record.id).toBe('openlibrary:work:OL82563W')
-  })
-
-  it('splits isbn[] into isbn10/isbn13 by length', () => {
-    const record = normaliseOpenLibrarySearchDoc(
-      baseSearchDoc({ isbn: ['0930289232', '9780930289232'] })
-    )
-    expect(record.identifiers).toMatchObject({ isbn10: '0930289232', isbn13: '9780930289232' })
-  })
-
-  it('leaves isbn10/isbn13 undefined when isbn is absent', () => {
-    const record = normaliseOpenLibrarySearchDoc(baseSearchDoc())
-    expect(record.identifiers?.isbn10).toBeUndefined()
-    expect(record.identifiers?.isbn13).toBeUndefined()
-  })
-
-  it('maps author_name/author_key pairs into creators, stripping /authors/', () => {
-    const record = normaliseOpenLibrarySearchDoc(
-      baseSearchDoc({ author_name: ['Alan Moore'], author_key: ['/authors/OL123A'] })
-    )
-    expect(record.creators).toEqual([{ name: 'Alan Moore', role: 'author', providerId: 'OL123A' }])
-  })
-
-  it('leaves creators undefined when there are no authors', () => {
-    expect(normaliseOpenLibrarySearchDoc(baseSearchDoc()).creators).toBeUndefined()
-  })
-
-  it('builds coverUrl from cover_i using openLibraryCoverUrl', () => {
-    const record = normaliseOpenLibrarySearchDoc(baseSearchDoc({ cover_i: 12345 }))
-    expect(record.coverUrl).toBe(openLibraryCoverUrl(12345))
-  })
-
-  it('leaves coverUrl undefined when cover_i is absent', () => {
-    expect(normaliseOpenLibrarySearchDoc(baseSearchDoc()).coverUrl).toBeUndefined()
-  })
-
-  it('stamps lastSyncedAt as a string', () => {
-    expect(normaliseOpenLibrarySearchDoc(baseSearchDoc()).lastSyncedAt).toEqual(expect.any(String))
-  })
-})
-
-describe('normaliseOpenLibraryWork', () => {
-  it('strips /works/ from the key to derive the id', () => {
-    const record = normaliseOpenLibraryWork(baseWork({ key: '/works/OL82563W' }))
-    expect(record.providerId).toBe('OL82563W')
-    expect(record.id).toBe('openlibrary:work:OL82563W')
-  })
-
-  it('uses the description string directly when it is a string', () => {
-    const record = normaliseOpenLibraryWork(baseWork({ description: 'Plain text description' }))
-    expect(record.description).toBe('Plain text description')
-  })
-
-  it('extracts description.value when description is an object', () => {
-    const record = normaliseOpenLibraryWork(
-      baseWork({ description: { value: 'Wrapped description' } })
-    )
-    expect(record.description).toBe('Wrapped description')
-  })
-
-  it('leaves description undefined when absent', () => {
-    expect(normaliseOpenLibraryWork(baseWork()).description).toBeUndefined()
-  })
-
-  it('builds coverUrl from covers[0]', () => {
-    const record = normaliseOpenLibraryWork(baseWork({ covers: [777, 888] }))
-    expect(record.coverUrl).toBe(openLibraryCoverUrl(777))
-  })
-})
-
-describe('normaliseOpenLibraryEdition', () => {
-  it('strips /books/ from the key to derive the id', () => {
-    const record = normaliseOpenLibraryEdition(baseEdition({ key: '/books/OL456M' }))
-    expect(record.providerId).toBe('OL456M')
-    expect(record.id).toBe('openlibrary:edition:OL456M')
-  })
-
-  it('reads isbn10/isbn13 from the first entries of isbn_10/isbn_13', () => {
-    const record = normaliseOpenLibraryEdition(
-      baseEdition({ isbn_10: ['0930289232'], isbn_13: ['9780930289232', '9999999999999'] })
-    )
-    expect(record.identifiers).toMatchObject({ isbn10: '0930289232', isbn13: '9780930289232' })
-  })
-
-  it('leaves isbn10/isbn13 undefined when absent', () => {
-    const record = normaliseOpenLibraryEdition(baseEdition())
-    expect(record.identifiers?.isbn10).toBeUndefined()
-    expect(record.identifiers?.isbn13).toBeUndefined()
-  })
-
-  it('builds coverUrl from covers[0]', () => {
-    const record = normaliseOpenLibraryEdition(baseEdition({ covers: [111] }))
-    expect(record.coverUrl).toBe(openLibraryCoverUrl(111))
-  })
-
-  it('takes publisher from publishers[0]', () => {
-    const record = normaliseOpenLibraryEdition(
-      baseEdition({ publishers: ['DC Comics', 'Vertigo'] })
-    )
-    expect(record.publisher).toBe('DC Comics')
-  })
-})

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/client.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it, vi } from 'vite-plus/test'
-
-vi.stubGlobal('useRuntimeConfig', () => ({
-  metadataTmdb: {
-    apiKey: 'test-key',
-    baseUrl: 'https://api.themoviedb.org/3',
-    imageBaseUrl: 'https://image.tmdb.org/t/p',
-  },
-}))
-
-const { tmdbImageUrl } = await import('./client')
-
-describe('tmdbImageUrl', () => {
-  it('returns undefined when path is null', () => {
-    expect(tmdbImageUrl(null)).toBeUndefined()
-  })
-
-  it('defaults size to w500', () => {
-    expect(tmdbImageUrl('/poster.jpg')).toBe('https://image.tmdb.org/t/p/w500/poster.jpg')
-  })
-
-  it('uses a custom size when provided', () => {
-    expect(tmdbImageUrl('/poster.jpg', 'w200')).toBe('https://image.tmdb.org/t/p/w200/poster.jpg')
-  })
-
-  it('prefixes imageBaseUrl from runtime config', () => {
-    expect(tmdbImageUrl('/backdrop.jpg')).toBe('https://image.tmdb.org/t/p/w500/backdrop.jpg')
-  })
-})

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/normalise.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it, vi } from 'vite-plus/test'
-
-import { tmdbImageUrl } from './client'
-import { normaliseTmdbMovie, normaliseTmdbSearchResult, normaliseTmdbTV } from './normalise'
-import type { TMDBMovie, TMDBSearchMultiResult, TMDBTVShow } from './types'
-
-// normalise.ts calls tmdbImageUrl() and getConfig() -> useRuntimeConfig() as Nitro auto-imports;
-// stub the runtime config and delegate to the real (pure, string-building) client implementation.
-vi.stubGlobal('useRuntimeConfig', () => ({
-  metadataTmdb: {
-    apiKey: 'test-key',
-    baseUrl: 'https://api.themoviedb.org/3',
-    imageBaseUrl: 'https://image.tmdb.org/t/p',
-  },
-}))
-vi.stubGlobal('tmdbImageUrl', tmdbImageUrl)
-
-function baseMovie(overrides: Partial<TMDBMovie> = {}): TMDBMovie {
-  return {
-    id: 550,
-    title: 'Fight Club',
-    overview: '',
-    poster_path: null,
-    backdrop_path: null,
-    release_date: '',
-    ...overrides,
-  }
-}
-
-function baseTV(overrides: Partial<TMDBTVShow> = {}): TMDBTVShow {
-  return {
-    id: 1399,
-    name: 'Game of Thrones',
-    overview: '',
-    poster_path: null,
-    backdrop_path: null,
-    first_air_date: '',
-    ...overrides,
-  }
-}
-
-function baseSearchResult(overrides: Partial<TMDBSearchMultiResult> = {}): TMDBSearchMultiResult {
-  return {
-    id: 1,
-    media_type: 'movie',
-    poster_path: null,
-    ...overrides,
-  }
-}
-
-describe('normaliseTmdbMovie', () => {
-  it('filters directors from credits.crew by job === "Director"', () => {
-    const record = normaliseTmdbMovie(
-      baseMovie({
-        credits: {
-          cast: [],
-          crew: [
-            { id: 1, name: 'David Fincher', job: 'Director', department: 'Directing' },
-            { id: 2, name: 'Jim Uhls', job: 'Screenplay', department: 'Writing' },
-          ],
-        },
-      })
-    )
-    expect(record.creators).toEqual([{ name: 'David Fincher', role: 'Director', providerId: '1' }])
-  })
-
-  it('omits creators entirely when there are no directors', () => {
-    const record = normaliseTmdbMovie(baseMovie())
-    expect('creators' in record).toBe(false)
-  })
-
-  it('omits description, publisher, publishedAt and coverUrl when source fields are absent', () => {
-    const record = normaliseTmdbMovie(baseMovie())
-    expect('description' in record).toBe(false)
-    expect('publisher' in record).toBe(false)
-    expect('publishedAt' in record).toBe(false)
-    expect('coverUrl' in record).toBe(false)
-  })
-
-  it('includes description, publisher, publishedAt and coverUrl when source fields are present', () => {
-    const record = normaliseTmdbMovie(
-      baseMovie({
-        overview: 'A depressed man forms an underground fight club.',
-        production_companies: [{ id: 1, name: 'Fox 2000 Pictures' }],
-        release_date: '1999-10-15',
-        poster_path: '/poster.jpg',
-      })
-    )
-    expect(record.description).toBe('A depressed man forms an underground fight club.')
-    expect(record.publisher).toBe('Fox 2000 Pictures')
-    expect(record.publishedAt).toBe('1999-10-15')
-    expect(record.coverUrl).toBe('https://image.tmdb.org/t/p/w500/poster.jpg')
-  })
-
-  it('includes imdbId in identifiers only when external_ids.imdb_id is present', () => {
-    const withImdb = normaliseTmdbMovie(baseMovie({ external_ids: { imdb_id: 'tt0137523' } }))
-    expect(withImdb.identifiers).toEqual({ tmdbId: '550', imdbId: 'tt0137523' })
-
-    const withoutImdb = normaliseTmdbMovie(baseMovie())
-    expect(withoutImdb.identifiers).toEqual({ tmdbId: '550' })
-    expect('imdbId' in (withoutImdb.identifiers as object)).toBe(false)
-  })
-
-  it('stamps lastSyncedAt as a string', () => {
-    expect(normaliseTmdbMovie(baseMovie()).lastSyncedAt).toEqual(expect.any(String))
-  })
-})
-
-describe('normaliseTmdbTV', () => {
-  it('maps created_by to Creator-role creators', () => {
-    const record = normaliseTmdbTV(baseTV({ created_by: [{ id: 9, name: 'David Benioff' }] }))
-    expect(record.creators).toEqual([{ name: 'David Benioff', role: 'Creator', providerId: '9' }])
-  })
-
-  it('omits creators when created_by is absent', () => {
-    const record = normaliseTmdbTV(baseTV())
-    expect('creators' in record).toBe(false)
-  })
-
-  it('takes publisher from the first network', () => {
-    const record = normaliseTmdbTV(baseTV({ networks: [{ id: 1, name: 'HBO' }] }))
-    expect(record.publisher).toBe('HBO')
-  })
-
-  it('includes imdbId in identifiers only when external_ids.imdb_id is present', () => {
-    const record = normaliseTmdbTV(baseTV({ external_ids: { imdb_id: 'tt0944947' } }))
-    expect(record.identifiers).toEqual({ tmdbId: '1399', imdbId: 'tt0944947' })
-  })
-})
-
-describe('normaliseTmdbSearchResult', () => {
-  it('uses title/release_date and the movie url path for movie results', () => {
-    const record = normaliseTmdbSearchResult(
-      baseSearchResult({ media_type: 'movie', title: 'Dune', release_date: '2021-10-22' })
-    )
-    expect(record.title).toBe('Dune')
-    expect(record.mediaType).toBe('movie')
-    expect(record.publishedAt).toBe('2021-10-22')
-    expect(record.sourceUrl).toBe('https://www.themoviedb.org/movie/1')
-    expect(record.id).toBe('tmdb:movie:1')
-  })
-
-  it('uses name/first_air_date, tv url path and mediaType tv-show for tv results', () => {
-    const record = normaliseTmdbSearchResult(
-      baseSearchResult({
-        media_type: 'tv',
-        name: 'Dune: Prophecy',
-        first_air_date: '2024-11-17',
-      })
-    )
-    expect(record.title).toBe('Dune: Prophecy')
-    expect(record.mediaType).toBe('tv-show')
-    expect(record.publishedAt).toBe('2024-11-17')
-    expect(record.sourceUrl).toBe('https://www.themoviedb.org/tv/1')
-    expect(record.id).toBe('tmdb:tv:1')
-  })
-
-  it('defaults title to empty string when the branch-specific field is missing', () => {
-    const record = normaliseTmdbSearchResult(baseSearchResult({ media_type: 'movie' }))
-    expect(record.title).toBe('')
-  })
-})

package/layers/data/metadata/server/utils/metadata/cache.test.ts

@@ -1,39 +0,0 @@
-import { describe, expect, it } from 'vite-plus/test'
-
-import { hashQuery, makeCacheKey } from './cache'
-
-describe('makeCacheKey', () => {
-  it('joins parts with ":"', () => {
-    expect(makeCacheKey('metadata', 'comicvine', 'issue', '1000')).toBe(
-      'metadata:comicvine:issue:1000'
-    )
-  })
-
-  it('handles a single part', () => {
-    expect(makeCacheKey('metadata')).toBe('metadata')
-  })
-
-  it('handles no parts', () => {
-    expect(makeCacheKey()).toBe('')
-  })
-})
-
-describe('hashQuery', () => {
-  it('is deterministic for the same input', () => {
-    expect(hashQuery('watchmen')).toBe(hashQuery('watchmen'))
-  })
-
-  it('differs for different inputs', () => {
-    expect(hashQuery('watchmen')).not.toBe(hashQuery('v for vendetta'))
-  })
-
-  it('handles an empty string', () => {
-    expect(hashQuery('')).toBe('0')
-  })
-
-  it('returns a non-negative base36 string', () => {
-    const hash = hashQuery('some query with lots of characters to hash')
-    expect(hash).toEqual(expect.any(String))
-    expect(hash.startsWith('-')).toBe(false)
-  })
-})

package/layers/data/metadata/server/utils/metadata/provider-fetch.test.ts

@@ -1,27 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
-
-import { MetadataProviderError } from './errors'
-import { providerFetch } from './provider-fetch'
-
-afterEach(() => vi.unstubAllGlobals())
-
-describe('providerFetch', () => {
-  it('returns the fetched body', async () => {
-    vi.stubGlobal(
-      '$fetch',
-      vi.fn(async () => ({ ok: true }))
-    )
-    await expect(providerFetch('tmdb', 'https://x.test')).resolves.toEqual({ ok: true })
-  })
-
-  it('wraps failures in a MetadataProviderError for the provider', async () => {
-    vi.stubGlobal(
-      '$fetch',
-      vi.fn(async () => Promise.reject(new Error('boom')))
-    )
-    const err = await providerFetch('tmdb', 'https://x.test').catch((e) => e)
-    expect(err).toBeInstanceOf(MetadataProviderError)
-    expect(err.provider).toBe('tmdb')
-    expect(err.message).toContain('API error')
-  })
-})

package/layers/data/metadata/server/utils/metadata/provider-registry.test.ts

@@ -1,54 +0,0 @@
-import type { MetadataProvider } from '#layers/metadata/shared/types'
-import { describe, expect, it } from 'vite-plus/test'
-
-import { getProvider, getProviders, registerProvider } from './provider-registry'
-
-function makeProvider(overrides: Partial<MetadataProvider> = {}): MetadataProvider {
-  return {
-    id: 'comicvine',
-    label: 'Comic Vine',
-    mediaTypes: ['comic'],
-    search: async () => [],
-    lookup: async () => null,
-    ...overrides,
-  }
-}
-
-// NOTE: _registry is a module-level Map singleton shared across every test in this file
-// (vitest isolates modules per test *file*, not per test). Tests below account for
-// accumulation by asserting deltas/membership rather than absolute counts, and by
-// checking unregistered ids before registering them.
-
-describe('provider-registry', () => {
-  it('returns null for an id that has not been registered yet', () => {
-    expect(getProvider('tmdb')).toBeNull()
-  })
-
-  it('registers a provider and retrieves it by id', () => {
-    const provider = makeProvider({ id: 'comicvine' })
-    registerProvider(provider)
-    expect(getProvider('comicvine')).toBe(provider)
-  })
-
-  it('includes registered providers in getProviders()', () => {
-    const before = getProviders().length
-    registerProvider(makeProvider({ id: 'openlibrary', label: 'Open Library' }))
-    const after = getProviders()
-    expect(after.length).toBe(before + 1)
-    expect(after.map((p) => p.id)).toContain('openlibrary')
-  })
-
-  it('overwrites the existing entry when registering the same id again', () => {
-    const countBefore = getProviders().length
-    const first = makeProvider({ id: 'google-books', label: 'First' })
-    const second = makeProvider({ id: 'google-books', label: 'Second' })
-
-    registerProvider(first)
-    expect(getProviders().length).toBe(countBefore + 1)
-
-    registerProvider(second)
-    expect(getProviders().length).toBe(countBefore + 1)
-    expect(getProvider('google-books')).toBe(second)
-    expect(getProvider('google-books')).not.toBe(first)
-  })
-})

package/layers/data/metadata/server/utils/metadata/resolve-record.test.ts

@@ -1,87 +0,0 @@
-import type { MetadataProvider, MetadataRecord } from '#layers/metadata/shared/types'
-import type * as CacheModule from './cache'
-import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-
-const { providerState, getCacheRecordMock, setCacheRecordMock } = vi.hoisted(() => ({
-  providerState: { provider: null as MetadataProvider | null },
-  getCacheRecordMock: vi.fn(async () => null as { normalised: MetadataRecord } | null),
-  setCacheRecordMock: vi.fn(async () => undefined),
-}))
-
-vi.mock('./provider-registry', () => ({ getProvider: () => providerState.provider }))
-vi.mock('./cache', async (importOriginal) => ({
-  ...(await importOriginal<typeof CacheModule>()),
-  getCacheRecord: getCacheRecordMock,
-  setCacheRecord: setCacheRecordMock,
-}))
-
-import { resolveRecord } from './resolve-record'
-
-const record = {
-  id: 'r1',
-  provider: 'comicvine',
-  providerId: '42',
-  mediaType: 'comic',
-  title: 'Watchmen',
-} as MetadataRecord
-
-const lookup = vi.fn(async () => record as MetadataRecord | null)
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  getCacheRecordMock.mockResolvedValue(null)
-  lookup.mockResolvedValue(record)
-  providerState.provider = {
-    id: 'comicvine',
-    label: 'Comic Vine',
-    mediaTypes: ['comic'],
-    search: async () => [],
-    lookup,
-  }
-})
-
-describe('resolveRecord', () => {
-  it('400s without provider or providerId', async () => {
-    await expect(resolveRecord({ provider: 'comicvine' })).rejects.toMatchObject({
-      statusCode: 400,
-    })
-  })
-
-  it('404s for an unregistered provider', async () => {
-    providerState.provider = null
-    await expect(resolveRecord({ provider: 'nope', providerId: '1' })).rejects.toMatchObject({
-      statusCode: 404,
-    })
-  })
-
-  it('fetches, caches and reports synced on a miss', async () => {
-    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
-    expect(out).toEqual({ record, synced: true })
-    expect(setCacheRecordMock).toHaveBeenCalledWith(
-      'metadata:comicvine:item:42',
-      expect.objectContaining({ id: 'r1', providerId: '42', resourceType: 'item' })
-    )
-  })
-
-  it('returns the cached record without calling the provider', async () => {
-    getCacheRecordMock.mockResolvedValue({ normalised: record })
-    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
-    expect(out).toEqual({ record, synced: false })
-    expect(lookup).not.toHaveBeenCalled()
-  })
-
-  it('force skips the cache read', async () => {
-    getCacheRecordMock.mockResolvedValue({ normalised: record })
-    const out = await resolveRecord({ provider: 'comicvine', providerId: '42', force: true })
-    expect(out.synced).toBe(true)
-    expect(lookup).toHaveBeenCalledOnce()
-  })
-
-  it('404s when the provider finds nothing and does not cache', async () => {
-    lookup.mockResolvedValue(null)
-    await expect(resolveRecord({ provider: 'comicvine', providerId: '42' })).rejects.toMatchObject({
-      statusCode: 404,
-    })
-    expect(setCacheRecordMock).not.toHaveBeenCalled()
-  })
-})