musora-content-services 2.167.2 → 2.167.4

package/test/unit/lib/sanity/decorators/navigate-to.test.ts

@@ -1,361 +0,0 @@
-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 })
-      }),
-    },
-  }
-  return { default: mockFns, ...mockFns }
-})
-
-import { initializeTestService } from '../../../../initializeTests.js'
-import {
-  NAVIGATE_TO_FIELD,
-  decorateNavigateTo,
-  navigateToDecorator,
-  type NavigateToDecoratable,
-} from '../../../../../src/lib/sanity/decorators/navigate-to'
-import { COLLECTION_TYPE } from '../../../../../src/services/sync/models/ContentProgress'
-
-const child = (id: number, type = 'course-lesson'): NavigateToDecoratable => ({
-  id,
-  type,
-  brand: 'drumeo',
-  thumbnail: '',
-  published_on: null,
-  status: 'published',
-})
-
-const parent = (
-  id: number,
-  type: string,
-  children: NavigateToDecoratable[]
-): NavigateToDecoratable => ({
-  id,
-  type,
-  brand: 'drumeo',
-  thumbnail: '',
-  published_on: null,
-  status: 'published',
-  children,
-})
-
-beforeEach(() => {
-  jest.clearAllMocks()
-  initializeTestService()
-  mockProgressRecords = []
-  mockLastInteracted = null
-})
-
-describe('navigate-to decorator', () => {
-  describe('navigateToDecorator (factory)', () => {
-    test('field is navigateTo', () => {
-      expect(navigateToDecorator().field).toBe('navigateTo')
-      expect(NAVIGATE_TO_FIELD).toBe('navigateTo')
-    })
-
-    test('recurse is false', () => {
-      expect(navigateToDecorator().recurse).toBe(false)
-    })
-
-    test('without ctx — navigates single item via DB', async () => {
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await navigateToDecorator().compute(item)
-      expect(result).toMatchObject({ id: 101, child: null })
-    })
-
-    test('with ctx — uses ctx states, not DB', async () => {
-      // DB says course is started; ctx overrides to not-started → should go to first child
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-      ]
-      const ctx = { states: new Map<number, string>([[1, '']]) }
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await navigateToDecorator(ctx).compute(item)
-      expect(result).toMatchObject({ id: 101 })
-    })
-  })
-
-  describe('decorateNavigateTo', () => {
-    test('non-navigable type → null', async () => {
-      const item = parent(1, 'lesson', [child(101)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toBeNull()
-    })
-
-    test('empty children → null', async () => {
-      const item = parent(1, 'course', [])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toBeNull()
-    })
-
-    test('not-started course → first child', async () => {
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101, child: null })
-    })
-
-    test('course started, lastInteracted started → lastInteracted', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-        { content_id: 101, state: 'started', progress_percent: 30, updated_at: 900 },
-        { content_id: 102, state: 'started', progress_percent: 10, updated_at: 1000 },
-      ]
-      mockLastInteracted = 101
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101 })
-    })
-
-    test('course started, lastInteracted completed → first incomplete after', 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 item = parent(1, 'course', [child(101), child(102), child(103)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 103 })
-    })
-
-    test('guided-course started → first incomplete regardless of 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 item = parent(1, 'guided-course', [child(101), child(102), child(103)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101 })
-    })
-
-    test('learning-path-v2 started → first incomplete regardless of 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 item = parent(1, COLLECTION_TYPE.LEARNING_PATH, [child(101), child(102), child(103)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101 })
-    })
-
-    test('two-depth: not-started course-collection nests first child nav', async () => {
-      const courseChild = parent(101, 'course', [child(201), child(202)])
-      const collection = parent(1, 'course-collection', [courseChild, parent(102, 'course', [])])
-      const result = await decorateNavigateTo(collection)
-      expect(result.navigateTo).toMatchObject({
-        id: 101,
-        child: { id: 201 },
-      })
-    })
-
-    test('two-depth: started course-collection nests lastInteracted child nav', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-        { content_id: 101, state: 'started', progress_percent: 50, updated_at: 1000 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 102
-      const courseA = parent(101, 'course', [child(201), child(202)])
-      const courseB = parent(102, 'course', [child(301), child(302)])
-      const collection = parent(1, 'course-collection', [courseA, courseB])
-      const result = await decorateNavigateTo(collection)
-      expect(result.navigateTo).toMatchObject({
-        id: 102,
-        child: { id: 301 },
-      })
-    })
-
-    test('two-depth: started course-collection, last-interacted course has completed lessons → first incomplete lesson, not lesson[0]', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-        { content_id: 101, state: 'started', progress_percent: 50, updated_at: 900 },
-        { content_id: 201, state: 'completed', progress_percent: 100, updated_at: 800 },
-        { content_id: 202, state: '', progress_percent: 0, updated_at: 0 },
-        { content_id: 203, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 101
-      const course = parent(101, 'course', [child(201), child(202), child(203)])
-      const collection = parent(1, 'course-collection', [course])
-      const result = await decorateNavigateTo(collection)
-      expect(result.navigateTo).toMatchObject({ id: 101, child: { id: 202 } })
-    })
-
-    test('decorates every item in an array', async () => {
-      const items = [parent(1, 'course', [child(101)]), parent(2, 'lesson', [child(201)])]
-      const result = await decorateNavigateTo(items)
-      expect(result[0].navigateTo).toMatchObject({ id: 101 })
-      expect(result[1].navigateTo).toBeNull()
-    })
-
-    test('returns the same reference it was given', async () => {
-      const items = [parent(1, 'course', [child(101)])]
-      const result = await decorateNavigateTo(items)
-      expect(result).toBe(items)
-    })
-
-    test('descendants of decorated items do not receive navigateTo field', async () => {
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).not.toBeNull()
-      const children = result.children as NavigateToDecoratable[]
-      expect((children[0] as Record<string, unknown>).navigateTo).toBeUndefined()
-      expect((children[1] as Record<string, unknown>).navigateTo).toBeUndefined()
-    })
-
-    test('skill-pack uses course flow', 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: 'started', progress_percent: 20, updated_at: 1000 },
-      ]
-      mockLastInteracted = 102
-      const item = parent(1, 'skill-pack', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('song-tutorial uses course flow', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 101
-      const item = parent(1, 'song-tutorial', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('guided-course STARTED, lastInteracted not in children → first incomplete', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 40, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-        { content_id: 103, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 999
-      const item = parent(1, 'guided-course', [child(101), child(102), child(103)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('guided-course STARTED, lastInteracted not in children, all complete → 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 = 999
-      const item = parent(1, 'guided-course', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101 })
-    })
-
-    test('learning-path-v2 STARTED, lastInteracted not in children → first incomplete', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 40, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 999
-      const item = parent(1, COLLECTION_TYPE.LEARNING_PATH, [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('course STARTED, lastInteracted not in children → first incomplete', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 40, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-        { content_id: 103, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 999
-      const item = parent(1, 'course', [child(101), child(102), child(103)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('skill-pack STARTED, lastInteracted not in children → first incomplete', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 40, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 999
-      const item = parent(1, 'skill-pack', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('song-tutorial STARTED, lastInteracted not in children → first incomplete', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 40, updated_at: 1000 },
-        { content_id: 101, state: 'completed', progress_percent: 100, updated_at: 900 },
-        { content_id: 102, state: '', progress_percent: 0, updated_at: 0 },
-      ]
-      mockLastInteracted = 999
-      const item = parent(1, 'song-tutorial', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 102 })
-    })
-
-    test('course STARTED, lastInteracted not in children, all complete → 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 = 999
-      const item = parent(1, 'course', [child(101), child(102)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toMatchObject({ id: 101 })
-    })
-
-    test('two-depth started but lastInteracted child not in collection → null', async () => {
-      mockProgressRecords = [
-        { content_id: 1, state: 'started', progress_percent: 50, updated_at: 1000 },
-      ]
-      mockLastInteracted = 999
-      const courseA = parent(101, 'course', [child(201)])
-      const collection = parent(1, 'course-collection', [courseA])
-      const result = await decorateNavigateTo(collection)
-      expect(result.navigateTo).toBeNull()
-    })
-
-    test('output shape matches NavigateTo interface', async () => {
-      const item = parent(1, 'course', [child(101)])
-      const result = await decorateNavigateTo(item)
-      expect(result.navigateTo).toEqual({
-        id: 101,
-        type: 'course-lesson',
-        brand: 'drumeo',
-        thumbnail: '',
-        published_on: null,
-        status: 'published',
-        child: null,
-        collection: null,
-      })
-    })
-  })
-})

package/test/unit/lib/sanity/decorators/need-access.test.ts

@@ -1,89 +0,0 @@
-const mockDoesUserNeedAccess = jest.fn()
-
-jest.mock('../../../../../src/services/permissions', () => ({
-  getPermissionsAdapter: () => ({
-    doesUserNeedAccess: mockDoesUserNeedAccess,
-  }),
-}))
-
-import {
-  NEED_ACCESS_FIELD,
-  accessDecorator,
-  decorateAccess,
-  type AccessDecoratable,
-} from '../../../../../src/lib/sanity/decorators/need-access'
-
-const perms = {
-  permissions: [78, 91],
-  isAdmin: false,
-  isModerator: false,
-  isABasicMember: false,
-}
-
-describe('need-access decorator', () => {
-  beforeEach(() => {
-    mockDoesUserNeedAccess.mockReset()
-  })
-
-  describe('accessDecorator (factory)', () => {
-    test('field is need_access', () => {
-      const dec = accessDecorator(perms)
-      expect(dec.field).toBe('need_access')
-      expect(NEED_ACCESS_FIELD).toBe('need_access')
-    })
-
-    test('compute delegates to adapter with item + perms', () => {
-      mockDoesUserNeedAccess.mockReturnValue(true)
-      const dec = accessDecorator(perms)
-      const item: AccessDecoratable = { permission_id: [78] }
-
-      const result = dec.compute(item)
-
-      expect(result).toBe(true)
-      expect(mockDoesUserNeedAccess).toHaveBeenCalledWith(item, perms)
-    })
-  })
-
-  describe('decorateAccess', () => {
-    test('writes adapter result onto each item', () => {
-      mockDoesUserNeedAccess.mockImplementation((item) =>
-        item.permission_id?.includes(78) ? false : true
-      )
-
-      const items: AccessDecoratable[] = [
-        { permission_id: [78] },
-        { permission_id: [999] },
-        {},
-      ]
-      const decorated = decorateAccess(items, perms)
-
-      expect(decorated.map((i) => i.need_access)).toEqual([false, true, true])
-    })
-
-    test('decorates children recursively', () => {
-      mockDoesUserNeedAccess.mockReturnValue(true)
-      const tree: AccessDecoratable = {
-        permission_id: [],
-        children: [
-          {
-            permission_id: [],
-            children: [{ permission_id: [] }],
-          },
-        ],
-      }
-
-      const decorated = decorateAccess(tree, perms)
-
-      expect(decorated.need_access).toBe(true)
-      expect(decorated.children![0].need_access).toBe(true)
-      expect(decorated.children![0].children![0].need_access).toBe(true)
-    })
-
-    test('returns the same reference it was given', () => {
-      mockDoesUserNeedAccess.mockReturnValue(false)
-      const items: AccessDecoratable[] = [{ permission_id: [78] }]
-      const decorated = decorateAccess(items, perms)
-      expect(decorated).toBe(items)
-    })
-  })
-})

package/test/unit/lib/sanity/decorators/need-lifetime-upgrade.test.ts

@@ -1,85 +0,0 @@
-import {
-  NEED_LIFETIME_UPGRADE_FIELD,
-  lifetimeUpgradeDecorator,
-  decorateLifetimeUpgrade,
-} from '../../../../../src/lib/sanity/decorators/need-lifetime-upgrade'
-
-const PLUS = 92
-const LIFETIME = 108
-const BASE = 91
-
-const lifetimeBase = { permissions: [LIFETIME, BASE], isAdmin: false, isModerator: false, isABasicMember: true }
-const lifetimeBasePlus = { permissions: [LIFETIME, BASE, PLUS], isAdmin: false, isModerator: false, isABasicMember: false }
-const baseOnly = { permissions: [BASE], isAdmin: false, isModerator: false, isABasicMember: true }
-
-const plusGatedLocked = { permission_id: [BASE, PLUS], need_access: true, membership_tier: 'plus' }
-const plusGatedUnlocked = { permission_id: [BASE, PLUS], need_access: false, membership_tier: 'plus' }
-
-describe('need-lifetime-upgrade decorator', () => {
-  describe('lifetimeUpgradeDecorator (factory)', () => {
-    test('field is need_lifetime_upgrade', () => {
-      const dec = lifetimeUpgradeDecorator(lifetimeBase)
-      expect(dec.field).toBe('need_lifetime_upgrade')
-      expect(NEED_LIFETIME_UPGRADE_FIELD).toBe('need_lifetime_upgrade')
-    })
-
-    test('true for lifetime member on Plus-gated content they cannot access', () => {
-      const dec = lifetimeUpgradeDecorator(lifetimeBase)
-      expect(dec.compute(plusGatedLocked)).toBe(true)
-    })
-
-    test('false when user already has Plus', () => {
-      const dec = lifetimeUpgradeDecorator(lifetimeBasePlus)
-      expect(dec.compute(plusGatedLocked)).toBe(false)
-    })
-
-    test('false when user does not have lifetime', () => {
-      const dec = lifetimeUpgradeDecorator(baseOnly)
-      expect(dec.compute(plusGatedLocked)).toBe(false)
-    })
-
-    test('false when user already has access to content (need_access false)', () => {
-      const dec = lifetimeUpgradeDecorator(lifetimeBase)
-      expect(dec.compute(plusGatedUnlocked)).toBe(false)
-    })
-  })
-
-  describe('decorateLifetimeUpgrade', () => {
-    test('decorates array of items', () => {
-      const items = [plusGatedLocked, plusGatedUnlocked]
-      const decorated = decorateLifetimeUpgrade(items, lifetimeBase)
-      expect(decorated.map((i) => i.need_lifetime_upgrade)).toEqual([true, false])
-    })
-
-    test('decorates a single item', () => {
-      const decorated = decorateLifetimeUpgrade(plusGatedLocked, lifetimeBase)
-      expect(decorated.need_lifetime_upgrade).toBe(true)
-    })
-
-    test('decorates children recursively', () => {
-      const tree = {
-        permission_id: [BASE, PLUS],
-        need_access: true,
-        membership_tier: 'plus',
-        children: [
-          {
-            permission_id: [BASE, PLUS],
-            need_access: true,
-            membership_tier: 'plus',
-            children: [{ permission_id: [BASE, PLUS], need_access: true, membership_tier: 'plus' }],
-          },
-        ],
-      }
-      const decorated = decorateLifetimeUpgrade(tree, lifetimeBase)
-      expect(decorated.need_lifetime_upgrade).toBe(true)
-      expect(decorated.children![0].need_lifetime_upgrade).toBe(true)
-      expect(decorated.children![0].children![0].need_lifetime_upgrade).toBe(true)
-    })
-
-    test('returns the same reference it was given', () => {
-      const items = [plusGatedLocked]
-      const decorated = decorateLifetimeUpgrade(items, lifetimeBase)
-      expect(decorated).toBe(items)
-    })
-  })
-})

package/test/unit/lib/sanity/decorators/page-type.test.ts

@@ -1,81 +0,0 @@
-import {
-  PAGE_TYPE_FIELD,
-  decoratePageType,
-  pageTypeDecorator,
-  type PageTypeDecoratable,
-} from '../../../../../src/lib/sanity/decorators/page-type'
-
-describe('page-type decorator', () => {
-  describe('pageTypeDecorator (const)', () => {
-    test('field is page_type', () => {
-      expect(pageTypeDecorator.field).toBe('page_type')
-      expect(PAGE_TYPE_FIELD).toBe('page_type')
-    })
-
-    test.each([
-      ['song', 'song'],
-      ['play-along', 'song'],
-      ['jam-track', 'song'],
-      ['song-tutorial', 'song'],
-      ['song-tutorial-lesson', 'song'],
-      ['course', 'lesson'],
-      ['workout', 'lesson'],
-      ['', 'lesson'],
-    ])('type=%j -> %s', (type, expected) => {
-      expect(pageTypeDecorator.compute({ type })).toBe(expected)
-    })
-
-    test('missing type falls through to lesson', () => {
-      expect(pageTypeDecorator.compute({})).toBe('lesson')
-    })
-  })
-
-  describe('decoratePageType', () => {
-    test('decorates a single object', () => {
-      const item: PageTypeDecoratable = { type: 'song' }
-      const decorated = decoratePageType(item)
-      expect(decorated.page_type).toBe('song')
-    })
-
-    test('decorates every item in an array', () => {
-      const items: PageTypeDecoratable[] = [
-        { type: 'song' },
-        { type: 'course' },
-        { type: 'play-along' },
-      ]
-      const decorated = decoratePageType(items)
-      expect(decorated.map((i) => i.page_type)).toEqual(['song', 'lesson', 'song'])
-    })
-
-    test('decorates nested children up to depth 3', () => {
-      const tree: PageTypeDecoratable = {
-        type: 'course',
-        children: [
-          {
-            type: 'song',
-            children: [
-              {
-                type: 'play-along',
-                children: [{ type: 'song' }],
-              },
-            ],
-          },
-        ],
-      }
-      const decorated = decoratePageType(tree)
-      expect(decorated.page_type).toBe('lesson')
-      const lvl1 = decorated.children![0]
-      const lvl2 = lvl1.children![0]
-      const lvl3 = lvl2.children![0]
-      expect(lvl1.page_type).toBe('song')
-      expect(lvl2.page_type).toBe('song')
-      expect(lvl3.page_type).toBeUndefined()
-    })
-
-    test('preserves the input reference', () => {
-      const items: PageTypeDecoratable[] = [{ type: 'song' }]
-      const decorated = decoratePageType(items)
-      expect(decorated).toBe(items)
-    })
-  })
-})

package/test/unit/playerSettings.test.ts

@@ -1,73 +0,0 @@
-import { HttpClient } from '../../src/infrastructure/http/HttpClient'
-import { fetchPlayerSettings, updatePlayerSettings } from '../../src/services/user/playerSettings'
-import type { PlayerSettings } from '../../src/services/user/types'
-
-jest.mock('../../src/infrastructure/http/HttpClient')
-
-const mockPlayerSettings: PlayerSettings = {
-  auto_play: true,
-  auto_next: true,
-  auto_complete: true,
-  playlist_auto_next: true,
-}
-
-describe('playerSettings', () => {
-  let mockGet: jest.Mock
-  let mockPatch: jest.Mock
-
-  beforeEach(() => {
-    mockGet = jest.fn().mockResolvedValue(mockPlayerSettings)
-    mockPatch = jest.fn().mockResolvedValue(mockPlayerSettings)
-    ;(HttpClient as jest.Mock).mockImplementation(() => ({
-      get: mockGet,
-      patch: mockPatch,
-    }))
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('fetchPlayerSettings', () => {
-    test('calls GET on the correct endpoint', async () => {
-      await fetchPlayerSettings()
-      expect(mockGet).toHaveBeenCalledWith('/api/user-management-system/v1/user/player-settings')
-    })
-
-    test('returns the player settings from the API', async () => {
-      const result = await fetchPlayerSettings()
-      expect(result).toEqual(mockPlayerSettings)
-    })
-  })
-
-  describe('updatePlayerSettings', () => {
-    test('calls PATCH on the correct endpoint with provided data', async () => {
-      await updatePlayerSettings({ auto_next: false })
-      expect(mockPatch).toHaveBeenCalledWith(
-        '/api/user-management-system/v1/user/player-settings',
-        { auto_next: false }
-      )
-    })
-
-    test('sends only the provided fields (partial update)', async () => {
-      await updatePlayerSettings({ playlist_auto_next: false })
-      expect(mockPatch).toHaveBeenCalledWith(
-        expect.any(String),
-        { playlist_auto_next: false }
-      )
-    })
-
-    test('sends all fields when all are provided', async () => {
-      const allFields = { auto_play: false, auto_next: false, auto_complete: false, playlist_auto_next: false }
-      await updatePlayerSettings(allFields)
-      expect(mockPatch).toHaveBeenCalledWith(expect.any(String), allFields)
-    })
-
-    test('returns the updated player settings from the API', async () => {
-      const updated = { ...mockPlayerSettings, auto_next: false }
-      mockPatch.mockResolvedValue(updated)
-      const result = await updatePlayerSettings({ auto_next: false })
-      expect(result).toEqual(updated)
-    })
-  })
-})