musora-content-services 2.158.2 → 2.159.0

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

@@ -0,0 +1,322 @@
+import { initializeTestService } from '../../initializeTests.js'
+import {
+  averageProgressesFor,
+  bubbleProgress,
+  computeBubbleTrickleProgresses,
+  getAncestorAndSiblingIds,
+  getChildrenToDepth,
+  trickleProgress,
+} from '../../../src/services/contentProgress.js'
+import { COLLECTION_ID_SELF, COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+
+let mockProgressRecords: any[] = []
+
+jest.mock('../../../src/services/sync/repository-proxy', () => {
+  const mockFns = {
+    contentProgress: {
+      getSomeProgressByContentIds: jest.fn().mockImplementation((contentIds) => {
+        const records = mockProgressRecords.filter(r => contentIds.includes(r.content_id))
+        return Promise.resolve({ data: records })
+      }),
+    },
+    practices: {
+      queryAll: jest.fn().mockResolvedValue({ data: [] }),
+      getAll: jest.fn().mockResolvedValue({ data: [] }),
+    },
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+jest.mock('../../../src/services/sanity.js', () => ({
+  getHierarchy: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getHierarchies: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getSanityDate: jest.fn((date: Date) => date.toISOString()),
+}))
+
+jest.mock('../../../src/services/content-org/learning-paths', () => ({
+  getDailySession: jest.fn(),
+  onLearningPathCompletedActions: jest.fn(),
+}))
+
+const flatHierarchy = {
+  parents: {
+    200: 100,
+    201: 100,
+    202: 100,
+  },
+  children: {
+    100: [200, 201, 202],
+  },
+  metadata: {},
+}
+
+const deepHierarchy = {
+  parents: {
+    300: 200,
+    301: 200,
+    200: 100,
+    201: 100,
+  },
+  children: {
+    100: [200, 201],
+    200: [300, 301],
+  },
+  metadata: {},
+}
+
+const collectionSelf = { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF }
+
+describe('getChildrenToDepth', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('no children returns empty array', () => {
+    const result = getChildrenToDepth(200, flatHierarchy, 1)
+    expect(result).toEqual([])
+  })
+
+  test('direct children at depth 1', () => {
+    const result = getChildrenToDepth(100, flatHierarchy, 1)
+    expect(result).toEqual([200, 201, 202])
+  })
+
+  test('grandchildren included at depth 2', () => {
+    const result = getChildrenToDepth(100, deepHierarchy, 2)
+    expect(result).toEqual([200, 201, 300, 301])
+  })
+
+  test('depth 0 on leaf node returns empty array', () => {
+    const result = getChildrenToDepth(300, deepHierarchy, 0)
+    expect(result).toEqual([])
+  })
+})
+
+describe('getAncestorAndSiblingIds', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('no parent returns empty array', () => {
+    const result = getAncestorAndSiblingIds(flatHierarchy, 100)
+    expect(result).toEqual([])
+  })
+
+  test('returns siblings and parent for direct child', () => {
+    const result = getAncestorAndSiblingIds(flatHierarchy, 200)
+    expect(result).toContain(100)
+    expect(result).toContain(200)
+    expect(result).toContain(201)
+    expect(result).toContain(202)
+  })
+
+  test('returns siblings, parent, parent siblings, and grandparent for nested child', () => {
+    const result = getAncestorAndSiblingIds(deepHierarchy, 300)
+    expect(result).toContain(300)
+    expect(result).toContain(301)
+    expect(result).toContain(200)
+    expect(result).toContain(201)
+    expect(result).toContain(100)
+  })
+
+  test('circular ref returns empty array and logs error', () => {
+    const circularHierarchy = {
+      parents: { 100: 100 },
+      children: { 100: [100] },
+      metadata: {},
+    }
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {
+    })
+    const result = getAncestorAndSiblingIds(circularHierarchy, 100)
+    expect(result).toEqual([])
+    expect(errorSpy).toHaveBeenCalled()
+    errorSpy.mockRestore()
+  })
+
+  test('stops at MAX_DEPTH of 3', () => {
+    const fourLevelHierarchy = {
+      parents: {
+        400: 300,
+        300: 200,
+        200: 100,
+        100: 50,
+      },
+      children: {
+        50: [100],
+        100: [200],
+        200: [300],
+        300: [400],
+      },
+      metadata: {},
+    }
+    const result = getAncestorAndSiblingIds(fourLevelHierarchy, 400)
+    expect(result).not.toContain(50)
+  })
+})
+
+describe('averageProgressesFor', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('no parent returns empty object', () => {
+    const progressData = new Map([[100, 50]])
+    const result = averageProgressesFor(flatHierarchy, 100, progressData)
+    expect(result).toEqual({})
+  })
+
+  test('single child average equals that child progress', () => {
+    const singleChildHierarchy = {
+      parents: { 200: 100 },
+      children: { 100: [200] },
+      metadata: {},
+    }
+    const progressData = new Map([[200, 60]])
+    const result = averageProgressesFor(singleChildHierarchy, 200, progressData)
+    expect(result[100]).toBe(60)
+  })
+
+  test('multiple children average is rounded sum divided by count', () => {
+    const progressData = new Map([[200, 50], [201, 70], [202, 90]])
+    const result = averageProgressesFor(flatHierarchy, 200, progressData)
+    expect(result[100]).toBe(Math.round((50 + 70 + 90) / 3))
+  })
+
+  test('missing child progress defaults to 0', () => {
+    const progressData = new Map([[200, 60]])
+    const result = averageProgressesFor(flatHierarchy, 200, progressData)
+    expect(result[100]).toBe(Math.round((60 + 0 + 0) / 3))
+  })
+
+  test('recurses up to compute grandparent progress', () => {
+    const progressData = new Map([[300, 80], [301, 40], [201, 50]])
+    const result = averageProgressesFor(deepHierarchy, 300, progressData)
+    expect(result[200]).toBeDefined()
+    expect(result[100]).toBeDefined()
+  })
+})
+
+describe('trickleProgress', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('no descendants returns empty object', () => {
+    const result = trickleProgress(flatHierarchy, 200, collectionSelf, 75)
+    expect(result).toEqual({})
+  })
+
+  test('all descendants receive same progress value', () => {
+    const result = trickleProgress(flatHierarchy, 100, collectionSelf, 100)
+    expect(result[200]).toBe(100)
+    expect(result[201]).toBe(100)
+    expect(result[202]).toBe(100)
+  })
+
+  test('trickles through multiple levels in deep hierarchy', () => {
+    const result = trickleProgress(deepHierarchy, 100, collectionSelf, 50)
+    expect(result[200]).toBe(50)
+    expect(result[201]).toBe(50)
+    expect(result[300]).toBe(50)
+    expect(result[301]).toBe(50)
+  })
+})
+
+describe('bubbleProgress', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('no parent returns empty object', () => {
+    const result = bubbleProgress(flatHierarchy, 100)
+    return expect(result).resolves.toEqual({})
+  })
+
+  test('averages sibling progress for parent', async () => {
+    mockProgressRecords = [
+      { content_id: 200, progress_percent: 60 },
+      { content_id: 201, progress_percent: 30 },
+      { content_id: 202, progress_percent: 0 },
+    ]
+    const result = await bubbleProgress(flatHierarchy, 200)
+    expect(result[100]).toBe(Math.round((60 + 30 + 0) / 3))
+  })
+
+  test('one sibling with progress and rest at 0 yields rounded average', async () => {
+    mockProgressRecords = [
+      { content_id: 201, progress_percent: 90 },
+    ]
+    const result = await bubbleProgress(flatHierarchy, 200)
+    expect(result[100]).toBe(Math.round(90 / 3))
+  })
+
+  test('uses contentId own progress in calculation', async () => {
+    mockProgressRecords = [
+      { content_id: 200, progress_percent: 100 },
+      { content_id: 201, progress_percent: 100 },
+      { content_id: 202, progress_percent: 100 },
+    ]
+    const result = await bubbleProgress(flatHierarchy, 200)
+    expect(result[100]).toBe(100)
+  })
+})
+
+describe('computeBubbleTrickleProgresses', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('both bubble and trickle combine results', async () => {
+    mockProgressRecords = [
+      { content_id: 200, progress_percent: 100 },
+      { content_id: 201, progress_percent: 100 },
+      { content_id: 202, progress_percent: 100 },
+    ]
+    const result = await computeBubbleTrickleProgresses(100, 100, collectionSelf, flatHierarchy, {
+      bubble: true,
+      trickle: true,
+    })
+    expect(result[200]).toBe(100)
+    expect(result[201]).toBe(100)
+    expect(result[202]).toBe(100)
+  })
+
+  test('bubble=false returns only trickled descendants', async () => {
+    const result = await computeBubbleTrickleProgresses(100, 75, collectionSelf, flatHierarchy, {
+      bubble: false,
+      trickle: true,
+    })
+    expect(result[200]).toBe(75)
+    expect(result[201]).toBe(75)
+    expect(result[202]).toBe(75)
+    expect(result[100]).toBeUndefined()
+  })
+
+  test('trickle=false returns only bubbled ancestors', async () => {
+    mockProgressRecords = [
+      { content_id: 200, progress_percent: 60 },
+    ]
+    const result = await computeBubbleTrickleProgresses(200, 60, collectionSelf, flatHierarchy, {
+      bubble: true,
+      trickle: false,
+    })
+    expect(result[100]).toBeDefined()
+    expect(result[200]).toBeUndefined()
+    expect(result[201]).toBeUndefined()
+  })
+
+  test('empty hierarchy returns empty object', async () => {
+    const emptyHierarchy = { parents: {}, children: {}, metadata: {} }
+    const result = await computeBubbleTrickleProgresses(100, 50, collectionSelf, emptyHierarchy, {
+      bubble: true,
+      trickle: true,
+    })
+    expect(result).toEqual({})
+  })
+})

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

@@ -0,0 +1,329 @@
+import { initializeTestService } from '../../initializeTests.js'
+import {
+  duplicateProgressForIds,
+  extractFromRecordId,
+  filterOutLearningPathsForDuplication,
+  filterOutNegativeProgress,
+  generateRecordId,
+  normalizeCollection,
+  normalizeContentId,
+  normalizeContentIds,
+} from '../../../src/services/contentProgress.js'
+import { COLLECTION_ID_SELF, COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+
+let mockProgressRecords: any[] = []
+
+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 })
+      }),
+      recordProgress: jest.fn().mockResolvedValue({ data: null }),
+      requestPushUnsynced: jest.fn(),
+    },
+    practices: {
+      queryAll: jest.fn().mockResolvedValue({ data: [] }),
+      getAll: jest.fn().mockResolvedValue({ data: [] }),
+    },
+  }
+  return { default: mockFns, ...mockFns }
+})
+
+jest.mock('../../../src/services/sanity.js', () => ({
+  getHierarchy: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getHierarchies: jest.fn().mockResolvedValue({ metadata: {}, parents: {}, children: {} }),
+  getSanityDate: jest.fn((date: Date) => date.toISOString()),
+}))
+
+jest.mock('../../../src/services/content-org/learning-paths', () => ({
+  getDailySession: jest.fn(),
+  onLearningPathCompletedActions: jest.fn(),
+}))
+
+const flushPromises = () => new Promise(resolve => setImmediate(resolve))
+
+const mockRepo = jest.requireMock('../../../src/services/sync/repository-proxy')
+
+describe('filterOutNegativeProgress', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('drops entry when new progress is less than existing', () => {
+    const result = filterOutNegativeProgress({ 101: 30 }, { 101: { progress: 70 } })
+    expect(result).not.toHaveProperty('101')
+  })
+
+  test('keeps entry when new progress equals existing', () => {
+    const result = filterOutNegativeProgress({ 101: 50 }, { 101: { progress: 50 } })
+    expect(result).toHaveProperty('101', 50)
+  })
+
+  test('keeps entry when new progress is greater than existing', () => {
+    const result = filterOutNegativeProgress({ 101: 80 }, { 101: { progress: 50 } })
+    expect(result).toHaveProperty('101', 80)
+  })
+
+  test('keeps entry when existing progress is 0 and new is also 0', () => {
+    const result = filterOutNegativeProgress({ 101: 0 }, { 101: { progress: 0 } })
+    expect(result).toHaveProperty('101', 0)
+  })
+
+  test('drops only entries below existing, keeps others in mixed set', () => {
+    const result = filterOutNegativeProgress(
+      { 101: 20, 102: 80, 103: 40 },
+      { 101: { progress: 70 }, 102: { progress: 20 }, 103: { progress: 0 } },
+    )
+    expect(result).not.toHaveProperty('101')
+    expect(result).toHaveProperty('102')
+    expect(result).toHaveProperty('103')
+  })
+
+  test('returns a new object and does not mutate input', () => {
+    const progresses: Record<string, number> = { 101: 10 }
+    const result = filterOutNegativeProgress(progresses, { 101: { progress: 50 } })
+    expect(result).not.toBe(progresses)
+    expect(progresses).toHaveProperty('101', 10)
+    expect(result).not.toHaveProperty('101')
+  })
+})
+
+describe('filterOutLearningPathsForDuplication', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('non-LP collection — all entries pass through', () => {
+    const progresses = { 101: 30, 102: 50 }
+    const result = filterOutLearningPathsForDuplication(progresses, {
+      type: COLLECTION_TYPE.SELF,
+      id: COLLECTION_ID_SELF,
+    })
+    expect(result).toEqual({ 101: 30, 102: 50 })
+  })
+
+  test('LP collection — excludes entry whose id matches collection id', () => {
+    const progresses = { 200: 50, 101: 30, 102: 60 }
+    const result = filterOutLearningPathsForDuplication(progresses, {
+      type: COLLECTION_TYPE.LEARNING_PATH,
+      id: 200,
+    })
+    expect(result).not.toHaveProperty('200')
+    expect(result).toEqual({ 101: 30, 102: 60 })
+  })
+
+  test('LP collection — string key is coerced via +id comparison', () => {
+    const progresses = { '300': 40, 101: 30 }
+    const result = filterOutLearningPathsForDuplication(progresses, {
+      type: COLLECTION_TYPE.LEARNING_PATH,
+      id: 300,
+    })
+    expect(result).not.toHaveProperty('300')
+    expect(result).toHaveProperty('101')
+  })
+
+  test('returns a new object, not the original', () => {
+    const progresses = { 101: 30 }
+    const result = filterOutLearningPathsForDuplication(progresses, {
+      type: COLLECTION_TYPE.SELF,
+      id: COLLECTION_ID_SELF,
+    })
+    expect(result).not.toBe(progresses)
+  })
+})
+
+describe('duplicateProgressForIds', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+    jest.clearAllMocks()
+  })
+
+  test('empty object — no recordProgress and no requestPushUnsynced', async () => {
+    await duplicateProgressForIds({})
+    await flushPromises()
+    expect(mockRepo.contentProgress.recordProgress).not.toHaveBeenCalled()
+    expect(mockRepo.contentProgress.requestPushUnsynced).not.toHaveBeenCalled()
+  })
+
+  test('single entry — calls recordProgress once and skips push', async () => {
+    await duplicateProgressForIds({ 101: 50 })
+    await flushPromises()
+    expect(mockRepo.contentProgress.recordProgress).toHaveBeenCalledTimes(1)
+    expect(mockRepo.contentProgress.requestPushUnsynced).not.toHaveBeenCalled()
+  })
+
+  test('multiple entries — calls recordProgress per entry and skips push', async () => {
+    await duplicateProgressForIds({ 101: 30, 102: 50, 103: 70 })
+    await flushPromises()
+    expect(mockRepo.contentProgress.recordProgress).toHaveBeenCalledTimes(3)
+    expect(mockRepo.contentProgress.requestPushUnsynced).not.toHaveBeenCalled()
+  })
+})
+
+describe('normalizeContentId', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('number — returns same number', () => {
+    expect(normalizeContentId(123)).toBe(123)
+  })
+
+  test('numeric string — returns number', () => {
+    expect(normalizeContentId('123')).toBe(123)
+  })
+
+  test('"0" — returns 0', () => {
+    expect(normalizeContentId('0')).toBe(0)
+  })
+
+  test('non-numeric string — throws with correct message', () => {
+    expect(() => normalizeContentId('abc')).toThrow('Invalid content id: abc')
+  })
+})
+
+describe('normalizeContentIds', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('mixed array — all normalized to numbers', () => {
+    expect(normalizeContentIds([1, '2', 3])).toEqual([1, 2, 3])
+  })
+
+  test('empty array — returns empty array', () => {
+    expect(normalizeContentIds([])).toEqual([])
+  })
+
+  test('throws on invalid entry', () => {
+    expect(() => normalizeContentIds([1, 'abc' as any])).toThrow('Invalid content id: abc')
+  })
+})
+
+describe('normalizeCollection', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('null — returns null', () => {
+    expect(normalizeCollection(null)).toBeNull()
+  })
+
+  test('undefined — returns null', () => {
+    expect(normalizeCollection(undefined)).toBeNull()
+  })
+
+  test('valid with numeric id — returns { type, id }', () => {
+    expect(normalizeCollection({ type: COLLECTION_TYPE.SELF, id: 123 })).toEqual({
+      type: 'self',
+      id: 123,
+    })
+  })
+
+  test('valid with string id — returns { type, id: number }', () => {
+    expect(normalizeCollection({ type: COLLECTION_TYPE.LEARNING_PATH, id: '456' as any })).toEqual({
+      type: 'learning-path-v2',
+      id: 456,
+    })
+  })
+
+  test('invalid type — throws', () => {
+    expect(() => normalizeCollection({ type: 'invalid' as any, id: 1 })).toThrow(
+      'Invalid collection type: invalid',
+    )
+  })
+
+  test('non-numeric string id — throws', () => {
+    expect(() => normalizeCollection({ type: COLLECTION_TYPE.SELF, id: 'abc' as any })).toThrow(
+      'Invalid collection id: abc',
+    )
+  })
+})
+
+describe('generateRecordId', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('0 contentId — returns null (falsy check)', () => {
+    expect(generateRecordId(0, null)).toBeNull()
+  })
+
+  test('null contentId — returns null', () => {
+    expect(generateRecordId(null as any, null)).toBeNull()
+  })
+
+  test('null collection — uses SELF defaults', () => {
+    expect(generateRecordId(123, null)).toBe(
+      `123:${COLLECTION_TYPE.SELF}:${COLLECTION_ID_SELF}`,
+    )
+  })
+
+  test('LP collection — returns correct format', () => {
+    expect(
+      generateRecordId(123, { type: COLLECTION_TYPE.LEARNING_PATH, id: 456 }),
+    ).toBe('123:learning-path-v2:456')
+  })
+
+  test('string contentId — normalized before use', () => {
+    expect(generateRecordId('123' as any, null)).toBe(
+      `123:${COLLECTION_TYPE.SELF}:${COLLECTION_ID_SELF}`,
+    )
+  })
+})
+
+describe('extractFromRecordId', () => {
+  beforeEach(() => {
+    initializeTestService()
+    mockProgressRecords = []
+  })
+
+  test('null — returns null', () => {
+    expect(extractFromRecordId(null)).toBeNull()
+  })
+
+  test('undefined — returns null', () => {
+    expect(extractFromRecordId(undefined as any)).toBeNull()
+  })
+
+  test('self record id — correct parse', () => {
+    expect(extractFromRecordId('123:self:0')).toEqual({
+      contentId: 123,
+      collection: { type: 'self', id: 0 },
+    })
+  })
+
+  test('LP record id — correct parse', () => {
+    expect(extractFromRecordId('456:learning-path-v2:789')).toEqual({
+      contentId: 456,
+      collection: { type: 'learning-path-v2', id: 789 },
+    })
+  })
+
+  test('missing collection type — defaults to SELF', () => {
+    expect(extractFromRecordId('123::')).toEqual({
+      contentId: 123,
+      collection: { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF },
+    })
+  })
+
+  test('missing collection id — defaults to COLLECTION_ID_SELF', () => {
+    expect(extractFromRecordId('123:self:')).toEqual({
+      contentId: 123,
+      collection: { type: 'self', id: COLLECTION_ID_SELF },
+    })
+  })
+})