musora-content-services 2.158.2 → 2.159.0

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

@@ -0,0 +1,334 @@
+import { initializeTestDB } from '../initializeTestDB'
+import {
+  _getAllStartedOrCompleted,
+  getAllCompleted,
+  getAllCompletedByIds,
+  getAllStarted,
+  getAllStartedOrCompleted,
+  getById,
+  getByIds,
+  getByRecordIds,
+  getLastInteractedOf,
+  getProgressDataByIds,
+  getProgressDataByRecordIds,
+  getProgressState,
+  getProgressStateByIds,
+  getProgressStateByRecordIds,
+  getResumeTimeSecondsByIds,
+  getResumeTimeSecondsByRecordIds,
+  getStartedOrCompletedProgressOnly,
+} from '../../../src/services/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())
+
+const meta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
+
+initializeTestDB()
+
+describe('getById', () => {
+  test('returns field value when record found', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, 120, { skipPush: true })
+    const result = await getById(100, null, 'state', '')
+    expect(result).toBe('started')
+  })
+
+  test('returns defaultValue when record not found', async () => {
+    const result = await getById(999, null, 'state', 'default-val')
+    expect(result).toBe('default-val')
+  })
+
+  test('returns defaultValue when contentId is falsy', async () => {
+    const result = await getById(0, null, 'state', 'fallback')
+    expect(result).toBe('fallback')
+  })
+})
+
+describe('getByIds', () => {
+  test('returns Map with correct values for found ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getByIds([100, 300], null, 'state', '')
+    expect(result.get(100)).toBe('started')
+    expect(result.get(300)).toBe('completed')
+  })
+
+  test('defaults to defaultValue for missing ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getByIds([100, 999], null, 'state', '')
+    expect(result.get(100)).toBe('started')
+    expect(result.get(999)).toBe('')
+  })
+
+  test('returns empty Map for empty array', async () => {
+    const result = await getByIds([], null, 'state', '')
+    expect(result.size).toBe(0)
+  })
+})
+
+describe('getByRecordIds', () => {
+  test('returns object with correct values for found record ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getByRecordIds(['100:self:0', '300:self:0'], 'state', '')
+    expect(result['100:self:0']).toBe('started')
+    expect(result['300:self:0']).toBe('completed')
+  })
+
+  test('defaults to defaultValue for missing record id', async () => {
+    const result = await getByRecordIds(['999:self:0'], 'state', '')
+    expect(result['999:self:0']).toBe('')
+  })
+})
+
+describe('getProgressState', () => {
+  test('returns started for started content', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    expect(await getProgressState(100)).toBe('started')
+  })
+
+  test('returns completed for completed content', async () => {
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    expect(await getProgressState(300)).toBe('completed')
+  })
+
+  test('returns empty string for unknown content', async () => {
+    expect(await getProgressState(999)).toBe('')
+  })
+})
+
+describe('getProgressStateByIds', () => {
+  test('returns Map with correct states for multiple ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getProgressStateByIds([100, 300])
+    expect(result.get(100)).toBe('started')
+    expect(result.get(300)).toBe('completed')
+  })
+
+  test('defaults to empty string for unknown ids', async () => {
+    const result = await getProgressStateByIds([999])
+    expect(result.get(999)).toBe('')
+  })
+
+  test('returns empty Map for empty array', async () => {
+    const result = await getProgressStateByIds([])
+    expect(result.size).toBe(0)
+  })
+})
+
+describe('getProgressStateByRecordIds', () => {
+  test('returns correct states by record id', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getProgressStateByRecordIds(['100:self:0', '300:self:0'])
+    expect(result['100:self:0']).toBe('started')
+    expect(result['300:self:0']).toBe('completed')
+  })
+
+  test('returns empty string for unknown record id', async () => {
+    const result = await getProgressStateByRecordIds(['999:self:0'])
+    expect(result['999:self:0']).toBe('')
+  })
+})
+
+describe('getResumeTimeSecondsByIds', () => {
+  test('returns resume time when record has one', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, 120, { skipPush: true })
+    const result = await getResumeTimeSecondsByIds([100])
+    expect(result.get(100)).toBe(120)
+  })
+
+  test('returns 0 for unknown ids', async () => {
+    const result = await getResumeTimeSecondsByIds([999])
+    expect(result.get(999)).toBe(0)
+  })
+})
+
+describe('getResumeTimeSecondsByRecordIds', () => {
+  test('returns correct value by record id', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, 120, { skipPush: true })
+    const result = await getResumeTimeSecondsByRecordIds(['100:self:0'])
+    expect(result['100:self:0']).toBe(120)
+  })
+
+  test('returns 0 for unknown record id', async () => {
+    const result = await getResumeTimeSecondsByRecordIds(['999:self:0'])
+    expect(result['999:self:0']).toBe(0)
+  })
+})
+
+describe('getProgressDataByIds', () => {
+  test('returns correct shape for seeded content', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getProgressDataByIds([100], null)
+    expect(result[100].progress).toBe(20)
+    expect(result[100].status).toBe('started')
+    expect(typeof result[100].last_update).toBe('number')
+  })
+
+  test('returns defaults for unknown id', async () => {
+    const result = await getProgressDataByIds([999], null)
+    expect(result[999]).toEqual({ last_update: 0, progress: 0, status: '' })
+  })
+
+  test('normalizes string content ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getProgressDataByIds(['100' as any], null)
+    expect(result[100].progress).toBe(20)
+  })
+})
+
+describe('getProgressDataByRecordIds', () => {
+  test('returns correct shape for seeded content', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getProgressDataByRecordIds(['100:self:0'])
+    expect(result['100:self:0'].progress).toBe(20)
+    expect(result['100:self:0'].status).toBe('started')
+    expect(typeof result['100:self:0'].last_update).toBe('number')
+  })
+
+  test('returns defaults for unknown record id', async () => {
+    const result = await getProgressDataByRecordIds(['999:self:0'])
+    expect(result['999:self:0']).toEqual({ last_update: 0, progress: 0, status: '' })
+  })
+})
+
+describe('getLastInteractedOf', () => {
+  test('returns a content id from the given list when records exist', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(200, null, 50, meta, undefined, { skipPush: true })
+    const result = await getLastInteractedOf([100, 200])
+    expect([100, 200]).toContain(result)
+  })
+
+  test('returns undefined when no records match', async () => {
+    const result = await getLastInteractedOf([999])
+    expect(result).toBeUndefined()
+  })
+})
+
+describe('getAllStarted', () => {
+  test('returns started content ids, not completed', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getAllStarted()
+    expect(result).toContain(100)
+    expect(result).not.toContain(300)
+  })
+
+  test('returns empty array when no started content', async () => {
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    expect(await getAllStarted()).toHaveLength(0)
+  })
+
+  test('respects limit', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(200, null, 50, meta, undefined, { skipPush: true })
+    expect(await getAllStarted(1)).toHaveLength(1)
+  })
+
+  test('onlyIds=false returns objects with content_id', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getAllStarted(null, { onlyIds: false })
+    expect(result[0]).toHaveProperty('content_id', 100)
+  })
+})
+
+describe('getAllCompleted', () => {
+  test('returns completed content ids, not started', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getAllCompleted()
+    expect(result).toContain(300)
+    expect(result).not.toContain(100)
+  })
+
+  test('returns empty array when no completed content', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    expect(await getAllCompleted()).toHaveLength(0)
+  })
+
+  test('respects limit', async () => {
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(400, null, 100, meta, undefined, { skipPush: true })
+    expect(await getAllCompleted(1)).toHaveLength(1)
+  })
+})
+
+describe('getAllCompletedByIds', () => {
+  test('returns only completed records within given ids', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(400, null, 100, meta, undefined, { skipPush: true })
+    const result = await getAllCompletedByIds([100, 300, 400])
+    const completedIds = result.data.map((r: any) => r.content_id)
+    expect(completedIds).toContain(300)
+    expect(completedIds).toContain(400)
+    expect(completedIds).not.toContain(100)
+  })
+
+  test('returns empty data array when no completed records match', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getAllCompletedByIds([100])
+    expect(result.data).toHaveLength(0)
+  })
+})
+
+describe('getAllStartedOrCompleted', () => {
+  test('returns ids for both started and completed records', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getAllStartedOrCompleted()
+    expect(result).toContain(100)
+    expect(result).toContain(300)
+  })
+
+  test('respects limit', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(400, null, 100, meta, undefined, { skipPush: true })
+    const result = await getAllStartedOrCompleted({ limit: 2 })
+    expect(result).toHaveLength(2)
+  })
+
+  test('onlyIds=false returns full record objects', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    const result = await getAllStartedOrCompleted({ onlyIds: false })
+    expect(result[0]).toHaveProperty('content_id')
+    expect(result[0]).toHaveProperty('state')
+    expect(result[0]).toHaveProperty('progress_percent')
+  })
+})
+
+describe('_getAllStartedOrCompleted', () => {
+  test('returns all started and completed records', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await _getAllStartedOrCompleted()
+    const ids = result.map((r: any) => r.content_id)
+    expect(ids).toContain(100)
+    expect(ids).toContain(300)
+  })
+
+  test('respects limit', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(400, null, 100, meta, undefined, { skipPush: true })
+    const result = await _getAllStartedOrCompleted({ limit: 2 })
+    expect(result).toHaveLength(2)
+  })
+})
+
+describe('getStartedOrCompletedProgressOnly', () => {
+  test('returns map of content_id to progress_percent', async () => {
+    await db.contentProgress.recordProgress(100, null, 20, meta, undefined, { skipPush: true })
+    await db.contentProgress.recordProgress(300, null, 100, meta, undefined, { skipPush: true })
+    const result = await getStartedOrCompletedProgressOnly()
+    expect(result[100]).toBe(20)
+    expect(result[300]).toBe(100)
+  })
+})

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

@@ -0,0 +1,263 @@
+import { initializeTestDB } from '../initializeTestDB'
+import {
+  bubbleAndTrickleProgressesSafely,
+  duplicateProgressToALaCarte,
+  getIdsWhereLastAccessedFromMethod,
+  getProgressState,
+  handleLearningPathProgressActions,
+} from '../../../src/services/contentProgress'
+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())
+
+const meta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
+const collectionSelf = { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF }
+const collectionLP = (id: number) => ({ type: COLLECTION_TYPE.LEARNING_PATH, id })
+
+const ctx = initializeTestDB()
+
+const flushPromises = async () => {
+  for (let i = 0; i < 200; i++) {
+    await new Promise(resolve => setImmediate(resolve))
+  }
+}
+
+// ─── bubbleAndTrickleProgressesSafely ─────────────────────────────────────────
+
+describe('bubbleAndTrickleProgressesSafely', () => {
+  test('non-reset writes records to DB', async () => {
+    const progresses = { 101: 50, 102: 75 }
+    const metadata = { 101: meta, 102: meta }
+    await bubbleAndTrickleProgressesSafely(progresses, collectionSelf, metadata)
+    expect(await getProgressState(101)).toBe('started')
+    expect(await getProgressState(102)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('non-reset with correct progress values', async () => {
+    const progresses = { 101: 50 }
+    const metadata = { 101: meta }
+    await bubbleAndTrickleProgressesSafely(progresses, collectionSelf, metadata)
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('non-reset with empty progresses does not create records', async () => {
+    await bubbleAndTrickleProgressesSafely({}, collectionSelf, {})
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data).toBeNull()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('reset action with all positive values writes records', async () => {
+    const progresses = { 101: 50, 102: 75 }
+    const metadata = { 101: meta, 102: meta }
+    await bubbleAndTrickleProgressesSafely(progresses, collectionSelf, metadata, { isResetAction: true })
+    expect(await getProgressState(101)).toBe('started')
+    expect(await getProgressState(102)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('reset action with all zero values erases records', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true })
+    expect(await getProgressState(101)).toBe('started')
+    await bubbleAndTrickleProgressesSafely({ 101: 0 }, collectionSelf, {}, { isResetAction: true })
+    expect(await getProgressState(101)).toBe('')
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('reset action with mixed values writes positive and erases zeros', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true })
+    const metadata = { 102: meta }
+    await bubbleAndTrickleProgressesSafely({ 101: 0, 102: 60 }, collectionSelf, metadata, { isResetAction: true })
+    expect(await getProgressState(101)).toBe('')
+    expect(await getProgressState(102)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('collection normalized — null collection writes to SELF', async () => {
+    const progresses = { 101: 50 }
+    const metadata = { 101: meta }
+    await bubbleAndTrickleProgressesSafely(progresses, null as any, metadata)
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('bubble lowers parent from 100% to 50% via allowRegression', async () => {
+    await db.contentProgress.recordProgress(1, null, 100, meta, undefined, { skipPush: true })
+    expect((await db.contentProgress.getOneProgressByContentId(1, null)).data?.progress_percent).toBe(100)
+
+    await bubbleAndTrickleProgressesSafely({ 1: 50 }, collectionSelf, { 1: meta })
+
+    const record = await db.contentProgress.getOneProgressByContentId(1, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── handleLearningPathProgressActions ────────────────────────────────────────
+
+describe('handleLearningPathProgressActions', () => {
+  const mockLearningPaths = jest.requireMock('../../../src/services/content-org/learning-paths.ts')
+
+  beforeEach(() => {
+    mockLearningPaths.onLearningPathCompletedActions.mockClear()
+  })
+
+  test('non-LP collection returns without action', async () => {
+    await handleLearningPathProgressActions({ 101: 100 }, collectionSelf)
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).not.toHaveBeenCalled()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP id at 100% calls onLearningPathCompletedActions', async () => {
+    await handleLearningPathProgressActions({ 200: 100 }, collectionLP(200))
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).toHaveBeenCalledWith(200)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('non-LP-id child at 100% does not call onLearningPathCompletedActions', async () => {
+    await handleLearningPathProgressActions({ 101: 100 }, collectionLP(200))
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).not.toHaveBeenCalled()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP id at <100% does not call onLearningPathCompletedActions', async () => {
+    await handleLearningPathProgressActions({ 200: 50 }, collectionLP(200))
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).not.toHaveBeenCalled()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP id + children at 100% calls onLearningPathCompletedActions once for LP id only', async () => {
+    await handleLearningPathProgressActions({ 200: 100, 101: 100, 102: 100 }, collectionLP(200))
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).toHaveBeenCalledTimes(1)
+    expect(mockLearningPaths.onLearningPathCompletedActions).toHaveBeenCalledWith(200)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP collection duplicates lesson progress to SELF records', async () => {
+    await handleLearningPathProgressActions({ 101: 50 }, collectionLP(200))
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── duplicateProgressToALaCarte ─────────────────────────────────────────────
+
+describe('duplicateProgressToALaCarte', () => {
+  test('writes SELF records for a-la-carte collection', async () => {
+    await duplicateProgressToALaCarte({ 101: 50 }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP collection excludes the LP id itself from duplication', async () => {
+    await duplicateProgressToALaCarte({ 200: 50, 101: 75 }, collectionLP(200))
+    await flushPromises()
+    const lpRecord = await db.contentProgress.getOneProgressByContentId(200, null)
+    const lessonRecord = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(lpRecord.data).toBeNull()
+    expect(lessonRecord.data?.progress_percent).toBe(75)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('lower progress than existing is filtered — existing stays unchanged', async () => {
+    await db.contentProgress.recordProgress(101, null, 80, meta, undefined, { skipPush: true })
+    await duplicateProgressToALaCarte({ 101: 50 }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(80)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('equal progress passes and record is updated', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true })
+    await duplicateProgressToALaCarte({ 101: 50 }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('empty progresses results in no new records', async () => {
+    await duplicateProgressToALaCarte({}, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data).toBeNull()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+// ─── getIdsWhereLastAccessedFromMethod ────────────────────────────────────────
+
+describe('getIdsWhereLastAccessedFromMethod', () => {
+  test('returns content_ids from records where last_interacted_a_la_carte is null', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true, accessedDirectly: false })
+    const result = await getIdsWhereLastAccessedFromMethod([101])
+    expect(result).toContain(101)
+  })
+
+  test('returns empty array when no records match', async () => {
+    const result = await getIdsWhereLastAccessedFromMethod([999])
+    expect(result).toEqual([])
+  })
+
+  test('normalizes string content ids before querying', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true, accessedDirectly: false })
+    const result = await getIdsWhereLastAccessedFromMethod(['101'] as any)
+    expect(result).toContain(101)
+  })
+})
+
+// ─── Scenario: LP lesson completion ───────────────────────────────────────────
+
+describe('Scenario: LP lesson at 100% triggers completion and duplicates to a-la-carte', () => {
+  const mockLearningPaths = jest.requireMock('../../../src/services/content-org/learning-paths.ts')
+
+  beforeEach(() => {
+    mockLearningPaths.onLearningPathCompletedActions.mockClear()
+  })
+
+  test('LP id 200 at 100% calls onLearningPathCompletedActions; lesson at 100% writes SELF record', async () => {
+    await handleLearningPathProgressActions({ 200: 100, 101: 100 }, collectionLP(200))
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).toHaveBeenCalledTimes(1)
+    expect(mockLearningPaths.onLearningPathCompletedActions).toHaveBeenCalledWith(200)
+    const selfRecord = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(selfRecord.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})
+
+describe('Scenario: Offline LP progress skips award check', () => {
+  const mockLearningPaths = jest.requireMock('../../../src/services/content-org/learning-paths.ts')
+
+  beforeEach(() => {
+    mockLearningPaths.onLearningPathCompletedActions.mockClear()
+  })
+
+  test('isOffline=true writes SELF record but skips onLearningPathCompletedActions', async () => {
+    await handleLearningPathProgressActions({ 101: 100 }, collectionLP(200), { isOffline: true })
+    await flushPromises()
+    expect(mockLearningPaths.onLearningPathCompletedActions).not.toHaveBeenCalled()
+    const selfRecord = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(selfRecord.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})