musora-content-services 2.167.1 → 2.167.3

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

@@ -1,144 +0,0 @@
-import type { AwardCallbackPayload, ProgressCallbackPayload, UnregisterFunction } from '../../../src/services/awards/types.d.ts'
-import { registerAwardCallback, registerProgressCallback } from '../../../src/services/awards/award-callbacks.js'
-import { awardEvents } from '../../../src/services/awards/internal/award-events.js'
-jest.mock('../../../src/services/awards/award-query.js', () => ({
-  ...jest.requireActual('../../../src/services/awards/award-query.js'),
-  getBadgeFields: jest.fn().mockReturnValue({
-    badge: 'https://cdn.example.com/badge.png',
-    badge_rear: 'https://cdn.example.com/badge_rear.png',
-    badge_logo: 'https://cdn.example.com/logo.png',
-    badge_template: 'template_front',
-    badge_template_rear: 'template_rear',
-    badge_template_unearned: 'template_unearned',
-  })
-}))
-interface AwardGrantedEmitPayload {
-  awardId: string
-  definition: {
-    name: string
-    brand: string
-    content_type: string
-    type: string
-    is_active: boolean
-  }
-  completionData: {
-    completed_at: string
-    days_user_practiced: number
-    practice_minutes: number
-    content_title: string
-  }
-  popupMessage: string
-}
-const mockPayload: AwardGrantedEmitPayload = {
-  awardId: 'award-123',
-  definition: {
-    name: 'Test Award',
-    brand: 'drumeo',
-    content_type: 'guided-course',
-    type: 'content-award',
-    is_active: true,
-  },
-  completionData: {
-    completed_at: '2024-01-01T00:00:00Z',
-    days_user_practiced: 14,
-    practice_minutes: 180,
-    content_title: 'Blues Foundations',
-  },
-  popupMessage: 'Congratulations!'
-}
-describe('registerAwardCallback', () => {
-  let unregister: UnregisterFunction
-
-  afterEach(() => {
-    unregister?.()
-    awardEvents.removeAllListeners()
-  })
-
-  test('throws if callback is not a function', () => {
-    expect(() => registerAwardCallback('not a function' as any)).toThrow(
-      'registerAwardCallback requires a function'
-    )
-  })
-
-  test('returns an unregister function', () => {
-    unregister = registerAwardCallback(jest.fn())
-    expect(typeof unregister).toBe('function')
-  })
-
-  test('callback is invoked with correctly shaped award object when awardGranted fires', async () => {
-    const callback = jest.fn() as jest.MockedFunction<(award: AwardCallbackPayload) => void>
-    unregister = registerAwardCallback(callback)
-    awardEvents.emitAwardGranted(mockPayload)
-    await new Promise(resolve => setTimeout(resolve, 0))
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining({
-      awardId: 'award-123',
-      name: 'Test Award',
-      brand: 'drumeo',
-      contentType: 'guided-course',
-      hasCertificate: true,
-      isCompleted: true,
-      completedAt: '2024-01-01T00:00:00Z',
-      completionData: expect.objectContaining({
-        content_title: 'Blues Foundations',
-        days_user_practiced: 14,
-        practice_minutes: 180,
-        message: 'Congratulations!',
-      })
-    }))
-  })
-
-  test('callback is not invoked after unregister is called', async () => {
-    const callback = jest.fn()
-    unregister = registerAwardCallback(callback)
-    unregister()
-    awardEvents.emitAwardGranted(mockPayload)
-    await new Promise(resolve => setTimeout(resolve, 0))
-    expect(callback).not.toHaveBeenCalled()
-  })
-
-  test('registering a second callback replaces the first', async () => {
-    const firstCallback = jest.fn()
-    const secondCallback = jest.fn()
-    registerAwardCallback(firstCallback)
-    unregister = registerAwardCallback(secondCallback)
-    awardEvents.emitAwardGranted(mockPayload)
-    await new Promise(resolve => setTimeout(resolve, 0))
-    expect(firstCallback).not.toHaveBeenCalled()
-    expect(secondCallback).toHaveBeenCalled()
-  })
-
-  test('throws if callback is not a function', () => {
-    expect(() => registerProgressCallback('not a function' as any)).toThrow(
-      'registerProgressCallback requires a function'
-    )
-  })
-
-  test('returns an unregister function', () => {
-    unregister = registerProgressCallback(jest.fn())
-    expect(typeof unregister).toBe('function')
-  })
-
-  test('callback is invoked with awardId and progressPercentage when awardProgress fires', () => {
-    const callback = jest.fn() as jest.MockedFunction<(progress: ProgressCallbackPayload) => void>
-    unregister = registerProgressCallback(callback)
-    awardEvents.emitAwardProgress({ awardId: 'award-123', progressPercentage: 50 })
-    expect(callback).toHaveBeenCalledWith({
-      awardId: 'award-123',
-      progressPercentage: 50,
-    })
-  })
-})
-
-describe('registerProgressCallback', () => {
-  let unregister: UnregisterFunction
-
-  afterEach(() => {
-    unregister?.()
-    awardEvents.removeAllListeners()
-  })
-
-  test.todo('throws if callback is not a function')
-  test.todo('returns an unregister function')
-  test.todo('callback is invoked with awardId and progressPercentage when awardProgress fires')
-  test.todo('callback is not invoked after unregister is called')
-})

package/test/unit/awards/award-certificate-display.test.ts

@@ -1,330 +0,0 @@
-import { buildCertificateData } from '../../../src/services/awards/internal/certificate-builder.js'
-import { mockAwardDefinitions, getAwardById } from '../../mockData/award-definitions.js'
-import { globalConfig } from '../../../src/services/config.js'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity'),
-  default: {
-    fetch: jest.fn()
-  },
-  fetchSanity: jest.fn()
-}))
-
-jest.mock('../../../src/services/user/management.js', () => ({
-  getUserData: jest.fn()
-}))
-
-jest.mock('../../../src/services/sync/repository-proxy.ts', () => {
-  const mockFns = {
-    userAwardProgress: {
-      getByAwardId: jest.fn()
-    }
-  }
-  return { default: mockFns, ...mockFns }
-})
-
-import sanityClient, { fetchSanity } from '../../../src/services/sanity.js'
-import { getUserData } from '../../../src/services/user/management.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 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(Number),
-        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')
-    })
-  })
-})

package/test/unit/awards/award-collection-edge-cases.test.ts

@@ -1,212 +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 } from '../../mockData/award-definitions.js'
-import { setupDefaultMocks, setupAwardEventListeners } from './helpers/index'
-import { COLLECTION_TYPE, 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'
-const db = db_ as any
-import { awardDefinitions } from '../../../src/services/awards/internal/award-definitions.js'
-
-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()
-    })
-  })
-})