musora-content-services 2.167.2 → 2.167.4

package/test/mockData/mockData_user_practices.json

@@ -1,9 +0,0 @@
-{
-  "version": 1,
-  "config": { "key": 1, "enabled": 1, "checkInterval": 1, "refreshInterval": 2 },
-  "data": {
-    "practices": {
-      "DATE_PLACEHOLDER": [{ "duration_seconds": "DURATION_PLACEHOLDER" }]
-    }
-  }
-}

package/test/setupConsole.js

@@ -1,6 +0,0 @@
-global.console.log = jest.fn()
-global.console.warn = jest.fn()
-
-if (typeof structuredClone === 'undefined') {
-  global.structuredClone = (v) => JSON.parse(JSON.stringify(v))
-}

package/test/setupNetworkGuard.js

@@ -1,3 +0,0 @@
-global.fetch = () => {
-  throw new Error('Real network call detected in unit/integration test. Mock the HTTP layer.')
-}

package/test/setupTimers.js

@@ -1,13 +0,0 @@
-const _originalSetTimeout = global.setTimeout
-global.setTimeout = function(fn, delay, ...args) {
-  const timer = _originalSetTimeout(fn, delay, ...args)
-  timer?.unref?.()
-  return timer
-}
-
-const _originalSetInterval = global.setInterval
-global.setInterval = function(fn, delay, ...args) {
-  const timer = _originalSetInterval(fn, delay, ...args)
-  timer?.unref?.()
-  return timer
-}

package/test/unit/HttpClient.test.ts

@@ -1,267 +0,0 @@
-import { HeaderProvider, HttpClient, RequestExecutor } from '../../src/infrastructure/http'
-
-describe('HttpClient', () => {
-  let httpClient: HttpClient
-  let mockHeaderProvider: jest.Mocked<HeaderProvider>
-  let mockRequestExecutor: jest.Mocked<RequestExecutor>
-  const baseUrl = 'https://api.example.com'
-  const token = 'test-token'
-  const headers = { 'Content-Type': 'application/json', Accept: 'application/json' }
-  const responseData = { success: true }
-
-  beforeEach(() => {
-    // Mock HeaderProvider
-    mockHeaderProvider = {
-      getHeaders: jest.fn().mockReturnValue(headers),
-    }
-
-    // Mock RequestExecutor
-    mockRequestExecutor = {
-      execute: jest.fn().mockResolvedValue(responseData),
-    }
-
-    // Create HttpClient instance with mocks
-    httpClient = new HttpClient(baseUrl, token, mockHeaderProvider, mockRequestExecutor)
-  })
-
-  describe('Constructor', () => {
-    test('should initialize with default parameters when not provided', () => {
-      const client = new HttpClient(baseUrl)
-      expect(client).toBeInstanceOf(HttpClient)
-    })
-
-    test('should initialize with provided parameters', () => {
-      expect(httpClient).toBeInstanceOf(HttpClient)
-    })
-  })
-
-  describe('credentials', () => {
-    test('should default to include', async () => {
-      const client = new HttpClient(baseUrl, token, mockHeaderProvider, mockRequestExecutor)
-      await client.get('/test')
-      const options = mockRequestExecutor.execute.mock.calls[0][1]
-      expect(options.credentials).toBe('include')
-    })
-
-    test('should use provided credentials value', async () => {
-      const client = new HttpClient(baseUrl, token, mockHeaderProvider, mockRequestExecutor, 'omit')
-      await client.get('/test')
-      const options = mockRequestExecutor.execute.mock.calls[0][1]
-      expect(options.credentials).toBe('omit')
-    })
-  })
-
-  describe('setToken', () => {
-    test('should update the token', () => {
-      const newToken = 'new-test-token'
-      httpClient.setToken(newToken)
-
-      // Verify token was updated by making a request and checking if the new token is used
-      httpClient.get('/test')
-
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${newToken}`,
-          }),
-        })
-      )
-    })
-  })
-
-  describe('HTTP Methods', () => {
-    test('get should make a GET request', async () => {
-      const url = '/test'
-      await httpClient.get(url)
-
-      expect(mockHeaderProvider.getHeaders).toHaveBeenCalled()
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${url}`,
-        expect.objectContaining({
-          method: 'GET',
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${token}`,
-          }),
-        })
-      )
-    })
-
-    test('post should make a POST request with data', async () => {
-      const url = '/test'
-      const data = { name: 'test' }
-      await httpClient.post(url, data)
-
-      expect(mockHeaderProvider.getHeaders).toHaveBeenCalled()
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${url}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${token}`,
-          }),
-          body: JSON.stringify(data),
-        })
-      )
-    })
-
-    test('put should make a PUT request with data', async () => {
-      const url = '/test'
-      const data = { name: 'test' }
-      await httpClient.put(url, data)
-
-      expect(mockHeaderProvider.getHeaders).toHaveBeenCalled()
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${url}`,
-        expect.objectContaining({
-          method: 'PUT',
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${token}`,
-          }),
-          body: JSON.stringify(data),
-        })
-      )
-    })
-
-    test('patch should make a PATCH request with data', async () => {
-      const url = '/test'
-      const data = { name: 'test' }
-      await httpClient.patch(url, data)
-
-      expect(mockHeaderProvider.getHeaders).toHaveBeenCalled()
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${url}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${token}`,
-          }),
-          body: JSON.stringify(data),
-        })
-      )
-    })
-
-    test('delete should make a DELETE request', async () => {
-      const url = '/test'
-      await httpClient.delete(url)
-
-      expect(mockHeaderProvider.getHeaders).toHaveBeenCalled()
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${url}`,
-        expect.objectContaining({
-          method: 'DELETE',
-          headers: expect.objectContaining({
-            Authorization: `Bearer ${token}`,
-          }),
-        })
-      )
-    })
-  })
-
-  describe('URL Resolution', () => {
-    test('should prepend baseUrl to relative URLs', async () => {
-      const relativeUrl = '/api/endpoint'
-      await httpClient.get(relativeUrl)
-
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
-        `${baseUrl}${relativeUrl}`,
-        expect.anything()
-      )
-    })
-
-    test('should not modify absolute URLs', async () => {
-      const absoluteUrl = 'https://another-api.example.com/endpoint'
-      await httpClient.get(absoluteUrl)
-
-      expect(mockRequestExecutor.execute).toHaveBeenCalledWith(absoluteUrl, expect.anything())
-    })
-  })
-
-  describe('Data Version Header', () => {
-    beforeEach(() => {
-      // Reset all mocks and create a fresh HttpClient for each test
-      jest.resetAllMocks()
-      mockHeaderProvider = {
-        getHeaders: jest.fn().mockReturnValue({ ...headers }),
-      }
-      mockRequestExecutor = {
-        execute: jest.fn().mockResolvedValue(responseData),
-      }
-      httpClient = new HttpClient(baseUrl, token, mockHeaderProvider, mockRequestExecutor)
-    })
-
-    test('should add Data-Version header when provided', async () => {
-      const url = '/test'
-      const dataVersion = '1.2.3'
-
-      await httpClient.get(url, { dataVersion })
-
-      // Check the actual calls that were made
-      expect(mockRequestExecutor.execute.mock.calls.length).toBe(1)
-
-      const requestOptions = mockRequestExecutor.execute.mock.calls[0][1]
-      expect(requestOptions.headers['Data-Version']).toBe(dataVersion)
-    })
-
-    test('should not add Data-Version header when not provided', async () => {
-
-      const url = '/test'
-
-      // Make sure we're using exact null here, not undefined
-      const dataVersion: string | null = null
-
-      // Create separate mocks for this test to avoid state bleeding
-      const testHeaderProvider: jest.Mocked<HeaderProvider> = {
-        getHeaders: jest.fn().mockReturnValue({
-          'Content-Type': 'application/json',
-          Accept: 'application/json',
-        }),
-      }
-
-      const testRequestExecutor: jest.Mocked<RequestExecutor> = {
-        execute: jest.fn().mockResolvedValue(responseData),
-      }
-
-      // Create a completely fresh HttpClient instance
-      const testClient = new HttpClient(baseUrl, token, testHeaderProvider, testRequestExecutor)
-
-      await testClient.get(url, { dataVersion })
-
-      // Direct check on the mock to validate Data-Version absence
-      const actualHeaders = testRequestExecutor.execute.mock.calls[0][1].headers
-      const hasDataVersion = Object.prototype.hasOwnProperty.call(actualHeaders, 'Data-Version')
-      expect(hasDataVersion).toBe(false)
-    })
-  })
-
-  describe('Error Handling', () => {
-    test('should properly handle HTTP errors', async () => {
-      const httpError = {
-        status: 404,
-        statusText: 'Not Found',
-        body: { message: 'Resource not found' },
-        url: `${baseUrl}/test`,
-        method: 'get',
-      }
-
-      mockRequestExecutor.execute.mockRejectedValueOnce(httpError)
-
-      await expect(httpClient.get('/test')).rejects.toEqual(httpError)
-    })
-
-    test('should properly handle network errors', async () => {
-      const networkError = new Error('Network error')
-
-      mockRequestExecutor.execute.mockImplementationOnce(() => {
-        throw networkError
-      })
-
-      await expect(httpClient.get('/test')).rejects.toMatchObject({
-        message: 'Network error',
-        url: '/test',
-        method: 'GET',
-        originalError: networkError,
-      })
-    })
-  })
-})

package/test/unit/awards/award-alacarte-observer.test.ts

@@ -1,199 +0,0 @@
-import { contentProgressObserver } from '../../../src/services/awards/internal/content-progress-observer.js'
-import { awardEvents } from '../../../src/services/awards/internal/award-events.js'
-import { mockAwardDefinitions, getAwardByContentId } from '../../mockData/award-definitions.js'
-import { setupDefaultMocks, setupAwardEventListeners } from './helpers/index'
-import { mockCompletionStates, mockAllCompleted } from './helpers/completion-mock'
-import { COLLECTION_TYPE, emitAlaCarteProgress, emitProgress, waitForDebounce } from './helpers/progress-emitter'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity'),
-  default: { fetch: jest.fn() },
-  fetchSanity: jest.fn()
-}))
-
-jest.mock('../../../src/services/sync/repository-proxy.ts', () => {
-  const mockFns = {
-    contentProgress: {
-      getOneProgressByContentId: jest.fn(),
-      getSomeProgressByContentIds: jest.fn(),
-      queryOne: jest.fn(),
-      queryAll: jest.fn()
-    },
-    practices: {
-      sumPracticeMinutesForContent: jest.fn()
-    },
-    userAwardProgress: {
-      hasCompletedAward: jest.fn(),
-      recordAwardProgress: jest.fn(),
-      getByAwardId: jest.fn()
-    }
-  }
-  return { default: mockFns, ...mockFns }
-})
-
-import sanityClient, { fetchSanity } from '../../../src/services/sanity.js'
-import db from '../../../src/services/sync/repository-proxy'
-import { awardDefinitions } from '../../../src/services/awards/internal/award-definitions.js'
-
-const mockDb = db as jest.MockedObjectDeep<typeof db>
-
-describe('Award Observer - A La Carte Progress (null collection)', () => {
-  let listeners
-
-  beforeEach(async () => {
-    jest.clearAllMocks()
-    awardEvents.removeAllListeners()
-
-    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
-    setupDefaultMocks(mockDb, fetchSanity)
-
-    await awardDefinitions.refresh()
-
-    listeners = setupAwardEventListeners(awardEvents)
-
-    await contentProgressObserver.start()
-  })
-
-  afterEach(() => {
-    awardEvents.removeAllListeners()
-    awardDefinitions.clear()
-    contentProgressObserver.stop()
-  })
-
-  describe('A la carte progress triggers award evaluation', () => {
-    const testAward = getAwardByContentId(417049)
-
-    test('finds awards when progress has null collection type', async () => {
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.granted).toHaveBeenCalled()
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload).toHaveProperty('awardId', testAward._id)
-    })
-
-    test('emits awardProgress for partial completion with null collection', async () => {
-      mockCompletionStates(mockDb, [417045])
-
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.progress).toHaveBeenCalled()
-      const payload = listeners.progress.mock.calls[0][0]
-      expect(payload).toHaveProperty('awardId', testAward._id)
-      expect(payload).toHaveProperty('progressPercentage')
-    })
-  })
-
-  describe('A la carte grants award when all children completed', () => {
-    const testAward = getAwardByContentId(416442)
-
-    test('grants award for guided course with null collection progress', async () => {
-      emitAlaCarteProgress(416444)
-      await waitForDebounce()
-
-      expect(listeners.granted).toHaveBeenCalled()
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload).toHaveProperty('awardId', testAward._id)
-      expect(payload).toHaveProperty('completionData')
-    })
-
-    test('includes completion data in granted event', async () => {
-      emitAlaCarteProgress(416444)
-      await waitForDebounce()
-
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload.completionData).toMatchObject({
-        content_title: expect.any(String),
-        completed_at: expect.any(String),
-        days_user_practiced: expect.any(Number),
-        practice_minutes: 200
-      })
-    })
-  })
-
-  describe('A la carte progress matches multiple awards', () => {
-    test('finds all awards containing the child content id', async () => {
-      const sharedChildId = 418003
-
-      mockAllCompleted(mockDb)
-
-      emitAlaCarteProgress(sharedChildId)
-      await waitForDebounce()
-
-      expect(mockDb.userAwardProgress.recordAwardProgress).toHaveBeenCalled()
-    })
-  })
-
-  describe('A la carte debouncing', () => {
-    beforeEach(() => {
-      mockCompletionStates(mockDb, [])
-    })
-
-    test('debounces multiple rapid a la carte updates', async () => {
-      emitAlaCarteProgress(416451)
-      emitAlaCarteProgress(416453)
-      emitAlaCarteProgress(416454)
-
-      await waitForDebounce()
-
-      expect(mockDb.userAwardProgress.recordAwardProgress).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('A la carte does not match unrelated content', () => {
-    test('ignores content not in any award child_ids', async () => {
-      emitAlaCarteProgress(999999)
-      await waitForDebounce()
-
-      expect(listeners.progress).not.toHaveBeenCalled()
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('A la carte already completed award', () => {
-    beforeEach(() => {
-      mockDb.userAwardProgress.hasCompletedAward.mockResolvedValue(true)
-    })
-
-    test('does not re-grant already completed award', async () => {
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('A la carte vs collection-scoped progress handling', () => {
-    test('a la carte progress finds awards regardless of award content_type', async () => {
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.granted).toHaveBeenCalled()
-    })
-
-    test('non-LP collection context still triggers awards (a la carte)', async () => {
-      emitProgress({
-        contentId: 417045,
-        collectionType: 'skill-pack',
-        collectionId: 999999
-      })
-      await waitForDebounce()
-
-      expect(listeners.granted).toHaveBeenCalled()
-    })
-
-    test('LP collection context requires matching collection', async () => {
-      listeners.granted.mockClear()
-
-      emitProgress({
-        contentId: 418004,
-        collectionType: COLLECTION_TYPE.LEARNING_PATH,
-        collectionId: 999999
-      })
-      await waitForDebounce()
-
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-})

package/test/unit/awards/award-auto-refresh.test.ts

@@ -1,84 +0,0 @@
-import { awardDefinitions } from '../../../src/services/awards/internal/award-definitions.js'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity'),
-  default: {
-    fetch: jest.fn()
-  },
-  fetchSanity: jest.fn()
-}))
-
-import { fetchSanity } from '../../../src/services/sanity.js'
-
-describe('Award Definitions Cache', () => {
-  const mockAwards = [
-    {
-      _id: 'test-award-1',
-      name: 'Test Award',
-      brand: 'drumeo',
-      content_id: 12345,
-      is_active: true,
-      content_type: 'guided-course'
-    }
-  ]
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    awardDefinitions.clear()
-    fetchSanity.mockResolvedValue(mockAwards)
-  })
-
-  afterEach(() => {
-    awardDefinitions.clear()
-  })
-
-  test('loads award definitions on first access', async () => {
-    const awards = await awardDefinitions.getAll()
-
-    expect(fetchSanity).toHaveBeenCalled()
-    expect(awards).toHaveLength(1)
-    expect(awards[0]._id).toBe('test-award-1')
-  })
-
-  test('uses cached definitions within refresh window', async () => {
-    await awardDefinitions.getAll()
-
-    fetchSanity.mockClear()
-
-    const awards = await awardDefinitions.getAll()
-
-    expect(fetchSanity).not.toHaveBeenCalled()
-    expect(awards).toHaveLength(1)
-  })
-
-  test('refreshes award definitions when cache expires', async () => {
-    awardDefinitions.lastFetch = Date.now() - (25 * 60 * 60 * 1000)
-
-    const awards = await awardDefinitions.getAll()
-
-    expect(fetchSanity).toHaveBeenCalled()
-    expect(awards).toHaveLength(1)
-
-    fetchSanity.mockClear()
-
-    const cachedAwards = await awardDefinitions.getAll()
-
-    expect(fetchSanity).not.toHaveBeenCalled()
-    expect(cachedAwards).toHaveLength(1)
-  })
-
-  test('does not refetch when called rapidly within cache window', async () => {
-    await awardDefinitions.getAll()
-    const callCountAfterFirst = fetchSanity.mock.calls.length
-
-    await Promise.all([
-      awardDefinitions.getAll(),
-      awardDefinitions.getAll(),
-      awardDefinitions.getAll(),
-      awardDefinitions.getAll(),
-      awardDefinitions.getAll()
-    ])
-
-    expect(fetchSanity.mock.calls.length).toBe(callCountAfterFirst)
-  })
-})

package/test/unit/awards/award-calculations.test.ts

@@ -1,34 +0,0 @@
-import { getEligibleChildIds } from '../../../src/services/awards/internal/award-definitions.js'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity'),
-  default: {
-    fetch: jest.fn()
-  },
-  fetchSanity: jest.fn()
-}))
-
-describe('Award Calculations', () => {
-  describe('getEligibleChildIds', () => {
-    test('returns all child_ids from award definition', () => {
-      const award = { child_ids: [1, 2, 3, 4] }
-      expect(getEligibleChildIds(award)).toEqual([1, 2, 3, 4])
-    })
-
-    test('returns empty array for empty child_ids', () => {
-      const award = { child_ids: [] }
-      expect(getEligibleChildIds(award)).toEqual([])
-    })
-
-    test('returns empty array for undefined child_ids', () => {
-      const award = {}
-      expect(getEligibleChildIds(award)).toEqual([])
-    })
-
-    test('returns empty array for null child_ids', () => {
-      const award = { child_ids: null }
-      expect(getEligibleChildIds(award)).toEqual([])
-    })
-  })
-
-})