musora-content-services 2.167.2 → 2.167.3

package/test/unit/recommendations.test.js

@@ -1,47 +0,0 @@
-import { fetchSimilarItems } from '../../src/services/recommendations.js'
-
-jest.mock('../../src/infrastructure/http/HttpClient.ts', () => {
-  const mockPost = jest.fn()
-  const MockHttpClient = jest.fn().mockImplementation(() => ({ post: mockPost }))
-  MockHttpClient._mockPost = mockPost
-  return { HttpClient: MockHttpClient, GET: jest.fn() }
-})
-
-const mockPost = () => require('../../src/infrastructure/http/HttpClient.ts').HttpClient._mockPost
-
-describe('fetchSimilarItems', () => {
-  beforeEach(() => {
-    mockPost().mockReset()
-  })
-
-  test('returns empty array when content_id is falsy', async () => {
-    expect(await fetchSimilarItems(null, 'drumeo')).toEqual([])
-    expect(await fetchSimilarItems(0, 'drumeo')).toEqual([])
-    expect(await fetchSimilarItems('', 'drumeo')).toEqual([])
-  })
-
-  test('parses string content_id to integer for filtering', async () => {
-    mockPost().mockResolvedValue({ similar_items: [42, 99] })
-    const result = await fetchSimilarItems('42', 'drumeo', 10)
-    expect(result).not.toContain(42)
-    expect(result).toEqual([99])
-  })
-
-  test('filters out the requested content_id from results', async () => {
-    mockPost().mockResolvedValue({ similar_items: [1, 2, 3] })
-    const result = await fetchSimilarItems(2, 'drumeo', 10)
-    expect(result).toEqual([1, 3])
-  })
-
-  test('respects count limit', async () => {
-    mockPost().mockResolvedValue({ similar_items: [10, 20, 30, 40, 50, 60] })
-    const result = await fetchSimilarItems(99, 'drumeo', 3)
-    expect(result).toHaveLength(3)
-  })
-
-  test('returns null on error', async () => {
-    mockPost().mockRejectedValue(new Error('network failure'))
-    const result = await fetchSimilarItems(1, 'drumeo')
-    expect(result).toBeNull()
-  })
-})

package/test/unit/sanityQueryService.test.ts

@@ -1,200 +0,0 @@
-import { initializeTestService } from '../initializeTests.js'
-import { getSortOrder } from '../../src/services/sanity.js'
-import { processMetadata } from '../../src/contentMetaData.js'
-import { FilterBuilder } from '../../src/filterBuilder.js'
-import { getFieldsForContentTypeWithFilteredChildren } from '../../src/contentTypeConfig.js'
-
-jest.mock('../../src/services/permissions/index.ts', () => ({
-  ...jest.requireActual('../../src/services/permissions/index.ts'),
-  getPermissionsAdapter: jest.fn().mockReturnValue({
-    fetchUserPermissions: jest.fn().mockResolvedValue({ permissions: [108, 91, 92], isAdmin: false }),
-    isAdmin: jest.fn().mockReturnValue(false),
-    generatePermissionsFilter: jest.fn().mockReturnValue(
-      `(!defined(permission_v2) || array::intersects(permission_v2, [108,91,92]))`
-    ),
-  }),
-}))
-
-describe('Filter Builder', function() {
-  beforeEach(() => {
-    initializeTestService()
-  })
-
-  test('baseConstructor', async () => {
-    const filter = 'railcontent_id = 111'
-    let builder = new FilterBuilder(filter, { bypassPermissions: true })
-    let finalFilter = await builder.buildFilter(filter)
-    let clauses = spliceFilterForAnds(finalFilter)
-    // bypassPermissions: true + default statuses auto-sets pullFutureContent: true via getFutureScheduledContentsOnly
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id)
-    expect(clauses[0].phrase).toBe(filter)
-    expect(clauses[1].field).toBe('status')
-    expect(clauses[2].phrase).toBe('!defined(deprecated_railcontent_id)')
-
-    builder = new FilterBuilder('', { bypassPermissions: true })
-    finalFilter = await builder.buildFilter(filter)
-    clauses = spliceFilterForAnds(finalFilter)
-    // clauses: [0] status in [...], [1] !defined(deprecated_railcontent_id)
-    expect(clauses[0].field).toBe('status')
-    expect(clauses[0].operator).toBe('in')
-    expect(clauses[1].phrase).toBe('!defined(deprecated_railcontent_id)')
-  })
-
-  test('withOnlyFilterAvailableStatuses', async () => {
-    const filter = 'railcontent_id = 111'
-    const builder = FilterBuilder.withOnlyFilterAvailableStatuses(filter, ['published', 'unlisted'], true)
-    const finalFilter = await builder.buildFilter()
-    const clauses = spliceFilterForAnds(finalFilter)
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id), [3] published_on <=
-    expect(clauses[0].phrase).toBe(filter)
-    expect(clauses[1].field).toBe('status')
-    expect(clauses[1].operator).toBe('in')
-    expect(clauses[1].condition).toBe(`['published','unlisted']`)
-    expect(clauses[3].field).toBe('published_on')
-  })
-
-  test('withContentStatusAndFutureScheduledContent', async () => {
-    const filter = 'railcontent_id = 111'
-    const builder = new FilterBuilder(filter, {
-      availableContentStatuses: ['published', 'unlisted', 'scheduled'], getFutureScheduledContentsOnly: true,
-    })
-    const finalFilter = await builder.buildFilter()
-    const clauses = spliceFilterForAnds(finalFilter)
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id)
-    // pullFutureContent is set true by getFutureScheduledContentsOnly so no published_on <= clause
-    expect(clauses[0].phrase).toBe(filter)
-    expect(clauses[1].field).toBe('status')
-    expect(clauses[1].operator).toBe('in')
-    expect(clauses[1].condition).toBe(`['published','unlisted','scheduled']`)
-  })
-
-  test('withUserPermissions', async () => {
-    const filter = 'railcontent_id = 111'
-    const builder = new FilterBuilder(filter)
-    const finalFilter = await builder.buildFilter()
-    // permissions from initializeTestService: [108, 91, 92]
-    // adapter wraps as: (!defined(permission_v2) || array::intersects(...))
-    const expected = `(!defined(permission_v2) || array::intersects(permission_v2, [108,91,92]))`
-    const isMatch = finalFilter.includes(expected)
-    expect(isMatch).toBeTruthy()
-  })
-
-  test('withUserPermissionsForPlusUser', async () => {
-    const filter = 'railcontent_id = 111'
-    const builder = new FilterBuilder(filter)
-    const finalFilter = await builder.buildFilter()
-    // permissions from initializeTestService: [108, 91, 92]
-    // adapter wraps as: (!defined(permission_v2) || array::intersects(...))
-    const expected = `(!defined(permission_v2) || array::intersects(permission_v2, [108,91,92]))`
-    const isMatch = finalFilter.includes(expected)
-    expect(isMatch).toBeTruthy()
-  })
-
-  test('withPermissionBypass', async () => {
-    const filter = 'railcontent_id = 111'
-    const builder = new FilterBuilder(filter, {
-      bypassPermissions: true, pullFutureContent: false,
-    })
-    const finalFilter = await builder.buildFilter()
-    const clauses = spliceFilterForAnds(finalFilter)
-    // bypassPermissions: true skips the permission clause entirely
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id)
-    const expected = `(!defined(permission_v2) || array::intersects(permission_v2, [108,91,92]))`
-    const isMatch = finalFilter.includes(expected)
-    expect(isMatch).toBeFalsy()
-    expect(clauses[0].field).toBe('railcontent_id')
-    expect(clauses[1].field).toBe('status')
-    expect(clauses[2].phrase).toBe('!defined(deprecated_railcontent_id)')
-  })
-
-  test('withPublishOnRestrictions', async () => {
-    const filter = 'railcontent_id = 111'
-    let builder = new FilterBuilder(filter, {
-      pullFutureContent: true, bypassPermissions: true,
-    })
-
-    let finalFilter = await builder.buildFilter()
-    let clauses = spliceFilterForAnds(finalFilter)
-    // pullFutureContent: true — _applyPublishingDateRestrictions does nothing (else branch)
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id)
-    expect(clauses[0].phrase).toBe(filter)
-    expect(clauses[1].field).toBe('status')
-    expect(clauses[1].operator).toBe('in')
-    expect(clauses[2].phrase).toBe('!defined(deprecated_railcontent_id)')
-
-    builder = new FilterBuilder(filter, {
-      getFutureContentOnly: true, bypassPermissions: true,
-    })
-    finalFilter = await builder.buildFilter()
-    clauses = spliceFilterForAnds(finalFilter)
-    // getFutureContentOnly: true — published_on >= is appended
-    // clauses: [0] railcontent_id = 111, [1] status in [...], [2] !defined(deprecated_railcontent_id), [3] published_on >=
-    expect(clauses[0].phrase).toBe(filter)
-    expect(clauses[3].field).toBe('published_on')
-    expect(clauses[3].operator).toBe('>=')
-  })
-
-  function spliceFilterForAnds(filter: string): {
-    phrase: string;
-    field: string;
-    operator: string;
-    condition: string }[] {
-    // this will not correctly split complex filters with && and || conditions.
-    let phrases = filter.split(' && ')
-    let clauses = []
-    phrases.forEach((phrase) => {
-      let field = phrase.substring(0, phrase.indexOf(' '))
-      //if(field.charAt(0) === '(' ) field = field.substring(1);
-      const temp = phrase.substring(phrase.indexOf(' ') + 1)
-      const operator = temp.substring(0, temp.indexOf(' '))
-      let condition = temp.substring(temp.indexOf(' ') + 1)
-      //if(condition.charAt(condition.length) === ')') condition = condition.slice(-1);
-      clauses.push({ phrase, field, operator, condition })
-    })
-    return clauses
-  }
-})
-
-describe('Sanity Queries', function() {
-  beforeEach(() => {
-    initializeTestService()
-  })
-
-  test('getSortOrder', () => {
-    let sort = getSortOrder()
-    expect(sort).toBe('published_on desc')
-    sort = getSortOrder('published_on')
-    expect(sort).toBe('published_on asc')
-    sort = getSortOrder('recommended')
-    expect(sort).toBe('published_on desc')
-    sort = getSortOrder('slug')
-    expect(sort).toBe('!defined(title_for_sort), title_for_sort asc, !defined(title), lower(title) asc')
-    sort = getSortOrder('-slug')
-    expect(sort).toBe('!defined(title_for_sort), title_for_sort desc, !defined(title), lower(title) desc')
-    sort = getSortOrder('-slug', 'drumeo', true)
-    expect(sort).toBe('name desc')
-    sort = getSortOrder('popularity')
-    expect(sort).toBe('popularity asc')
-    sort = getSortOrder('-popularity')
-    expect(sort).toBe('coalesce(popularity, -1) desc')
-    sort = getSortOrder('popularity', 'drumeo', 'artist')
-    expect(sort).toBe('popularity.drumeo asc')
-    sort = getSortOrder('-popularity', 'drumeo', 'genre')
-    expect(sort).toBe('coalesce(popularity.drumeo, -1) desc')
-  })
-
-  test('invalidContentType', async () => {
-    const metaData = processMetadata('guitareo', 'not a real type')
-    expect(metaData).toBeNull()
-  })
-
-  test('newAndScheduledProjectionIncludesChildren', async () => {
-    const projection = await getFieldsForContentTypeWithFilteredChildren('new-and-scheduled')
-    expect(projection).toContain('"children": child[')
-  })
-
-  test('newAndScheduledProjectionIncludesParentFields', async () => {
-    const projection = await getFieldsForContentTypeWithFilteredChildren('new-and-scheduled')
-    expect(projection).toContain('show_in_new_feed')
-  })
-})

package/test/unit/search.test.ts

@@ -1,44 +0,0 @@
-import { searchAlgolia } from '../../src/services/search'
-
-const mockPost = jest.fn()
-
-jest.mock('../../src/infrastructure/http/HttpClient', () => ({
-    POST: (...args: unknown[]) => mockPost(...args),
-}))
-
-describe('searchAlgolia', () => {
-    beforeEach(() => {
-        mockPost.mockReset()
-    })
-
-    test('posts requests to the correct endpoint', async () => {
-        mockPost.mockResolvedValue({ results: [] })
-
-        await searchAlgolia([{ query: 'drum', hitsPerPage: 5 }])
-
-        expect(mockPost).toHaveBeenCalledWith('/api/content/v1/search', {
-            requests: [{ query: 'drum', hitsPerPage: 5 }],
-        })
-    })
-
-    test('returns the response from the endpoint', async () => {
-        const mockResponse = {
-            results: [{ hits: [{ objectID: 'abc123' }], nbHits: 1 }],
-        }
-        mockPost.mockResolvedValue(mockResponse)
-
-        const result = await searchAlgolia([{ query: 'drum' }])
-
-        expect(result).toEqual(mockResponse)
-    })
-
-    test('passes multiple requests', async () => {
-        mockPost.mockResolvedValue({ results: [] })
-
-        await searchAlgolia([{ query: 'drum' }, { query: 'piano' }])
-
-        expect(mockPost).toHaveBeenCalledWith('/api/content/v1/search', {
-            requests: [{ query: 'drum' }, { query: 'piano' }],
-        })
-    })
-})

package/test/unit/sentry.test.ts

@@ -1,62 +0,0 @@
-import { composeHandlers } from '../../src/services/sentry/index'
-
-test('returns value from first handler when it returns non-defined', () => {
-  const first = jest.fn().mockReturnValue('first')
-  const second = jest.fn().mockReturnValue('second')
-  const composed = composeHandlers(first, second)
-  const result = composed('arg1' as any, 'arg2' as any)
-
-  expect(result).toBe('first')
-})
-
-test('does not call subsequent handlers when first returns a value', () => {
-  const first = jest.fn().mockReturnValue('first')
-  const second = jest.fn().mockReturnValue('second')
-  const composed = composeHandlers(first, second)
-  composed('arg1' as any, 'arg2' as any)
-  expect(second).not.toHaveBeenCalled()
-})
-
-test('skips first handler returning undefined and uses second', () => {
-  const first = jest.fn().mockReturnValue(undefined)
-  const second = jest.fn().mockReturnValue('second')
-  const composed = composeHandlers(first, second)
-  const result = composed('arg1' as any, 'arg2' as any)
-
-  expect(result).toBe('second')
-})
-
-test('skips multiple undefined handlers to find first returning value', () => {
-  const first = jest.fn().mockReturnValue(undefined)
-  const second = jest.fn().mockReturnValue(undefined)
-  const third = jest.fn().mockReturnValue('third')
-  const composed = composeHandlers(first, second, third)
-  const result = composed('arg1' as any, 'arg2' as any)
-
-  expect(result).toBe('third')
-})
-
-test('returns args[0] when all handlers return undefined', () => {
-  const first = jest.fn().mockReturnValue(undefined)
-  const second = jest.fn().mockReturnValue(undefined)
-  const composed = composeHandlers(first, second)
-  const result = composed('fallback' as any, 'arg2' as any)
-
-  expect(result).toBe('fallback')
-})
-
-test('returns args[0] when no handlers are provided', () => {
-  const composed = composeHandlers()
-  const result = composed('fallback' as any, 'arg2' as any)
-  expect(result).toBe('fallback')
-})
-
-
-test('passes all arguments to each handler', () => {
-  const first = jest.fn().mockReturnValue(undefined)
-  const second = jest.fn().mockReturnValue('second')
-  const composed = composeHandlers(first, second)
-  composed('arg1' as any, 'arg2' as any)
-  expect(first).toHaveBeenCalledWith('arg1', 'arg2')
-  expect(second).toHaveBeenCalledWith('arg1', 'arg2')
-})

package/test/unit/services/progress-internal/bubble.test.ts

@@ -1,279 +0,0 @@
-let mockProgressRecords: any[] = []
-let mockRecordProgressMany = jest.fn()
-let mockEraseProgressMany = jest.fn()
-
-const repoMocks = {
-  contentProgress: {
-    getSomeProgressByContentIds: jest.fn().mockImplementation((contentIds: number[]) => {
-      const records = mockProgressRecords.filter((r) => contentIds.includes(r.content_id))
-      return Promise.resolve({ data: records })
-    }),
-    recordProgressMany: mockRecordProgressMany,
-    eraseProgressMany: mockEraseProgressMany,
-  },
-}
-
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({
-  __esModule: true,
-  default: repoMocks,
-  ...repoMocks,
-}))
-
-import {
-  averageProgressesFor,
-  bubbleAndTrickleProgressesSafely,
-  bubbleProgress,
-  computeBubbleTrickleProgresses,
-  filterOutNegativeProgress,
-  getAncestorAndSiblingIds,
-  getChildrenToDepth,
-  trickleProgress,
-} from '../../../../src/services/progress/internal/bubble'
-import type { Hierarchy } from '../../../../src/services/progress/types'
-import { COLLECTION_TYPE } from '../../../../src/services/sync/models/ContentProgress'
-
-beforeEach(() => {
-  jest.clearAllMocks()
-  mockProgressRecords = []
-  mockRecordProgressMany.mockResolvedValue({ data: null })
-  mockEraseProgressMany.mockResolvedValue({ data: null })
-})
-
-describe('filterOutNegativeProgress', () => {
-  test('drops entry when new progress is less than existing', () => {
-    const result = filterOutNegativeProgress(
-      { 101: 30 },
-      { 101: { progress: 70, last_update: 0, status: 'started' } }
-    )
-    expect(result).not.toHaveProperty('101')
-  })
-
-  test('keeps entry when new progress equals existing', () => {
-    const result = filterOutNegativeProgress(
-      { 101: 50 },
-      { 101: { progress: 50, last_update: 0, status: 'started' } }
-    )
-    expect(result[101]).toBe(50)
-  })
-
-  test('keeps entry when new progress is greater than existing', () => {
-    const result = filterOutNegativeProgress(
-      { 101: 80 },
-      { 101: { progress: 50, last_update: 0, status: 'started' } }
-    )
-    expect(result[101]).toBe(80)
-  })
-
-  test('keeps entry when no existing snapshot', () => {
-    const result = filterOutNegativeProgress({ 101: 10 }, {})
-    expect(result[101]).toBe(10)
-  })
-
-  test('drops only entries below existing, keeps others in mixed set', () => {
-    const result = filterOutNegativeProgress(
-      { 101: 20, 102: 80, 103: 40 },
-      {
-        101: { progress: 70, last_update: 0, status: 'started' },
-        102: { progress: 20, last_update: 0, status: 'started' },
-        103: { progress: 0, last_update: 0, status: '' },
-      }
-    )
-    expect(result).not.toHaveProperty('101')
-    expect(result[102]).toBe(80)
-    expect(result[103]).toBe(40)
-  })
-
-  test('returns new object, does not mutate input', () => {
-    const progresses = { 101: 10 }
-    const result = filterOutNegativeProgress(progresses, {
-      101: { progress: 50, last_update: 0, status: 'started' },
-    })
-    expect(result).not.toBe(progresses)
-    expect(progresses[101]).toBe(10)
-  })
-})
-
-describe('getChildrenToDepth', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1, 3: 1, 4: 2 },
-    children: { 1: [2, 3], 2: [4], 3: [], 4: [] },
-  }
-
-  test('returns direct children', () => {
-    expect(getChildrenToDepth(1, hierarchy)).toEqual(expect.arrayContaining([2, 3]))
-  })
-
-  test('returns empty when no children', () => {
-    expect(getChildrenToDepth(4, hierarchy)).toEqual([])
-  })
-
-  test('returns empty for unknown parent', () => {
-    expect(getChildrenToDepth(99, hierarchy)).toEqual([])
-  })
-})
-
-describe('getAncestorAndSiblingIds', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1, 3: 1, 4: 2, 5: 2 },
-    children: { 1: [2, 3], 2: [4, 5] },
-  }
-
-  test('returns siblings and parent for child node', () => {
-    const result = getAncestorAndSiblingIds(hierarchy, 4)
-    expect(result).toEqual(expect.arrayContaining([5, 2]))
-  })
-
-  test('returns empty for root', () => {
-    expect(getAncestorAndSiblingIds(hierarchy, 1)).toEqual([])
-  })
-
-  test('handles circular dependency without infinite loop', () => {
-    const circular: Hierarchy = { parents: { 1: 1 }, children: { 1: [] } }
-    expect(getAncestorAndSiblingIds(circular, 1)).toEqual([])
-  })
-})
-
-describe('averageProgressesFor', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1, 3: 1, 4: 2, 5: 2 },
-    children: { 1: [2, 3], 2: [4, 5] },
-  }
-
-  test('averages child progresses up the chain', () => {
-    const progress = new Map<number, number>([
-      [4, 100],
-      [5, 0],
-      [2, 50],
-      [3, 50],
-    ])
-    const result = averageProgressesFor(hierarchy, 4, progress)
-    expect(result[2]).toBe(50)
-    expect(result[1]).toBe(50)
-  })
-
-  test('returns empty for root', () => {
-    expect(averageProgressesFor(hierarchy, 1, new Map())).toEqual({})
-  })
-
-  test('treats missing child progress as 0', () => {
-    const progress = new Map<number, number>([[4, 80]])
-    const result = averageProgressesFor(hierarchy, 4, progress)
-    expect(result[2]).toBe(40)
-  })
-})
-
-describe('trickleProgress', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1, 3: 1, 4: 2 },
-    children: { 1: [2, 3], 2: [4], 3: [], 4: [] },
-  }
-
-  test('returns descendants with given progress', () => {
-    const result = trickleProgress(hierarchy, 1, 75)
-    expect(result[2]).toBe(75)
-    expect(result[3]).toBe(75)
-  })
-
-  test('returns empty when no descendants', () => {
-    expect(trickleProgress(hierarchy, 4, 100)).toEqual({})
-  })
-})
-
-describe('bubbleProgress', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1, 3: 1 },
-    children: { 1: [2, 3] },
-  }
-
-  test('aggregates sibling progresses into parent', async () => {
-    mockProgressRecords = [
-      { content_id: 2, progress_percent: 100 },
-      { content_id: 3, progress_percent: 0 },
-    ]
-    const result = await bubbleProgress(hierarchy, 2)
-    expect(result[1]).toBe(50)
-  })
-})
-
-describe('computeBubbleTrickleProgresses', () => {
-  const hierarchy: Hierarchy = {
-    parents: { 2: 1 },
-    children: { 1: [2], 2: [] },
-  }
-
-  test('combines bubble and trickle', async () => {
-    mockProgressRecords = [{ content_id: 2, progress_percent: 80 }]
-    const result = await computeBubbleTrickleProgresses(2, 80, hierarchy)
-    expect(result[1]).toBe(80)
-  })
-
-  test('respects { bubble: false }', async () => {
-    mockProgressRecords = [{ content_id: 2, progress_percent: 80 }]
-    const result = await computeBubbleTrickleProgresses(2, 80, hierarchy, undefined, {
-      bubble: false,
-    })
-    expect(result).not.toHaveProperty('1')
-  })
-
-  test('respects { trickle: false }', async () => {
-    const result = await computeBubbleTrickleProgresses(1, 50, hierarchy, undefined, {
-      trickle: false,
-    })
-    expect(result).not.toHaveProperty('2')
-  })
-})
-
-describe('bubbleAndTrickleProgressesSafely', () => {
-  test('passes positive progresses to recordProgressMany', async () => {
-    await bubbleAndTrickleProgressesSafely({ 1: 50, 2: 100 }, {})
-    expect(mockRecordProgressMany).toHaveBeenCalledWith(
-      { 1: 50, 2: 100 },
-      undefined,
-      {},
-      { skipPush: true, accessedDirectly: true, allowRegression: true }
-    )
-    expect(mockEraseProgressMany).not.toHaveBeenCalled()
-  })
-
-  test('isResetAction separates zero progresses into eraseProgressMany', async () => {
-    await bubbleAndTrickleProgressesSafely(
-      { 1: 50, 2: 0, 3: 0 },
-      {},
-      { isResetAction: true }
-    )
-    expect(mockRecordProgressMany).toHaveBeenCalledWith(
-      { 1: 50 },
-      undefined,
-      {},
-      expect.objectContaining({ allowRegression: true })
-    )
-    expect(mockEraseProgressMany).toHaveBeenCalledWith([2, 3], undefined, { skipPush: true })
-  })
-
-  test('forwards collection argument', async () => {
-    const collection = { type: COLLECTION_TYPE.LEARNING_PATH, id: 10 }
-    await bubbleAndTrickleProgressesSafely({ 1: 50 }, {}, {}, collection)
-    expect(mockRecordProgressMany).toHaveBeenCalledWith(
-      { 1: 50 },
-      collection,
-      {},
-      expect.anything()
-    )
-  })
-
-  test('forwards accessedDirectly option', async () => {
-    await bubbleAndTrickleProgressesSafely({ 1: 50 }, {}, { accessedDirectly: false })
-    expect(mockRecordProgressMany).toHaveBeenCalledWith(
-      { 1: 50 },
-      undefined,
-      {},
-      expect.objectContaining({ accessedDirectly: false })
-    )
-  })
-
-  test('skips both calls when all empty', async () => {
-    await bubbleAndTrickleProgressesSafely({}, {})
-    expect(mockRecordProgressMany).not.toHaveBeenCalled()
-    expect(mockEraseProgressMany).not.toHaveBeenCalled()
-  })
-})