musora-content-services 2.157.2 → 2.158.0

package/test/unit/sync/run-scope.test.ts

@@ -0,0 +1,23 @@
+import SyncRunScope from '../../../src/services/sync/run-scope'
+import { SyncAbortError } from '../../../src/services/sync/errors/index'
+describe('SyncRunScope', () => {
+  let scope: SyncRunScope
+  beforeEach(() => {
+    scope = new SyncRunScope()
+  })
+  test('signal returns the AbortSignal', () => {
+    expect(scope.signal).toBeInstanceOf(AbortSignal)
+  })
+  test('abort aborts the signal', () => {
+    scope.abort('test reason')
+    expect(scope.signal.aborted).toBe(true)
+  })
+  test('abortable runs fn when not aborted and returns result', async () => {
+    const result = await scope.abortable(() => Promise.resolve('hello'))
+    expect(result).toBe('hello')
+  })
+  test('abortable rejects with SyncAbortError when already aborted', async () => {
+    scope.abort('cancelled')
+    await expect(scope.abortable(() => Promise.resolve('hello'))).rejects.toThrow(SyncAbortError)
+  })
+})

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,64 @@
+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/url-builder.test.ts

@@ -0,0 +1,72 @@
+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')
+  })
+})