musora-content-services 2.158.2 → 2.159.0

package/test/unit/content-progress/navigateTo.test.ts

@@ -0,0 +1,381 @@
+import { initializeTestService } from '../../initializeTests.js'
+import {
+  buildNavigateTo,
+  findIncompleteLesson,
+  getNavigateTo,
+  getNavigateToForMethod,
+} from '../../../src/services/contentProgress.js'
+import { COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+
+let mockProgressRecords: any[] = []
+let mockLastInteracted: number | null = null
+
+jest.mock('../../../src/services/sync/repository-proxy', () => {
+  const mockFns = {
+    contentProgress: {
+      getOneProgressByContentId: jest.fn().mockImplementation((contentId) => {
+        const record = mockProgressRecords.find(r => r.content_id === contentId)
+        return Promise.resolve({ data: record || null })
+      }),
+      getSomeProgressByContentIds: jest.fn().mockImplementation((contentIds) => {
+        const records = mockProgressRecords.filter(r => contentIds.includes(r.content_id))
+        return Promise.resolve({ data: records })
+      }),
+      mostRecentlyUpdatedId: jest.fn().mockImplementation(() => {
+        return Promise.resolve({ data: mockLastInteracted })
+      }),
+    },
+    practices: {
+      queryAll: jest.fn().mockResolvedValue({ data: [] }),
+      getAll: jest.fn().mockResolvedValue({ data: [] }),
+    },
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+jest.mock('../../../src/services/content-org/learning-paths', () => ({
+  getDailySession: jest.fn().mockResolvedValue(null),
+  onLearningPathCompletedActions: jest.fn().mockResolvedValue(undefined),
+}))
+
+jest.mock('../../../src/services/sanity.js', () => ({
+  getHierarchy: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getHierarchies: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getSanityDate: jest.fn((date: Date) => date.toISOString()),
+}))
+
+const { getDailySession } = jest.requireMock('../../../src/services/content-org/learning-paths')
+
+const child = (id: number, type = 'lesson') => ({
+  id,
+  brand: 'drumeo',
+  thumbnail: '',
+  type,
+  published_on: null,
+  status: 'published',
+  children: null as any,
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  initializeTestService()
+  mockProgressRecords = []
+  mockLastInteracted = null
+})
+
+// ─── buildNavigateTo ──────────────────────────────────────────────────────────
+
+describe('buildNavigateTo', () => {
+  test('null content returns null', () => {
+    expect(buildNavigateTo(null)).toBeNull()
+  })
+
+  test('valid content returns correct shape', () => {
+    const content = {
+      id: 101,
+      brand: 'drumeo',
+      thumbnail: 'thumb.jpg',
+      type: 'lesson',
+      published_on: '2024-01-01',
+      status: 'published',
+    }
+    const result = buildNavigateTo(content)
+    expect(result).toEqual({
+      brand: 'drumeo',
+      thumbnail: 'thumb.jpg',
+      id: 101,
+      type: 'lesson',
+      published_on: '2024-01-01',
+      status: 'published',
+      child: null,
+      collection: null,
+    })
+  })
+
+  test('missing fields fall back to defaults', () => {
+    const result = buildNavigateTo({ id: 5 })
+    expect(result).toMatchObject({
+      brand: '',
+      thumbnail: '',
+      id: 5,
+      type: '',
+      published_on: null,
+      status: '',
+      child: null,
+      collection: null,
+    })
+  })
+
+  test('child and collection args pass through', () => {
+    const childObj = {
+      id: 200,
+      brand: 'drumeo',
+      thumbnail: '',
+      type: 'lesson',
+      published_on: null,
+      status: 'published',
+    }
+    const collection = { type: COLLECTION_TYPE.LEARNING_PATH, id: 999 }
+    const result = buildNavigateTo({ id: 100 }, childObj, collection)
+    expect(result?.child).toBe(childObj)
+    expect(result?.collection).toBe(collection)
+  })
+})
+
+// ─── findIncompleteLesson ─────────────────────────────────────────────────────
+
+describe('findIncompleteLesson', () => {
+  describe('course type', () => {
+    test('finds first incomplete after currentContentId', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, 'completed'],
+        [103, 'started'],
+        [104, ''],
+      ])
+      expect(findIncompleteLesson(progresses, 102, 'course')).toBe(103)
+    })
+
+    // todo(BEHSTP-325): add a test "returns currentContentId if it's incomplete"
+
+    test('wraps to first when all after current are completed, even if some before are incomplete', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, 'started'],
+        [103, 'completed'],
+        [104, 'completed'],
+      ])
+      expect(findIncompleteLesson(progresses, 103, 'course')).toBe(101)
+    })
+
+    test('returns null when currentContentId not in ids', () => {
+      const progresses = new Map([
+        [101, 'started'],
+        [102, 'completed'],
+      ])
+      expect(findIncompleteLesson(progresses, 999, 'course')).toBeNull()
+    })
+  })
+
+  describe('guided-course type', () => {
+    test('finds first incomplete regardless of position', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, ''],
+        [103, 'started'],
+      ])
+      expect(findIncompleteLesson(progresses, 103, 'guided-course')).toBe(102)
+    })
+
+    test('returns first id when all completed', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, 'completed'],
+        [103, 'completed'],
+      ])
+      expect(findIncompleteLesson(progresses, 102, 'guided-course')).toBe(101)
+    })
+  })
+
+  describe('learning-path-v2 type', () => {
+    test('finds first incomplete regardless of position', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, ''],
+        [103, 'started'],
+      ])
+      expect(findIncompleteLesson(progresses, 103, 'learning-path-v2')).toBe(102)
+    })
+
+    test('returns first id when all completed', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, 'completed'],
+        [103, 'completed'],
+      ])
+      expect(findIncompleteLesson(progresses, 102, 'learning-path-v2')).toBe(101)
+    })
+  })
+
+  describe('Map vs Object input', () => {
+    test('works with Map input', () => {
+      const progresses = new Map([
+        [101, 'completed'],
+        [102, ''],
+      ])
+      expect(findIncompleteLesson(progresses, 101, 'course')).toBe(102)
+    })
+
+    test('works with Object input', () => {
+      const progresses = { 101: 'completed', 102: '' }
+      expect(findIncompleteLesson(progresses, 101, 'course')).toBe(102)
+    })
+  })
+})
+
+// ─── getNavigateTo ────────────────────────────────────────────────────────────
+
+describe('getNavigateTo', () => {
+  test('null entry in data array skipped', async () => {
+    const result = await getNavigateTo([null as any, { id: 1, type: 'lesson', children: [] }])
+    expect(result[1]).toBeNull()
+    expect(Object.keys(result)).not.toContain('null')
+    expect(Object.keys(result)).not.toContain('undefined')
+  })
+
+  test('non-navigable type returns null', async () => {
+    const result = await getNavigateTo([{ id: 1, type: 'lesson', children: [child(101)] }])
+    expect(result[1]).toBeNull()
+  })
+
+  test('null children returns null', async () => {
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: null }])
+    expect(result[1]).toBeNull()
+  })
+
+  test('empty children after filtering nulls returns null', async () => {
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: [null, null] }])
+    expect(result[1]).toBeNull()
+  })
+
+  test('content not started navigates to first child', async () => {
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: [child(101), child(102)] }])
+    expect(result[1]).toMatchObject({ id: 101 })
+  })
+
+  test('course started lastInteracted started navigates to lastInteracted child', async () => {
+    mockProgressRecords = [
+      { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
+      { content_id: 101, state: 'started', progress_percent: 100, updated_at: 900 },
+      { content_id: 102, state: 'started', progress_percent: 30, updated_at: 1000 },
+    ]
+    mockLastInteracted = 101
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: [child(101), child(102)] }])
+    expect(result[1]).toMatchObject({ id: 101 })
+  })
+
+  test('course started lastInteracted completed navigates to first incomplete after lastInteracted', async () => {
+    mockProgressRecords = [
+      { content_id: 1, state: 'started', progress_percent: 60, updated_at: 1000 },
+      { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
+      { content_id: 102, state: 'completed', progress_percent: 100, updated_at: 1000 },
+      { content_id: 103, state: 'started', progress_percent: 20, updated_at: 800 },
+    ]
+    mockLastInteracted = 101
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: [child(101), child(102), child(103)] }])
+    expect(result[1]).toMatchObject({ id: 103 })
+  })
+
+  test('course started all children completed wraps to first child', async () => {
+    mockProgressRecords = [
+      { content_id: 1, state: 'started', progress_percent: 100, updated_at: 1000 },
+      { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
+      { content_id: 102, state: 'completed', progress_percent: 100, updated_at: 1000 },
+    ]
+    mockLastInteracted = 102
+    const result = await getNavigateTo([{ id: 1, type: 'course', children: [child(101), child(102)] }])
+    expect(result[1]).toMatchObject({ id: 101 })
+  })
+
+  test('guided-course started navigates to first incomplete child', async () => {
+    mockProgressRecords = [
+      { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
+      { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
+    ]
+    mockLastInteracted = 101
+    const result = await getNavigateTo([{
+      id: 1,
+      type: 'guided-course',
+      children: [child(101), child(102), child(103)],
+    }])
+    expect(result[1]).toMatchObject({ id: 102 })
+  })
+
+  describe.each(['course', 'skill-pack', 'song-tutorial'])('course-flow type %s', (type) => {
+    test('lastInteracted completed → first incomplete after lastInteracted', async () => {
+      mockProgressRecords = [
+        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
+        { content_id: 101, state: '', progress_percent: 0, updated_at: 0 },
+        { content_id: 102, state: 'completed', progress_percent: 100, updated_at: 1000 },
+        { content_id: 103, state: '', progress_percent: 0, updated_at: 0 },
+      ]
+      mockLastInteracted = 102
+      const result = await getNavigateTo([{ id: 1, type, children: [child(101), child(102), child(103)] }])
+      expect(result[1]).toMatchObject({ id: 103 })
+    })
+  })
+
+  describe.each(['guided-course', COLLECTION_TYPE.LEARNING_PATH])('guided-course-flow type %s', (type) => {
+    test('finds first incomplete regardless of lastInteracted position', async () => {
+      mockProgressRecords = [
+        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
+        { content_id: 101, state: '', progress_percent: 0, updated_at: 0 },
+        { content_id: 102, state: 'completed', progress_percent: 100, updated_at: 1000 },
+        { content_id: 103, state: '', progress_percent: 0, updated_at: 0 },
+      ]
+      mockLastInteracted = 102
+      const result = await getNavigateTo([{ id: 1, type, children: [child(101), child(102), child(103)] }])
+      expect(result[1]).toMatchObject({ id: 101 })
+    })
+  })
+
+  // need more tests to support other types and potentially other logic branches.
+})
+
+// ─── getNavigateToForMethod ───────────────────────────────────────────────────
+
+describe('getNavigateToForMethod', () => {
+  const lpContent = (id: number, children: any[]) => ({
+    id,
+    brand: 'drumeo',
+    thumbnail: '',
+    type: COLLECTION_TYPE.LEARNING_PATH,
+    published_on: null,
+    status: 'published',
+    children,
+    record_id: `${id}:${COLLECTION_TYPE.LEARNING_PATH}:${id}`,
+  })
+
+  const nonLpContent = (id: number) => ({
+    id,
+    brand: 'drumeo',
+    thumbnail: '',
+    type: 'course',
+    published_on: null,
+    status: 'published',
+    children: [child(201), child(202)],
+    record_id: `${id}:self:0`,
+  })
+
+  test('non-LP content type returns null', async () => {
+    const result = await getNavigateToForMethod([nonLpContent(1)])
+    expect(result[1]).toBeNull()
+  })
+
+  test('LP type with no daily session navigates to first incomplete child', async () => {
+    getDailySession.mockResolvedValueOnce(null)
+    const result = await getNavigateToForMethod([lpContent(10, [child(301), child(302), child(303)])])
+    expect(result[10]).toMatchObject({ id: 301 })
+  })
+
+  test('LP type with active learning path and daily session navigates using daily session', async () => {
+    mockProgressRecords = [
+      { content_id: 301, state: 'completed', progress_percent: 100, updated_at: 900 },
+    ]
+    getDailySession.mockResolvedValueOnce({
+      active_learning_path_id: 10,
+      daily_session: [{ content_ids: [301, 302] }],
+    })
+    const result = await getNavigateToForMethod([lpContent(10, [child(300), child(301), child(302)])])
+    expect(result[10]).toMatchObject({ id: 302 })
+  })
+
+  test('null content entries skipped', async () => {
+    getDailySession.mockResolvedValueOnce(null)
+    const validContent = lpContent(10, [child(301)])
+    const result = await getNavigateToForMethod([validContent, null as any])
+    expect(Object.keys(result)).toContain('10')
+    expect(Object.keys(result)).not.toContain('null')
+    expect(Object.keys(result)).not.toContain('undefined')
+  })
+})

package/test/unit/contentMetaData.test.ts

@@ -0,0 +1,58 @@
+import { processMetadata } from '@/contentMetaData'
+
+describe('processMetadata', () => {
+  test('returns null for unknown brand and type', () => {
+    expect(processMetadata('unknown', 'unknown')).toBeNull()
+  })
+
+  test('returns null for unknown type on known brand', () => {
+    expect(processMetadata('drumeo', 'unknown-type')).toBeNull()
+  })
+
+  test('returns expected shape for known brand and type', () => {
+    const result = processMetadata('drumeo', 'lessons')
+
+    expect(result).not.toBeNull()
+    expect(result.type).toBe('lessons')
+    expect(result.name).toBeDefined()
+    expect(result.sort).toBeDefined()
+    expect(result.tabs).toBeDefined()
+    expect(Array.isArray(result.tabs)).toBe(true)
+  })
+
+  test('does not include filters when withFilters is false', () => {
+    const result = processMetadata('drumeo', 'lessons')
+
+    expect(result.filters).toBeUndefined()
+  })
+
+  test('includes filters when withFilters is true', () => {
+    const result = processMetadata('drumeo', 'lessons', true)
+
+    expect(result.filters).toBeDefined()
+  })
+
+  test('brand-specific filters differ between brands for the same type', () => {
+    const drumeo = processMetadata('drumeo', 'lessons', true)
+    const pianote = processMetadata('pianote', 'lessons', true)
+
+    expect(JSON.stringify(drumeo.filters)).not.toBe(JSON.stringify(pianote.filters))
+  })
+
+  test('shared structure is consistent across brands for the same type', () => {
+    const drumeo = processMetadata('drumeo', 'lessons')
+    const pianote = processMetadata('pianote', 'lessons')
+
+    expect(drumeo.type).toBe(pianote.type)
+    expect(drumeo.name).toBe(pianote.name)
+    expect(JSON.stringify(drumeo.tabs)).toBe(JSON.stringify(pianote.tabs))
+  })
+
+  test('songs tabs are brand-specific based on song types config', () => {
+    const result = processMetadata('drumeo', 'songs')
+
+    expect(result).not.toBeNull()
+    expect(result.tabs.length).toBeGreaterThan(0)
+    expect(result.tabs[0].name).toBe('For You')
+  })
+})

package/tools/generate-index.cjs

@@ -52,11 +52,14 @@ function extractExportedFunctions(filePath) {
  * @returns {string[]}
  */
 function getExclusionList(fileContent) {
-  const excludeRegex = /const\s+excludeFromGeneratedIndex\s*=\s*\[(.*?)\];?/
+  const excludeRegex = /const\s+excludeFromGeneratedIndex\s*=\s*\[([\s\S]*?)\]/
   const excludeMatch = fileContent.match(excludeRegex)
   let excludedFunctions = []
   if (excludeMatch) {
-    excludedFunctions = excludeMatch[1].split(',').map((name) => name.trim().replace(/['"`]/g, ''))
+    excludedFunctions = excludeMatch[1]
+      .split(',')
+      .map((name) => name.trim().replace(/['"`]/g, ''))
+      .filter(Boolean)
   }
   return excludedFunctions
 }
@@ -80,7 +83,7 @@ treeElements.forEach((treeNode) => {
     addFunctionsToFileExports(filePath, treeNode)
   } else if (fs.lstatSync(filePath).isDirectory()) {
 
-    // Check for .indexignore file to skip this directory
+    // Check for .= file to skip this directory
     if (fs.existsSync(path.join(filePath, '.indexignore'))) {
       console.log(`Skipping directory: ${treeNode} due to .indexignore`)
       return

package/test/SKIPPED_TESTS.md

@@ -1,151 +0,0 @@
-# Skipped Tests Reference
-
-This document tracks all skipped tests and why they are skipped. Tests are divided into two categories:
-
-1. **Skipped for CI** — were passing but depend on live external services; skipped to enable clean CI runs
-2. **Previously skipped — failing or unknown** — were already skipped before CI work; many confirmed failing
-
-The goal is to eventually move all Category 1 tests into a dedicated integration/live test suite, and to triage Category 2 tests as either fixable or retired.
-
----
-
-## Category 1: Skipped for CI (were passing, have external dependencies)
-
-### `test/sanityQueryService.test.js` — Sanity CMS
-
-All tests in this file call real Sanity GROQ queries via `initializeTestService(true)`.
-
-| Test | Dependency |
-|---|---|
-| fetchSongById | Sanity |
-| fetchReturning | Sanity |
-| fetchLeaving | Sanity |
-| fetchComingSoon | Sanity |
-| fetchSanity-WithPostProcess | Sanity |
-| fetchSanityPostProcess | Sanity |
-| fetchByRailContentIds | Sanity |
-| fetchByRailContentIds_Order | Sanity |
-| fetchUpcomingNewReleases | Sanity |
-| fetchLessonContent | Sanity |
-| fetchAllSongsInProgress | Sanity |
-| fetchNewReleases | Sanity |
-| fetchAllWorkouts | Sanity |
-| fetchAllInstructorField | Sanity |
-| fetchAllInstructors | Sanity |
-| fetchAll-CustomFields | Sanity |
-| fetchRelatedLessons | Sanity |
-| fetchRelatedLessons-quick-tips | Sanity |
-| fetchRelatedLessons-in-rhythm | Sanity |
-| getSortOrder | Sanity (describe block requires live auth) |
-| fetchAll-WithProgress | Sanity |
-| fetchAllFilterOptions-WithProgress | Sanity |
-| fetchAll-IncludedFields | Sanity |
-| fetchAll-IncludedFields-rudiment-multiple-gear | Sanity |
-| fetchByReference | Sanity |
-| fetchScheduledReleases | Sanity |
-| fetchAll-GroupBy-Artists | Sanity |
-| fetchAll-GroupBy-Instructors | Sanity |
-| fetchMetadata | Sanity |
-| fetchMetadata-Coach-Lessons | Sanity |
-| invalidContentType | Sanity (describe block requires live auth) |
-| metaDataForLessons | Sanity |
-| metaDataForSongs | Sanity |
-| fetchAllFilterOptionsLessons | Sanity |
-| fetchAllFilterOptionsSongs | Sanity |
-| fetchLiveEvent | Sanity |
-| fetchRelatedLessons-pack-bundle-lessons | Sanity |
-| fetchRelatedLessons-course-parts | Sanity |
-| fetchRelatedLessons-song-tutorial-children | Sanity |
-| fetchMetadata (second) | Sanity |
-
-### `test/content.test.js` — Sanity CMS + Railcontent API
-
-| Test | Dependency |
-|---|---|
-| getTabResults-Singles | Sanity + Railcontent |
-| getTabResults-Courses | Sanity + Railcontent |
-| getTabResults-Type-Explore-All | Sanity + Railcontent |
-
-### `test/user/permissions.test.js` — Railcontent API
-
-| Test | Dependency |
-|---|---|
-| fetchUserPermissions | Railcontent `fetchUserPermissionsData` |
-
----
-
-## Category 2: Previously Skipped — Failing or Unknown State
-
-These were already skipped before CI work. Status is noted where confirmed.
-
-### `test/sanityQueryService.test.js`
-
-| Test | Status | Failure Reason |
-|---|---|---|
-| fetchSongArtistCount | Unknown | — |
-| fetchUpcomingEvents | Unknown | — |
-| fetchLessonContent-PlayAlong-containts-array-of-videos | Unknown | — |
-| fetchAllSortField | Unknown | — |
-| fetchRelatedLessons-child | Unknown | — |
-| fetchPackAll | Unknown | — |
-| fetchAllPacks | Unknown | — |
-| fetchAll-IncludedFields-multiple | Unknown | — |
-| fetchAll-IncludedFields-playalong-multiple | Unknown | — |
-| fetchAll-IncludedFields-coaches-multiple-focus | Unknown | — |
-| fetchAll-IncludedFields-songs-multiple-instrumentless | Unknown | — |
-| fetchAll-GroupBy-Genre | Unknown | — |
-| fetchShowsData | Unknown | — |
-| fetchShowsData-OddTimes | Unknown | — |
-| fetchTopLevelParentId | Unknown | — |
-| fetchHierarchy | Unknown | — |
-| fetchTopLeveldrafts | Failing | Timeout (>5s) |
-| fetchCommentData | Failing | `null.forEach` — Sanity returns null for content IDs |
-| baseConstructor | Unknown | — |
-| withOnlyFilterAvailableStatuses | Unknown | — |
-| withContentStatusAndFutureScheduledContent | Unknown | — |
-| withUserPermissions | Unknown | — |
-| withUserPermissionsForPlusUser | Unknown | — |
-| withPermissionBypass | Unknown | — |
-| withPublishOnRestrictions | Unknown | — |
-| fetchAllFilterOptions | Unknown | — |
-| fetchAllFilterOptions-Rudiment | Unknown | — |
-| fetchAllFilterOptions-PlayAlong | Unknown | — |
-| fetchAllFilterOptions-Coaches | Unknown | — |
-| fetchAllFilterOptions-filter-selected | Failing | `null.meta` — API returns null for filter combination |
-| customBrandTypeExists | Unknown | — |
-| withCommon | Unknown | — |
-| fetchOtherSongVersions | Failing | 0 results — content is drafted/admin-only |
-| fetchLessonsFeaturingThisContent | Failing | 0 results — content is drafted/admin-only |
-| getRecommendedForYou | Failing | `SyncError: Intended user ID does not match` |
-| getRecommendedForYou-SeeAll | Failing | `SyncError: Intended user ID does not match` |
-
-### `test/content.test.js`
-
-| Test | Status | Failure Reason |
-|---|---|---|
-| getTabResults-Filters | Failing | Timeout (>5s) |
-| getTabResults-Type-Filter | Failing | `TypeError: null.entity` — Sanity returns null |
-| getContentRows | Unknown |Sanity & pw-recommender  |
-| getNewAndUpcoming | Failing | Timeout (>5s) |
-| getScheduleContentRows | Failing | Timeout (>5s) |
-| getSpecificScheduleContentRow | Failing | Timeout (>5s) |
-
-### `test/contentProgress.test.js`
-
-| Test | Status | Failure Reason |
-|---|---|---|
-| get-Songs-Tutorials | Unknown | Live Sanity call |
-| get-Songs-Transcriptions | Unknown | Live Sanity call |
-| get-Songs-Play-Alongs | Unknown | Live Sanity call |
-
-### `test/progressRows.test.js`
-
-| Test | Status | Failure Reason |
-|---|---|---|
-| check progress rows logic | Failing | Stale mock data — not a live API issue; mock data no longer reflects current data shape |
-
-### `test/learningPaths.test.js`
-
-| Test | Status | Failure Reason |
-|---|---|---|
-| learningPathCompletion | Unknown | Uses `initializeTestService(true)` — live API |