musora-content-services 2.167.2 → 2.167.3

package/test/unit/awards/award-multi-lesson.test.ts

@@ -1,243 +0,0 @@
-import { awardManager } from '../../../src/services/awards/internal/award-manager.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, mockNoneCompleted } from './helpers/completion-mock'
-
-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'
-const db = db_ as any
-import { awardDefinitions } from '../../../src/services/awards/internal/award-definitions.js'
-
-describe('Award Progress Calculation', () => {
-  let listeners
-
-  beforeEach(async () => {
-    jest.clearAllMocks()
-    awardEvents.removeAllListeners()
-
-    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
-    setupDefaultMocks(db, fetchSanity, { practiceMinutes: 120 })
-
-    db.contentProgress.getSomeProgressByContentIds.mockResolvedValue({
-      data: [{ created_at: Math.floor(Date.now() / 1000) - 86400 * 5 }]
-    })
-
-    await awardDefinitions.refresh()
-
-    listeners = setupAwardEventListeners(awardEvents)
-  })
-
-  afterEach(() => {
-    awardEvents.removeAllListeners()
-    awardDefinitions.clear()
-  })
-
-  describe('Single lesson course (content_id: 416446, child_ids: [416448])', () => {
-    const award = getAwardByContentId(416446)
-    const childId = 416448
-
-    test('grants award at 100% when the single lesson is completed', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(childId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          completionData: expect.objectContaining({
-            content_title: award.content_title,
-            days_user_practiced: expect.any(Number),
-            practice_minutes: expect.any(Number)
-          }),
-          progressData: {
-            completedLessonIds: [childId],
-            totalLessons: 1,
-            completedCount: 1
-          },
-          immediate: true
-        })
-      )
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-
-    test('records 0% progress when the lesson is not completed', async () => {
-      mockNoneCompleted(db)
-
-      await awardManager.onContentCompleted(childId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        0,
-        expect.objectContaining({
-          progressData: {
-            completedLessonIds: [],
-            totalLessons: 1,
-            completedCount: 0
-          }
-        })
-      )
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('10-lesson course (content_id: 416450, child_ids: 10 lessons)', () => {
-    const award = getAwardByContentId(416450)
-    const childIds = award.child_ids
-
-    test('calculates 50% progress when 5 of 10 lessons are completed', async () => {
-      mockCompletionStates(db, childIds.slice(0, 5))
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        50,
-        expect.objectContaining({
-          progressData: expect.objectContaining({
-            totalLessons: 10,
-            completedCount: 5
-          })
-        })
-      )
-    })
-
-    test('calculates 90% progress when 9 of 10 lessons are completed', async () => {
-      mockCompletionStates(db, childIds.slice(0, 9))
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        90,
-        expect.objectContaining({
-          progressData: expect.objectContaining({
-            totalLessons: 10,
-            completedCount: 9
-          })
-        })
-      )
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-
-    test('grants award when all 10 lessons are completed', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          progressData: expect.objectContaining({
-            totalLessons: 10,
-            completedCount: 10
-          }),
-          immediate: true
-        })
-      )
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('22-lesson learning path (content_id: 417140)', () => {
-    const award = getAwardByContentId(417140)
-    const childIds = award.child_ids
-
-    test('calculates correct percentage for partial completion (11/22 = 50%)', async () => {
-      mockCompletionStates(db, childIds.slice(0, 11))
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        50,
-        expect.objectContaining({
-          progressData: expect.objectContaining({
-            totalLessons: 22,
-            completedCount: 11
-          })
-        })
-      )
-    })
-
-    test('does not grant award when 21 of 22 lessons completed (95%)', async () => {
-      mockCompletionStates(db, childIds.slice(0, 21))
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        award._id,
-        95,
-        expect.objectContaining({
-          progressData: expect.objectContaining({
-            totalLessons: 22,
-            completedCount: 21
-          })
-        })
-      )
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-
-    test('grants award with correct popup message when all 22 lessons completed', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(childIds[0])
-
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload.awardId).toBe(award._id)
-      expect(payload.popupMessage).toContain(award.content_title)
-      expect(payload.popupMessage).toContain('120 minutes')
-      expect(payload.completionData).toEqual(expect.objectContaining({
-        content_title: award.content_title,
-        practice_minutes: 120
-      }))
-    })
-  })
-
-  describe('Award already completed', () => {
-    const award = getAwardByContentId(416446)
-    const childId = 416448
-
-    test('skips evaluation when award is already completed', async () => {
-      db.userAwardProgress.hasCompletedAward.mockResolvedValue(true)
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(childId)
-
-      expect(db.userAwardProgress.recordAwardProgress).not.toHaveBeenCalled()
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-})

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

@@ -1,327 +0,0 @@
-import { contentProgressObserver } from '../../../src/services/awards/internal/content-progress-observer.js'
-import { awardEvents } from '../../../src/services/awards/internal/award-events.js'
-import { emitProgressSaved } from '../../../src/services/progress-events.js'
-import { mockAwardDefinitions, getAwardByContentId } from '../../mockData/award-definitions.js'
-import { setupDefaultMocks, setupAwardEventListeners } from './helpers/index'
-import { mockCompletionStates } from './helpers/completion-mock'
-import { COLLECTION_TYPE, 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'
-const db = db_ as any
-import { awardDefinitions } from '../../../src/services/awards/internal/award-definitions.js'
-
-describe('Award Observer Integration - E2E Scenarios', () => {
-  let listeners
-
-  const emitProgressWithCollection = (contentId, collectionType, collectionId, progressPercent = 100) => {
-    emitProgressSaved({
-      userId: 123,
-      contentId,
-      progressPercent,
-      progressStatus: progressPercent === 100 ? 'completed' : 'started',
-      bubble: true,
-      collectionType,
-      collectionId,
-      resumeTimeSeconds: null,
-      timestamp: Date.now()
-    })
-  }
-
-  const emitAlaCarteProgress = (contentId, progressPercent = 100) => {
-    emitProgressWithCollection(contentId, null, null, progressPercent)
-  }
-
-  beforeEach(async () => {
-    jest.clearAllMocks()
-    awardEvents.removeAllListeners()
-
-    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
-    setupDefaultMocks(db, fetchSanity)
-
-    await awardDefinitions.refresh()
-
-    listeners = setupAwardEventListeners(awardEvents)
-
-    await contentProgressObserver.start()
-  })
-
-  afterEach(() => {
-    awardEvents.removeAllListeners()
-    awardDefinitions.clear()
-    contentProgressObserver.stop()
-  })
-
-  describe('Scenario: Observer setup and initialization', () => {
-    test('starts observing progress events', async () => {
-      expect(contentProgressObserver.isObserving).toBe(true)
-    })
-
-    test('loads award definitions on start', async () => {
-      expect(fetchSanity).toHaveBeenCalled()
-      expect(contentProgressObserver.allChildIds.size).toBeGreaterThan(0)
-    })
-
-    test('includes content_id in allChildIds Set', async () => {
-      const lpAward = getAwardByContentId(417140)
-      const gcAward = getAwardByContentId(416446)
-
-      expect(contentProgressObserver.allChildIds.has(lpAward.content_id)).toBe(true)
-      expect(contentProgressObserver.allChildIds.has(gcAward.content_id)).toBe(true)
-    })
-
-    test('includes all child_ids in allChildIds Set', async () => {
-      const award = getAwardByContentId(416446)
-
-      award.child_ids.forEach(childId => {
-        expect(contentProgressObserver.allChildIds.has(childId)).toBe(true)
-      })
-    })
-
-    test('returns cleanup function', async () => {
-      const cleanup = await contentProgressObserver.start()
-      expect(typeof cleanup).toBe('function')
-    })
-
-    test('does not start twice', async () => {
-      const firstCallCount = fetchSanity.mock.calls.length
-      await contentProgressObserver.start()
-      expect(fetchSanity.mock.calls.length).toBe(firstCallCount)
-    })
-  })
-
-  describe('Scenario: Progress update triggers award progress event', () => {
-    const testAward = getAwardByContentId(417049)
-
-    beforeEach(() => {
-      mockCompletionStates(db, [417045])
-    })
-
-    test('emits awardProgress event when lesson completed', async () => {
-      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')
-    })
-
-    test('calculates correct progress percentage', async () => {
-      mockCompletionStates(db, [417045, 417046])
-
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        50,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-  })
-
-  describe('Scenario: Progress update triggers award granted event', () => {
-    const testAward = getAwardByContentId(417049)
-
-    test('emits awardGranted event when all lessons completed', async () => {
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload).toHaveProperty('awardId', testAward._id)
-      expect(payload).toHaveProperty('completionData')
-      expect(payload).toHaveProperty('popupMessage')
-    })
-
-    test('includes completion data in granted event', async () => {
-      emitAlaCarteProgress(417045)
-      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('Scenario: Multiple lessons update rapidly (debouncing)', () => {
-    const testAward = getAwardByContentId(416464)
-    const nonKickoffLessons = [
-      416467, 416468, 416469, 416470, 416471, 416472, 416473,
-      416474, 416475, 416476, 416477, 416478, 416479, 416480, 416481,
-      416482, 416483, 416484, 416485, 416486, 416487, 416488, 416489
-    ]
-
-    beforeEach(() => {
-      mockCompletionStates(db, nonKickoffLessons.slice(0, 12))
-    })
-
-    test('debounces multiple rapid updates to same course', async () => {
-      emitAlaCarteProgress(416467)
-      emitAlaCarteProgress(416468)
-      emitAlaCarteProgress(416469)
-
-      await waitForDebounce()
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('Scenario: Progress for lessons without awards', () => {
-    test('ignores lessons not associated with awards', async () => {
-      emitAlaCarteProgress(999999)
-      await waitForDebounce()
-
-      expect(listeners.progress).not.toHaveBeenCalled()
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Scenario: Non-completed progress status', () => {
-    beforeEach(() => {
-      mockCompletionStates(db, [])
-    })
-
-    test('does not trigger award granted when lessons not completed in DB', async () => {
-      emitAlaCarteProgress(417045, 50)
-      await waitForDebounce()
-
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-
-    test('started progress state in DB does not grant award', async () => {
-      emitProgressSaved({
-        userId: 123,
-        contentId: 417045,
-        progressPercent: 75,
-        progressStatus: 'started',
-        bubble: true,
-        collectionType: null,
-        collectionId: null,
-        resumeTimeSeconds: null,
-        timestamp: Date.now()
-      })
-      await waitForDebounce()
-
-      expect(listeners.granted).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Scenario: Excluded content progress', () => {
-    test('excluded content (not in child_ids) does not trigger award progress', async () => {
-      emitAlaCarteProgress(416447)
-      await waitForDebounce()
-
-      expect(db.userAwardProgress.recordAwardProgress).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Scenario: Already completed award', () => {
-    beforeEach(() => {
-      db.userAwardProgress.hasCompletedAward.mockResolvedValue(true)
-    })
-
-    test('does not re-grant already completed award', async () => {
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.granted).not.toHaveBeenCalled()
-      expect(db.userAwardProgress.recordAwardProgress).not.toHaveBeenCalledWith(
-        expect.anything(),
-        100,
-        expect.objectContaining({ immediate: true })
-      )
-    })
-  })
-
-  describe('Scenario: Observer cleanup', () => {
-    test('removes event listeners on stop', () => {
-      contentProgressObserver.stop()
-      expect(contentProgressObserver.isObserving).toBe(false)
-    })
-
-    test('clears debounce timers on stop', async () => {
-      emitAlaCarteProgress(417045)
-      contentProgressObserver.stop()
-
-      expect(contentProgressObserver.debounceTimers.size).toBe(0)
-    })
-
-    test('clears allChildIds on stop', async () => {
-      contentProgressObserver.stop()
-
-      expect(contentProgressObserver.allChildIds.size).toBe(0)
-    })
-  })
-
-  describe('Scenario: Learning path award events', () => {
-    const learningPathAward = getAwardByContentId(417140)
-
-    test('learning path award has correct popup message', async () => {
-      emitProgressWithCollection(417105, COLLECTION_TYPE.LEARNING_PATH, 417140)
-      await waitForDebounce()
-
-      const payload = listeners.granted.mock.calls[0][0]
-      expect(payload.popupMessage).toContain('Learn To Play The Drums')
-      expect(payload.popupMessage).toContain('minutes')
-      expect(payload.popupMessage).toContain('days')
-    })
-  })
-
-  describe('Scenario: Multiple courses progressing simultaneously', () => {
-    const testAward1 = getAwardByContentId(416446)
-    const testAward2 = getAwardByContentId(417049)
-
-    beforeEach(() => {
-      mockCompletionStates(db, [])
-    })
-
-    test('tracks progress for multiple courses independently', async () => {
-      emitAlaCarteProgress(416448)
-      await waitForDebounce()
-
-      emitAlaCarteProgress(417045)
-      await waitForDebounce()
-
-      expect(listeners.progress).toHaveBeenCalledTimes(2)
-
-      const calls = listeners.progress.mock.calls
-      const awardIds = calls.map(call => call[0].awardId)
-      expect(awardIds).toContain(testAward1._id)
-      expect(awardIds).toContain(testAward2._id)
-    })
-  })
-})