musora-content-services 2.94.7 → 2.95.0

package/test/HttpClient.test.js

@@ -65,7 +65,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'get',
+          method: 'GET',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -82,7 +82,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'post',
+          method: 'POST',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -100,7 +100,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'put',
+          method: 'PUT',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -118,7 +118,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'patch',
+          method: 'PATCH',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -135,7 +135,7 @@ describe('HttpClient', () => {
       expect(mockRequestExecutor.execute).toHaveBeenCalledWith(
         `${baseUrl}${url}`,
         expect.objectContaining({
-          method: 'delete',
+          method: 'DELETE',
           headers: expect.objectContaining({
             Authorization: `Bearer ${token}`,
           }),
@@ -249,7 +249,7 @@ describe('HttpClient', () => {
       await expect(httpClient.get('/test')).rejects.toMatchObject({
         message: 'Network error',
         url: '/test',
-        method: 'get',
+        method: 'GET',
         originalError: networkError,
       })
     })

package/test/awards/award-alacarte-observer.test.js

@@ -0,0 +1,196 @@
+import { contentProgressObserver } from '../../src/services/awards/internal/content-progress-observer'
+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'
+import { COLLECTION_TYPE, emitAlaCarteProgress, 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 Observer - A La Carte Progress (null collection)', () => {
+  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('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(db, [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(db)
+
+      emitAlaCarteProgress(sharedChildId)
+      await waitForDebounce()
+
+      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalled()
+    })
+  })
+
+  describe('A la carte debouncing', () => {
+    beforeEach(() => {
+      mockCompletionStates(db, [])
+    })
+
+    test('debounces multiple rapid a la carte updates', async () => {
+      emitAlaCarteProgress(416451)
+      emitAlaCarteProgress(416453)
+      emitAlaCarteProgress(416454)
+
+      await waitForDebounce()
+
+      expect(db.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(() => {
+      db.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/awards/award-auto-refresh.test.js

@@ -0,0 +1,83 @@
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: {
+    fetch: jest.fn()
+  },
+  fetchSanity: jest.fn()
+}))
+
+import { fetchSanity } from '../../src/services/sanity'
+
+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/awards/award-calculations.test.js

@@ -0,0 +1,33 @@
+import { getEligibleChildIds } from '../../src/services/awards/internal/award-definitions'
+
+jest.mock('../../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([])
+    })
+  })
+
+})

package/test/awards/award-certificate-display.test.js

@@ -0,0 +1,328 @@
+import { buildCertificateData } from '../../src/services/awards/internal/certificate-builder'
+import { mockAwardDefinitions, getAwardById } from '../mockData/award-definitions'
+import { globalConfig } from '../../src/services/config'
+
+jest.mock('../../src/services/sanity', () => ({
+  default: {
+    fetch: jest.fn()
+  },
+  fetchSanity: jest.fn()
+}))
+
+jest.mock('../../src/services/user/management', () => ({
+  getUserData: jest.fn()
+}))
+
+jest.mock('../../src/services/sync/repository-proxy', () => {
+  const mockFns = {
+    userAwardProgress: {
+      getByAwardId: jest.fn()
+    }
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+import sanityClient, { fetchSanity } from '../../src/services/sanity'
+import { getUserData } from '../../src/services/user/management'
+import db from '../../src/services/sync/repository-proxy'
+import { awardDefinitions } from '../../src/services/awards/internal/award-definitions'
+
+describe('Award Certificate Display - E2E Scenarios', () => {
+  const testAward = getAwardById('0238b1e5-ebee-42b3-9390-91467d113575')
+  const awardId = testAward._id
+
+  beforeEach(async () => {
+    jest.clearAllMocks()
+
+    globalConfig.sessionConfig = {
+      userId: 12345,
+      token: 'test-token'
+    }
+
+    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
+    fetchSanity.mockResolvedValue(mockAwardDefinitions)
+
+    db.userAwardProgress = {
+      getByAwardId: jest.fn()
+    }
+
+    getUserData.mockResolvedValue({
+      id: 12345,
+      display_name: 'John Doe',
+      name: 'John Doe',
+      email: 'john@example.com'
+    })
+
+    await awardDefinitions.refresh()
+  })
+
+  afterEach(() => {
+    awardDefinitions.clear()
+  })
+
+  describe('Scenario: Display complete certificate for earned award', () => {
+    beforeEach(() => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardId,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000) - 86400 * 3,
+          completion_data: {
+            content_title: 'Adrian Guided Course Test',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 14,
+            practice_minutes: 180
+          },
+        },
+      })
+    })
+
+    test('returns complete certificate data with all fields', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate).toMatchObject({
+        userId: 12345,
+        userName: 'John Doe',
+        completedAt: expect.any(String),
+        awardId: awardId,
+        awardType: 'content-award',
+        awardTitle: testAward.name,
+        popupMessage: expect.any(String),
+        certificateMessage: expect.any(String),
+        ribbonImage: expect.any(String),
+        awardImage: testAward.award,
+        badgeImage: testAward.badge,
+        brandLogo: expect.any(String),
+        musoraLogo: expect.any(String),
+        musoraBgLogo: expect.any(String),
+        instructorName: testAward.instructor_name
+      })
+    })
+
+    test('includes correct user information from globalConfig and getUserData', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.userId).toBe(12345)
+      expect(certificate.userName).toBe('John Doe')
+    })
+
+    test('includes correct award information from Sanity', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.awardId).toBe(awardId)
+      expect(certificate.awardTitle).toBe('Adrian Guided Course Test Award')
+      expect(certificate.badgeImage).toBe(testAward.badge)
+      expect(certificate.awardImage).toBe(testAward.award)
+      expect(certificate.instructorName).toBe('Aaron Graham')
+    })
+
+    test('includes client-generated popup message', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.popupMessage).toContain('Adrian Guided Course Test')
+      expect(certificate.popupMessage).toContain('180 minutes')
+      expect(certificate.popupMessage).toContain('14 days')
+    })
+
+    test('includes client-generated certificate message', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.certificateMessage).toContain('180 minutes')
+      expect(certificate.certificateMessage).toContain('Adrian Guided Course Test')
+      expect(certificate.certificateMessage).toContain('Well Done!')
+    })
+
+    test('includes brand logo based on award brand', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.brandLogo).toBeDefined()
+      expect(typeof certificate.brandLogo).toBe('string')
+    })
+
+    test('includes completion date from WatermelonDB', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.completedAt).toBeDefined()
+      const completedDate = new Date(certificate.completedAt)
+      expect(completedDate).toBeInstanceOf(Date)
+      expect(completedDate.getTime()).toBeLessThanOrEqual(Date.now())
+    })
+  })
+
+  describe('Scenario: Certificate with custom award text', () => {
+    const awardWithCustomText = getAwardById('0f49cb6a-1b23-4628-968e-15df02ffad7f')
+
+    beforeEach(() => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardWithCustomText._id,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: {
+            content_title: 'Enrolling w/ Kickoff, has product GC (EC)',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 10,
+            practice_minutes: 200
+          },
+        },
+      })
+    })
+
+    test('includes custom text in certificate message', async () => {
+      const certificate = await buildCertificateData(awardWithCustomText._id)
+
+      expect(certificate.certificateMessage).toContain('Huzzah congratz')
+      expect(certificate.certificateMessage).toContain('200 minutes')
+      expect(certificate.certificateMessage).toContain('Enrolling w/ Kickoff, has product GC (EC)')
+    })
+  })
+
+  describe('Scenario: Certificate with null instructor signature', () => {
+    const awardWithoutSignature = getAwardById('0f49cb6a-1b23-4628-968e-15df02ffad7f')
+
+    beforeEach(() => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardWithoutSignature._id,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: {
+            content_title: 'Test Course',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 5,
+            practice_minutes: 100
+          },
+        },
+      })
+    })
+
+    test('handles null instructor signature gracefully', async () => {
+      const certificate = await buildCertificateData(awardWithoutSignature._id)
+
+      expect(certificate.instructorName).toBe('Lisa Witt')
+    })
+  })
+
+  describe('Scenario: User with no display_name falls back to name', () => {
+    beforeEach(() => {
+      getUserData.mockResolvedValue({
+        id: 12345,
+        display_name: null,
+        name: 'Jane Smith',
+        email: 'jane@example.com'
+      })
+
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardId,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: {
+            content_title: 'Test Course',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 7,
+            practice_minutes: 150
+          },
+        },
+      })
+    })
+
+    test('uses name field when display_name is null', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.userName).toBe('Jane Smith')
+    })
+  })
+
+  describe('Scenario: User with neither display_name nor name', () => {
+    beforeEach(() => {
+      getUserData.mockResolvedValue({
+        id: 12345,
+        display_name: null,
+        name: null,
+        email: 'anonymous@example.com'
+      })
+
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardId,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: {
+            content_title: 'Test Course',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 3,
+            practice_minutes: 90
+          },
+        },
+      })
+    })
+
+    test('falls back to "User" when no name available', async () => {
+      const certificate = await buildCertificateData(awardId)
+
+      expect(certificate.userName).toBe('User')
+    })
+  })
+
+  describe('Scenario: Error handling', () => {
+    test('throws error when award definition not found', async () => {
+      await expect(
+        buildCertificateData('non-existent-award-id')
+      ).rejects.toThrow('Award definition not found')
+    })
+
+    test('throws error when completion data not found in local DB', async () => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: null
+      })
+
+      await expect(
+        buildCertificateData(awardId)
+      ).rejects.toThrow('Completion data not found')
+    })
+
+    test('throws error when completion_data is missing', async () => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: awardId,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: null
+        },
+      })
+
+      await expect(
+        buildCertificateData(awardId)
+      ).rejects.toThrow('Completion data not found')
+    })
+  })
+
+  describe('Scenario: Learning path vs guided course message differences', () => {
+    const learningPathAward = getAwardById('361f3034-c6c9-45f7-bbfb-0d58dbe14411')
+
+    beforeEach(() => {
+      db.userAwardProgress.getByAwardId.mockResolvedValue({
+        data: {
+          award_id: learningPathAward._id,
+          progress_percentage: 100,
+          completed_at: Math.floor(Date.now() / 1000),
+          completion_data: {
+            content_title: 'Learn To Play The Drums',
+            completed_at: new Date().toISOString(),
+            days_user_practiced: 30,
+            practice_minutes: 600
+          },
+        },
+      })
+    })
+
+    test('generates learning path message for learning path award', async () => {
+      const certificate = await buildCertificateData(learningPathAward._id)
+
+      expect(certificate.popupMessage).toContain('Learn To Play The Drums')
+      expect(certificate.popupMessage).toContain('600 minutes')
+      expect(certificate.popupMessage).toContain('30 days')
+    })
+  })
+})