musora-content-services 2.157.2 → 2.158.0

package/test/unit/infrastructure/DefaultHeaderProvider.test.ts

@@ -0,0 +1,39 @@
+import { DefaultHeaderProvider } from '../../../src/infrastructure/http/providers/DefaultHeaderProvider'
+import { globalConfig } from '../../../src/services/config.js'
+jest.mock('../../../src/services/config.js', () => ({
+  globalConfig: {
+    localTimezoneString: null,
+    isMA: false,
+  }
+}))
+describe('DefaultHeaderProvider', () => {
+  let provider: DefaultHeaderProvider
+  beforeEach(() => {
+    provider = new DefaultHeaderProvider()
+    globalConfig.localTimezoneString = null
+    globalConfig.isMA = false
+  })
+  test('always includes Content-Type and Accept headers', () => {
+    const headers = provider.getHeaders()
+    expect(headers['Content-Type']).toBe('application/json')
+    expect(headers['Accept']).toBe('application/json')
+  })
+  test('adds M-Client-Timezone header when localTimezoneString is set', () => {
+    globalConfig.localTimezoneString = 'America/Vancouver'
+    const headers = provider.getHeaders()
+    expect(headers['M-Client-Timezone']).toBe('America/Vancouver')
+  })
+  test('omits M-Client-Timezone header when localTimezoneString is not set', () => {
+    const headers = provider.getHeaders()
+    expect(headers['M-Client-Timezone']).toBeUndefined()
+  })
+  test('adds X-Client-Platform header when isMA is true', () => {
+    globalConfig.isMA = true
+    const headers = provider.getHeaders()
+    expect(headers['X-Client-Platform']).toBe('mobile')
+  })
+  test('omits X-Client-Platform header when isMA is false', () => {
+    const headers = provider.getHeaders()
+    expect(headers['X-Client-Platform']).toBeUndefined()
+  })
+})

package/test/unit/infrastructure/FetchRequestExecutor.test.ts

@@ -0,0 +1,88 @@
+import { FetchRequestExecutor } from '../../../src/infrastructure/http'
+describe('FetchRequestExecutor', () => {
+  let executor: FetchRequestExecutor
+  beforeEach(() => {
+    executor = new FetchRequestExecutor()
+  })
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+  describe('successful responses', () => {
+    test('returns parsed JSON when content-type is application/json', async () => {
+      const mockData = { id: 1, name: 'test' }
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        headers: { get: jest.fn().mockReturnValue('application/json') },
+        json: jest.fn().mockResolvedValue(mockData),
+        text: jest.fn(),
+      })
+      const result = await executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
+      expect(result).toEqual(mockData)
+    })
+    test('returns text when content-type is not application/json', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        headers: { get: jest.fn().mockReturnValue('text/plain') },
+        json: jest.fn(),
+        text: jest.fn().mockResolvedValue('plain text response'),
+      })
+      const result = await executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
+      expect(result).toBe('plain text response')
+    })
+  })
+  describe('error responses', () => {
+    test('throws HttpError with correct shape when response is not ok', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        headers: { get: jest.fn().mockReturnValue('application/json') },
+        json: jest.fn().mockResolvedValue({ message: 'not found' }),
+        text: jest.fn(),
+      })
+      await expect(
+        executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
+      ).rejects.toMatchObject({
+        status: 404,
+        statusText: 'Not Found',
+        url: 'https://api.example.com/test',
+        method: 'GET',
+        body: { message: 'not found' },
+      })
+    })
+    test('error body is parsed as JSON when response body is valid JSON', async () => {
+      const errorBody = { message: 'validation failed', code: 422 }
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 422,
+        statusText: 'Unprocessable Entity',
+        headers: { get: jest.fn() },
+        json: jest.fn().mockResolvedValue(errorBody),
+        text: jest.fn(),
+      })
+      await expect(
+        executor.execute('https://api.example.com/test', { method: 'POST', headers: {} })
+      ).rejects.toMatchObject({
+        body: errorBody,
+      })
+    })
+    test('error body falls back to text when response body is not JSON', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: { get: jest.fn() },
+        json: jest.fn().mockRejectedValue(new Error('invalid json')),
+        text: jest.fn().mockResolvedValue('Internal Server Error'),
+      })
+      await expect(
+        executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
+      ).rejects.toMatchObject({
+        body: 'Internal Server Error',
+      })
+    })
+  })
+})
+
+
+

package/test/unit/progress-row/playlist-card.test.ts

@@ -0,0 +1,104 @@
+import { processPlaylistItem, getRecentPlaylists, getPlaylistEngagedOnContent } from '../../../src/services/progress-row/rows/playlist-card.js'
+jest.mock('../../../src/services/content-org/playlists.js', () => ({
+  fetchUserPlaylists: jest.fn(),
+}))
+jest.mock('../../../src/services/sanity.js', () => ({
+  ...jest.requireActual('../../../src/services/sanity.js'),
+  fetchByRailContentIds: jest.fn(),
+}))
+jest.mock('../../../src/services/contentAggregator.js', () => ({
+  addContextToContent: jest.fn(),
+}))
+import { fetchUserPlaylists } from '../../../src/services/content-org/playlists.js'
+const mockPlaylistItem = {
+  pinned: false,
+  progressTimestamp: 1234567890,
+  playlist: {
+    id: 1,
+    name: 'My Playlist',
+    brand: 'drumeo',
+    duration_formated: '1h 30m',
+    total_items: 10,
+    likes: 5,
+    first_items_thumbnail_url: [
+    {
+        thumbnail: 'https://cdn.example.com/thumb.jpg',
+        type: 'song',
+        artist_name: 'Kiss',
+        title: "Mwaa"
+     }
+    ],
+    navigateTo: { id: 42, content_id: 99 },
+    user: { display_name: 'John Doe' },
+  },
+}
+describe('processPlaylistItem', () => {
+  test('returns correctly shaped object from playlist item', () => {
+    const result = processPlaylistItem(mockPlaylistItem)
+    expect(result).toMatchObject({
+      id: 1,
+      progressType: 'playlist',
+      header: 'playlist',
+      pinned: false,
+      progressTimestamp: 1234567890,
+      cta: {
+        text: 'Continue',
+        action: {
+          brand: 'drumeo',
+          item_id: 42,
+          content_id: 99,
+          type: 'playlists',
+          id: 1,
+        },
+      },
+    })
+  })
+  test('pinned defaults to false when not set', () => {
+    const item = { ...mockPlaylistItem, pinned: undefined }
+    const result = processPlaylistItem(item)
+    expect(result.pinned).toBe(false)
+  })
+  test('pinned is true when set', () => {
+    const item = { ...mockPlaylistItem, pinned: true }
+    const result = processPlaylistItem(item)
+    expect(result.pinned).toBe(true)
+  })
+  test('subtitle combines duration, total_items, likes and display_name', () => {
+    const result = processPlaylistItem(mockPlaylistItem)
+    expect(result.body.subtitle).toBe('1h 30m • 10 items • 5 likes • John Doe')
+  })
+})
+describe('getRecentPlaylists', () => {
+  test('filters out playlists with no last_progress', async () => {
+    (fetchUserPlaylists as jest.Mock).mockResolvedValue({
+      data: [
+        { id: 1, last_progress: '2024-01-01 10:00:00', last_engaged_on: 123 },
+        { id: 2, last_progress: null, last_engaged_on: 123 },
+      ]
+    })
+    const result = await getRecentPlaylists('drumeo', 10)
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe(1)
+  })
+  test('converts last_progress date string to UTC timestamp', async () => {
+    (fetchUserPlaylists as jest.Mock).mockResolvedValue({
+      data: [
+        { id: 1, last_progress: '2024-01-01 10:00:00', last_engaged_on: 123 },
+      ]
+    })
+    const result = await getRecentPlaylists('drumeo', 10)
+    expect(typeof result[0].progressTimestamp).toBe('number')
+    expect(result[0].progressTimestamp).toBe(new Date('2024-01-01T10:00:00Z').getTime())
+  })
+  test('returns empty array when response has no data', async () => {
+    (fetchUserPlaylists as jest.Mock).mockResolvedValue({ data: [] })
+    const result = await getRecentPlaylists('drumeo', 10)
+    expect(result).toHaveLength(0)
+  })
+})
+describe('getPlaylistEngagedOnContent', () => {
+  test('returns empty array when recentPlaylists is empty', async () => {
+    const result = await getPlaylistEngagedOnContent([])
+    expect(result).toEqual([])
+  })
+})

package/test/unit/sentry.test.ts

@@ -0,0 +1,62 @@
+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/sync/context.test.ts

@@ -0,0 +1,51 @@
+jest.mock('../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
+jest.mock('../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+import { makeContext } from './helpers/index'
+describe('SyncContext', () => {
+  test('start calls start on all providers', () => {
+    const context = makeContext() as any
+    const providers = [
+      context.session,
+      context.connectivity,
+      context.visibility,
+      context.tabs,
+      context.durability,
+    ]
+    providers.forEach(p => jest.spyOn(p, 'start'))
+    context.start()
+    providers.forEach(p => expect(p.start).toHaveBeenCalled())
+  })
+  test('stop calls stop on all providers', () => {
+    const context = makeContext() as any
+    const providers = [
+      context.session,
+      context.connectivity,
+      context.visibility,
+      context.tabs,
+      context.durability,
+    ]
+    providers.forEach(p => jest.spyOn(p, 'stop'))
+    context.stop()
+    providers.forEach(p => expect(p.stop).toHaveBeenCalled())
+  })
+  test('session getter returns session provider', () => {
+    const context = makeContext()
+    expect(context.session).toBeDefined()
+  })
+  test('connectivity getter returns connectivity provider', () => {
+    const context = makeContext()
+    expect(context.connectivity).toBeDefined()
+  })
+  test('visibility getter returns visibility provider', () => {
+    const context = makeContext()
+    expect(context.visibility).toBeDefined()
+  })
+  test('tabs getter returns tabs provider', () => {
+    const context = makeContext()
+    expect(context.tabs).toBeDefined()
+  })
+  test('durability getter returns durability provider', () => {
+    const context = makeContext()
+    expect(context.durability).toBeDefined()
+  })
+})

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

@@ -0,0 +1,106 @@
+import { SyncError, SyncValidationError, SyncAbortError, SyncInitError, SyncSetupError, SyncUnexpectedError } from '../../../../src/services/sync/errors/index'
+import { inBoundary } from '../../../../src/services/sync/errors/boundary'
+import { SyncTelemetry } from '../../../../src/services/sync/telemetry/index'
+
+jest.spyOn(SyncTelemetry, 'getInstance').mockReturnValue({
+  capture: jest.fn()
+} as any)
+
+describe('SyncError', () => {
+  test('has correct name property', () => {
+    const error = new SyncError('test message')
+    expect(error.name).toBe('SyncError')
+  })
+  test('isReported() returns false by default', () => {
+    const error = new SyncError('test message')
+    expect(error.isReported()).toBe(false)
+  })
+  test('markReported() sets isReported() to true', () => {
+    const error = new SyncError('test message')
+    error.markReported()
+    expect(error.isReported()).toBe(true)
+  })
+  test('getDetails() returns details passed to constructor', () => {
+    const details = { table: 'content_progress', userId: 1 }
+    const error = new SyncError('test message', details)
+    expect(error.getDetails()).toEqual(details)
+  })
+})
+describe('SyncValidationError', () => {
+  test('has correct name property', () => {
+    const error = new SyncValidationError('invalid value', {} as any)
+    expect(error.name).toBe('SyncValidationError')
+  })
+  test('is instanceof SyncError', () => {
+    const error = new SyncValidationError('invalid value', {} as any)
+    expect(error).toBeInstanceOf(SyncError)
+  })
+})
+describe('SyncAbortError', () => {
+  test('has default message when none provided', () => {
+    const error = new SyncAbortError()
+    expect(error.message).toBe('Sync operation was aborted')
+  })
+  test('accepts custom message', () => {
+    const error = new SyncAbortError('custom abort message')
+    expect(error.message).toBe('custom abort message')
+  })
+})
+describe('SyncInitError', () => {
+  test('has correct name and stores cause in details', () => {
+    const cause = new Error('original error')
+    const error = new SyncInitError(cause)
+    expect(error.name).toBe('SyncInitError')
+    expect(error.getDetails()).toEqual({ cause })
+  })
+})
+describe('SyncSetupError', () => {
+  test('is instanceof SyncError', () => {
+    const error = new SyncSetupError(new Error('setup failed'))
+    expect(error).toBeInstanceOf(SyncError)
+  })
+})
+describe('SyncUnexpectedError', () => {
+  test('is instanceof SyncError', () => {
+    const error = new SyncUnexpectedError('unexpected')
+    expect(error).toBeInstanceOf(SyncError)
+  })
+})
+
+describe('inBoundary', () => {
+  let mockCapture: jest.Mock
+
+  beforeEach(() => {
+    mockCapture = jest.fn()
+    jest.spyOn(SyncTelemetry, 'getInstance').mockReturnValue({
+      capture: mockCapture
+    } as any)
+  })
+  test('returns result of sync function when no error', () => {
+    const result = inBoundary(() => 'hello')
+    expect(result).toBe('hello')
+    expect(mockCapture).not.toHaveBeenCalled()
+  })
+  test('throws and calls capture when sync function throws', () => {
+    const error = new Error('sync error')
+    expect(() => inBoundary(() => { throw error })).toThrow('sync error')
+    expect(mockCapture).toHaveBeenCalledWith(error, undefined)
+  })
+  test('returns resolved value of async function when no error', async () => {
+    const result = await inBoundary(async () => 'async hello')
+    expect(result).toBe('async hello')
+    expect(mockCapture).not.toHaveBeenCalled()
+  })
+  test('re-throws and calls capture when async function rejects', async () => {
+    const error = new Error('async error')
+    await expect(inBoundary(async () => { throw error })).rejects.toThrow('async error')
+    expect(mockCapture).toHaveBeenCalledWith(error, undefined)
+  })
+  test('passes context to fn and to capture on error', () => {
+    const context = { table: 'content_progress' }
+    const error = new Error('context error')
+    expect(() => inBoundary((ctx) => { throw error }, context)).toThrow('context error')
+    expect(mockCapture).toHaveBeenCalledWith(error, context)
+  })
+})
+

package/test/unit/sync/errors/validators.test.ts

@@ -0,0 +1,61 @@
+import { percent, nullableString, string, number, varchar, numberInRange, enumValue } from '../../../../src/services/sync/errors/validators'
+import { SyncValidationError } from '../../../../src/services/sync/errors/index'
+describe('validators', () => {
+  describe('percent', () => {
+    test('returns value when within 0-100', () => {
+      expect(percent(50)).toBe(50)
+    })
+  })
+  test('returns 0 at minimum boundary', () => {
+    expect(percent(0)).toBe(0)
+  })
+  test('returns 100 at maximum boundary', () => {
+    expect(percent(100)).toBe(100)
+  })
+  test('throws SyncValidationError when value exceeds 100', () => {
+    expect(() => percent(101)).toThrow(SyncValidationError)
+  })
+  test('throws SyncValidationError when value is negative', () => {
+    expect(() => percent(-1)).toThrow(SyncValidationError)
+  })
+})
+describe('nullableString', () => {
+  test('returns null when value is null', () => {
+    expect(nullableString(null)).toBeNull()
+  })
+  test('returns string when value is a string', () => {
+    expect(nullableString('hello')).toBe('hello')
+  })
+})
+describe('string', () => {
+  test('throws SyncValidationError when value is not a string', () => {
+    expect(() => string(123)).toThrow(SyncValidationError)
+  })
+})
+describe('number', () => {
+  test('throws SyncValidationError when value is not a number', () => {
+    expect(() => number('abc')).toThrow(SyncValidationError)
+  })
+})
+describe('varchar', () => {
+  test('returns string when within max length', () => {
+    expect(varchar(10)('hello')).toBe('hello')
+  })
+  test('throws SyncValidationError when string exceeds max length', () => {
+    expect(() => varchar(5)('toolong')).toThrow(SyncValidationError)
+  })
+})
+describe('numberInRange', () => {
+  test('returns value when within range', () => {
+    expect(numberInRange(0, 10)(5)).toBe(5)
+  })
+  test('throws SyncValidationError when value exceeds max', () => {
+    expect(() => numberInRange(0, 10)(11)).toThrow(SyncValidationError)
+  })
+})
+describe('enumValue', () => {
+  test('throws SyncValidationError when value is not in enum', () => {
+    enum TestEnum { A = 'a', B = 'b' }
+    expect(() => enumValue(TestEnum)('c')).toThrow(SyncValidationError)
+  })
+})

package/test/unit/sync/models/user-award-progress.test.ts

@@ -0,0 +1,82 @@
+jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
+jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+
+import { Database } from '@nozbe/watermelondb'
+import { makeDatabase, makeStore, resetDatabase } from '../helpers/index'
+import UserAwardProgress from '../../../../src/services/sync/models/UserAwardProgress'
+import UserAwardProgressRepository from '../../../../src/services/sync/repositories/user-award-progress'
+let db: Database
+let repo: UserAwardProgressRepository
+beforeEach(() => {
+  db = makeDatabase()
+  const { store } = makeStore(UserAwardProgress, db)
+  repo = new UserAwardProgressRepository(store)
+})
+afterEach(async () => {
+  await resetDatabase(db)
+})
+describe('UserAwardProgress model', () => {
+  describe('getters', () => {
+    test('award_id returns raw string value', async () => {
+      await repo.recordAwardProgress('test-award-id', 50)
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.award_id).toBe('test-award-id')
+    })
+    test('progress_percentage returns raw number value', async () => {
+      await repo.recordAwardProgress('test-award-id', 75)
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.progress_percentage).toBe(75)
+    })
+    test('completed_at returns null when not set', async () => {
+      await repo.recordAwardProgress('test-award-id', 50)
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.completed_at).toBeNull()
+    })
+    test('progress_data parses JSON when set', async () => {
+      const progressData = { step: 1, total: 5 }
+      await repo.recordAwardProgress('test-award-id', 50, { progressData })
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.progress_data).toEqual(progressData)
+    })
+    test('progress_data returns null when not set', async () => {
+      await repo.recordAwardProgress('test-award-id', 50)
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.progress_data).toBeNull()
+    })
+    test('completion_data parses JSON when set', async () => {
+      const completionData = {
+        content_title: 'Blues Foundations',
+        completed_at: '2024-01-01T00:00:00Z',
+        days_user_practiced: 14,
+        practice_minutes: 180,
+      }
+      await repo.recordAwardProgress('test-award-id', 100, { completionData })
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.completion_data).toEqual(completionData)
+    })
+    test('completion_data returns null when not set', async () => {
+      await repo.recordAwardProgress('test-award-id', 50)
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.completion_data).toBeNull()
+    })
+  })
+  describe('setters via validators', () => {
+    test.todo('progress_percentage throws SyncValidationError when value exceeds 100')
+    test('completed_at accepts null', async () => {
+      await repo.recordAwardProgress('test-award-id', 50, { completedAt: null })
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.completed_at).toBeNull()
+    })
+    test('completion_data serialises to JSON when set', async () => {
+      const completionData = {
+        content_title: 'Test',
+        completed_at: '2024-01-01T00:00:00Z',
+        days_user_practiced: 5,
+        practice_minutes: 60,
+      }
+      await repo.recordAwardProgress('test-award-id', 100, { completionData })
+      const result = await repo.getByAwardId('test-award-id')
+      expect(result.data?.completion_data).toEqual(completionData)
+    })
+  })
+})

package/test/unit/sync/repositories/user-award-progress.static.test.ts

@@ -0,0 +1,68 @@
+jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
+jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+
+import UserAwardProgressRepository from '../../../../src/services/sync/repositories/user-award-progress'
+
+describe('UserAwardProgressRepository static methods', () => {
+  describe('isCompleted', () => {
+    test('returns true when completed_at is set and progress_percentage is 100', () => {
+      const result = UserAwardProgressRepository.isCompleted({
+        completed_at: '2024-01-01T00:00:00Z',
+        progress_percentage: 100,
+      })
+      expect(result).toBe(true)
+    })
+    test('returns false when completed_at is null', () => {
+      const result = UserAwardProgressRepository.isCompleted({
+        completed_at: null,
+        progress_percentage: 100,
+      })
+      expect(result).toBe(false)
+    })
+    test('returns false when progress_percentage is less than 100', () => {
+      const result = UserAwardProgressRepository.isCompleted({
+        completed_at: '2024-01-01T00:00:00Z',
+        progress_percentage: 50,
+      })
+      expect(result).toBe(false)
+    })
+  })
+  describe('isInProgress', () => {
+    test('returns true when progress is greater than 0 and not completed', () => {
+      const result = UserAwardProgressRepository.isInProgress({
+        completed_at: null,
+        progress_percentage: 50,
+      })
+      expect(result).toBe(true)
+    })
+    test('returns false when award is completed', () => {
+      const result = UserAwardProgressRepository.isInProgress({
+        completed_at: '2024-01-01T00:00:00Z',
+        progress_percentage: 100,
+      })
+      expect(result).toBe(false)
+    })
+    test('returns true when progress is 0 and not completed', () => {
+      const result = UserAwardProgressRepository.isInProgress({
+        completed_at: null,
+        progress_percentage: 0,
+      })
+      expect(result).toBe(true)
+    })
+  })
+  describe('completedAtDate', () => {
+    test('returns a Date object when completed_at is set', () => {
+      const result = UserAwardProgressRepository.completedAtDate({
+        completed_at: '2024-01-01T00:00:00Z',
+      })
+      expect(result).toBeInstanceOf(Date)
+      expect(result?.toISOString()).toBe('2024-01-01T00:00:00.000Z')
+    })
+    test('returns null when completed_at is null', () => {
+      const result = UserAwardProgressRepository.completedAtDate({
+        completed_at: null,
+      })
+      expect(result).toBeNull()
+    })
+  })
+})