musora-content-services 2.167.2 → 2.167.4

package/test/integration/awards/award-exclusion-handling.test.ts

@@ -1,275 +0,0 @@
-import { awardManager } from '../../../src/services/awards/internal/award-manager.js'
-import { awardEvents } from '../../../src/services/awards/internal/award-events.js'
-import { mockAwardDefinitions, getAwardByContentId } from '../../mockData/award-definitions.js'
-import { globalConfig } from '../../../src/services/config.js'
-import { LocalStorageMock } from '../../localStorageMock.js'
-import { setupDefaultMocks, setupAwardEventListeners } from '../../unit/awards/helpers/index'
-import { mockCompletionStates, mockAllCompleted, mockNoneCompleted } from '../../unit/awards/helpers/completion-mock'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity'),
-  default: { fetch: jest.fn() },
-  fetchSanity: jest.fn()
-}))
-
-jest.mock('../../../src/services/railcontent.js', () => ({
-  ...jest.requireActual('../../../src/services/railcontent'),
-  fetchUserPermissionsData: jest.fn().mockResolvedValue({ permissions: [108, 91, 92], isAdmin: false })
-}))
-
-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(),
-      completeAward: 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 Content Exclusion Handling - E2E Scenarios', () => {
-  let listeners
-
-  beforeEach(async () => {
-    jest.clearAllMocks()
-    globalConfig.localStorage = new LocalStorageMock()
-    awardEvents.removeAllListeners()
-
-    sanityClient.fetch = jest.fn().mockResolvedValue(mockAwardDefinitions)
-    setupDefaultMocks(db, fetchSanity, { practiceMinutes: 150 })
-
-    db.userAwardProgress.completeAward = jest.fn().mockResolvedValue({ data: {}, status: 'synced' })
-
-    db.contentProgress.getSomeProgressByContentIds.mockResolvedValue({
-      data: [{ created_at: Math.floor(Date.now() / 1000) - 86400 * 7 }]
-    })
-
-    await awardDefinitions.refresh()
-
-    listeners = setupAwardEventListeners(awardEvents)
-  })
-
-  afterEach(() => {
-    awardEvents.removeAllListeners()
-    awardDefinitions.clear()
-  })
-
-  describe('Scenario: Guided course with excluded intro video (416446 - 1 eligible lesson)', () => {
-    const testAward = getAwardByContentId(416446)
-    const courseId = 416446
-
-    test('completing the single eligible lesson grants award at 100%', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        expect.any(String),
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          immediate: true
-        })
-      )
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-
-    test('shows 0% progress when eligible lesson not completed', async () => {
-      mockNoneCompleted(db)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        0,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-  })
-
-  describe('Scenario: Course with 4 eligible lessons (417049 - intro excluded)', () => {
-    const testAward = getAwardByContentId(417049)
-    const courseId = 417049
-
-    test('completing 1 of 4 lessons shows 25% progress', async () => {
-      mockCompletionStates(db, [417045])
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        25,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-
-    test('completing 2 of 4 lessons shows 50% progress', async () => {
-      mockCompletionStates(db, [417045, 417046])
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        50,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-
-    test('must complete all 4 eligible lessons to earn award', async () => {
-      mockCompletionStates(db, [417045, 417046, 417047, 417048])
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        expect.any(String),
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          immediate: true
-        })
-      )
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('Scenario: Large course with 23 eligible lessons (416464 - intro excluded)', () => {
-    const testAward = getAwardByContentId(416464)
-    const courseId = 416464
-    const eligibleLessons = [
-      416467, 416468, 416469, 416470, 416471, 416472, 416473,
-      416474, 416475, 416476, 416477, 416478, 416479, 416480, 416481,
-      416482, 416483, 416484, 416485, 416486, 416487, 416488, 416489
-    ]
-
-    test('shows 0% progress when no eligible lessons completed', async () => {
-      mockNoneCompleted(db)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        0,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-
-    test('completing 12 of 23 lessons shows ~52% progress', async () => {
-      mockCompletionStates(db, eligibleLessons.slice(0, 12))
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        52,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-
-    test('must complete all 23 eligible lessons to earn award', async () => {
-      mockCompletionStates(db, eligibleLessons)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        expect.any(String),
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          immediate: true
-        })
-      )
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('Scenario: Course type without excluded content (417039 - all 3 lessons count)', () => {
-    const testAward = getAwardByContentId(417039)
-    const courseId = 417039
-
-    test('first lesson counts toward progress', async () => {
-      mockCompletionStates(db, [417035])
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        33,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-
-    test('all 3 lessons must be completed to earn award', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        expect.any(String),
-        100,
-        expect.objectContaining({
-          completedAt: expect.any(String),
-          immediate: true
-        })
-      )
-    })
-  })
-
-  describe('Scenario: Learning path content type (417140)', () => {
-    const testAward = getAwardByContentId(417140)
-    const courseId = 417140
-
-    test('all child content counts toward progress', async () => {
-      mockCompletionStates(db, testAward.child_ids.slice(0, 11))
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(db.userAwardProgress.recordAwardProgress).toHaveBeenCalledWith(
-        testAward._id,
-        50,
-        expect.objectContaining({
-          progressData: expect.any(Object)
-        })
-      )
-    })
-  })
-
-  describe('Scenario: Skill pack content type (418000)', () => {
-    const courseId = 418000
-
-    test('completing all lessons grants award', async () => {
-      mockAllCompleted(db)
-
-      await awardManager.onContentCompleted(courseId)
-
-      expect(listeners.granted).toHaveBeenCalledTimes(1)
-    })
-  })
-})

package/test/integration/awards/internal/image-utils.test.ts

@@ -1,86 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import { urlToBase64, urlMapToBase64 } from '../../../../src/services/awards/internal/image-utils.js'
-describe('urlToBase64', () => {
-  test('returns empty string when url is falsy', async () => {
-    const result = await urlToBase64('')
-    expect(result).toBe('')
-  })
-  test('returns empty string when fetch response is not ok', async () => {
-    global.fetch = jest.fn().mockResolvedValue({
-      ok: false,
-      blob: jest.fn(),
-    })
-    const result = await urlToBase64('https://cdn.example.com/image.png')
-    expect(result).toBe('')
-  })
-  test('returns base64 data string on successful fetch', async () => {
-    global.fetch = jest.fn().mockResolvedValue({
-      ok: true,
-      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
-    })
-    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
-      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
-        this.result = 'data:image/png;base64,abc123=='
-        this.onloadend()
-      }),
-      onerror: null,
-      onloadend: null,
-      result: null,
-    } as any))
-    const result = await urlToBase64('https://cdn.example.com/image.png')
-    expect(result).toBe('abc123==')
-  })
-  // BUG: onerror path uses reject() inside new Promise() which escapes the outer try/catch.
-  // The function contract says it should return '' on failure but instead rejects.
-  // Fix: change reject() to resolve('') in the onerror handler in image-utils.js
-  test('returns empty string when FileReader errors', async () => {
-    jest.spyOn(console, 'error').mockImplementation(() => {})
-    global.fetch = jest.fn().mockResolvedValue({
-      ok: true,
-      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
-    })
-    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
-      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
-        setTimeout(() => this.onerror(), 0)
-      }),
-      onerror: null,
-      onloadend: null,
-      result: null,
-    } as any))
-    await expect(urlToBase64('https://cdn.example.com/image.png')).rejects.toThrow(
-      'Failed to convert image to base64'
-    )
-  })
-})
-
-describe('urlMapToBase64', () => {
-  test('converts all URLs in a map to base64', async () => {
-    global.fetch = jest.fn().mockResolvedValue({
-      ok: true,
-      blob: jest.fn().mockResolvedValue(new Blob(['fake-image-data'], { type: 'image/png' })),
-    })
-    jest.spyOn(global, 'FileReader').mockImplementation(() => ({
-      readAsDataURL: jest.fn().mockImplementation(function(this: any) {
-        this.result = 'data:image/png;base64,abc123=='
-        this.onloadend()
-      }),
-      onerror: null,
-      onloadend: null,
-      result: null,
-    } as any))
-    const result = await urlMapToBase64({
-      badge: 'https://cdn.example.com/badge.png',
-      logo: 'https://cdn.example.com/logo.png',
-    })
-    expect(result).toEqual({
-      badge: 'abc123==',
-      logo: 'abc123==',
-    })
-  })
-  test('returns empty object when map is empty', async () => {
-    const result = await urlMapToBase64({})
-    expect(result).toEqual({})
-  })
-})

package/test/integration/content-progress/__mocks__/mocks.ts

@@ -1,104 +0,0 @@
-export const mockContentProgressObserver = () => ({
-  contentProgressObserver: {
-    start: jest.fn().mockResolvedValue(undefined),
-    stop: jest.fn(),
-  },
-})
-
-export const mockLearningPaths = () => ({
-  getDailySession: jest.fn().mockResolvedValue(null),
-  onLearningPathCompletedActions: jest.fn().mockResolvedValue(undefined),
-})
-
-export const mockProgressEvents = () => ({
-  emitProgressSaved: jest.fn(),
-})
-
-export type HierarchyTreeNode = {
-  id: number
-  type?: string
-  brand?: string
-  children?: HierarchyTreeNode[]
-}
-
-type HierarchyLookups = {
-  topLevelId: number
-  parents: Record<number, number>
-  children: Record<number, number[]>
-  metadata: Record<number, { type: string; brand: string; parent_id: number }>
-}
-
-const LP_TYPE = 'learning-path-v2'
-
-const ALC_KEY = 'alc'
-const LP_KEY = 'lp'
-
-let hierarchiesByKey: Record<string, Record<number, HierarchyLookups>> = {}
-let topByKey: Record<string, Record<number, number>> = {}
-
-function keyFor(collection?: { type?: string } | null): string {
-  return collection?.type === LP_TYPE ? LP_KEY : ALC_KEY
-}
-
-export function setHierarchy(tree: HierarchyTreeNode, options?: { lp?: boolean }) {
-  const key = options?.lp ? LP_KEY : ALC_KEY
-  hierarchiesByKey[key] ??= {}
-  topByKey[key] ??= {}
-  hierarchiesByKey[key][tree.id] = treeToLookups(tree)
-  registerIds(tree, tree.id, topByKey[key])
-}
-
-export function clearHierarchies() {
-  hierarchiesByKey = {}
-  topByKey = {}
-}
-
-function treeToLookups(root: HierarchyTreeNode): HierarchyLookups {
-  const parents: Record<number, number> = {}
-  const children: Record<number, number[]> = {}
-  const metadata: Record<number, { type: string; brand: string; parent_id: number }> = {}
-
-  function walk(node: HierarchyTreeNode, parentId: number) {
-    const childIds = (node.children ?? []).map(c => c.id)
-    metadata[node.id] = {
-      type: node.type ?? 'lesson',
-      brand: node.brand ?? 'drumeo',
-      parent_id: parentId,
-    }
-    if (parentId) parents[node.id] = parentId
-    if (childIds.length > 0) children[node.id] = childIds
-    for (const c of node.children ?? []) walk(c, node.id)
-  }
-
-  walk(root, 0)
-
-  return { topLevelId: root.id, parents, children, metadata }
-}
-
-function registerIds(node: HierarchyTreeNode, topId: number, target: Record<number, number>) {
-  target[node.id] = topId
-  for (const c of node.children ?? []) registerIds(c, topId, target)
-}
-
-function lookupFor(contentId: number, collection?: any): HierarchyLookups {
-  const key = keyFor(collection)
-  const tops = topByKey[key] ?? {}
-  const hierarchies = hierarchiesByKey[key] ?? {}
-  const topId = tops[contentId] ?? (key === LP_KEY ? collection?.id : contentId)
-  return hierarchies[topId] ?? {
-    topLevelId: contentId,
-    parents: {},
-    children: {},
-    metadata: { [contentId]: { brand: 'drumeo', type: 'lesson', parent_id: 0 } },
-  }
-}
-
-export const mockSanity = () => ({
-  getHierarchy: jest.fn((contentId: number, collection?: any) =>
-    Promise.resolve(lookupFor(contentId, collection)),
-  ),
-  getHierarchies: jest.fn((contentIds: number[], collection?: any) =>
-    Promise.resolve(Object.fromEntries(contentIds.map(id => [id, lookupFor(id, collection)]))),
-  ),
-  getSanityDate: jest.fn((date: Date) => date.toISOString()),
-})