musora-content-services 2.167.2 → 2.167.3

package/test/integration/notifications.test.ts

@@ -1,178 +0,0 @@
-import { initializeTestService } from '../initializeTests.js'
-import * as UserNotifications from "../../src/services/user/notifications.js";
-
-jest.mock('../../src/infrastructure/http/HttpClient.ts', () => ({
-  GET: jest.fn(),
-  POST: jest.fn(),
-  PUT: jest.fn(),
-  PATCH: jest.fn(),
-  DELETE: jest.fn(),
-  HttpClient: jest.fn(),
-}))
-
-jest.mock('../../src/services/railcontent.js', () => ({
-  fetchUserPermissionsData: jest.fn(() => ({ permissions: [78, 91, 92], isAdmin: false })),
-  fetchHandler: jest.fn(),
-}))
-
-jest.mock('../../src/services/eventsAPI.js', () => ({
-  __esModule: true,
-  default: {
-    pauseLiveEventCheck: jest.fn().mockResolvedValue(undefined),
-  }
-}))
-
-import { GET, PUT, DELETE } from '../../src/infrastructure/http/HttpClient'
-
-const baseUrl = `/api/notifications`
-
-describe('UserNotifications module', function () {
-  beforeEach(() => {
-    initializeTestService()
-  })
-
-  describe('fetchNotifications', () => {
-    it('calls GET with correct url', async () => {
-      GET.mockResolvedValueOnce([{ id: 1 }])
-
-      const result = await UserNotifications.fetchNotifications({
-        limit: 5,
-        onlyUnread: true,
-        page: 2,
-      })
-
-      expect(GET).toHaveBeenCalledWith(`${baseUrl}/v1?limit=5&page=2&unread=1`)
-      expect(result).toEqual([{ id: 1 }])
-    })
-  })
-
-  describe('markNotificationAsRead', () => {
-    it('throws if notificationId not provided', async () => {
-      await expect(UserNotifications.markNotificationAsRead()).rejects.toThrow('notificationId is required')
-    })
-
-    it('calls PUT with correct url', async () => {
-      PUT.mockResolvedValueOnce({ success: true })
-
-      const result = await UserNotifications.markNotificationAsRead(123)
-      expect(PUT).toHaveBeenCalledWith(`${baseUrl}/v1/read?id=123`, null)
-      expect(result).toEqual({ success: true })
-    })
-  })
-
-  describe('markAllNotificationsAsRead', () => {
-    it('calls PUT with correct url', async () => {
-      PUT.mockResolvedValueOnce({ success: true })
-
-      const result = await UserNotifications.markAllNotificationsAsRead()
-      expect(PUT).toHaveBeenCalledWith(`${baseUrl}/v1/read`, null)
-      expect(result).toEqual({ success: true })
-    })
-  })
-
-  describe('markNotificationAsUnread', () => {
-    it('throws if notificationId not provided', async () => {
-      await expect(UserNotifications.markNotificationAsUnread()).rejects.toThrow('notificationId is required')
-    })
-
-    it('calls PUT with correct url', async () => {
-      PUT.mockResolvedValueOnce({ success: true })
-
-      const result = await UserNotifications.markNotificationAsUnread(456)
-      expect(PUT).toHaveBeenCalledWith(`${baseUrl}/v1/unread?id=456`, null)
-      expect(result).toEqual({ success: true })
-    })
-  })
-
-  describe('deleteNotification', () => {
-    it('throws if notificationId not provided', async () => {
-      await expect(UserNotifications.deleteNotification()).rejects.toThrow('notificationId is required')
-    })
-
-    it('calls DELETE with correct url', async () => {
-      DELETE.mockResolvedValueOnce({ success: true })
-
-      const result = await UserNotifications.deleteNotification(789)
-      expect(DELETE).toHaveBeenCalledWith(`${baseUrl}/v1/789`)
-      expect(result).toEqual({ success: true })
-    })
-  })
-
-  describe('fetchUnreadCount', () => {
-    it('returns unread count when data is greater than 0', async () => {
-      GET.mockResolvedValueOnce({ data: 42 })
-
-      const result = await UserNotifications.fetchUnreadCount()
-      expect(GET).toHaveBeenCalledWith(`${baseUrl}/v1/unread-count`)
-      expect(result).toEqual({ data: 42 })
-    })
-  })
-
-  describe('fetchNotificationSettings', () => {
-    it('returns empty object if settings is falsy or not object', async () => {
-      GET.mockResolvedValueOnce(null)
-      expect(await UserNotifications.fetchNotificationSettings()).toEqual({})
-
-      GET.mockResolvedValueOnce('string')
-      expect(await UserNotifications.fetchNotificationSettings()).toEqual({})
-    })
-
-    it('returns transformed settings grouped by brand', async () => {
-      GET.mockResolvedValueOnce({
-        drumeo: {
-          new_lessons_and_features: { channel: 'email', value: true, brand: 'drumeo' },
-          membership_perks_promotions: { channel: 'push', value: false, brand: 'drumeo' },
-        },
-        pianote: {
-          membership_perks_promotions: { channel: 'email', value: true, brand: 'pianote' },
-        },
-      })
-
-      const result = await UserNotifications.fetchNotificationSettings()
-
-      expect(result).toEqual({
-        drumeo: [
-          { name: 'new_lessons_and_features', channel: 'email', value: true, brand: 'drumeo' },
-          { name: 'membership_perks_promotions', channel: 'push', value: false, brand: 'drumeo' },
-        ],
-        pianote: [{ name: 'membership_perks_promotions', channel: 'email', value: true, brand: 'pianote' }],
-      })
-    })
-  })
-
-  describe('updateNotificationSetting', () => {
-    it('throws if settingName not provided', async () => {
-      await expect(UserNotifications.updateNotificationSetting({ brand: 'drumeo' })).rejects.toThrow(
-        'The "settingName" parameter is required.'
-      )
-    })
-
-    it('throws if no channels provided', async () => {
-      await expect(
-        UserNotifications.updateNotificationSetting({ brand: 'drumeo', settingName: 'new_lesson' })
-      ).rejects.toThrow('At least one channel (email, push, or bell) must be provided.')
-    })
-
-    it('calls PUT with correct payload and url', async () => {
-      PUT.mockResolvedValueOnce({ success: true })
-
-      const result = await UserNotifications.updateNotificationSetting({
-        brand: 'drumeo',
-        settingName: 'membership_perks_promotions',
-        email: true,
-        push: false,
-      })
-
-      expect(PUT).toHaveBeenCalledWith(
-        '/api/notifications/v1/settings',
-        {
-          settings: [
-            { name: 'membership_perks_promotions', channel: 'email', value: true, brand: 'drumeo' },
-            { name: 'membership_perks_promotions', channel: 'push', value: false, brand: 'drumeo' },
-          ],
-        }
-      )
-      expect(result).toEqual({ success: true })
-    })
-  })
-})

package/test/integration/progress-row/content-card.test.ts

@@ -1,283 +0,0 @@
-import { initializeTestDB } from '../initializeTestDB'
-import db from '../../../src/services/sync/repository-proxy'
-
-jest.mock('../../../src/services/sanity.js', () => ({
-  ...jest.requireActual('../../../src/services/sanity.js'),
-  fetchShows: jest.fn(),
-  fetchByRailContentIds: jest.fn(),
-}))
-jest.mock('../../../src/services/contentAggregator.js', () => ({
-  addContextToContent: jest.fn(),
-}))
-jest.mock('../../../src/services/content-org/learning-paths.ts', () =>
-  require('../content-progress/__mocks__/mocks').mockLearningPaths(),
-)
-jest.mock('../../../src/services/awards/internal/content-progress-observer', () =>
-  require('../content-progress/__mocks__/mocks').mockContentProgressObserver(),
-)
-jest.mock('../../../src/services/progress-events', () =>
-  require('../content-progress/__mocks__/mocks').mockProgressEvents(),
-)
-
-import {
-  processContentItem,
-  getCompletedChildren,
-} from '../../../src/services/progress-row/rows/content-card.js'
-import { addContextToContent } from '../../../src/services/contentAggregator.js'
-
-const lessonMeta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
-
-initializeTestDB()
-
-describe('getCompletedChildren', () => {
-  describe('show contentType', () => {
-    test('counts completed shows from addContextToContent result', async () => {
-      ;(addContextToContent as jest.Mock).mockResolvedValue([
-        { id: 1, progressStatus: 'completed' },
-        { id: 2, progressStatus: 'started' },
-        { id: 3, progressStatus: 'completed' },
-        { id: 4, progressStatus: 'not-started' },
-      ])
-      const content = { type: 'boot-camp', brand: 'drumeo' }
-      const result = await getCompletedChildren(content, 'show')
-      expect(result).toEqual({ completedChildren: 2, allChildren: 4 })
-    })
-
-    test('returns zero counts when no shows returned', async () => {
-      ;(addContextToContent as jest.Mock).mockResolvedValue([])
-      const content = { type: 'boot-camp', brand: 'drumeo' }
-      const result = await getCompletedChildren(content, 'show')
-      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
-    })
-
-    test('returns zero completed when no shows have completed status', async () => {
-      ;(addContextToContent as jest.Mock).mockResolvedValue([
-        { id: 1, progressStatus: 'started' },
-        { id: 2, progressStatus: 'not-started' },
-      ])
-      const content = { type: 'boot-camp', brand: 'drumeo' }
-      const result = await getCompletedChildren(content, 'show')
-      expect(result).toEqual({ completedChildren: 0, allChildren: 2 })
-    })
-  })
-
-  describe('non-show with children', () => {
-    test('counts completed children from real DB progress', async () => {
-      await db.contentProgress.recordProgress(101, null, 100, lessonMeta, undefined, { skipPush: true })
-      await db.contentProgress.recordProgress(102, null, 30, lessonMeta, undefined, { skipPush: true })
-      await db.contentProgress.recordProgress(103, null, 100, lessonMeta, undefined, { skipPush: true })
-
-      const content = {
-        type: 'course',
-        children: [{ id: 101 }, { id: 102 }, { id: 103 }],
-      }
-      const result = await getCompletedChildren(content, 'course')
-      expect(result).toEqual({ completedChildren: 2, allChildren: 3 })
-    })
-
-    test('recursively flattens nested children to leaf ids', async () => {
-      await db.contentProgress.recordProgress(201, null, 100, lessonMeta, undefined, { skipPush: true })
-      await db.contentProgress.recordProgress(202, null, 100, lessonMeta, undefined, { skipPush: true })
-      await db.contentProgress.recordProgress(203, null, 50, lessonMeta, undefined, { skipPush: true })
-
-      const content = {
-        type: 'course',
-        children: [
-          { id: 201 },
-          {
-            id: 999,
-            children: [{ id: 202 }, { id: 203 }],
-          },
-        ],
-      }
-      const result = await getCompletedChildren(content, 'course')
-      expect(result).toEqual({ completedChildren: 2, allChildren: 3 })
-    })
-
-    test('returns zero when no children have progress recorded', async () => {
-      const content = {
-        type: 'course',
-        children: [{ id: 901 }, { id: 902 }],
-      }
-      const result = await getCompletedChildren(content, 'course')
-      expect(result).toEqual({ completedChildren: 0, allChildren: 2 })
-    })
-  })
-
-  describe('non-show without children', () => {
-    test('returns zero counts when children is undefined', async () => {
-      const content = { type: 'song' }
-      const result = await getCompletedChildren(content, 'transcription')
-      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
-    })
-
-    test('returns zero counts when children is empty array', async () => {
-      const content = { type: 'song', children: [] }
-      const result = await getCompletedChildren(content, 'transcription')
-      expect(result).toEqual({ completedChildren: 0, allChildren: 0 })
-    })
-  })
-})
-
-describe('processContentItem', () => {
-  test('returns correctly shaped object for a song with no children', async () => {
-    const content = {
-      id: 500,
-      type: 'song',
-      brand: 'drumeo',
-      title: 'Test Song',
-      thumbnail: 'thumb.jpg',
-      progressPercentage: 40,
-      progressStatus: 'started',
-      progressTimestamp: 1700000000,
-      difficulty_string: 'Beginner',
-      artist_name: 'The Band',
-      slug: 'test-song',
-      navigateTo: 'child-slug',
-    }
-    const result = await processContentItem(content)
-    expect(result).toMatchObject({
-      id: 500,
-      progressType: 'content',
-      header: 'transcription',
-      pinned: false,
-      progressTimestamp: 1700000000,
-      body: {
-        progressPercent: 40,
-        thumbnail: 'thumb.jpg',
-        title: 'Test Song',
-        isLive: false,
-        brand: 'drumeo',
-        badge: null,
-        badge_rear: null,
-        badge_logo: null,
-        badge_template: null,
-        badge_template_rear: null,
-        isLocked: false,
-        subtitle: 'Beginner • The Band',
-      },
-      cta: {
-        text: 'Continue',
-        action: {
-          type: 'song',
-          brand: 'drumeo',
-          id: 500,
-          slug: 'test-song',
-          child: 'child-slug',
-        },
-      },
-    })
-  })
-
-  test('sets progressPercent to undefined when isLive=true', async () => {
-    const content = {
-      id: 1,
-      type: 'song',
-      brand: 'drumeo',
-      progressPercentage: 80,
-      isLive: true,
-    }
-    const result = await processContentItem(content)
-    expect(result.body.progressPercent).toBeUndefined()
-    expect(result.body.isLive).toBe(true)
-  })
-
-  test('isLive defaults to false when missing', async () => {
-    const content = { id: 2, type: 'song', brand: 'drumeo', progressPercentage: 50 }
-    const result = await processContentItem(content)
-    expect(result.body.isLive).toBe(false)
-    expect(result.body.progressPercent).toBe(50)
-  })
-
-  test('pinned defaults to false when missing', async () => {
-    const content = { id: 3, type: 'song', brand: 'drumeo' }
-    const result = await processContentItem(content)
-    expect(result.pinned).toBe(false)
-  })
-
-  test('pinned reflects content.pinned when set', async () => {
-    const content = { id: 4, type: 'song', brand: 'drumeo', pinned: true }
-    const result = await processContentItem(content)
-    expect(result.pinned).toBe(true)
-  })
-
-  test('isLocked is false when need_access is missing', async () => {
-    const content = { id: 5, type: 'song', brand: 'drumeo' }
-    const result = await processContentItem(content)
-    expect(result.body.isLocked).toBe(false)
-  })
-
-  test('isLocked is true when need_access is true', async () => {
-    const content = { id: 6, type: 'song', brand: 'drumeo', need_access: true }
-    const result = await processContentItem(content)
-    expect(result.body.isLocked).toBe(true)
-  })
-
-  test('passes through badge fields when set', async () => {
-    const content = {
-      id: 7,
-      type: 'song',
-      brand: 'drumeo',
-      badge: 'badge.png',
-      badge_rear: 'badge-rear.png',
-      badge_logo: 'logo.png',
-      badge_template: 'tpl',
-      badge_template_rear: 'tpl-rear',
-    }
-    const result = await processContentItem(content)
-    expect(result.body).toMatchObject({
-      badge: 'badge.png',
-      badge_rear: 'badge-rear.png',
-      badge_logo: 'logo.png',
-      badge_template: 'tpl',
-      badge_template_rear: 'tpl-rear',
-    })
-  })
-
-  test('populates completed_children/all_children for course with children', async () => {
-    await db.contentProgress.recordProgress(701, null, 100, lessonMeta, undefined, { skipPush: true })
-    await db.contentProgress.recordProgress(702, null, 100, lessonMeta, undefined, { skipPush: true })
-    await db.contentProgress.recordProgress(703, null, 25, lessonMeta, undefined, { skipPush: true })
-
-    const content: any = {
-      id: 700,
-      type: 'course',
-      brand: 'drumeo',
-      children: [{ id: 701 }, { id: 702 }, { id: 703 }],
-    }
-    const result = await processContentItem(content)
-    expect(content.completed_children).toBe(2)
-    expect(content.all_children).toBe(3)
-    expect(result.body.subtitle).toBe('2 of 3 Lessons Complete')
-  })
-
-  test('uses contentType from getFormattedType in header and cta resolution', async () => {
-    const content = {
-      id: 8,
-      type: 'guided-course',
-      brand: 'drumeo',
-      progressStatus: 'not-started',
-    }
-    const result = await processContentItem(content)
-    expect(result.header).toBe('guided course')
-    expect(result.cta.text).toBe('Start Course')
-  })
-
-  test('cta action mirrors content identity fields', async () => {
-    const content = {
-      id: 9,
-      type: 'song',
-      brand: 'pianote',
-      slug: 'my-slug',
-      navigateTo: 'next-child',
-    }
-    const result = await processContentItem(content)
-    expect(result.cta.action).toEqual({
-      type: 'song',
-      brand: 'pianote',
-      id: 9,
-      slug: 'my-slug',
-      child: 'next-child',
-    })
-  })
-})

package/test/integration/sync/adapters/idb-errors.test.ts

@@ -1,144 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-// Replace jsdom's incomplete IndexedDB with a spec-compliant fake
-import 'fake-indexeddb/auto'
-
-import {
-  patchIndexedDBOpenErrors,
-  patchIndexedDBDeleteDatabaseErrors,
-  simulateIndexedDBDelay,
-  simulateIndexedDBUnavailable,
-  simulateIndexedDBFailure,
-  simulateIndexedDBQuotaExceeded,
-} from '@/services/sync/adapters/lokijs'
-
-// Each test gets a fresh indexedDB instance so patches don't bleed between tests
-let originalOpen: typeof indexedDB.open
-let originalDeleteDatabase: typeof indexedDB.deleteDatabase
-
-beforeEach(() => {
-  originalOpen = indexedDB.open.bind(indexedDB)
-  originalDeleteDatabase = indexedDB.deleteDatabase.bind(indexedDB)
-})
-
-afterEach(() => {
-  // Restore original methods after each test
-  ;(indexedDB as any).open = originalOpen
-  ;(indexedDB as any).deleteDatabase = originalDeleteDatabase
-})
-
-// ---
-
-describe('patchIndexedDBOpenErrors', () => {
-  test('fires callback when open request errors', done => {
-    patchIndexedDBOpenErrors((error, _event) => {
-      expect(error).not.toBeNull()
-      done()
-    })
-
-    // Force an error by opening with a downgrade attempt
-    const req = indexedDB.open('test-db', 1)
-    req.onsuccess = () => {
-      // Now try to open with lower version to trigger an error via another mechanism
-      // Actually trigger via a direct error simulation instead
-    }
-
-    // Simplest: patch is in place, manually fire an open error by opening the same db
-    // at a lower version after it exists at version 1
-    req.onsuccess = () => {
-      req.result.close()
-      // Open at lower version → versionchange error in strict IDB
-      // In fakeIndexedDB this won't error the same way; test by calling stored onerror
-      // The patch intercepts onerror — trigger it via the proxy
-      ;(indexedDB as any).open = originalOpen  // restore so next open works normally
-
-      // Verify patch was applied by checking it wraps the error handler
-      done()
-    }
-
-    req.onerror = () => done()
-  })
-
-  test('still calls original onerror handler', done => {
-    const originalHandler = jest.fn()
-
-    patchIndexedDBOpenErrors((_error, _event) => {
-      // patch callback called
-    })
-
-    const req = indexedDB.open(`test-onerror-${Date.now()}`)
-    const proxiedReq = req as any
-
-    // Simulate an error event through the proxy
-    proxiedReq.onerror = originalHandler
-
-    // Synthesize an error event on the real request
-    const errorEvent = new Event('error')
-    Object.defineProperty(errorEvent, 'target', {
-      value: { error: new DOMException('Test error', 'UnknownError') },
-      configurable: true,
-    })
-    ;(req as any).onerror?.(errorEvent)
-
-    expect(originalHandler).toHaveBeenCalled()
-    done()
-  })
-})
-
-describe('simulateIndexedDBUnavailable', () => {
-  test('causes indexedDB.open to throw synchronously', () => {
-    simulateIndexedDBUnavailable()
-
-    expect(() => {
-      indexedDB.open('test-unavailable')
-    }).toThrow(DOMException)
-  })
-})
-
-describe('simulateIndexedDBQuotaExceeded', () => {
-  test('triggers QuotaExceededError after open call', done => {
-    simulateIndexedDBQuotaExceeded()
-
-    const req = indexedDB.open(`test-quota-${Date.now()}`)
-    req.onerror = event => {
-      const error = (event.target as any)?.error
-      expect(error?.name).toBe('QuotaExceededError')
-      done()
-    }
-
-    // Timeout safety
-    setTimeout(() => done(new Error('QuotaExceeded event not fired in time')), 1000)
-  })
-})
-
-describe('simulateIndexedDBFailure', () => {
-  test('triggers an error after the specified delay', done => {
-    simulateIndexedDBFailure(50) // 50ms delay for test speed
-
-    const req = indexedDB.open(`test-failure-${Date.now()}`)
-    req.onerror = event => {
-      const error = (event.target as any)?.error
-      expect(error).toBeInstanceOf(DOMException)
-      done()
-    }
-
-    setTimeout(() => done(new Error('Failure event not fired in time')), 2000)
-  })
-})
-
-describe('patchIndexedDBDeleteDatabaseErrors', () => {
-  test('returns a proxy request immediately, real delete fires after 1ms', done => {
-    patchIndexedDBDeleteDatabaseErrors()
-
-    // The patched deleteDatabase should return immediately (a proxy)
-    const req = indexedDB.deleteDatabase(`test-delete-${Date.now()}`)
-    expect(req).toBeDefined()
-
-    // Set handler on proxy — it should fire after the real request completes
-    req.onsuccess = () => done()
-
-    setTimeout(() => done(new Error('Delete did not complete')), 1000)
-  })
-})