musora-content-services 2.167.2 → 2.167.3

package/test/unit/sync/store/push-coalescer.test.ts

@@ -1,156 +0,0 @@
-import PushCoalescer from '@/services/sync/store/push-coalescer'
-import type BaseModel from '@/services/sync/models/Base'
-import type { SyncPushResponse } from '@/services/sync/fetch'
-
-const BASE_TIME = 1700000000000
-const SUCCESS_RESPONSE: SyncPushResponse = { ok: true, results: [] }
-
-class TestSetup {
-  coalescer = new PushCoalescer()
-
-  record(id: string, timeOffset = 0): BaseModel {
-    return { id, updated_at: BASE_TIME + timeOffset } as unknown as BaseModel
-  }
-
-  mockPusher() {
-    return jest.fn().mockReturnValue(new Promise(() => {}))
-  }
-
-  controllablePusher() {
-    let resolve!: (value: SyncPushResponse) => void
-    let reject!: (error: Error) => void
-
-    const promise = new Promise<SyncPushResponse>((res, rej) => {
-      resolve = res
-      reject = rej
-    })
-
-    return {
-      pusher: jest.fn().mockReturnValue(promise),
-      resolve: () => resolve(SUCCESS_RESPONSE),
-      reject: (error: Error) => reject(error)
-    }
-  }
-}
-
-let setup: TestSetup
-beforeEach(() => {
-  setup = new TestSetup()
-})
-
-describe('coalescing behavior', () => {
-  describe('when to coalesce', () => {
-    test('identical records return same promise', () => {
-      const records = [setup.record('rec-1')]
-      const pusher = setup.mockPusher()
-
-      const p1 = setup.coalescer.push(records, pusher)
-      const p2 = setup.coalescer.push(records, pusher)
-
-      expect(p1).toBe(p2)
-      expect(pusher).toHaveBeenCalledTimes(1)
-    })
-
-    test('same timestamp coalesces', () => {
-      const pusher = setup.mockPusher()
-      const p1 = setup.coalescer.push([setup.record('rec-1')], pusher)
-      const p2 = setup.coalescer.push([setup.record('rec-1')], pusher)
-
-      expect(p1).toBe(p2)
-      expect(pusher).toHaveBeenCalledTimes(1)
-    })
-
-    test('all records must match for multi-record coalescing', () => {
-      const pusher = setup.mockPusher()
-      const records = [setup.record('rec-1'), setup.record('rec-2')]
-
-      const p1 = setup.coalescer.push(records, pusher)
-      const p2 = setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2')], pusher)
-
-      expect(p1).toBe(p2)
-      expect(pusher).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('when NOT to coalesce', () => {
-    test('newer timestamp triggers new push', () => {
-      const pusher = setup.mockPusher()
-
-      setup.coalescer.push([setup.record('rec-1')], pusher)
-      setup.coalescer.push([setup.record('rec-1', 1)], pusher) // +1ms newer
-
-      expect(pusher).toHaveBeenCalledTimes(2)
-    })
-
-    test('different record IDs trigger separate pushes', () => {
-      const pusher = setup.mockPusher()
-
-      setup.coalescer.push([setup.record('rec-1')], pusher)
-      setup.coalescer.push([setup.record('rec-2')], pusher)
-
-      expect(pusher).toHaveBeenCalledTimes(2)
-    })
-
-    test('partial record match prevents coalescing', () => {
-      const pusher = setup.mockPusher()
-
-      setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2')], pusher)
-      setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2', 1)], pusher) // rec-2 newer
-
-      expect(pusher).toHaveBeenCalledTimes(2)
-    })
-  })
-})
-
-describe('intent lifecycle', () => {
-  test('cleans up after successful push', async () => {
-    const { pusher, resolve } = setup.controllablePusher()
-    const records = [setup.record('rec-1')]
-
-    setup.coalescer.push(records, pusher)
-    resolve()
-    await Promise.resolve() // flush cleanup
-
-    // Should trigger new push since intent was cleaned up
-    const newPusher = setup.mockPusher()
-    setup.coalescer.push(records, newPusher)
-    expect(newPusher).toHaveBeenCalled()
-  })
-
-  test('cleans up after failed push', async () => {
-    const { pusher, reject } = setup.controllablePusher()
-    const records = [setup.record('rec-1')]
-
-    const promise = setup.coalescer.push(records, pusher)
-    promise.catch(() => {}) // prevent unhandled rejection
-
-    reject(new Error('push failed'))
-    await Promise.resolve()
-
-    const newPusher = setup.mockPusher()
-    setup.coalescer.push(records, newPusher)
-    expect(newPusher).toHaveBeenCalled()
-  })
-
-  test('coalesces while intent is in-flight', () => {
-    const { pusher } = setup.controllablePusher()
-    const records = [setup.record('rec-1')]
-
-    const p1 = setup.coalescer.push(records, pusher)
-    const p2 = setup.coalescer.push(records, setup.mockPusher())
-
-    expect(p1).toBe(p2) // Same promise returned
-  })
-})
-
-describe('edge cases', () => {
-  test('empty record arrays coalesce', () => {
-    const pusher = setup.mockPusher()
-
-    const p1 = setup.coalescer.push([], pusher)
-    const p2 = setup.coalescer.push([], pusher)
-
-    expect(p1).toBe(p2)
-    expect(pusher).toHaveBeenCalledTimes(1)
-  })
-})

package/test/unit/sync/store-configs.test.ts

@@ -1,37 +0,0 @@
-jest.mock('../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../src/services/sync/repository-proxy', () => ({ db: {} }))
-jest.mock('../../../src/services/sync/fetch', () => ({
-  handlePull: jest.fn(() => jest.fn()),
-  handlePush: jest.fn(() => jest.fn()),
-  makeFetchRequest: jest.fn(() => jest.fn()),
-}))
-import createStoresFromConfig from '../../../src/services/sync/store-configs'
-import ContentProgress from '../../../src/services/sync/models/ContentProgress'
-describe('createStoresFromConfig', () => {
-  const configs = createStoresFromConfig()
-  const progressConfig = configs.find(c => c.model === ContentProgress)!
-  const comparator = progressConfig.comparator!
-  describe('ContentProgress comparator', () => {
-    test('returns SERVER when server progress_percent is higher', () => {
-      const result = comparator(
-        { record: { progress_percent: 80 }, meta: { lifecycle: { updated_at: 1000 } } } as any,
-        { progress_percent: 50, updated_at: 2000 } as any
-      )
-      expect(result).toBe('SERVER')
-    })
-    test('returns LOCAL when local progress_percent is higher', () => {
-      const result = comparator(
-        { record: { progress_percent: 50 }, meta: { lifecycle: { updated_at: 2000 } } } as any,
-        { progress_percent: 80, updated_at: 1000 } as any
-      )
-      expect(result).toBe('LOCAL')
-    })
-    test('returns SERVER when server updated_at is newer and either side is 0', () => {
-      const result = comparator(
-        { record: { progress_percent: 0 }, meta: { lifecycle: { updated_at: 2000 } } } as any,
-        { progress_percent: 50, updated_at: 1000 } as any
-      )
-      expect(result).toBe('SERVER')
-    })
-  })
-})

package/test/unit/sync/telemetry/sync-telemetry.test.ts

@@ -1,118 +0,0 @@
-import { SyncTelemetry, SeverityLevel } from '../../../../src/services/sync/telemetry/index'
-import { SyncError, SyncUnexpectedError } from '../../../../src/services/sync/errors/index'
-import { makeUserScope } from '../helpers/index'
-const makeSentry = () => ({
-  captureException: jest.fn(),
-  captureMessage: jest.fn(),
-  addBreadcrumb: jest.fn(),
-  startSpan: jest.fn(),
-  logger: {
-    debug: jest.fn(),
-    info: jest.fn(),
-  },
-})
-const makeTelemetry = (level = SeverityLevel.DEBUG) => {
-  const sentry = makeSentry()
-  const telemetry = new SyncTelemetry(makeUserScope(), {
-    Sentry: sentry,
-    level,
-    pretty: false,
-  })
-  return { telemetry, sentry }
-}
-describe('SyncTelemetry', () => {
-  afterEach(() => {
-    SyncTelemetry.clearInstance()
-  })
-  describe('static methods', () => {
-    test('setInstance and getInstance round-trip', () => {
-      const { telemetry } = makeTelemetry()
-      SyncTelemetry.setInstance(telemetry)
-      expect(SyncTelemetry.getInstance()).toBe(telemetry)
-    })
-    test('clearInstance sets instance to null', () => {
-      const { telemetry } = makeTelemetry()
-      SyncTelemetry.setInstance(telemetry)
-      SyncTelemetry.clearInstance()
-      expect(SyncTelemetry.getInstance()).toBeNull()
-    })
-    test('isSyncConsoleMessage returns true for sync-prefixed messages', () => {
-      expect(SyncTelemetry.isSyncConsoleMessage(['📡 SYNC: something'])).toBe(true)
-    })
-    test('isSyncConsoleMessage returns false for non-sync messages', () => {
-      expect(SyncTelemetry.isSyncConsoleMessage(['regular message'])).toBe(false)
-    })
-  })
-  describe('capture', () => {
-    // BUG: condition checks `err instanceof SyncUnexpectedError` but err is the original Error,
-    // not the wrapped one. mechanism: { handled: false } is never triggered for plain Errors.
-    // Should be checking `wrapped instanceof SyncUnexpectedError` instead.
-    test('calls captureException with undefined when err is a plain Error', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      const error = new Error('raw error')
-      telemetry.capture(error)
-      expect(sentry.captureException).toHaveBeenCalledWith(error, undefined)
-    })
-    test('passes mechanism handled:false when err is SyncUnexpectedError', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      const error = new SyncUnexpectedError('unexpected')
-      telemetry.capture(error)
-      expect(sentry.captureException).toHaveBeenCalledWith(error, { mechanism: { handled: false } })
-    })
-    test('passes SyncError directly without wrapping', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      const error = new SyncError('sync error')
-      telemetry.capture(error)
-      expect(sentry.captureException).toHaveBeenCalledWith(error, undefined)
-    })
-    test('marks error as reported after capture', () => {
-      const { telemetry } = makeTelemetry()
-      const error = new SyncError('sync error')
-      telemetry.capture(error)
-      expect(error.isReported()).toBe(true)
-    })
-  })
-  describe('ignoreLike and shouldIgnoreMessage', () => {
-    test('ignoreLike with string suppresses matching messages', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      telemetry.ignoreLike('ignored message')
-      telemetry.debug('ignored message')
-      expect(sentry.addBreadcrumb).not.toHaveBeenCalled()
-    })
-    test('ignoreLike with RegExp suppresses matching messages', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      telemetry.ignoreLike(/ignore.*/)
-      telemetry.debug('ignore this')
-      expect(sentry.addBreadcrumb).not.toHaveBeenCalled()
-    })
-    test('shouldIgnoreRejection returns true for matching error', () => {
-      const { telemetry } = makeTelemetry()
-      telemetry.ignoreLike('abort')
-      expect(telemetry.shouldIgnoreRejection(new Error('abort error'))).toBe(true)
-    })
-    test('shouldIgnoreException returns true for matching Error', () => {
-      const { telemetry } = makeTelemetry()
-      telemetry.ignoreLike('abort')
-      expect(telemetry.shouldIgnoreException(new Error('abort error'))).toBe(true)
-    })
-  })
-  describe('level filtering', () => {
-    test('debug does not call Sentry when level is above DEBUG', () => {
-      const { telemetry, sentry } = makeTelemetry(SeverityLevel.ERROR)
-      telemetry.debug('debug message')
-      expect(sentry.addBreadcrumb).not.toHaveBeenCalled()
-    })
-    test('warn calls captureException with correct level', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      const error = new Error('warn error')
-      telemetry.warn(error)
-      expect(sentry.captureException).toHaveBeenCalledWith(error, { level: 'warning' })
-    })
-    test('error calls captureException with correct level', () => {
-      const { telemetry, sentry } = makeTelemetry()
-      const error = new Error('error message')
-      telemetry.error(error)
-      expect(sentry.captureException).toHaveBeenCalledWith(error, { level: 'error' })
-    })
-  })
-})

package/test/unit/sync/utils/event-emitter.test.ts

@@ -1,64 +0,0 @@
-import EventEmitter from '../../../../src/services/sync/utils/event-emitter'
-type TestEvents = {
-  data: [string]
-  update: [number, boolean]
-}
-describe('EventEmitter', () => {
-  let emitter: EventEmitter<TestEvents>
-  beforeEach(() => {
-    emitter = new EventEmitter()
-  })
-  test('on registers a listener and returns an unsubscribe function', () => {
-    const listener = jest.fn()
-    const unsubscribe = emitter.on('data', listener)
-    expect(typeof unsubscribe).toBe('function')
-  })
-  test('emit calls all registered listeners with correct args', () => {
-    const listener = jest.fn()
-    emitter.on('data', listener)
-    emitter.emit('data', 'hello')
-    expect(listener).toHaveBeenCalledWith('hello')
-  })
-  test('off with a specific function removes only that listener', () => {
-    const first = jest.fn()
-    const second = jest.fn()
-    emitter.on('data', first)
-    emitter.on('data', second)
-    emitter.off('data', first)
-    emitter.emit('data', 'hello')
-    expect(first).not.toHaveBeenCalled()
-    expect(second).toHaveBeenCalledWith('hello')
-  })
-  test('off without a function removes all listeners for that event', () => {
-    const first = jest.fn()
-    const second = jest.fn()
-    emitter.on('data', first)
-    emitter.on('data', second)
-    emitter.off('data')
-    emitter.emit('data', 'hello')
-    expect(first).not.toHaveBeenCalled()
-    expect(second).not.toHaveBeenCalled()
-  })
-  test('unsubscribe function returned by on removes the listener', () => {
-    const listener = jest.fn()
-    const unsubscribe = emitter.on('data', listener)
-    unsubscribe()
-    emitter.emit('data', 'hello')
-    expect(listener).not.toHaveBeenCalled()
-  })
-  test('emit on an event with no listeners does nothing', () => {
-    expect(() => emitter.emit('data', 'hello')).not.toThrow()
-  })
-  test('multiple listeners on same event all receive the emit', () => {
-    const first = jest.fn()
-    const second = jest.fn()
-    const third = jest.fn()
-    emitter.on('data', first)
-    emitter.on('data', second)
-    emitter.on('data', third)
-    emitter.emit('data', 'hello')
-    expect(first).toHaveBeenCalledWith('hello')
-    expect(second).toHaveBeenCalledWith('hello')
-    expect(third).toHaveBeenCalledWith('hello')
-  })
-})

package/test/unit/sync/utils/throttle.test.ts

@@ -1,245 +0,0 @@
-import { createThrottleState, dropThrottle, queueThrottle } from '@/services/sync/utils/throttle'
-
-// ---
-
-beforeEach(() => {
-  jest.useFakeTimers()
-})
-
-afterEach(() => {
-  jest.useRealTimers()
-})
-
-// ---
-
-describe('createThrottleState', () => {
-  test('initialises with correct defaults', () => {
-    const state = createThrottleState(1000)
-
-    expect(state.minIntervalMs).toBe(1000)
-    expect(state.isWaiting).toBe(false)
-    expect(state.current).toBeNull()
-    expect(state.next).toBeNull()
-    expect(state.lastCallTime).toBe(0)
-  })
-})
-
-// ---
-
-describe('dropThrottle', () => {
-  test('calls fn immediately on first invocation', async () => {
-    const fn = jest.fn().mockResolvedValue('result')
-    const state = createThrottleState(1000)
-    const throttled = dropThrottle({ state }, fn)
-
-    const p = throttled()
-    jest.runAllTimers()
-    await p
-
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-
-  test('returns same promise for concurrent calls', async () => {
-    const fn = jest.fn().mockResolvedValue('result')
-    const state = createThrottleState(1000)
-    const throttled = dropThrottle({ state }, fn)
-
-    const p1 = throttled()
-    const p2 = throttled()
-
-    expect(p1).toBe(p2)
-
-    await jest.runAllTimersAsync()
-
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-
-  test('drops second call when one is already in-flight', async () => {
-    const fn = jest.fn().mockResolvedValue('result')
-    const state = createThrottleState(0)
-    const throttled = dropThrottle({ state }, fn)
-
-    const p1 = throttled()
-    jest.runAllTimers()
-    await p1
-
-    const p2 = throttled()
-    jest.runAllTimers()
-    await p2
-
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('waits minIntervalMs before next call', async () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(500)
-    const throttled = dropThrottle({ state }, fn)
-
-    const p1 = throttled()
-    jest.runAllTimers()
-    await p1
-
-    // Second call — interval not elapsed yet, so wait is triggered
-    const p2 = throttled()
-    expect(fn).toHaveBeenCalledTimes(1)
-
-    jest.advanceTimersByTime(500)
-    await p2
-
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('deferOnce queues next call while current is running', async () => {
-    let resolveFirst!: () => void
-    const firstPromise = new Promise<string>(res => { resolveFirst = () => res('first') })
-    const fn = jest.fn()
-      .mockReturnValueOnce(firstPromise)
-      .mockResolvedValue('second')
-
-    const state = createThrottleState(0)
-    const throttled = dropThrottle({ state, deferOnce: true }, fn)
-
-    throttled() // first call — starts wait phase
-
-    await jest.runAllTimersAsync() // flush wait → fn is now called and in-flight, isWaiting = false
-    expect(fn).toHaveBeenCalledTimes(1)
-
-    throttled() // second call — deferOnce queues it now that isWaiting is false
-
-    resolveFirst()
-    await jest.runAllTimersAsync()
-
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('deferOnce does not queue when already waiting', () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(1000)
-    const throttled = dropThrottle({ state, deferOnce: true }, fn)
-
-    throttled() // starts wait, sets isWaiting = true
-    throttled() // isWaiting is true — does not queue
-    throttled() // isWaiting is true — does not queue
-
-    expect(state.next).toBeNull()
-    expect(fn).toHaveBeenCalledTimes(0) // still waiting
-  })
-
-  test('sets lastCallTime after execution', async () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(0)
-    const throttled = dropThrottle({ state }, fn)
-
-    const before = Date.now()
-    const p = throttled()
-    jest.runAllTimers()
-    await p
-
-    expect(state.lastCallTime).toBeGreaterThanOrEqual(before)
-  })
-})
-
-// ---
-
-describe('queueThrottle', () => {
-  test('calls fn immediately on first invocation', async () => {
-    const fn = jest.fn().mockResolvedValue('result')
-    const state = createThrottleState(0)
-    const throttled = queueThrottle({ state }, fn)
-
-    const p = throttled()
-    jest.runAllTimers()
-    await p
-
-    expect(fn).toHaveBeenCalledTimes(1)
-  })
-
-  test('queues second call while first is in-flight', async () => {
-    let resolveFirst!: () => void
-    const firstDone = new Promise<string>(res => { resolveFirst = () => res('first') })
-    const fn = jest.fn()
-      .mockReturnValueOnce(firstDone)
-      .mockResolvedValue('second')
-
-    const state = createThrottleState(0)
-    const throttled = queueThrottle({ state }, fn)
-
-    throttled() // first — in-flight
-    throttled() // second — queued
-
-    expect(fn).toHaveBeenCalledTimes(1)
-
-    resolveFirst()
-    await jest.runAllTimersAsync()
-
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('second call overwrites queued next (only one queued at a time)', async () => {
-    let resolveFirst!: () => void
-    const firstDone = new Promise<string>(res => { resolveFirst = () => res('first') })
-    const fn = jest.fn()
-      .mockReturnValueOnce(firstDone)
-      .mockResolvedValue('later')
-
-    const state = createThrottleState(0)
-    const throttled = queueThrottle({ state }, fn)
-
-    throttled()
-    throttled() // queued as next
-    throttled() // overwrites next
-
-    expect(fn).toHaveBeenCalledTimes(1)
-    expect(state.next).not.toBeNull()
-
-    resolveFirst()
-    await jest.runAllTimersAsync()
-
-    // Only one more call (the last queued), not two
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('returns current promise for concurrent calls', () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(0)
-    const throttled = queueThrottle({ state }, fn)
-
-    const p1 = throttled()
-    const p2 = throttled()
-
-    expect(p1).toBe(p2)
-  })
-
-  test('respects minIntervalMs between calls', async () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(500)
-    const throttled = queueThrottle({ state }, fn)
-
-    const p1 = throttled()
-    jest.runAllTimers()
-    await p1
-
-    const before = Date.now()
-    jest.advanceTimersByTime(100) // only 100ms since last call
-
-    const p2 = throttled()
-    expect(fn).toHaveBeenCalledTimes(1) // not called yet — waiting for interval
-
-    jest.advanceTimersByTime(400) // now 500ms elapsed
-    await p2
-
-    expect(fn).toHaveBeenCalledTimes(2)
-  })
-
-  test('clears current after completion', async () => {
-    const fn = jest.fn().mockResolvedValue('ok')
-    const state = createThrottleState(0)
-    const throttled = queueThrottle({ state }, fn)
-
-    const p = throttled()
-    jest.runAllTimers()
-    await p
-
-    expect(state.current).toBeNull()
-  })
-})

package/test/unit/url-builder.test.ts

@@ -1,72 +0,0 @@
-import { generateForumPostUrl, generatePlaylistUrl, generateContentUrl } from '../../src/services/urlBuilder'
-jest.mock('../../src/services/config.js', () => ({
-  globalConfig: { frontendUrl: 'https://www.musora.com' }
-}))
-jest.mock('../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../src/services/sanity.js'),
-  fetchByRailContentIds: jest.fn(),
-}))
-jest.mock('../../src/services/contentProgress.js', () => ({
-  getNavigateTo: jest.fn(),
-}))
-describe('generateForumPostUrl', () => {
-  test('returns path without domain by default', () => {
-    const result = generateForumPostUrl({ brand: 'drumeo' })
-    expect(result).toBe('/drumeo/forums/jump-to-post/')
-  })
-  test('returns full URL with domain when withDomain is true', () => {
-    const result = generateForumPostUrl({ brand: 'drumeo' }, true)
-    expect(result).toBe('https://www.musora.com/drumeo/forums/jump-to-post/')
-  })
-})
-
-describe('generatePlaylistUrl', () => {
-  test('returns /playlists/{id} without domain', () => {
-    const result = generatePlaylistUrl({ id: 123 })
-    expect(result).toBe('/playlists/123')
-  })
-  test('returns full URL with domain when withDomain is true', () => {
-    const result = generatePlaylistUrl({ id: 123 }, true)
-    expect(result).toBe('https://www.musora.com/playlists/123')
-  })
-})
-
-describe('generateContentUrl', () => {
-  test('returns /{brand}/method for type method', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'method', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/method')
-  })
-  test('returns # when id is missing', async () => {
-    const result = await generateContentUrl({ id: 0, type: 'song', brand: 'drumeo' })
-    expect(result).toBe('#')
-  })
-  test('returns /{brand}/lessons/{id}/live for type live', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'live', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/lessons/123/live')
-  })
-  test('returns /{brand}/lessons/course-collection/overview/{id} for type course-collection', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'course-collection', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/lessons/course-collection/overview/123')
-  })
-  test('returns /{brand}/lessons/pack/{id} for type pack', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'pack', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/lessons/pack/123')
-  })
-  test('returns /{brand}/lessons/pack-bundle/{id}/{navigateTo.id} for pack-bundle with navigateTo', async () => {
-    const result = await generateContentUrl({
-      id: 123,
-      type: 'pack-bundle',
-      brand: 'drumeo',
-      navigateTo: { id: 456 }
-    })
-    expect(result).toBe('/drumeo/lessons/pack-bundle/123/456')
-  })
-  test('returns /{brand}/lessons/pack-bundle/{id} for pack-bundle without navigateTo', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'pack-bundle', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/lessons/pack-bundle/123')
-  })
-  test('returns /{brand}/songs/transcription/{id} for type song', async () => {
-    const result = await generateContentUrl({ id: 123, type: 'song', brand: 'drumeo' })
-    expect(result).toBe('/drumeo/songs/transcription/123')
-  })
-})