musora-content-services 2.158.2 → 2.159.0

package/test/integration/content-progress/contentProgress.test.ts

@@ -0,0 +1,335 @@
+import { initializeTestDB } from '../initializeTestDB'
+import {
+  _recordWatchSession,
+  contentStatusCompleted,
+  contentStatusCompletedMany,
+  contentStatusReset,
+  contentStatusStarted,
+  flushWatchSession,
+  getProgressState,
+  recordWatchSession,
+  resetStatus,
+  saveContentProgress,
+  setStartedOrCompletedStatus,
+  setStartedOrCompletedStatusMany,
+  trackProgress,
+} from '../../../src/services/contentProgress.js'
+import { COLLECTION_ID_SELF, COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+import db from '../../../src/services/sync/repository-proxy'
+
+jest.mock('../../../src/services/sanity.js', () => require('./__mocks__/mocks').mockSanity())
+jest.mock('../../../src/services/content-org/learning-paths.ts', () => require('./__mocks__/mocks').mockLearningPaths())
+jest.mock('../../../src/services/awards/internal/content-progress-observer', () => require('./__mocks__/mocks').mockContentProgressObserver())
+jest.mock('../../../src/services/progress-events', () => require('./__mocks__/mocks').mockProgressEvents())
+
+jest.mock('../../../src/services/userActivity', () => ({
+  trackUserPractice: jest.fn().mockResolvedValue(undefined),
+}))
+
+const meta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
+const collectionSelf = { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF }
+
+const ctx = initializeTestDB()
+
+// ─── contentStatusCompleted ───────────────────────────────────────────────────
+
+describe('contentStatusCompleted', () => {
+  test('sets state to completed in DB', async () => {
+    await contentStatusCompleted(500)
+    expect(await getProgressState(500)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+
+  test('sets progress_percent to 100 in DB', async () => {
+    await contentStatusCompleted(500)
+    const record = await db.contentProgress.getOneProgressByContentId(500, null)
+    expect(record.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+
+  test('defaults to SELF collection when null is passed', async () => {
+    await contentStatusCompleted(500, null)
+    const record = await db.contentProgress.getOneProgressByContentId(500, null)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+})
+
+// ─── contentStatusCompletedMany ───────────────────────────────────────────────
+
+describe('contentStatusCompletedMany', () => {
+  test('sets all ids to completed state in DB', async () => {
+    await contentStatusCompletedMany([501, 502, 503])
+    expect(await getProgressState(501)).toBe('completed')
+    expect(await getProgressState(502)).toBe('completed')
+    expect(await getProgressState(503)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status-many')
+  })
+
+  test('each record has progress_percent of 100', async () => {
+    await contentStatusCompletedMany([501, 502])
+    const r1 = await db.contentProgress.getOneProgressByContentId(501, null)
+    const r2 = await db.contentProgress.getOneProgressByContentId(502, null)
+    expect(r1.data?.progress_percent).toBe(100)
+    expect(r2.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status-many')
+  })
+})
+
+// ─── contentStatusStarted ─────────────────────────────────────────────────────
+
+describe('contentStatusStarted', () => {
+  test('sets state to started in DB', async () => {
+    await contentStatusStarted(600)
+    expect(await getProgressState(600)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+
+  test('sets progress_percent to 0 in DB', async () => {
+    await contentStatusStarted(600)
+    const record = await db.contentProgress.getOneProgressByContentId(600, null)
+    expect(record.data?.progress_percent).toBe(0)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+})
+
+// ─── contentStatusReset ───────────────────────────────────────────────────────
+
+describe('contentStatusReset', () => {
+  test('removes record from DB so getProgressState returns empty string', async () => {
+    await contentStatusCompleted(700)
+    expect(await getProgressState(700)).toBe('completed')
+    await contentStatusReset(700)
+    expect(await getProgressState(700)).toBe('')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+  })
+})
+
+// ─── saveContentProgress ──────────────────────────────────────────────────────
+
+describe('saveContentProgress', () => {
+  test('progress higher than existing writes new value', async () => {
+    await db.contentProgress.recordProgress(800, null, 30, meta, undefined, { skipPush: true })
+    const hierarchy = { metadata: { 800: meta }, parents: {}, children: {} }
+    await saveContentProgress(800, collectionSelf, 60, null, { hierarchy, isOffline: true })
+    const record = await db.contentProgress.getOneProgressByContentId(800, null)
+    expect(record.data?.progress_percent).toBe(60)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+
+  test('progress lower than existing is filtered — DB value unchanged', async () => {
+    await db.contentProgress.recordProgress(800, null, 70, meta, undefined, { skipPush: true })
+    const hierarchy = { metadata: { 800: meta }, parents: {}, children: {} }
+    await saveContentProgress(800, collectionSelf, 40, null, { hierarchy, isOffline: true })
+    const record = await db.contentProgress.getOneProgressByContentId(800, null)
+    expect(record.data?.progress_percent).toBe(70)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('progress equal to existing writes successfully', async () => {
+    await db.contentProgress.recordProgress(800, null, 50, meta, undefined, { skipPush: true })
+    const hierarchy = { metadata: { 800: meta }, parents: {}, children: {} }
+    await saveContentProgress(800, collectionSelf, 50, null, { hierarchy, isOffline: true })
+    const record = await db.contentProgress.getOneProgressByContentId(800, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+// ─── setStartedOrCompletedStatus ─────────────────────────────────────────────
+
+describe('setStartedOrCompletedStatus', () => {
+  test('completed=true writes state=completed to DB', async () => {
+    await setStartedOrCompletedStatus(900, collectionSelf, true)
+    expect(await getProgressState(900)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+
+  test('completed=false writes state=started to DB', async () => {
+    await setStartedOrCompletedStatus(900, collectionSelf, false)
+    expect(await getProgressState(900)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+
+  test('skipBubbleTrickle=true still writes the main record', async () => {
+    await setStartedOrCompletedStatus(900, collectionSelf, true, { skipBubbleTrickle: true })
+    expect(await getProgressState(900)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+})
+
+// ─── setStartedOrCompletedStatusMany ─────────────────────────────────────────
+
+describe('setStartedOrCompletedStatusMany', () => {
+  test('isCompleted=true sets all ids to completed in DB', async () => {
+    await setStartedOrCompletedStatusMany([1001, 1002, 1003], collectionSelf, true)
+    expect(await getProgressState(1001)).toBe('completed')
+    expect(await getProgressState(1002)).toBe('completed')
+    expect(await getProgressState(1003)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status-many')
+  })
+
+  test('isCompleted=false sets all ids to started in DB', async () => {
+    await setStartedOrCompletedStatusMany([1001, 1002], collectionSelf, false)
+    expect(await getProgressState(1001)).toBe('started')
+    expect(await getProgressState(1002)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status-many')
+  })
+})
+
+// ─── resetStatus ─────────────────────────────────────────────────────────────
+
+describe('resetStatus', () => {
+  test('removes record so getProgressState returns empty string', async () => {
+    await db.contentProgress.recordProgress(1100, null, 80, meta, undefined, { skipPush: true })
+    expect(await getProgressState(1100)).toBe('started')
+    await resetStatus(1100, collectionSelf)
+    expect(await getProgressState(1100)).toBe('')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+  })
+})
+
+// ─── trackProgress ────────────────────────────────────────────────────────────
+
+describe('trackProgress', () => {
+  test('50 of 200 seconds records progress ~25 to DB', async () => {
+    const hierarchy = { metadata: { 100: meta }, parents: {}, children: {} }
+    await trackProgress(100, collectionSelf, 50, 200, false, true, hierarchy)
+    const record = await db.contentProgress.getOneProgressByContentId(100, null)
+    expect(record.data?.progress_percent).toBe(25)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('0 seconds clamps to progress 1 in DB', async () => {
+    const hierarchy = { metadata: { 100: meta }, parents: {}, children: {} }
+    await trackProgress(100, collectionSelf, 0, 200, false, true, hierarchy)
+    const record = await db.contentProgress.getOneProgressByContentId(100, null)
+    expect(record.data?.progress_percent).toBe(1)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('full duration (200/200) clamps to 99 — never reaches 100 via track', async () => {
+    const hierarchy = { metadata: { 100: meta }, parents: {}, children: {} }
+    await trackProgress(100, collectionSelf, 200, 200, false, true, hierarchy)
+    const record = await db.contentProgress.getOneProgressByContentId(100, null)
+    expect(record.data?.progress_percent).toBe(99)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── recordWatchSession ───────────────────────────────────────────────────────
+
+describe('recordWatchSession', () => {
+  const mockUserActivity = jest.requireMock('../../../src/services/userActivity')
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('writes progress to DB and calls trackUserPractice', async () => {
+    await recordWatchSession(234, null, 200, 100, 30)
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(mockUserActivity.trackUserPractice).toHaveBeenCalledWith(234, 30, expect.any(Object))
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('normalizes string contentId to number in DB', async () => {
+    await recordWatchSession('234' as any, null, 200, 100, 30)
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.content_id).toBe(234)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── _recordWatchSession ──────────────────────────────────────────────────────
+
+describe('_recordWatchSession', () => {
+  const mockUserActivity = jest.requireMock('../../../src/services/userActivity')
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('writes progress to DB and calls trackUserPractice', async () => {
+    const hierarchy = { metadata: { 234: meta }, parents: {}, children: {} }
+    await _recordWatchSession(234, 200, 100, 30, { collection: null, isOffline: true, hierarchy })
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(mockUserActivity.trackUserPractice).toHaveBeenCalledWith(234, 30, expect.any(Object))
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── flushWatchSession ────────────────────────────────────────────────────────
+
+describe('flushWatchSession', () => {
+  test('triggers push for both contentProgress and practices', async () => {
+    await expect(flushWatchSession()).resolves.not.toThrow()
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('flush-watch-session')
+    expect(ctx.pushSpies.practices).toHaveBeenCalledWith('flush-watch-session')
+  })
+})
+
+// ─── E2E Scenarios ────────────────────────────────────────────────────────────
+
+describe('Scenario: User completes lesson a-la-carte', () => {
+  test('state=completed and progress_percent=100 written to DB', async () => {
+    await contentStatusCompleted(42001)
+    const record = await db.contentProgress.getOneProgressByContentId(42001, null)
+    expect(record.data?.state).toBe('completed')
+    expect(record.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+})
+
+describe('Scenario: User starts lesson a-la-carte', () => {
+  test('state=started and progress_percent=0 written to DB', async () => {
+    await contentStatusStarted(42002)
+    const record = await db.contentProgress.getOneProgressByContentId(42002, null)
+    expect(record.data?.state).toBe('started')
+    expect(record.data?.progress_percent).toBe(0)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+  })
+})
+
+describe('Scenario: User resets lesson progress', () => {
+  test('record removed from DB after reset', async () => {
+    await contentStatusCompleted(42003)
+    expect(await getProgressState(42003)).toBe('completed')
+    await contentStatusReset(42003)
+    expect(await getProgressState(42003)).toBe('')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+  })
+})
+
+describe('Scenario: User watches video halfway through', () => {
+  test('progress written and clamped correctly', async () => {
+    await recordWatchSession(42004, null, 200, 100, 30)
+    const record = await db.contentProgress.getOneProgressByContentId(42004, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+describe('Scenario: User watches to end — clamped at 99 (not 100)', () => {
+  test('progress_percent is 99, not 100, after watching to the end', async () => {
+    await recordWatchSession(42005, null, 200, 200, 60)
+    const record = await db.contentProgress.getOneProgressByContentId(42005, null)
+    expect(record.data?.progress_percent).toBe(99)
+    expect(record.data?.state).toBe('started')
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+describe('Scenario: Completing multiple lessons at once', () => {
+  test('all lessons written as completed to DB', async () => {
+    await contentStatusCompletedMany([50001, 50002, 50003])
+    expect(await getProgressState(50001)).toBe('completed')
+    expect(await getProgressState(50002)).toBe('completed')
+    expect(await getProgressState(50003)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('set-started-or-completed-status-many')
+  })
+})

package/test/integration/content-progress/e2eOfflineProgress.test.ts

@@ -0,0 +1,352 @@
+import { initializeTestDB } from '../initializeTestDB'
+import {
+  contentStatusCompletedManyOffline,
+  contentStatusCompletedOffline,
+  contentStatusResetOffline,
+  contentStatusStartedOffline,
+  recordWatchSessionOffline,
+} from '../../../src/services/offline/progress'
+import { flushWatchSession } from '../../../src/services/contentProgress.js'
+import {
+  COLLECTION_ID_SELF,
+  COLLECTION_TYPE,
+  CollectionParameter,
+} from '../../../src/services/sync/models/ContentProgress'
+import db from '../../../src/services/sync/repository-proxy'
+import { clearHierarchies, HierarchyTreeNode } from './__mocks__/mocks'
+
+jest.mock('../../../src/services/sanity.js', () => require('./__mocks__/mocks').mockSanity())
+jest.mock('../../../src/services/content-org/learning-paths.ts', () => require('./__mocks__/mocks').mockLearningPaths())
+jest.mock('../../../src/services/awards/internal/content-progress-observer', () => require('./__mocks__/mocks').mockContentProgressObserver())
+jest.mock('../../../src/services/progress-events', () => require('./__mocks__/mocks').mockProgressEvents())
+
+jest.mock('../../../src/services/userActivity', () => ({
+  trackUserPractice: jest.fn().mockResolvedValue(undefined),
+}))
+
+const selfCollection = { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF }
+const playlistCollection = { type: COLLECTION_TYPE.PLAYLIST, id: 123 }
+const lpCollection = { type: COLLECTION_TYPE.LEARNING_PATH, id: 999 }
+
+const testMetadata = { brand: 'test-brand', type: 'test-type', parent_id: 0 }
+
+const learningPathsMock = jest.requireMock('../../../src/services/content-org/learning-paths.ts')
+const sanityMock = jest.requireMock('../../../src/services/sanity.js')
+
+const ctx = initializeTestDB()
+
+beforeEach(() => {
+  clearHierarchies()
+  learningPathsMock.onLearningPathCompletedActions.mockClear()
+  learningPathsMock.getDailySession.mockClear()
+  sanityMock.getHierarchy.mockClear()
+  sanityMock.getHierarchies.mockClear()
+  sanityMock.getSanityDate.mockClear()
+})
+
+afterEach(() => {
+  expect(sanityMock.getHierarchy).not.toHaveBeenCalled()
+  expect(sanityMock.getHierarchies).not.toHaveBeenCalled()
+  expect(sanityMock.getSanityDate).not.toHaveBeenCalled()
+})
+
+type ExpectedProgress = {
+  state?: string
+  percent?: number
+  collection?: CollectionParameter
+}
+
+function expectProgress(data: any, expected: ExpectedProgress) {
+  const expectedState = expected.state ?? (expected.percent === 100 ? 'completed' : 'started')
+  expect(data).not.toBeNull()
+  if (expected.state !== undefined) expect(data.state).toBe(expectedState)
+  if (expected.percent !== undefined) expect(data.progress_percent).toBe(expected.percent)
+  if (expected.collection !== undefined) expect(data.collection_type).toBe(expected.collection.type)
+  if (expected.collection !== undefined) expect(data.collection_id).toBe(expected.collection.id)
+}
+
+async function getOne(contentId: number, collection: CollectionParameter = null) {
+  const result = await db.contentProgress.getOneProgressByContentId(contentId, collection)
+  return result.data
+}
+
+async function writeOne(contentId: number, progress: number, collection: CollectionParameter = null) {
+  await db.contentProgress.recordProgress(contentId, collection, progress, testMetadata, 0, { skipPush: true })
+}
+
+function buildHierarchy(tree: HierarchyTreeNode) {
+  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(tree, 0)
+
+  return { topLevelId: tree.id, parents, children, metadata }
+}
+
+const flatHierarchy = (contentId: number) => buildHierarchy({ id: contentId, type: 'lesson' })
+
+const flatHierarchyForMany = (contentIds: number[]) => ({
+  topLevelId: contentIds[0],
+  parents: {},
+  children: {},
+  metadata: Object.fromEntries(contentIds.map(id => [id, { ...testMetadata }])),
+})
+
+describe('contentStatusCompletedOffline', () => {
+
+  describe('a-la-carte collection', () => {
+    test('singular a-la-carte lesson', async () => {
+      await contentStatusCompletedOffline(500, null, flatHierarchy(500))
+      const record = await getOne(500, null)
+
+      expectProgress(record, { percent: 100, collection: selfCollection })
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledTimes(1)
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+    })
+
+    test('child a-la-carte lesson does NOT bubble to parent', async () => {
+      const hierarchy = buildHierarchy({
+        id: 1, type: 'course', children: [
+          { id: 100, type: 'lesson' },
+          { id: 200, type: 'lesson' },
+        ],
+      })
+
+      await contentStatusCompletedOffline(100, null, hierarchy)
+
+      const child = await getOne(100, null)
+      const sibling = await getOne(200, null)
+      const parent = await getOne(1, null)
+
+      expectProgress(child, { percent: 100, collection: selfCollection })
+      expect(sibling).toBeNull()
+      expect(parent).toBeNull()
+
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledTimes(1)
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+    })
+  })
+
+  describe('learning path collection', () => {
+    test('learning path lesson writes LP record and duplicates to a-la-carte without bubbling', async () => {
+      const hierarchy = buildHierarchy({
+        id: 999, type: 'learning-path-v2', children: [
+          { id: 100, type: 'lesson' },
+          { id: 300, type: 'lesson' },
+        ],
+      })
+
+      await contentStatusCompletedOffline(100, lpCollection, hierarchy)
+
+      const childLP = await getOne(100, lpCollection)
+      const lpLP = await getOne(999, lpCollection)
+      const childALC = await getOne(100, null)
+      const lpALC = await getOne(999, null)
+      const siblingALC = await getOne(300, null)
+
+      expectProgress(childLP, { percent: 100, collection: lpCollection })
+      expect(lpLP).toBeNull()
+      expectProgress(childALC, { percent: 100, collection: selfCollection })
+      expect(lpALC).toBeNull()
+      expect(siblingALC).toBeNull()
+
+      expect(learningPathsMock.onLearningPathCompletedActions).not.toHaveBeenCalled()
+
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+    })
+
+    // not possible to complete parents offline, currently
+    // test('learning path completion writes LP record but skips onLearningPathCompletedActions (offline)', async () => {})
+  })
+})
+
+describe('contentStatusCompletedManyOffline', () => {
+  test('all ids written in a-la-carte', async () => {
+    await contentStatusCompletedManyOffline(
+      [50001, 50002, 50003],
+      null,
+      flatHierarchyForMany([50001, 50002, 50003]),
+    )
+
+    expectProgress(await getOne(50001, null), { percent: 100, collection: selfCollection })
+    expectProgress(await getOne(50002, null), { percent: 100, collection: selfCollection })
+    expectProgress(await getOne(50003, null), { percent: 100, collection: selfCollection })
+
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+describe('contentStatusStartedOffline', () => {
+  test('singular a-la-carte lesson started', async () => {
+    await contentStatusStartedOffline(500, null, flatHierarchy(500))
+    const record = await getOne(500, null)
+
+    expectProgress(record, { percent: 0, state: 'started', collection: selfCollection })
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+describe('contentStatusResetOffline', () => {
+  describe('a-la-carte collection', () => {
+    test('reset singular a-la-carte lesson', async () => {
+      await writeOne(500, 100)
+      await contentStatusResetOffline(500)
+
+      const record = await getOne(500, null)
+
+      expect(record).toBeNull()
+
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledTimes(1)
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+    })
+
+    test('reset child a-la-carte lesson does NOT touch parent', async () => {
+      await writeOne(100, 100)
+      await writeOne(200, 100)
+      await writeOne(1, 100)
+
+      await contentStatusResetOffline(100)
+
+      const child = await getOne(100, null)
+      const sibling = await getOne(200, null)
+      const parent = await getOne(1, null)
+
+      expect(child).toBeNull()
+      expectProgress(sibling, { percent: 100 })
+      expectProgress(parent, { percent: 100 })
+
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledTimes(1)
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+    })
+  })
+
+  describe('learning path collection', () => {
+    test('reset learning path lesson removes LP record only', async () => {
+      await writeOne(100, 100, lpCollection)
+      await writeOne(999, 50, lpCollection)
+      await writeOne(100, 100)
+      await writeOne(50, 50)
+
+      await contentStatusResetOffline(100, lpCollection)
+
+      const childLP = await getOne(100, lpCollection)
+      const lpLP = await getOne(999, lpCollection)
+      const childALC = await getOne(100, null)
+      const parentALC = await getOne(50, null)
+
+      expect(childLP).toBeNull()
+      expectProgress(lpLP, { percent: 50 })
+      expectProgress(childALC, { percent: 100 })
+      expectProgress(parentALC, { percent: 50 })
+
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledTimes(1)
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+    })
+  })
+})
+
+describe('recordWatchSessionOffline', () => {
+
+  describe('a-la-carte collection', () => {
+    test('singular a-la-carte lesson, halfway', async () => {
+      await recordWatchSessionOffline(500, 200, 100, 30, flatHierarchy(500))
+
+      const record = await getOne(500, null)
+      expectProgress(record, { percent: 50, collection: selfCollection })
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+    })
+
+    test('singular a-la-carte lesson, watched to end clamps at 99', async () => {
+      await recordWatchSessionOffline(500, 200, 200, 60, flatHierarchy(500))
+
+      const record = await getOne(500, null)
+      expectProgress(record, { percent: 99 })
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+    })
+
+    test('child a-la-carte lesson does NOT bubble to parent', async () => {
+      const hierarchy = buildHierarchy({
+        id: 1, type: 'course', children: [
+          { id: 100, type: 'lesson' },
+          { id: 200, type: 'lesson' },
+        ],
+      })
+
+      await recordWatchSessionOffline(100, 200, 100, 30, hierarchy)
+
+      const child = await getOne(100, null)
+      const sibling = await getOne(200, null)
+      const parent = await getOne(1, null)
+
+      expectProgress(child, { percent: 50 })
+      expect(sibling).toBeNull()
+      expect(parent).toBeNull()
+
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+    })
+
+    test('flushWatchSession triggers push after offline watch', async () => {
+      await recordWatchSessionOffline(500, 200, 100, 30, flatHierarchy(500))
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+
+      await flushWatchSession()
+      expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('flush-watch-session')
+    })
+  })
+
+  describe('playlist collection', () => {
+    test('singular lesson in playlist duplicates progress to a-la-carte', async () => {
+      await recordWatchSessionOffline(500, 200, 100, 30, flatHierarchy(500), {
+        collection: playlistCollection,
+      })
+
+      const aLaCarte = await getOne(500, null)
+      const playlistRec = await getOne(500, playlistCollection)
+
+      expectProgress(aLaCarte, { percent: 50, collection: selfCollection })
+      expect(playlistRec).toBeNull()
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('learning path collection', () => {
+    test('child lesson in LP writes LP record, duplicates to a-la-carte, no bubble', async () => {
+      const hierarchy = buildHierarchy({
+        id: 999, type: 'learning-path-v2', children: [
+          { id: 100, type: 'lesson' },
+          { id: 300, type: 'lesson' },
+        ],
+      })
+
+      await recordWatchSessionOffline(100, 200, 100, 30, hierarchy, {
+        collection: lpCollection,
+      })
+
+      const childLP = await getOne(100, lpCollection)
+      const lpLP = await getOne(999, lpCollection)
+      const childALC = await getOne(100, null)
+      const lpALC = await getOne(999, null)
+
+      expectProgress(childLP, { percent: 50, collection: lpCollection })
+      expect(lpLP).toBeNull()
+      expectProgress(childALC, { percent: 50, collection: selfCollection })
+      expect(lpALC).toBeNull()
+
+      expect(learningPathsMock.onLearningPathCompletedActions).not.toHaveBeenCalled()
+      expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+    })
+  })
+})