musora-content-services 2.167.2 → 2.167.4

package/test/unit/eventsAPI.test.ts

@@ -1,159 +0,0 @@
-import eventsAPISingleton from '../../src/services/eventsAPI.js'
-import { initializeTestService } from '../initializeTests.js'
-
-const notificationsModule = require('../../src/services/user/notifications.js')
-const EventsAPI = eventsAPISingleton.constructor as new () => typeof eventsAPISingleton
-
-function deferred<T>() {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((res) => {
-    resolve = res
-  })
-
-  return { promise, resolve }
-}
-
-describe('EventsAPI notification polling lifecycle', () => {
-  let api: typeof eventsAPISingleton
-  let fetchUnreadCountMock: jest.SpyInstance
-
-  beforeEach(() => {
-    initializeTestService()
-    jest.useFakeTimers()
-
-    api = new EventsAPI()
-    jest.spyOn(api, 'initPollingControl').mockResolvedValue({})
-    fetchUnreadCountMock = jest
-      .spyOn(notificationsModule, 'fetchUnreadCount')
-      .mockResolvedValue({ data: 0 })
-  })
-
-  afterEach(() => {
-    api.destroy()
-    jest.useRealTimers()
-    jest.restoreAllMocks()
-  })
-
-  test('initialize keeps the existing polling behavior', async () => {
-    await api.initialize({ brand: 'pianote' })
-
-    expect(fetchUnreadCountMock).toHaveBeenCalledWith({ brand: 'pianote' })
-    expect(api.pollingInterval).not.toBeNull()
-
-    fetchUnreadCountMock.mockClear()
-    await jest.advanceTimersByTimeAsync(60000)
-
-    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
-  })
-
-  test('pause stops polling without removing subscribers', async () => {
-    const handler = jest.fn()
-    api.addNotificationStateUpdatedHandler(handler)
-    await api.initialize()
-    handler.mockClear()
-    fetchUnreadCountMock.mockClear()
-
-    api.pauseNotificationPolling()
-    await jest.advanceTimersByTimeAsync(120000)
-
-    expect(api.pollingInterval).toBeNull()
-    expect(api.onNotificationStateUpdated).toEqual([handler])
-    expect(fetchUnreadCountMock).not.toHaveBeenCalled()
-  })
-
-  test('resume starts one interval and immediately refreshes existing subscribers', async () => {
-    const handler = jest.fn()
-    api.addNotificationStateUpdatedHandler(handler)
-    await api.initialize()
-    api.pauseNotificationPolling()
-    fetchUnreadCountMock.mockResolvedValue({ data: 1, liveEvent: null })
-    fetchUnreadCountMock.mockClear()
-    handler.mockClear()
-
-    await api.resumeNotificationPolling()
-    const resumedInterval = api.pollingInterval
-    await api.resumeNotificationPolling()
-
-    expect(resumedInterval).not.toBeNull()
-    expect(api.pollingInterval).toBe(resumedInterval)
-    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(2)
-    expect(handler).toHaveBeenLastCalledWith({ unreadCount: 1, liveEvent: null })
-  })
-
-  test('repeated pause calls are safe', async () => {
-    await api.initialize()
-
-    api.pauseNotificationPolling()
-    api.pauseNotificationPolling()
-
-    expect(api.pollingInterval).toBeNull()
-  })
-
-  test('pause during asynchronous setup prevents the interval from being created', async () => {
-    const pollingControl = deferred<Record<string, never>>()
-    jest.spyOn(api, 'initPollingControl').mockReturnValue(pollingControl.promise)
-
-    const initializePromise = api.initialize()
-    api.pauseNotificationPolling()
-    pollingControl.resolve({})
-    await initializePromise
-
-    expect(api.pollingInterval).toBeNull()
-    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
-  })
-
-  test('resume during asynchronous setup creates no duplicate interval', async () => {
-    const pollingControl = deferred<Record<string, never>>()
-    jest.spyOn(api, 'initPollingControl').mockReturnValue(pollingControl.promise)
-
-    const initializePromise = api.initialize()
-    api.pauseNotificationPolling()
-    const resumePromise = api.resumeNotificationPolling()
-    const resumedInterval = api.pollingInterval
-    pollingControl.resolve({})
-    await Promise.all([initializePromise, resumePromise])
-
-    expect(resumedInterval).not.toBeNull()
-    expect(api.pollingInterval).toBe(resumedInterval)
-  })
-
-  test('pause and resume while the initial unread request is pending restores polling', async () => {
-    const initialUnreadCount = deferred<{ data: number }>()
-    fetchUnreadCountMock
-      .mockReturnValueOnce(initialUnreadCount.promise)
-      .mockResolvedValue({ data: 1 })
-
-    const initializePromise = api.initialize()
-    await Promise.resolve()
-    await Promise.resolve()
-    expect(api.pollingInterval).not.toBeNull()
-
-    api.pauseNotificationPolling()
-    const resumePromise = api.resumeNotificationPolling()
-
-    expect(api.pollingInterval).not.toBeNull()
-    initialUnreadCount.resolve({ data: 0 })
-    await Promise.all([initializePromise, resumePromise])
-
-    fetchUnreadCountMock.mockClear()
-    await jest.advanceTimersByTimeAsync(60000)
-    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
-  })
-
-  test('destroy remains a full teardown and initialize can start again', async () => {
-    api.addNotificationStateUpdatedHandler(jest.fn())
-    await api.initialize()
-
-    api.destroy()
-
-    expect(api.pollingInterval).toBeNull()
-    expect(api.onNotificationStateUpdated).toEqual([])
-    expect(api.isLiveEventPollingActive).toBe(false)
-
-    fetchUnreadCountMock.mockClear()
-    await api.initialize()
-
-    expect(api.pollingInterval).not.toBeNull()
-    expect(fetchUnreadCountMock).toHaveBeenCalledTimes(1)
-  })
-})

package/test/unit/imageSRCBuilder.test.ts

@@ -1,37 +0,0 @@
-import { buildImageSRC, applySanityTransformations }  from '../../src/services/imageSRCBuilder.js'
-
-describe('imageSRCBuilder', function () {
-  beforeEach(() => {})
-
-  test('applySanityTransformations', async () => {
-    const url =
-      'https://cdn.sanity.io/images/4032r8py/production/83c3b6e7354a46c605804c093f707daa4e3f8f25-8000x4500.png'
-    const width = 500
-    const height = 100
-    const quality = 95
-    const resultingURL = applySanityTransformations(url, {
-      width: width,
-      quality: quality,
-      height: height,
-    })
-    const expected = `${url}?q=100&w=${width}&h=${height}`
-
-    expect(resultingURL).toStrictEqual(expected)
-  })
-
-  test('buildImageSRC', async () => {
-    const url = 'https://d2vyvo0tyx8ig5.cloudfront.net/books/foundations/level-2.jpg'
-    const width = 500
-    const height = 100
-    const quality = 95
-    const resultingURL = buildImageSRC(url, {
-      width: width,
-      quality: quality,
-      height: height,
-    })
-
-    const expected = `https://www.musora.com/cdn-cgi/image/width=${width},height=${height},quality=${quality}/${url}`
-
-    expect(resultingURL).toStrictEqual(expected)
-  })
-})

package/test/unit/imageSRCVerify.test.ts

@@ -1,155 +0,0 @@
-import { extractSanityUrl, isBucketUrl, verifyImageSRC } from '../../src/services/imageSRCVerify.js'
-
-const originalConsoleWarn = console.warn
-const originalConsoleError = console.error
-const originalNodeEnv = process.env.NODE_ENV
-
-describe('Image URL Verification', () => {
-  let consoleWarnMock: any
-
-  beforeEach(() => {
-    consoleWarnMock = jest.fn()
-    console.warn = consoleWarnMock
-    console.error = jest.fn()
-    process.env.NODE_ENV = 'development'
-  })
-
-  afterEach(() => {
-    console.warn = originalConsoleWarn
-    console.error = originalConsoleError
-    process.env.NODE_ENV = originalNodeEnv
-  })
-
-  describe('verifyImageSRC', () => {
-    test('should not warn for Sanity URL with parameters', () => {
-      // Arrange
-      const url =
-        'https://cdn.sanity.io/images/4032r8py/staging/504c4e3393170f937a579de6f3c75c457b0c9e65-640x360.jpg?w=500&q=95'
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).not.toHaveBeenCalled()
-    })
-
-    test('should warn for Sanity URL without parameters', () => {
-      // Arrange
-      const url =
-        'https://cdn.sanity.io/images/4032r8py/staging/504c4e3393170f937a579de6f3c75c457b0c9e65-640x360.jpg'
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).toHaveBeenCalled()
-      expect(consoleWarnMock.mock.calls[0][0]).toContain(
-        'WARNING: Sanity CDN URL without parameters detected'
-      )
-    })
-
-    test('should warn for direct S3 bucket URL', () => {
-      // Arrange
-      const url = 'https://musora-images.s3.amazonaws.com/drumeo/images/some-image.jpg'
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).toHaveBeenCalled()
-      expect(consoleWarnMock.mock.calls[0][0]).toContain('Direct S3 bucket URL detected')
-    })
-
-    test('should not warn when URL is empty', () => {
-      // Arrange
-      const url = ''
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Cloudflare wrapped Sanity URLs', () => {
-    test('should extract and validate Sanity URL from Cloudflare wrapper', () => {
-      // Arrange
-      const url =
-        'https://www.musora.com/cdn-cgi/image/width=500,quality=95/https://cdn.sanity.io/images/4032r8py/staging/504c4e3393170f937a579de6f3c75c457b0c9e65-640x360.jpg'
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).toHaveBeenCalled()
-      expect(consoleWarnMock.mock.calls[0][0]).toContain(
-        'WARNING: Sanity CDN URL without parameters detected'
-      )
-    })
-
-    test('should not warn for Cloudflare wrapped Sanity URL with parameters', () => {
-      // Arrange
-      const url =
-        'https://www.musora.com/cdn-cgi/image/width=500,quality=95/https://cdn.sanity.io/images/4032r8py/staging/504c4e3393170f937a579de6f3c75c457b0c9e65-640x360.jpg?w=500&q=95'
-
-      // Act
-      verifyImageSRC(url)
-
-      // Assert
-      expect(consoleWarnMock).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('isBucketUrl', () => {
-    test('should detect standard S3 URLs', () => {
-      // Arrange & Act & Assert
-      expect(isBucketUrl('https://my-bucket.s3.amazonaws.com/image.jpg')).toBe(true)
-      expect(isBucketUrl('https://s3.us-east-1.amazonaws.com/my-bucket/image.jpg')).toBe(true)
-      expect(isBucketUrl('https://musora-images.s3.amazonaws.com/path/to/image.jpg')).toBe(true)
-    })
-
-    test('should not flag non-S3 URLs', () => {
-      // Arrange & Act & Assert
-      expect(isBucketUrl('https://cdn.sanity.io/images/123/production/image.jpg')).toBe(false)
-      expect(isBucketUrl('https://www.musora.com/image.jpg')).toBe(false)
-    })
-  })
-
-  describe('extractSanityUrl', () => {
-    test('should extract Sanity URL from Cloudflare wrapper', () => {
-      // Arrange
-      const wrappedUrl =
-        'https://www.musora.com/cdn-cgi/image/width=500,quality=95/https://cdn.sanity.io/images/123/production/image.jpg'
-      const expectedExtracted = 'https://cdn.sanity.io/images/123/production/image.jpg'
-
-      // Act
-      const result = extractSanityUrl(wrappedUrl)
-
-      // Assert
-      expect(result).toBe(expectedExtracted)
-    })
-
-    test('should return original URL if not Cloudflare wrapped', () => {
-      // Arrange
-      const url = 'https://cdn.sanity.io/images/123/production/image.jpg'
-
-      // Act
-      const result = extractSanityUrl(url)
-
-      // Assert
-      expect(result).toBe(url)
-    })
-
-    test('should handle malformed Cloudflare URLs gracefully', () => {
-      // Arrange
-      const malformedUrl = 'https://www.musora.com/cdn-cgi/image/width=500'
-
-      // Act
-      const result = extractSanityUrl(malformedUrl)
-
-      // Assert
-      expect(result).toBe(malformedUrl)
-    })
-  })
-})

package/test/unit/infrastructure/DefaultHeaderProvider.test.ts

@@ -1,39 +0,0 @@
-import { DefaultHeaderProvider } from '../../../src/infrastructure/http/providers/DefaultHeaderProvider'
-import { globalConfig } from '../../../src/services/config.js'
-jest.mock('../../../src/services/config.js', () => ({
-  globalConfig: {
-    localTimezoneString: null,
-    isMA: false,
-  }
-}))
-describe('DefaultHeaderProvider', () => {
-  let provider: DefaultHeaderProvider
-  beforeEach(() => {
-    provider = new DefaultHeaderProvider()
-    globalConfig.localTimezoneString = null
-    globalConfig.isMA = false
-  })
-  test('always includes Content-Type and Accept headers', () => {
-    const headers = provider.getHeaders()
-    expect(headers['Content-Type']).toBe('application/json')
-    expect(headers['Accept']).toBe('application/json')
-  })
-  test('adds M-Client-Timezone header when localTimezoneString is set', () => {
-    globalConfig.localTimezoneString = 'America/Vancouver'
-    const headers = provider.getHeaders()
-    expect(headers['M-Client-Timezone']).toBe('America/Vancouver')
-  })
-  test('omits M-Client-Timezone header when localTimezoneString is not set', () => {
-    const headers = provider.getHeaders()
-    expect(headers['M-Client-Timezone']).toBeUndefined()
-  })
-  test('adds X-Client-Platform header when isMA is true', () => {
-    globalConfig.isMA = true
-    const headers = provider.getHeaders()
-    expect(headers['X-Client-Platform']).toBe('mobile')
-  })
-  test('omits X-Client-Platform header when isMA is false', () => {
-    const headers = provider.getHeaders()
-    expect(headers['X-Client-Platform']).toBeUndefined()
-  })
-})

package/test/unit/infrastructure/sanity/ContentClient.test.ts

@@ -1,168 +0,0 @@
-import { ContentClient } from '../../../../src/infrastructure/sanity/clients/ContentClient'
-import { ConfigProvider } from '../../../../src/infrastructure/sanity/interfaces/ConfigProvider'
-import { QueryExecutor } from '../../../../src/infrastructure/sanity/interfaces/QueryExecutor'
-import { SanityConfig } from '../../../../src/infrastructure/sanity/interfaces/SanityConfig'
-import { SanityQuery } from '../../../../src/infrastructure/sanity/interfaces/SanityQuery'
-import { SanityResponse } from '../../../../src/infrastructure/sanity/interfaces/SanityResponse'
-
-describe('ContentClient', () => {
-  const config: SanityConfig = {
-    projectId: 'p',
-    dataset: 'd',
-    version: '2021-06-07',
-    token: 't',
-  }
-  let mockConfigProvider: jest.Mocked<ConfigProvider>
-  let mockExecutor: jest.Mocked<QueryExecutor>
-  let client: ContentClient
-  let capturedQueries: string[]
-
-  beforeEach(() => {
-    capturedQueries = []
-    mockConfigProvider = { getConfig: jest.fn().mockReturnValue(config) }
-    mockExecutor = {
-      execute: jest.fn().mockImplementation((q: SanityQuery) => {
-        capturedQueries.push(q.query)
-        return Promise.resolve({ result: [], ms: 1, query: q.query } as SanityResponse<any>)
-      }),
-    }
-    client = new ContentClient(mockConfigProvider, mockExecutor)
-  })
-
-  describe('fetchById', () => {
-    test('builds query with railcontent_id, _type and [0] suffix', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({
-        result: [{ id: 42, title: 'Song' }],
-        ms: 1,
-        query: '',
-      } as any)
-      const result = await client.fetchById<{ id: number; title: string }>({
-        type: 'song',
-        id: 42,
-      })
-
-      expect(result).toEqual({ id: 42, title: 'Song' })
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('railcontent_id == 42')
-      expect(q).toContain("_type == 'song'")
-      expect(q).toContain("'id': railcontent_id")
-      expect(q.trim().endsWith('[0]')).toBe(true)
-    })
-
-    test('uses custom fields when provided', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [{}], ms: 1, query: '' } as any)
-      await client.fetchById({
-        type: 'song',
-        id: 1,
-        fields: ['title', 'artist'],
-      })
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('{title,\n    artist}')
-      expect(q).not.toContain("'thumbnail'")
-    })
-
-    test('adds children fields when includeChildren is true', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [{}], ms: 1, query: '' } as any)
-      await client.fetchById({
-        type: 'course',
-        id: 1,
-        includeChildren: true,
-      })
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('child_count')
-      expect(q).toContain('"lessons": child[]->{')
-    })
-
-    test('returns null when nothing matches', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
-      const result = await client.fetchById({ type: 'song', id: 999 })
-      expect(result).toBeNull()
-    })
-  })
-
-  describe('fetchByIds', () => {
-    test('returns empty array immediately when no ids supplied', async () => {
-      const result = await client.fetchByIds([])
-      expect(result).toEqual([])
-      expect(mockExecutor.execute).not.toHaveBeenCalled()
-    })
-
-    test('builds query with id list and optional type/brand filters', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
-      await client.fetchByIds([1, 2, 3], 'song', 'drumeo')
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('railcontent_id in [1,2,3]')
-      expect(q).toContain("_type == 'song'")
-      expect(q).toContain('brand == "drumeo"')
-    })
-
-    test('omits type and brand filters when not provided', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
-      await client.fetchByIds([10, 20])
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('railcontent_id in [10,20]')
-      expect(q).not.toContain('_type ==')
-      expect(q).not.toContain('brand ==')
-    })
-
-    test('sorts results to match input id order', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({
-        result: [{ id: 3 }, { id: 1 }, { id: 2 }],
-        ms: 1,
-        query: '',
-      } as any)
-      const result = await client.fetchByIds<{ id: number }>([1, 2, 3])
-      expect(result.map((r) => r.id)).toEqual([1, 2, 3])
-    })
-
-    test('sorts by railcontent_id when id field is absent', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({
-        result: [{ railcontent_id: 2 }, { railcontent_id: 1 }],
-        ms: 1,
-        query: '',
-      } as any)
-      const result = await client.fetchByIds<{ railcontent_id: number }>([1, 2])
-      expect(result.map((r) => r.railcontent_id)).toEqual([1, 2])
-    })
-  })
-
-  describe('fetchByBrandAndType', () => {
-    test('applies default limit, offset, sort', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
-      await client.fetchByBrandAndType('drumeo', 'song')
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('brand == "drumeo"')
-      expect(q).toContain('_type == "song"')
-      expect(q).toContain('order(published_on desc)')
-      expect(q).toContain('[0...10]')
-    })
-
-    test('honours custom limit, offset, sort, fields', async () => {
-      mockExecutor.execute.mockResolvedValueOnce({ result: [], ms: 1, query: '' } as any)
-      await client.fetchByBrandAndType('pianote', 'course', {
-        limit: 5,
-        offset: 20,
-        sortBy: 'title asc',
-        fields: ['title'],
-      })
-      const q = mockExecutor.execute.mock.calls[0][0].query
-      expect(q).toContain('order(title asc)')
-      expect(q).toContain('[20...25]')
-      expect(q).toContain('{title}')
-    })
-
-    test('returns list from executor', async () => {
-      const items = [{ id: 1 }, { id: 2 }]
-      mockExecutor.execute.mockResolvedValueOnce({ result: items, ms: 1, query: '' } as any)
-      const result = await client.fetchByBrandAndType<{ id: number }>('drumeo', 'song')
-      expect(result).toEqual(items)
-    })
-
-    test('rethrows wrapped SanityError on executor failure', async () => {
-      mockExecutor.execute.mockRejectedValueOnce(new Error('boom'))
-      await expect(client.fetchByBrandAndType('drumeo', 'song')).rejects.toMatchObject({
-        message: 'boom',
-      })
-    })
-  })
-})

package/test/unit/infrastructure/sanity/DefaultConfigProvider.test.ts

@@ -1,93 +0,0 @@
-import { DefaultConfigProvider } from '../../../../src/infrastructure/sanity/providers/DefaultConfigProvider'
-import { globalConfig } from '../../../../src/services/config.js'
-
-jest.mock('../../../../src/services/config.js', () => ({
-  globalConfig: {
-    sanityConfig: null,
-  },
-}))
-
-describe('DefaultConfigProvider', () => {
-  let provider: DefaultConfigProvider
-
-  beforeEach(() => {
-    provider = new DefaultConfigProvider()
-    ;(globalConfig as any).sanityConfig = null
-  })
-
-  test('throws when sanityConfig is missing from globalConfig', () => {
-    ;(globalConfig as any).sanityConfig = null
-    expect(() => provider.getConfig()).toThrow('Sanity configuration is not available in globalConfig')
-  })
-
-  test('throws when token is missing', () => {
-    ;(globalConfig as any).sanityConfig = {
-      projectId: 'p',
-      dataset: 'd',
-      version: 'v',
-    }
-    expect(() => provider.getConfig()).toThrow('Sanity token is missing in configuration')
-  })
-
-  test('throws when projectId is missing', () => {
-    ;(globalConfig as any).sanityConfig = {
-      token: 't',
-      dataset: 'd',
-      version: 'v',
-    }
-    expect(() => provider.getConfig()).toThrow('Sanity projectId is missing in configuration')
-  })
-
-  test('throws when dataset is missing', () => {
-    ;(globalConfig as any).sanityConfig = {
-      token: 't',
-      projectId: 'p',
-      version: 'v',
-    }
-    expect(() => provider.getConfig()).toThrow('Sanity dataset is missing in configuration')
-  })
-
-  test('throws when version is missing', () => {
-    ;(globalConfig as any).sanityConfig = {
-      token: 't',
-      projectId: 'p',
-      dataset: 'd',
-    }
-    expect(() => provider.getConfig()).toThrow('Sanity version is missing in configuration')
-  })
-
-  test('returns config with defaults when optional fields are absent', () => {
-    ;(globalConfig as any).sanityConfig = {
-      token: 't',
-      projectId: 'p',
-      dataset: 'd',
-      version: '2021-06-07',
-    }
-    const config = provider.getConfig()
-    expect(config).toEqual({
-      projectId: 'p',
-      dataset: 'd',
-      version: '2021-06-07',
-      token: 't',
-      perspective: 'published',
-      useCachedAPI: false,
-      debug: false,
-    })
-  })
-
-  test('passes through optional perspective, useCachedAPI, debug', () => {
-    ;(globalConfig as any).sanityConfig = {
-      token: 't',
-      projectId: 'p',
-      dataset: 'd',
-      version: '2021-06-07',
-      perspective: 'previewDrafts',
-      useCachedAPI: true,
-      debug: true,
-    }
-    const config = provider.getConfig()
-    expect(config.perspective).toBe('previewDrafts')
-    expect(config.useCachedAPI).toBe(true)
-    expect(config.debug).toBe(true)
-  })
-})