musora-content-services 2.167.2 → 2.167.3

package/test/integration/sync/repositories/progress.test.ts

@@ -1,245 +0,0 @@
-// Break circular dep: sync/index → manager → award chain → UserAwardProgressRepository
-// extends SyncRepository before it's defined in the module evaluation order.
-jest.mock('@/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('@/services/sync/repository-proxy', () => ({ db: {} }))
-
-import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
-import ContentProgress, {
-  COLLECTION_TYPE,
-  COLLECTION_ID_SELF,
-  STATE,
-} from '@/services/sync/models/ContentProgress'
-import ProgressRepository from '@/services/sync/repositories/content-progress'
-
-let db: Database
-let repo: ProgressRepository
-
-const BRAND = 'drumeo'
-const TYPE = 'lesson'
-
-function upsertProgress(
-  contentId: number,
-  progressPct: number,
-  overrides: Partial<{
-    collection: { type: COLLECTION_TYPE; id: number }
-    brand: string
-    contentType: string
-    parentId: number
-    lastInteractedALaCarte: number | null
-  }> = {}
-) {
-  const id = ContentProgress.generateId(contentId, overrides.collection ?? null)
-  return repo['store'].upsertOne(id, r => {
-    r.content_id = contentId
-    r.content_brand = overrides.brand ?? BRAND
-    r.content_type = overrides.contentType ?? TYPE
-    r.content_parent_id = overrides.parentId ?? 0
-    r.collection_type = overrides.collection?.type ?? COLLECTION_TYPE.SELF
-    r.collection_id = overrides.collection?.id ?? COLLECTION_ID_SELF
-    r.progress_percent = progressPct
-    if (overrides.lastInteractedALaCarte !== undefined) {
-      r.last_interacted_a_la_carte = overrides.lastInteractedALaCarte
-    }
-  })
-}
-
-beforeEach(() => {
-  db = makeDatabase()
-  const { store } = makeStore(ContentProgress, db)
-  repo = new ProgressRepository(store)
-})
-
-afterEach(async () => {
-  await resetDatabase(db)
-})
-
-// ---
-
-describe('started / completed', () => {
-  test('started returns records with started state', async () => {
-    await upsertProgress(100, 50)   // started
-    await upsertProgress(101, 100)  // completed
-    await upsertProgress(102, 30)   // started
-
-    const result = await repo.started()
-    expect(result.map(r => r.content_id).sort()).toEqual([100, 102])
-  })
-
-  test('completed returns records with completed state', async () => {
-    await upsertProgress(200, 100)  // completed
-    await upsertProgress(201, 50)   // started
-    await upsertProgress(202, 100)  // completed
-
-    const result = await repo.completed()
-    expect(result.map(r => r.content_id).sort()).toEqual([200, 202])
-  })
-
-  test('started with limit respects limit', async () => {
-    await Promise.all([1, 2, 3, 4, 5].map(id => upsertProgress(id, 50)))
-
-    const result = await repo.started(2)
-    expect(result).toHaveLength(2)
-  })
-
-  test('started with onlyIds returns content_id array', async () => {
-    await upsertProgress(300, 50)
-
-    const result = await repo.started(undefined, { onlyIds: true })
-    expect(result).toContain(300)
-  })
-})
-
-describe('startedOrCompleted', () => {
-  test('returns all started and completed records', async () => {
-    await upsertProgress(400, 50)   // started
-    await upsertProgress(401, 100)  // completed
-    await upsertProgress(402, 30)   // started
-
-    const result = await repo.startedOrCompleted()
-    expect(result.data.map(r => r.content_id).sort()).toEqual([400, 401, 402])
-  })
-
-  test('filters by brand', async () => {
-    await upsertProgress(500, 50, { brand: 'drumeo' })
-    await upsertProgress(501, 50, { brand: 'pianote' })
-
-    const result = await repo.startedOrCompleted({ brand: 'drumeo' })
-    expect(result.data).toHaveLength(1)
-    expect(result.data[0].content_id).toBe(500)
-  })
-
-  test('filters by updatedAfter', async () => {
-    const now = Date.now()
-    await upsertProgress(600, 50)
-
-    // Record updated_at is set by BaseModel._prepareCreate to Date.now()
-    const result = await repo.startedOrCompleted({ updatedAfter: now - 1000 })
-    expect(result.data.length).toBeGreaterThanOrEqual(1)
-
-    const resultFuture = await repo.startedOrCompleted({ updatedAfter: now + 60000 })
-    expect(resultFuture.data).toHaveLength(0)
-  })
-})
-
-describe('collectionTypeFilter', () => {
-  test('no filter returns all collection types', async () => {
-    await upsertProgress(700, 50)
-    await upsertProgress(700, 50, { collection: { type: COLLECTION_TYPE.LEARNING_PATH, id: 99 } })
-
-    const result = await repo.started()
-    expect(result).toHaveLength(2)
-  })
-
-  test('aLaCarte filter returns only self-accessed records with lastInteractedALaCarte set', async () => {
-    const now = Date.now()
-    await upsertProgress(800, 50, { lastInteractedALaCarte: now })                      // aLaCarte accessed
-    await upsertProgress(801, 50, { lastInteractedALaCarte: null })                     // not aLaCarte
-    await upsertProgress(800, 50, { collection: { type: COLLECTION_TYPE.LEARNING_PATH, id: 42 } }) // LP
-
-    const result = await repo.started(undefined, { include: { aLaCarte: true } })
-    const ids = result.map(r => r.content_id)
-    expect(ids).toContain(800)
-    expect(ids).not.toContain(801)
-  })
-
-  test('learningPaths filter returns LP parent records', async () => {
-    // LP parent: collection_type=learning-path-v2 AND content_id === collection_id
-    await upsertProgress(900, 50, { collection: { type: COLLECTION_TYPE.LEARNING_PATH, id: 900 } }) // parent
-    await upsertProgress(901, 50, { collection: { type: COLLECTION_TYPE.LEARNING_PATH, id: 900 } }) // child
-    await upsertProgress(900, 50)  // self record for same content
-
-    const result = await repo.started(undefined, { include: { learningPaths: true } })
-    const ids = result.map(r => r.content_id)
-    expect(ids).toContain(900)
-    // child (content_id 901, collection_id 900) should NOT be in result
-    expect(ids).not.toContain(901)
-  })
-})
-
-describe('getOneProgressByContentId', () => {
-  test('returns record for matching contentId', async () => {
-    await upsertProgress(1000, 75)
-
-    const result = await repo.getOneProgressByContentId(1000)
-    expect(result.data).not.toBeNull()
-    expect(result.data!.content_id).toBe(1000)
-    expect(result.data!.progress_percent).toBe(75)
-  })
-
-  test('returns null when no record', async () => {
-    const result = await repo.getOneProgressByContentId(9999)
-    expect(result.data).toBeNull()
-  })
-})
-
-describe('getSomeProgressByContentIds', () => {
-  test('returns multiple records', async () => {
-    await upsertProgress(1100, 50)
-    await upsertProgress(1101, 100)
-    await upsertProgress(1102, 30)
-
-    const result = await repo.getSomeProgressByContentIds([1100, 1101])
-    expect(result.data).toHaveLength(2)
-    expect(result.data.map(r => r.content_id).sort()).toEqual([1100, 1101])
-  })
-})
-
-describe('recordProgress', () => {
-  test('creates progress record via repository', async () => {
-    await repo.recordProgress(1200, null, 60, { brand: BRAND, type: TYPE, parent_id: 0 })
-
-    const result = await repo.getOneProgressByContentId(1200)
-    expect(result.data!.progress_percent).toBe(60)
-    expect(result.data!.state).toBe(STATE.STARTED)
-  })
-
-  test('sets state to completed at 100%', async () => {
-    await repo.recordProgress(1300, null, 100, { brand: BRAND, type: TYPE, parent_id: 0 })
-
-    const result = await repo.getOneProgressByContentId(1300)
-    expect(result.data!.state).toBe(STATE.COMPLETED)
-  })
-
-  test('progress_percent never goes backwards', async () => {
-    await repo.recordProgress(1400, null, 80, { brand: BRAND, type: TYPE, parent_id: 0 })
-    await repo.recordProgress(1400, null, 40, { brand: BRAND, type: TYPE, parent_id: 0 })
-
-    const result = await repo.getOneProgressByContentId(1400)
-    expect(result.data!.progress_percent).toBe(80)
-  })
-})
-
-describe('eraseProgress', () => {
-  test('removes the record', async () => {
-    await upsertProgress(1500, 50)
-    await repo.eraseProgress(1500, null)
-
-    const result = await repo.getOneProgressByContentId(1500)
-    expect(result.data).toBeNull()
-  })
-})
-
-describe('mostRecentlyUpdatedId', () => {
-  test('returns id of most recently updated record', async () => {
-    await upsertProgress(1600, 50)
-    // Small delay so updated_at differs
-    await new Promise(r => setTimeout(r, 2))
-    await upsertProgress(1601, 50)
-
-    const result = await repo.mostRecentlyUpdatedId([1600, 1601])
-    // 1601 was updated last
-    expect(result.data).toBe(ContentProgress.generateId(1601, null))
-  })
-})
-
-describe('completedByContentIds', () => {
-  test('returns only completed records in the provided set', async () => {
-    await upsertProgress(1700, 100)  // completed
-    await upsertProgress(1701, 50)   // started
-    await upsertProgress(1702, 100)  // completed
-
-    const result = await repo.completedByContentIds([1700, 1701, 1702])
-    expect(result.data.map(r => r.content_id).sort()).toEqual([1700, 1702])
-  })
-})

package/test/integration/sync/repositories/user-award-progress.static.test.ts

@@ -1,68 +0,0 @@
-jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
-
-import UserAwardProgressRepository from '../../../../src/services/sync/repositories/user-award-progress'
-
-describe('UserAwardProgressRepository static methods', () => {
-  describe('isCompleted', () => {
-    test('returns true when completed_at is set and progress_percentage is 100', () => {
-      const result = UserAwardProgressRepository.isCompleted({
-        completed_at: '2024-01-01T00:00:00Z',
-        progress_percentage: 100,
-      })
-      expect(result).toBe(true)
-    })
-    test('returns false when completed_at is null', () => {
-      const result = UserAwardProgressRepository.isCompleted({
-        completed_at: null,
-        progress_percentage: 100,
-      })
-      expect(result).toBe(false)
-    })
-    test('returns false when progress_percentage is less than 100', () => {
-      const result = UserAwardProgressRepository.isCompleted({
-        completed_at: '2024-01-01T00:00:00Z',
-        progress_percentage: 50,
-      })
-      expect(result).toBe(false)
-    })
-  })
-  describe('isInProgress', () => {
-    test('returns true when progress is greater than 0 and not completed', () => {
-      const result = UserAwardProgressRepository.isInProgress({
-        completed_at: null,
-        progress_percentage: 50,
-      })
-      expect(result).toBe(true)
-    })
-    test('returns false when award is completed', () => {
-      const result = UserAwardProgressRepository.isInProgress({
-        completed_at: '2024-01-01T00:00:00Z',
-        progress_percentage: 100,
-      })
-      expect(result).toBe(false)
-    })
-    test('returns true when progress is 0 and not completed', () => {
-      const result = UserAwardProgressRepository.isInProgress({
-        completed_at: null,
-        progress_percentage: 0,
-      })
-      expect(result).toBe(true)
-    })
-  })
-  describe('completedAtDate', () => {
-    test('returns a Date object when completed_at is set', () => {
-      const result = UserAwardProgressRepository.completedAtDate({
-        completed_at: '2024-01-01T00:00:00Z',
-      })
-      expect(result).toBeInstanceOf(Date)
-      expect(result?.toISOString()).toBe('2024-01-01T00:00:00.000Z')
-    })
-    test('returns null when completed_at is null', () => {
-      const result = UserAwardProgressRepository.completedAtDate({
-        completed_at: null,
-      })
-      expect(result).toBeNull()
-    })
-  })
-})

package/test/integration/sync/repositories/user-award-progress.test.ts

@@ -1,387 +0,0 @@
-jest.mock('@/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('@/services/sync/repository-proxy', () => ({ db: {} }))
-jest.mock('../../../../src/services/awards/internal/award-definitions', () => ({
-  awardDefinitions: {
-    getByContentId: jest.fn(),
-    getByContentIds: jest.fn(),
-  },
-}))
-
-import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
-import UserAwardProgress from '@/services/sync/models/UserAwardProgress'
-import UserAwardProgressRepository from '@/services/sync/repositories/user-award-progress'
-import type { CompletionData, AwardDefinition } from '../../../../src/services/awards/types'
-
-let db: Database
-let repo: UserAwardProgressRepository
-
-const COMPLETION_DATA: CompletionData = {
-  content_title: 'Test Course',
-  completed_at: '2024-01-15T10:00:00.000Z',
-  days_user_practiced: 30,
-  practice_minutes: 600,
-}
-
-function upsertAward(
-  awardId: string,
-  progressPct: number,
-  overrides: Partial<{
-    completedAt: string | null
-    completionData: CompletionData | null
-    progressData: any
-  }> = {}
-) {
-  return repo['store'].upsertOne(awardId, r => {
-    r.award_id = awardId
-    r.progress_percentage = progressPct
-    if (overrides.completedAt !== undefined) {
-      r.completed_at = overrides.completedAt
-    }
-    if (overrides.completionData !== undefined) {
-      r.completion_data = overrides.completionData
-    }
-    if (overrides.progressData !== undefined) {
-      r.progress_data = overrides.progressData
-    }
-  })
-}
-
-beforeEach(() => {
-  db = makeDatabase()
-  const { store } = makeStore(UserAwardProgress, db)
-  repo = new UserAwardProgressRepository(store)
-})
-
-afterEach(async () => {
-  await resetDatabase(db)
-})
-
-// ---
-
-describe('static helpers', () => {
-  test('isCompleted returns true when completed_at set and progress is 100', () => {
-    expect(UserAwardProgressRepository.isCompleted({
-      completed_at: '2024-01-15T10:00:00.000Z',
-      progress_percentage: 100,
-    })).toBe(true)
-  })
-
-  test('isCompleted returns false when progress is 100 but completed_at is null', () => {
-    expect(UserAwardProgressRepository.isCompleted({
-      completed_at: null,
-      progress_percentage: 100,
-    })).toBe(false)
-  })
-
-  test('isCompleted returns false when completed_at set but progress is not 100', () => {
-    expect(UserAwardProgressRepository.isCompleted({
-      completed_at: '2024-01-15T10:00:00.000Z',
-      progress_percentage: 50,
-    })).toBe(false)
-  })
-
-  test('isInProgress returns true when progress >= 0 and not completed', () => {
-    expect(UserAwardProgressRepository.isInProgress({
-      completed_at: null,
-      progress_percentage: 50,
-    })).toBe(true)
-  })
-
-  test('isInProgress returns false when completed', () => {
-    expect(UserAwardProgressRepository.isInProgress({
-      completed_at: '2024-01-15T10:00:00.000Z',
-      progress_percentage: 100,
-    })).toBe(false)
-  })
-
-  test('completedAtDate returns Date for valid ISO string', () => {
-    const result = UserAwardProgressRepository.completedAtDate({
-      completed_at: '2024-01-15T10:00:00.000Z',
-    })
-    expect(result).toBeInstanceOf(Date)
-    expect(result!.getFullYear()).toBe(2024)
-  })
-
-  test('completedAtDate returns null when completed_at is null', () => {
-    expect(UserAwardProgressRepository.completedAtDate({ completed_at: null })).toBeNull()
-  })
-})
-
-// ---
-
-describe('getAll', () => {
-  test('returns all records', async () => {
-    await upsertAward('award-1', 50)
-    await upsertAward('award-2', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-
-    const result = await repo.getAll()
-    expect(result.data).toHaveLength(2)
-  })
-
-  test('onlyCompleted filters to completed records', async () => {
-    await upsertAward('award-1', 50)
-    await upsertAward('award-2', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-    await upsertAward('award-3', 100, { completedAt: '2024-01-16T10:00:00.000Z' })
-
-    const result = await repo.getAll({ onlyCompleted: true })
-    expect(result.data).toHaveLength(2)
-    expect(result.data.every(r => r.completed_at !== null)).toBe(true)
-  })
-
-  test('respects limit', async () => {
-    await Promise.all(['a', 'b', 'c', 'd'].map(id => upsertAward(id, 50)))
-
-    const result = await repo.getAll({ limit: 2 })
-    expect(result.data).toHaveLength(2)
-  })
-
-  test('returns empty when no records', async () => {
-    const result = await repo.getAll()
-    expect(result.data).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('getCompleted', () => {
-  test('returns only records with completed_at set', async () => {
-    await upsertAward('award-1', 50)
-    await upsertAward('award-2', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-
-    const result = await repo.getCompleted()
-    expect(result.data).toHaveLength(1)
-    expect(result.data[0].award_id).toBe('award-2')
-  })
-
-  test('respects limit', async () => {
-    await upsertAward('award-1', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-    await upsertAward('award-2', 100, { completedAt: '2024-01-16T10:00:00.000Z' })
-    await upsertAward('award-3', 100, { completedAt: '2024-01-17T10:00:00.000Z' })
-
-    const result = await repo.getCompleted(2)
-    expect(result.data).toHaveLength(2)
-  })
-})
-
-// ---
-
-describe('getInProgress', () => {
-  test('returns records with progress > 0 and no completed_at', async () => {
-    await upsertAward('in-progress', 50)
-    await upsertAward('completed', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-    await upsertAward('not-started', 0)
-
-    const result = await repo.getInProgress()
-    const ids = result.data.map(r => r.award_id)
-    expect(ids).toContain('in-progress')
-    expect(ids).not.toContain('completed')
-    expect(ids).not.toContain('not-started')
-  })
-
-  test('respects limit', async () => {
-    await Promise.all(['a', 'b', 'c'].map(id => upsertAward(id, 50)))
-
-    const result = await repo.getInProgress(2)
-    expect(result.data).toHaveLength(2)
-  })
-})
-
-// ---
-
-describe('getByAwardId / getByAwardIds', () => {
-  test('getByAwardId returns matching record', async () => {
-    await upsertAward('award-abc', 75)
-
-    const result = await repo.getByAwardId('award-abc')
-    expect(result.data).not.toBeNull()
-    expect(result.data!.award_id).toBe('award-abc')
-  })
-
-  test('getByAwardId returns null for missing id', async () => {
-    const result = await repo.getByAwardId('nonexistent')
-    expect(result.data).toBeNull()
-  })
-
-  test('getByAwardIds returns all matching records', async () => {
-    await upsertAward('award-1', 25)
-    await upsertAward('award-2', 50)
-    await upsertAward('award-3', 75)
-
-    const result = await repo.getByAwardIds(['award-1', 'award-3'])
-    expect(result.data).toHaveLength(2)
-    expect(result.data.map(r => r.award_id).sort()).toEqual(['award-1', 'award-3'])
-  })
-
-  test('getByAwardIds returns empty for empty input', async () => {
-    const result = await repo.getByAwardIds([])
-    expect(result.data).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('hasCompletedAward', () => {
-  test('returns true when award is completed', async () => {
-    await upsertAward('award-done', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-
-    expect(await repo.hasCompletedAward('award-done')).toBe(true)
-  })
-
-  test('returns false when award has progress but not completed', async () => {
-    await upsertAward('award-partial', 80)
-
-    expect(await repo.hasCompletedAward('award-partial')).toBe(false)
-  })
-
-  test('returns false when progress is 100 but completed_at is null', async () => {
-    await upsertAward('award-no-date', 100)
-
-    expect(await repo.hasCompletedAward('award-no-date')).toBe(false)
-  })
-
-  test('returns false when award does not exist', async () => {
-    expect(await repo.hasCompletedAward('nonexistent')).toBe(false)
-  })
-})
-
-// ---
-
-describe('recordAwardProgress', () => {
-  test('creates record with progress percentage', async () => {
-    await repo.recordAwardProgress('award-x', 60)
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.progress_percentage).toBe(60)
-    expect(result.data!.award_id).toBe('award-x')
-  })
-
-  test('sets completedAt when provided', async () => {
-    const completedAt = '2024-06-01T12:00:00.000Z'
-    await repo.recordAwardProgress('award-x', 100, { completedAt })
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.completed_at).toBe(completedAt)
-  })
-
-  test('sets completionData when provided', async () => {
-    await repo.recordAwardProgress('award-x', 100, {
-      completedAt: COMPLETION_DATA.completed_at,
-      completionData: COMPLETION_DATA,
-    })
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.completion_data).toEqual(COMPLETION_DATA)
-  })
-
-  test('sets progressData when provided', async () => {
-    const progressData = { lesson_ids: [1, 2, 3], current: 2 }
-    await repo.recordAwardProgress('award-x', 50, { progressData })
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.progress_data).toEqual(progressData)
-  })
-
-  test('updates existing record on second call', async () => {
-    await repo.recordAwardProgress('award-x', 40)
-    await repo.recordAwardProgress('award-x', 80)
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.progress_percentage).toBe(80)
-  })
-})
-
-// ---
-
-describe('completeAward', () => {
-  test('sets progress to 100 and records completionData', async () => {
-    await repo.completeAward('award-x', COMPLETION_DATA)
-
-    const result = await repo.getByAwardId('award-x')
-    expect(result.data!.progress_percentage).toBe(100)
-    expect(result.data!.completion_data).toEqual(COMPLETION_DATA)
-  })
-
-  test('sets completed_at to an ISO date string', async () => {
-    const before = new Date().toISOString()
-    await repo.completeAward('award-x', COMPLETION_DATA)
-    const after = new Date().toISOString()
-
-    const result = await repo.getByAwardId('award-x')
-    const completedAt = result.data!.completed_at!
-    expect(completedAt >= before).toBe(true)
-    expect(completedAt <= after).toBe(true)
-  })
-
-  test('hasCompletedAward returns true after completeAward', async () => {
-    await repo.completeAward('award-x', COMPLETION_DATA)
-    expect(await repo.hasCompletedAward('award-x')).toBe(true)
-  })
-})
-
-// ---
-
-describe('getAwardsForContent', () => {
-  test('returns definitions and matching progress map', async () => {
-    const { awardDefinitions } = await import('../../../../src/services/awards/internal/award-definitions')
-    const mockDefinitions: AwardDefinition[] = [
-      { _id: 'award-1', name: 'Test Award', content_id: 100, is_active: true, logo: null, badge: null, badge_rear: null, award: 'completion', content_type: 'lesson', type: 'course-completion', brand: 'drumeo', content_title: 'Test', award_custom_text: null, instructor_name: null, child_ids: [] },
-    ]
-    ;(awardDefinitions.getByContentId as jest.Mock).mockResolvedValue(mockDefinitions)
-
-    await upsertAward('award-1', 50)
-
-    const result = await repo.getAwardsForContent(100)
-    expect(result.definitions).toEqual(mockDefinitions)
-    expect(result.progress.get('award-1')).toBeDefined()
-    expect(result.progress.get('award-1')!.progress_percentage).toBe(50)
-  })
-
-  test('returns empty progress map when no progress recorded', async () => {
-    const { awardDefinitions } = await import('../../../../src/services/awards/internal/award-definitions')
-    ;(awardDefinitions.getByContentId as jest.Mock).mockResolvedValue([
-      { _id: 'award-1', name: 'Test Award', content_id: 100, is_active: true, logo: null, badge: null, badge_rear: null, award: 'completion', content_type: 'lesson', type: 'course-completion', brand: 'drumeo', content_title: 'Test', award_custom_text: null, instructor_name: null, child_ids: [] },
-    ])
-
-    const result = await repo.getAwardsForContent(100)
-    expect(result.definitions).toHaveLength(1)
-    expect(result.progress.size).toBe(0)
-  })
-})
-
-// ---
-
-describe('getAwardsForContentMany', () => {
-  test('returns map keyed by contentId with definitions and progress', async () => {
-    const { awardDefinitions } = await import('../../../../src/services/awards/internal/award-definitions')
-    const defsByContent = new Map([
-      [100, [{ _id: 'award-100', name: 'Award 100', content_id: 100, is_active: true, logo: null, badge: null, badge_rear: null, award: 'completion', content_type: 'lesson', type: 'course-completion', brand: 'drumeo', content_title: 'Course 100', award_custom_text: null, instructor_name: null, child_ids: [] }]],
-      [200, [{ _id: 'award-200', name: 'Award 200', content_id: 200, is_active: true, logo: null, badge: null, badge_rear: null, award: 'completion', content_type: 'lesson', type: 'course-completion', brand: 'drumeo', content_title: 'Course 200', award_custom_text: null, instructor_name: null, child_ids: [] }]],
-    ])
-    ;(awardDefinitions.getByContentIds as jest.Mock).mockResolvedValue(defsByContent)
-
-    await upsertAward('award-100', 75)
-
-    const result = await repo.getAwardsForContentMany([100, 200])
-    expect(result.size).toBe(2)
-    expect(result.get(100)!.progress.get('award-100')!.progress_percentage).toBe(75)
-    expect(result.get(200)!.progress.size).toBe(0)
-  })
-})
-
-// ---
-
-describe('deleteAllAwards', () => {
-  test('returns deletedCount of 0 when no awards', async () => {
-    const result = await repo.deleteAllAwards()
-    expect(result.deletedCount).toBe(0)
-  })
-
-  test('returns correct deletedCount', async () => {
-    await upsertAward('award-1', 50)
-    await upsertAward('award-2', 100, { completedAt: '2024-01-15T10:00:00.000Z' })
-
-    const result = await repo.deleteAllAwards()
-    expect(result.deletedCount).toBe(2)
-  })
-})