musora-content-services 2.94.8 → 2.95.1

package/test/awards/award-collection-edge-cases.test.js

@@ -0,0 +1,210 @@
+import { contentProgressObserver } from '../../src/services/awards/internal/content-progress-observer'
+import { awardEvents } from '../../src/services/awards/internal/award-events'
+import { mockAwardDefinitions } from '../mockData/award-definitions'
+import { setupDefaultMocks, setupAwardEventListeners } from './helpers'
+import { COLLECTION_TYPE, emitProgress, waitForDebounce } from './helpers/progress-emitter'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: { fetch: jest.fn() },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  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'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+
+describe('Award Collection Filtering - Edge Cases', () => {
+  let listeners
+
+  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('Child in collection with no awards', () => {
+    test('gracefully handles child with no matching awards', async () => {
+      emitProgress({
+        contentId: 999999,
+        collectionType: 'skill-pack',
+        collectionId: 999000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+      expect(listeners.progress).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Collection type case sensitivity for learning paths', () => {
+    test('wrong case LP collection type falls back to a la carte', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: 'Learning-Path-V2',
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+
+    test('case mismatch in non-LP still triggers (a la carte)', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'SKILL-PACK',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+  })
+
+  describe('Debouncing per collection', () => {
+    test('rapid completion of children debounces per award content_id', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      emitProgress({
+        contentId: 418002,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+
+      await waitForDebounce()
+
+      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledTimes(1)
+    })
+
+    test('rapid completion of children in different contexts processes separately', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      emitProgress({
+        contentId: 416448
+      })
+
+      await waitForDebounce()
+
+      expect(listeners.granted.mock.calls.length).toBeGreaterThanOrEqual(2)
+      const awardIds = listeners.granted.mock.calls.map(call => call[0].awardId)
+      expect(awardIds).toContain('b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e')
+      expect(awardIds).toContain('0238b1e5-ebee-42b3-9390-91467d113575')
+    })
+  })
+
+  describe('Observer state management', () => {
+    test('stop clears debounce timers', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+
+      contentProgressObserver.stop()
+
+      expect(contentProgressObserver.debounceTimers.size).toBe(0)
+    })
+
+    test('stop clears processing content IDs', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+
+      contentProgressObserver.stop()
+
+      expect(contentProgressObserver.processingContentIds.size).toBe(0)
+    })
+
+    test('restart after stop works correctly', async () => {
+      contentProgressObserver.stop()
+      await contentProgressObserver.start()
+
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+  })
+
+  describe('Collection ID type handling', () => {
+    test('collection ID as number matches correctly for LP', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e' })
+      )
+    })
+
+    test('LP collection ID mismatch with correct type fails', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 999999
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+    })
+
+    test('non-LP collection ID mismatch still triggers (a la carte)', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418002
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+  })
+})

package/test/awards/award-collection-filtering.test.js

@@ -0,0 +1,285 @@
+import { contentProgressObserver } from '../../src/services/awards/internal/content-progress-observer'
+import { awardEvents } from '../../src/services/awards/internal/award-events'
+import { mockAwardDefinitions } from '../mockData/award-definitions'
+import { setupDefaultMocks, setupAwardEventListeners } from './helpers'
+import { COLLECTION_TYPE, emitProgress, waitForDebounce } from './helpers/progress-emitter'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: { fetch: jest.fn() },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  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'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+
+describe('Award Collection Filtering', () => {
+  let listeners
+
+  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('Collection type matching', () => {
+    test('child in learning-path-v2 triggers only learning-path-v2 award', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e' })
+      )
+    })
+
+    test('child in skill-pack triggers only skill-pack award', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d' })
+      )
+    })
+
+    test('child in course triggers course award (a la carte)', async () => {
+      emitProgress({
+        contentId: 416448
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: '0238b1e5-ebee-42b3-9390-91467d113575' })
+      )
+    })
+  })
+
+  describe('Collection ID matching', () => {
+    test('same content_type but different content_id does not trigger', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 999999
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+    })
+
+    test('both type and ID must match to trigger award', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      const call = listeners.granted.mock.calls[0]
+      expect(call).toBeDefined()
+      expect(call[0].definition.content_type).toBe('skill-pack')
+      expect(call[0].definition.content_id).toBe(418000)
+    })
+  })
+
+  describe('Overlapping children', () => {
+    test('shared child in non-LP context triggers all matching awards (a la carte)', async () => {
+      emitProgress({
+        contentId: 418003,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d' })
+      )
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e' })
+      )
+    })
+
+    test('shared child in learning-path-v2 context triggers only learning-path award', async () => {
+      emitProgress({
+        contentId: 418003,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'b2c3d4e5-f6a7-4b8c-9d0e-1f2a3b4c5d6e' })
+      )
+      expect(listeners.granted).not.toHaveBeenCalledWith(
+        expect.objectContaining({ awardId: 'a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d' })
+      )
+    })
+
+    test('non-LP context triggers all awards, LP context triggers only matching LP award', async () => {
+      emitProgress({
+        contentId: 418003,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledTimes(2)
+
+      listeners.granted.mockClear()
+      db.userAwardProgress.hasCompletedAward.mockResolvedValue(true)
+
+      emitProgress({
+        contentId: 418003,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('A la carte collection context', () => {
+    test('collectionType null and collectionId null triggers awards (a la carte)', async () => {
+      emitProgress({ contentId: 418001 })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+
+    test('collectionType present but collectionId null triggers awards (a la carte)', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: null
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+
+    test('collectionType null but collectionId present triggers awards (a la carte)', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: null,
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+  })
+
+  describe('Direct string comparison', () => {
+    test('learning-path-v2 matches learning-path-v2 exactly', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({
+          definition: expect.objectContaining({
+            content_type: 'learning-path-v2'
+          })
+        })
+      )
+    })
+
+    test('skill-pack matches skill-pack exactly', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalledWith(
+        expect.objectContaining({
+          definition: expect.objectContaining({
+            content_type: 'skill-pack'
+          })
+        })
+      )
+    })
+  })
+
+  describe('Non-matching collection context', () => {
+    test('LP child in wrong LP collection ID ignores award', async () => {
+      emitProgress({
+        contentId: 418004,
+        collectionType: COLLECTION_TYPE.LEARNING_PATH,
+        collectionId: 999999
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+      expect(listeners.progress).not.toHaveBeenCalled()
+    })
+
+    test('non-LP child with wrong collection still triggers (a la carte)', async () => {
+      emitProgress({
+        contentId: 418001,
+        collectionType: 'skill-pack',
+        collectionId: 418010
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).toHaveBeenCalled()
+    })
+
+    test('child not in any award ignores completely', async () => {
+      emitProgress({
+        contentId: 999999,
+        collectionType: 'skill-pack',
+        collectionId: 418000
+      })
+      await waitForDebounce()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+      expect(listeners.progress).not.toHaveBeenCalled()
+    })
+  })
+})

package/test/awards/award-completion-flow.test.js

@@ -0,0 +1,213 @@
+import { awardManager } from '../../src/services/awards/internal/award-manager'
+import { awardEvents } from '../../src/services/awards/internal/award-events'
+import { mockAwardDefinitions, getAwardByContentId } from '../mockData/award-definitions'
+import { setupDefaultMocks, setupAwardEventListeners } from './helpers'
+import { mockCompletionStates, mockAllCompleted } from './helpers/completion-mock'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: { fetch: jest.fn() },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  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'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+
+describe('Award Completion Flow - E2E Scenarios', () => {
+  let listeners
+  const testAward = getAwardByContentId(416446)
+  const courseId = 416446
+
+  beforeEach(async () => {
+    jest.clearAllMocks()
+    awardEvents.removeAllListeners()
+
+    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
+    setupDefaultMocks(db, fetchSanity, { practiceMinutes: 180 })
+
+    await awardDefinitions.refresh()
+
+    listeners = setupAwardEventListeners(awardEvents)
+  })
+
+  afterEach(() => {
+    awardEvents.removeAllListeners()
+    awardDefinitions.clear()
+  })
+
+  describe('Scenario: User completes all lessons in course', () => {
+    beforeEach(() => {
+      mockAllCompleted(db)
+    })
+
+    test('award is granted with 100% progress', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
+        testAward._id,
+        100,
+        expect.objectContaining({
+          completedAt: expect.any(Number),
+          completionData: expect.objectContaining({
+            content_title: expect.any(String),
+            days_user_practiced: expect.any(Number),
+            practice_minutes: 180
+          }),
+          progressData: expect.any(Object),
+          immediate: true
+        })
+      )
+
+      expect(listeners.granted).toHaveBeenCalledTimes(1)
+    })
+
+    test('awardGranted event contains complete payload', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      const payload = listeners.granted.mock.calls[0][0]
+
+      expect(payload).toMatchObject({
+        awardId: testAward._id,
+        definition: expect.objectContaining({
+          name: testAward.name,
+          badge: testAward.badge,
+          award: testAward.award
+        }),
+        completionData: expect.objectContaining({
+          content_title: expect.any(String),
+          days_user_practiced: expect.any(Number),
+          practice_minutes: 180
+        }),
+        popupMessage: expect.stringContaining('Adrian Guided Course Test'),
+        timestamp: expect.any(Number)
+      })
+    })
+
+    test('popup message contains correct practice data', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      const payload = listeners.granted.mock.calls[0][0]
+
+      expect(payload.popupMessage).toContain('180 minutes')
+      expect(payload.popupMessage).toContain('Adrian Guided Course Test')
+    })
+
+    test('award is immediately synced to backend', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
+        testAward._id,
+        100,
+        expect.objectContaining({
+          completedAt: expect.any(Number),
+          immediate: true
+        })
+      )
+    })
+
+    test('multiple event listeners all receive notification', async () => {
+      const listener1 = jest.fn()
+      const listener2 = jest.fn()
+      const listener3 = jest.fn()
+
+      awardEvents.on('awardGranted', listener1)
+      awardEvents.on('awardGranted', listener2)
+      awardEvents.on('awardGranted', listener3)
+
+      await awardManager.onContentCompleted(courseId)
+
+      expect(listener1).toHaveBeenCalledTimes(1)
+      expect(listener2).toHaveBeenCalledTimes(1)
+      expect(listener3).toHaveBeenCalledTimes(1)
+
+      const payload1 = listener1.mock.calls[0][0]
+      const payload2 = listener2.mock.calls[0][0]
+      expect(payload1.awardId).toBe(payload2.awardId)
+    })
+  })
+
+  describe('Scenario: Parent course completed but children incomplete', () => {
+    const multiLessonAward = getAwardByContentId(417049)
+    const parentCourseId = 417049
+
+    test('does not grant award when parent completed but only 2 of 4 children completed', async () => {
+      mockCompletionStates(db, [417045, 417046])
+
+      await awardManager.onContentCompleted(parentCourseId)
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
+        multiLessonAward._id,
+        50,
+        expect.objectContaining({
+          progressData: expect.any(Object)
+        })
+      )
+    })
+
+    test('emits awardProgress event with partial progress when parent completed', async () => {
+      mockCompletionStates(db, [417045, 417046])
+
+      await awardManager.onContentCompleted(parentCourseId)
+
+      expect(listeners.progress).toHaveBeenCalledWith(
+        expect.objectContaining({
+          awardId: multiLessonAward._id,
+          progressPercentage: 50,
+          timestamp: expect.any(Number)
+        })
+      )
+    })
+  })
+
+  describe('Scenario: Content has no associated award', () => {
+    test('completes gracefully without errors', async () => {
+      const nonExistentCourseId = 999999
+
+      await expect(
+        awardManager.onContentCompleted(nonExistentCourseId)
+      ).resolves.not.toThrow()
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Scenario: User already earned the award', () => {
+    beforeEach(() => {
+      db.userAwardProgress.hasCompletedAward.mockResolvedValue(true)
+      mockAllCompleted(db)
+    })
+
+    test('does not grant award again', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      expect(listeners.granted).not.toHaveBeenCalled()
+    })
+
+    test('does not update progress', async () => {
+      await awardManager.onContentCompleted(courseId)
+
+      expect(db.userAwardProgress.recordAwardProgress).not.toHaveBeenCalled()
+    })
+  })
+})