musora-content-services 2.160.0 → 2.160.2

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(npm run lint:*)",
+      "Bash(ls:*)",
+      "Bash(npm test *)",
+      "Bash(npx jest *)"
+    ],
+    "deny": []
+  }
+}

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.160.2](https://github.com/railroadmedia/musora-content-services/compare/v2.160.1...v2.160.2) (2026-05-14)
+
+
+### Bug Fixes
+
+* **BR-678:** fix issues with is_locked and collection ([#972](https://github.com/railroadmedia/musora-content-services/issues/972)) ([725529b](https://github.com/railroadmedia/musora-content-services/commit/725529bd69d05ab79113b21a5e3dca5ce1deb0dc))
+
+### [2.160.1](https://github.com/railroadmedia/musora-content-services/compare/v2.160.0...v2.160.1) (2026-05-13)
+
+
+### Bug Fixes
+
+* disable debug code ([#970](https://github.com/railroadmedia/musora-content-services/issues/970)) ([4046c4f](https://github.com/railroadmedia/musora-content-services/commit/4046c4fca4457b9d21eab5221876a991bdf22973))
+
 ## [2.160.0](https://github.com/railroadmedia/musora-content-services/compare/v2.159.0...v2.160.0) (2026-05-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.160.0",
+  "version": "2.160.2",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/services/progress-row/rows/content-card.js

@@ -6,14 +6,20 @@ import { addContextToContent } from '../../contentAggregator.js'
 import { fetchByRailContentIds, fetchShows } from '../../sanity.js'
 import {
   postProcessBadge,
-  collectionLessonTypes,
   getFormattedType,
   recentTypes,
   showsLessonTypes,
   songs,
+  getNextLessonLessonParentTypes,
 } from '../../../contentTypeConfig.js'
 import { PARENT_ID_TOP_LEVEL } from '../../sync/models/ContentProgress'
 
+const excludeFromGeneratedIndex = [
+  'getSubtitle',
+  'getDefaultCTATextForContent',
+  'getCompletedChildren',
+]
+
 /**
  * Fetch any content IDs with some progress, include the userPinnedItem,
  * and generate a map of the cards keyed by the content IDs
@@ -102,7 +108,7 @@ export async function processContentItem(content) {
       badge_logo: content.badge_logo ?? null,
       badge_template: content.badge_template ?? null,
       badge_template_rear: content.badge_template_rear ?? null,
-      isLocked: content.is_locked ?? false,
+      isLocked: content.need_access ?? false,
       subtitle: getSubtitle(content, contentType, isLive),
     },
     cta: {
@@ -119,17 +125,21 @@ export async function processContentItem(content) {
   }
 }
 
-function getSubtitle(content, contentType, isLive) {
-  if (collectionLessonTypes.includes(content.type) || content.lesson_count > 1) {
-    return `${content.completed_children ?? 0} of ${content.all_children ?? content.lesson_count ?? content.child_count} Lessons Complete`
+export function getSubtitle(content, contentType, isLive) {
+  if (getNextLessonLessonParentTypes.includes(content.type) || content.lesson_count > 1) {
+    const total = content.all_children ?? content.lesson_count ?? content.child_count
+    if (!total && total !== 0) return null
+    return `${content.completed_children ?? 0} of ${total} Lessons Complete`
   }
   if ((contentType === 'lesson' || contentType === 'show') && !isLive) {
+    if (content.progressPercentage == null) return null
     return `${content.progressPercentage}% Complete`
   }
-  return `${content.difficulty_string} • ${content.artist_name}`
+  const parts = [content.difficulty_string, content.artist_name].filter(Boolean)
+  return parts.length ? parts.join(' • ') : null
 }
 
-function getDefaultCTATextForContent(content, contentType) {
+export function getDefaultCTATextForContent(content, contentType) {
   const notStarted =
     !content.progressStatus ||
     content.progressStatus === 'not-started' ||
@@ -144,7 +154,7 @@ function getDefaultCTATextForContent(content, contentType) {
     )
       return 'Replay Song'
     if (contentType === 'lesson' || contentType === 'show') return 'Revisit Lesson'
-    if (contentType === 'song tutorial' || collectionLessonTypes.includes(content.type))
+    if (getNextLessonLessonParentTypes.includes(content.type))
       return 'Revisit Lessons'
     if (contentType === 'course-collection') return 'View Lessons'
   }
@@ -152,7 +162,7 @@ function getDefaultCTATextForContent(content, contentType) {
   return 'Continue'
 }
 
-async function getCompletedChildren(content, contentType) {
+export async function getCompletedChildren(content, contentType) {
   let completedChildren = 0
   let allChildren = 0
 

package/src/services/sync/stale-record-cleanup.ts

@@ -11,7 +11,7 @@ const SYNC_TABLES = ['progress', 'content_likes', 'practices', 'practice_day_not
 
 export async function repairStaleSyncedRecords(storesRegistry: Record<string, SyncStore<any>>) {
   const db = Object.values(storesRegistry)[0]!.db
-  // if (await db.localStorage.get<string>(CLEANUP_FLAG_KEY)) return // todo
+  if (await db.localStorage.get<string>(CLEANUP_FLAG_KEY)) return
 
   const cutoff = Date.now() - STALE_CUTOFF_MS
   const payload: Record<string, [id: string, updated_at: EpochMs][]> = {}

package/test/integration/progress-row/content-card.test.ts

@@ -0,0 +1,283 @@
+import { initializeTestDB } from '../initializeTestDB'
+import db from '../../../src/services/sync/repository-proxy'
+
+jest.mock('../../../src/services/sanity.js', () => ({
+  ...jest.requireActual('../../../src/services/sanity.js'),
+  fetchShows: jest.fn(),
+  fetchByRailContentIds: jest.fn(),
+}))
+jest.mock('../../../src/services/contentAggregator.js', () => ({
+  addContextToContent: jest.fn(),
+}))
+jest.mock('../../../src/services/content-org/learning-paths.ts', () =>
+  require('../content-progress/__mocks__/mocks').mockLearningPaths(),
+)
+jest.mock('../../../src/services/awards/internal/content-progress-observer', () =>
+  require('../content-progress/__mocks__/mocks').mockContentProgressObserver(),
+)
+jest.mock('../../../src/services/progress-events', () =>
+  require('../content-progress/__mocks__/mocks').mockProgressEvents(),
+)
+
+import {
+  processContentItem,
+  getCompletedChildren,
+} from '../../../src/services/progress-row/rows/content-card.js'
+import { addContextToContent } from '../../../src/services/contentAggregator.js'
+
+const lessonMeta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
+
+initializeTestDB()
+
+describe('getCompletedChildren', () => {
+  describe('show contentType', () => {
+    test('counts completed shows from addContextToContent result', async () => {
+      ;(addContextToContent as jest.Mock).mockResolvedValue([
+        { id: 1, progressStatus: 'completed' },
+        { id: 2, progressStatus: 'started' },
+        { id: 3, progressStatus: 'completed' },
+        { id: 4, progressStatus: 'not-started' },
+      ])
+      const content = { type: 'boot-camp', brand: 'drumeo' }
+      const result = await getCompletedChildren(content, 'show')
+      expect(result).toEqual({ completedChildren: 2, allChildren: 4 })
+    })
+
+    test('returns zero counts when no shows returned', async () => {
+      ;(addContextToContent as jest.Mock).mockResolvedValue([])
+      const content = { type: 'boot-camp', brand: 'drumeo' }
+      const result = await getCompletedChildren(content, 'show')
+      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
+    })
+
+    test('returns zero completed when no shows have completed status', async () => {
+      ;(addContextToContent as jest.Mock).mockResolvedValue([
+        { id: 1, progressStatus: 'started' },
+        { id: 2, progressStatus: 'not-started' },
+      ])
+      const content = { type: 'boot-camp', brand: 'drumeo' }
+      const result = await getCompletedChildren(content, 'show')
+      expect(result).toEqual({ completedChildren: 0, allChildren: 2 })
+    })
+  })
+
+  describe('non-show with children', () => {
+    test('counts completed children from real DB progress', async () => {
+      await db.contentProgress.recordProgress(101, null, 100, lessonMeta, undefined, { skipPush: true })
+      await db.contentProgress.recordProgress(102, null, 30, lessonMeta, undefined, { skipPush: true })
+      await db.contentProgress.recordProgress(103, null, 100, lessonMeta, undefined, { skipPush: true })
+
+      const content = {
+        type: 'course',
+        children: [{ id: 101 }, { id: 102 }, { id: 103 }],
+      }
+      const result = await getCompletedChildren(content, 'course')
+      expect(result).toEqual({ completedChildren: 2, allChildren: 3 })
+    })
+
+    test('recursively flattens nested children to leaf ids', async () => {
+      await db.contentProgress.recordProgress(201, null, 100, lessonMeta, undefined, { skipPush: true })
+      await db.contentProgress.recordProgress(202, null, 100, lessonMeta, undefined, { skipPush: true })
+      await db.contentProgress.recordProgress(203, null, 50, lessonMeta, undefined, { skipPush: true })
+
+      const content = {
+        type: 'course',
+        children: [
+          { id: 201 },
+          {
+            id: 999,
+            children: [{ id: 202 }, { id: 203 }],
+          },
+        ],
+      }
+      const result = await getCompletedChildren(content, 'course')
+      expect(result).toEqual({ completedChildren: 2, allChildren: 3 })
+    })
+
+    test('returns zero when no children have progress recorded', async () => {
+      const content = {
+        type: 'course',
+        children: [{ id: 901 }, { id: 902 }],
+      }
+      const result = await getCompletedChildren(content, 'course')
+      expect(result).toEqual({ completedChildren: 0, allChildren: 2 })
+    })
+  })
+
+  describe('non-show without children', () => {
+    test('returns zero counts when children is undefined', async () => {
+      const content = { type: 'song' }
+      const result = await getCompletedChildren(content, 'transcription')
+      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
+    })
+
+    test('returns zero counts when children is empty array', async () => {
+      const content = { type: 'song', children: [] }
+      const result = await getCompletedChildren(content, 'transcription')
+      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
+    })
+  })
+})
+
+describe('processContentItem', () => {
+  test('returns correctly shaped object for a song with no children', async () => {
+    const content = {
+      id: 500,
+      type: 'song',
+      brand: 'drumeo',
+      title: 'Test Song',
+      thumbnail: 'thumb.jpg',
+      progressPercentage: 40,
+      progressStatus: 'started',
+      progressTimestamp: 1700000000,
+      difficulty_string: 'Beginner',
+      artist_name: 'The Band',
+      slug: 'test-song',
+      navigateTo: 'child-slug',
+    }
+    const result = await processContentItem(content)
+    expect(result).toMatchObject({
+      id: 500,
+      progressType: 'content',
+      header: 'transcription',
+      pinned: false,
+      progressTimestamp: 1700000000,
+      body: {
+        progressPercent: 40,
+        thumbnail: 'thumb.jpg',
+        title: 'Test Song',
+        isLive: false,
+        brand: 'drumeo',
+        badge: null,
+        badge_rear: null,
+        badge_logo: null,
+        badge_template: null,
+        badge_template_rear: null,
+        isLocked: false,
+        subtitle: 'Beginner • The Band',
+      },
+      cta: {
+        text: 'Continue',
+        action: {
+          type: 'song',
+          brand: 'drumeo',
+          id: 500,
+          slug: 'test-song',
+          child: 'child-slug',
+        },
+      },
+    })
+  })
+
+  test('sets progressPercent to undefined when isLive=true', async () => {
+    const content = {
+      id: 1,
+      type: 'song',
+      brand: 'drumeo',
+      progressPercentage: 80,
+      isLive: true,
+    }
+    const result = await processContentItem(content)
+    expect(result.body.progressPercent).toBeUndefined()
+    expect(result.body.isLive).toBe(true)
+  })
+
+  test('isLive defaults to false when missing', async () => {
+    const content = { id: 2, type: 'song', brand: 'drumeo', progressPercentage: 50 }
+    const result = await processContentItem(content)
+    expect(result.body.isLive).toBe(false)
+    expect(result.body.progressPercent).toBe(50)
+  })
+
+  test('pinned defaults to false when missing', async () => {
+    const content = { id: 3, type: 'song', brand: 'drumeo' }
+    const result = await processContentItem(content)
+    expect(result.pinned).toBe(false)
+  })
+
+  test('pinned reflects content.pinned when set', async () => {
+    const content = { id: 4, type: 'song', brand: 'drumeo', pinned: true }
+    const result = await processContentItem(content)
+    expect(result.pinned).toBe(true)
+  })
+
+  test('isLocked is false when need_access is missing', async () => {
+    const content = { id: 5, type: 'song', brand: 'drumeo' }
+    const result = await processContentItem(content)
+    expect(result.body.isLocked).toBe(false)
+  })
+
+  test('isLocked is true when need_access is true', async () => {
+    const content = { id: 6, type: 'song', brand: 'drumeo', need_access: true }
+    const result = await processContentItem(content)
+    expect(result.body.isLocked).toBe(true)
+  })
+
+  test('passes through badge fields when set', async () => {
+    const content = {
+      id: 7,
+      type: 'song',
+      brand: 'drumeo',
+      badge: 'badge.png',
+      badge_rear: 'badge-rear.png',
+      badge_logo: 'logo.png',
+      badge_template: 'tpl',
+      badge_template_rear: 'tpl-rear',
+    }
+    const result = await processContentItem(content)
+    expect(result.body).toMatchObject({
+      badge: 'badge.png',
+      badge_rear: 'badge-rear.png',
+      badge_logo: 'logo.png',
+      badge_template: 'tpl',
+      badge_template_rear: 'tpl-rear',
+    })
+  })
+
+  test('populates completed_children/all_children for course with children', async () => {
+    await db.contentProgress.recordProgress(701, null, 100, lessonMeta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(702, null, 100, lessonMeta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(703, null, 25, lessonMeta, undefined, { skipPush: true })
+
+    const content: any = {
+      id: 700,
+      type: 'course',
+      brand: 'drumeo',
+      children: [{ id: 701 }, { id: 702 }, { id: 703 }],
+    }
+    const result = await processContentItem(content)
+    expect(content.completed_children).toBe(2)
+    expect(content.all_children).toBe(3)
+    expect(result.body.subtitle).toBe('2 of 3 Lessons Complete')
+  })
+
+  test('uses contentType from getFormattedType in header and cta resolution', async () => {
+    const content = {
+      id: 8,
+      type: 'guided-course',
+      brand: 'drumeo',
+      progressStatus: 'not-started',
+    }
+    const result = await processContentItem(content)
+    expect(result.header).toBe('guided course')
+    expect(result.cta.text).toBe('Start Course')
+  })
+
+  test('cta action mirrors content identity fields', async () => {
+    const content = {
+      id: 9,
+      type: 'song',
+      brand: 'pianote',
+      slug: 'my-slug',
+      navigateTo: 'next-child',
+    }
+    const result = await processContentItem(content)
+    expect(result.cta.action).toEqual({
+      type: 'song',
+      brand: 'pianote',
+      id: 9,
+      slug: 'my-slug',
+      child: 'next-child',
+    })
+  })
+})

package/test/unit/progress-row/content-card.test.ts

@@ -0,0 +1,314 @@
+import {
+  getSubtitle,
+  getDefaultCTATextForContent,
+} from '../../../src/services/progress-row/rows/content-card.js'
+
+describe('getSubtitle', () => {
+  describe('parent lesson types', () => {
+    test.each([
+      'course',
+      'guided-course',
+      'course-collection',
+      'song-tutorial',
+      'learning-path-v2',
+      'skill-pack',
+    ])('returns "X of Y Lessons Complete" for type %s', (type) => {
+      const content = {
+        type,
+        completed_children: 3,
+        all_children: 10,
+      }
+      expect(getSubtitle(content, 'course', false)).toBe('3 of 10 Lessons Complete')
+    })
+
+    test('uses 0 when completed_children is missing', () => {
+      const content = { type: 'course', all_children: 8 }
+      expect(getSubtitle(content, 'course', false)).toBe('0 of 8 Lessons Complete')
+    })
+
+    test('falls back to lesson_count when all_children missing', () => {
+      const content = { type: 'course', completed_children: 2, lesson_count: 5 }
+      expect(getSubtitle(content, 'course', false)).toBe('2 of 5 Lessons Complete')
+    })
+
+    test('falls back to child_count when all_children and lesson_count missing', () => {
+      const content = { type: 'course', completed_children: 1, child_count: 4 }
+      expect(getSubtitle(content, 'course', false)).toBe('1 of 4 Lessons Complete')
+    })
+
+    test('prefers all_children over lesson_count and child_count', () => {
+      const content = {
+        type: 'course',
+        completed_children: 1,
+        all_children: 9,
+        lesson_count: 5,
+        child_count: 7,
+      }
+      expect(getSubtitle(content, 'course', false)).toBe('1 of 9 Lessons Complete')
+    })
+
+    test('returns null when all count fields missing', () => {
+      const content = { type: 'course', completed_children: 2 }
+      expect(getSubtitle(content, 'course', false)).toBeNull()
+    })
+  })
+
+  describe('lesson_count > 1', () => {
+    test('returns "X of Y Lessons Complete" when lesson_count > 1 even for non-parent type', () => {
+      const content = {
+        type: 'song',
+        completed_children: 2,
+        all_children: 6,
+        lesson_count: 6,
+      }
+      expect(getSubtitle(content, 'song', false)).toBe('2 of 6 Lessons Complete')
+    })
+
+    test('does not trigger when lesson_count is 1', () => {
+      const content = {
+        type: 'song',
+        lesson_count: 1,
+        difficulty_string: 'Beginner',
+        artist_name: 'Artist',
+      }
+      expect(getSubtitle(content, 'song', false)).toBe('Beginner • Artist')
+    })
+
+    test('does not trigger when lesson_count is 0', () => {
+      const content = {
+        type: 'song',
+        lesson_count: 0,
+        difficulty_string: 'Intermediate',
+        artist_name: 'Band',
+      }
+      expect(getSubtitle(content, 'song', false)).toBe('Intermediate • Band')
+    })
+  })
+
+  describe('lesson and show contentType', () => {
+    test('returns "X% Complete" for lesson when not live', () => {
+      const content = { type: 'course-lesson', progressPercentage: 42 }
+      expect(getSubtitle(content, 'lesson', false)).toBe('42% Complete')
+    })
+
+    test('returns "X% Complete" for show when not live', () => {
+      const content = { type: 'show', progressPercentage: 75 }
+      expect(getSubtitle(content, 'show', false)).toBe('75% Complete')
+    })
+
+    test('returns "0% Complete" when progressPercentage is 0', () => {
+      const content = { type: 'course-lesson', progressPercentage: 0 }
+      expect(getSubtitle(content, 'lesson', false)).toBe('0% Complete')
+    })
+
+    test('returns null when progressPercentage missing for lesson', () => {
+      const content = { type: 'course-lesson' }
+      expect(getSubtitle(content, 'lesson', false)).toBeNull()
+    })
+
+    test('returns null when progressPercentage missing for show', () => {
+      const content = { type: 'show' }
+      expect(getSubtitle(content, 'show', false)).toBeNull()
+    })
+
+    test('falls through to difficulty/artist when lesson isLive=true', () => {
+      const content = {
+        type: 'course-lesson',
+        progressPercentage: 80,
+        difficulty_string: 'Advanced',
+        artist_name: 'Live Artist',
+      }
+      expect(getSubtitle(content, 'lesson', true)).toBe('Advanced • Live Artist')
+    })
+
+    test('falls through to difficulty/artist when show isLive=true', () => {
+      const content = {
+        type: 'show',
+        progressPercentage: 50,
+        difficulty_string: 'Beginner',
+        artist_name: 'Live Show',
+      }
+      expect(getSubtitle(content, 'show', true)).toBe('Beginner • Live Show')
+    })
+  })
+
+  describe('default difficulty/artist subtitle', () => {
+    test('returns "difficulty • artist" for song', () => {
+      const content = {
+        type: 'song',
+        difficulty_string: 'Intermediate',
+        artist_name: 'The Beatles',
+      }
+      expect(getSubtitle(content, 'song', false)).toBe('Intermediate • The Beatles')
+    })
+
+    test('returns null when both difficulty and artist missing', () => {
+      const content = { type: 'song' }
+      expect(getSubtitle(content, 'song', false)).toBeNull()
+    })
+
+    test('returns difficulty only when artist missing', () => {
+      const content = { type: 'song', difficulty_string: 'Beginner' }
+      expect(getSubtitle(content, 'song', false)).toBe('Beginner')
+    })
+
+    test('returns artist only when difficulty missing', () => {
+      const content = { type: 'song', artist_name: 'The Beatles' }
+      expect(getSubtitle(content, 'song', false)).toBe('The Beatles')
+    })
+  })
+
+  describe('priority ordering', () => {
+    test('parent-type rule wins over lesson contentType', () => {
+      const content = {
+        type: 'course',
+        completed_children: 4,
+        all_children: 12,
+        progressPercentage: 33,
+      }
+      expect(getSubtitle(content, 'lesson', false)).toBe('4 of 12 Lessons Complete')
+    })
+
+    test('lesson_count>1 rule wins over lesson contentType', () => {
+      const content = {
+        type: 'song',
+        lesson_count: 3,
+        completed_children: 1,
+        all_children: 3,
+        progressPercentage: 33,
+      }
+      expect(getSubtitle(content, 'lesson', false)).toBe('1 of 3 Lessons Complete')
+    })
+  })
+})
+
+describe('getDefaultCTATextForContent', () => {
+  describe('guided-course not started', () => {
+    test('returns "Start Course" when progressStatus is undefined', () => {
+      const content = { type: 'guided-course' }
+      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
+    })
+
+    test('returns "Start Course" when progressStatus is "not-started"', () => {
+      const content = { type: 'guided-course', progressStatus: 'not-started' }
+      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
+    })
+
+    test('returns "Start Course" when progressPercentage is 0', () => {
+      const content = {
+        type: 'guided-course',
+        progressStatus: 'started',
+        progressPercentage: 0,
+      }
+      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Start Course')
+    })
+
+    test('returns "Continue" when guided-course is in-progress', () => {
+      const content = {
+        type: 'guided-course',
+        progressStatus: 'started',
+        progressPercentage: 25,
+      }
+      expect(getDefaultCTATextForContent(content, 'guided course')).toBe('Continue')
+    })
+  })
+
+  describe('completed - song variants', () => {
+    test.each([
+      ['drumeo', 'transcription'],
+      ['guitareo', 'tab'],
+      ['pianote', 'sheet music'],
+      ['singeo', 'sheet music'],
+      ['playbass', 'tab'],
+    ])('returns "Replay Song" when completed for brand %s with song contentType %s', (brand, contentType) => {
+      const content = { type: 'song', brand, progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, contentType)).toBe('Replay Song')
+    })
+
+    test('returns "Replay Song" when completed and contentType is "play along"', () => {
+      const content = { type: 'play-along', brand: 'drumeo', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'play along')).toBe('Replay Song')
+    })
+
+    test('returns "Replay Song" when completed and contentType is "jam track"', () => {
+      const content = { type: 'jam-track', brand: 'drumeo', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'jam track')).toBe('Replay Song')
+    })
+
+    test('does not return "Replay Song" when brand song contentType mismatches', () => {
+      const content = { type: 'song', brand: 'drumeo', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'tab')).toBe('Continue')
+    })
+  })
+
+  describe('completed - lesson/show', () => {
+    test('returns "Revisit Lesson" when completed lesson', () => {
+      const content = { type: 'course-lesson', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Revisit Lesson')
+    })
+
+    test('returns "Revisit Lesson" when completed show', () => {
+      const content = { type: 'show', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'show')).toBe('Revisit Lesson')
+    })
+  })
+
+  describe('completed - parent lesson types', () => {
+    test.each([
+      'course',
+      'guided-course',
+      'course-collection',
+      'song-tutorial',
+      'learning-path-v2',
+      'skill-pack',
+    ])('returns "Revisit Lessons" when completed for type %s', (type) => {
+      const content = { type, progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'course')).toBe('Revisit Lessons')
+    })
+  })
+
+  describe('completed - other', () => {
+    test('returns "Continue" when completed and no rule matches', () => {
+      const content = { type: 'some-type', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'unknown')).toBe('Continue')
+    })
+  })
+
+  describe('default fallback', () => {
+    test('returns "Continue" when no progressStatus for non-guided-course', () => {
+      const content = { type: 'song' }
+      expect(getDefaultCTATextForContent(content, 'song')).toBe('Continue')
+    })
+
+    test('returns "Continue" when progressStatus is "started"', () => {
+      const content = {
+        type: 'course-lesson',
+        progressStatus: 'started',
+        progressPercentage: 50,
+      }
+      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Continue')
+    })
+
+    test('returns "Continue" when not-started and not guided-course', () => {
+      const content = { type: 'course-lesson', progressStatus: 'not-started' }
+      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Continue')
+    })
+  })
+
+  describe('priority ordering', () => {
+    test('guided-course not-started wins even when contentType is lesson', () => {
+      const content = { type: 'guided-course', progressPercentage: 0 }
+      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Start Course')
+    })
+
+    test('completed song-match wins over completed lesson contentType', () => {
+      const content = { type: 'song', brand: 'drumeo', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'transcription')).toBe('Replay Song')
+    })
+
+    test('completed lesson contentType wins over parent-type rule', () => {
+      const content = { type: 'course', progressStatus: 'completed' }
+      expect(getDefaultCTATextForContent(content, 'lesson')).toBe('Revisit Lesson')
+    })
+  })
+})