musora-content-services 2.167.2 → 2.167.3

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

@@ -1,173 +0,0 @@
-/**
- * Tests for SQLiteErrorAwareAdapter and FullFailingSQLiteAdapter.
- *
- * WatermelonDB's SQLiteAdapter is React Native-only and can't be instantiated in Node.
- * We mock the parent class so we can test our error-handling wrapper logic.
- * better-sqlite3 provides ground-truth SQLite error message formats, confirming
- * our isSQLiteFullError detection handles both the RN format and native SQLite format.
- */
-
-import BetterSqlite3 from 'better-sqlite3'
-
-// Mock the RN-only SQLiteAdapter before importing our wrapper
-jest.mock('@nozbe/watermelondb/adapters/sqlite', () => {
-  return class MockSQLiteAdapter {
-    _dispatcher = {
-      call: (_method: string, _args: any[], callback: any) => callback({ error: null }),
-    }
-    constructor(public options: any) {}
-    // Route through _dispatcher like the real RN adapter — required so
-    // FullFailingSQLiteAdapter's dispatcher patch intercepts batch calls
-    batch(operations: any[], callback: (result: any) => void) {
-      this._dispatcher.call('batch', [operations], callback)
-    }
-    get schema() { return this.options?.schema }
-  }
-})
-
-import SQLiteErrorAwareAdapter, {
-  FullFailingSQLiteAdapter,
-} from '@/services/sync/adapters/sqlite'
-
-// ---
-
-describe('isSQLiteFullError detection via SQLiteErrorAwareAdapter.batch()', () => {
-  function makeAdapterWithDispatcherError(error: Error | null, onFullError?: jest.Mock) {
-    const adapter = new SQLiteErrorAwareAdapter(
-      { schema: null } as any,
-      onFullError ? { onFullError } : {}
-    )
-    // Override dispatcher to return a specific error result
-    ;(adapter as any)._dispatcher.call = (_method: string, _args: any[], callback: any) =>
-      callback({ error })
-    return adapter
-  }
-
-  test('calls onFullError for RN-style "sqlite error 13" message', done => {
-    const onFullError = jest.fn()
-    const adapter = makeAdapterWithDispatcherError(
-      new Error('sqlite error 13 (database or disk is full)'),
-      onFullError
-    )
-
-    adapter.batch([], _result => {
-      expect(onFullError).toHaveBeenCalledTimes(1)
-      done()
-    })
-  })
-
-  test('calls onFullError for "database or disk is full" message', done => {
-    const onFullError = jest.fn()
-    const adapter = makeAdapterWithDispatcherError(
-      new Error('database or disk is full'),
-      onFullError
-    )
-
-    adapter.batch([], _result => {
-      expect(onFullError).toHaveBeenCalledTimes(1)
-      done()
-    })
-  })
-
-  test('does NOT call onFullError for unrelated errors', done => {
-    const onFullError = jest.fn()
-    const adapter = makeAdapterWithDispatcherError(
-      new Error('no such table: foo'),
-      onFullError
-    )
-
-    adapter.batch([], _result => {
-      expect(onFullError).not.toHaveBeenCalled()
-      done()
-    })
-  })
-
-  test('does NOT call onFullError when no error', done => {
-    const onFullError = jest.fn()
-    const adapter = makeAdapterWithDispatcherError(null, onFullError)
-
-    adapter.batch([], _result => {
-      expect(onFullError).not.toHaveBeenCalled()
-      done()
-    })
-  })
-
-  test('still calls original callback regardless of error type', done => {
-    const adapter = makeAdapterWithDispatcherError(new Error('some error'))
-    const callback = jest.fn()
-
-    adapter.batch([], callback)
-    expect(callback).toHaveBeenCalledTimes(1)
-    done()
-  })
-})
-
-describe('FullFailingSQLiteAdapter', () => {
-  test('batch always fires error callback', done => {
-    const onFullError = jest.fn()
-    const adapter = new FullFailingSQLiteAdapter({ schema: null } as any, { onFullError })
-
-    adapter.batch([], result => {
-      expect(result.error).toBeInstanceOf(Error)
-      expect(result.error.message).toContain('sqlite error 13')
-      done()
-    })
-  })
-
-  test('batch calls onFullError', done => {
-    const onFullError = jest.fn()
-    const adapter = new FullFailingSQLiteAdapter({ schema: null } as any, { onFullError })
-
-    adapter.batch([], _result => {
-      expect(onFullError).toHaveBeenCalledTimes(1)
-      done()
-    })
-  })
-
-  test('non-batch methods pass through to real adapter', () => {
-    const adapter = new FullFailingSQLiteAdapter({ schema: null } as any)
-    // schema getter should work (delegated to parent/mock)
-    expect(() => adapter.schema).not.toThrow()
-  })
-})
-
-describe('better-sqlite3 error message format', () => {
-  // Confirms that native SQLite error messages use the "database or disk is full"
-  // phrase, which our isSQLiteFullError function checks for.
-  // We can't easily trigger SQLITE_FULL (error 13) in a test, but we can verify
-  // that other sqlite errors come through with the expected message structure,
-  // and manually construct a SQLITE_FULL error to verify detection.
-
-  test('better-sqlite3 errors are plain Error instances with message string', () => {
-    const db = new BetterSqlite3(':memory:')
-    let caught: Error | null = null
-
-    try {
-      db.exec('SELECT * FROM nonexistent_table_xyz')
-    } catch (e) {
-      caught = e as Error
-    }
-
-    expect(caught).toBeInstanceOf(Error)
-    expect(typeof caught!.message).toBe('string')
-    expect(caught!.message.length).toBeGreaterThan(0)
-    db.close()
-  })
-
-  test('simulated SQLITE_FULL error matches our detection logic', done => {
-    const onFullError = jest.fn()
-    const adapter = new SQLiteErrorAwareAdapter({ schema: null } as any, { onFullError })
-
-    // Construct error the way better-sqlite3 would for SQLITE_FULL (error code 13)
-    const fullError = new Error('database or disk is full') as any
-    fullError.code = 'SQLITE_FULL'
-
-    ;(adapter as any)._dispatcher.call = (_method: string, _args: any[], callback: any) =>
-      callback({ error: fullError })
-
-    adapter.batch([], _result => {
-      expect(onFullError).toHaveBeenCalledWith(fullError)
-      done()
-    })
-  })
-})

package/test/integration/sync/fetch.test.ts

@@ -1,224 +0,0 @@
-import * as fflate from 'fflate'
-import { handlePull, type SyncPullResponse } from '@/services/sync/fetch'
-import { makeContext } from '../../unit/sync/helpers/index'
-import type { EpochMs } from '@/services/sync/index'
-
-// ---
-
-const USER_ID = 1
-const TOKEN = 1700000001000 as EpochMs
-const TABLE = 'content_progress'
-
-function gzipBase64(data: object): string {
-  const bytes = fflate.strToU8(JSON.stringify(data))
-  const compressed = fflate.gzipSync(bytes)
-  let binary = ''
-  compressed.forEach(b => { binary += String.fromCharCode(b) })
-  return btoa(binary)
-}
-
-function rawPullBody(overrides: object = {}) {
-  return {
-    meta: { since: null, max_updated_at: TOKEN, timestamp: TOKEN },
-    entries: [],
-    ...overrides,
-  }
-}
-
-function mockResponse(body: string, headers: Record<string, string> = {}, status = 200) {
-  return new Response(body, {
-    status,
-    headers: { 'X-Sync-Intended-User-Id': String(USER_ID), ...headers },
-  })
-}
-
-function makePull() {
-  return handlePull(() => new Request('https://api.example.com/sync'))
-}
-
-function callPull(pull: ReturnType<typeof handlePull>, lastFetchToken: any = null) {
-  return pull(TABLE, 1, USER_ID, makeContext(), new AbortController().signal, lastFetchToken)
-}
-
-// ---
-
-describe('plain JSON response', () => {
-  test('parses entries from JSON body', async () => {
-    const entry = { record: { id: 'rec-1' }, meta: { ids: { id: 'rec-1' }, lifecycle: { created_at: TOKEN, updated_at: TOKEN, deleted_at: null } } }
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify(rawPullBody({ entries: [entry] })))
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, entries: expect.arrayContaining([entry]) })
-  })
-
-  test('returns token from max_updated_at', async () => {
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify(rawPullBody()))
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, token: TOKEN })
-  })
-
-  test('falls back to timestamp when max_updated_at is null', async () => {
-    const timestamp = 1700000009999 as EpochMs
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify({ meta: { since: null, max_updated_at: null, timestamp }, entries: [] }))
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, token: timestamp })
-  })
-})
-
-// ---
-
-describe('gzip-base64 response', () => {
-  test('decompresses and parses entries', async () => {
-    const entry = { record: { id: 'gz-1' }, meta: { ids: { id: 'gz-1' }, lifecycle: { created_at: TOKEN, updated_at: TOKEN, deleted_at: null } } }
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(
-        gzipBase64(rawPullBody({ entries: [entry] })),
-        { 'X-Sync-Content-Encoding': 'gzip-base64' }
-      )
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, entries: expect.arrayContaining([entry]) })
-  })
-
-  test('entry data survives compression round-trip', async () => {
-    const entry = {
-      record: { id: 'gz-2', value: 'hello', score: 42 },
-      meta: { ids: { id: 'gz-2' }, lifecycle: { created_at: TOKEN, updated_at: TOKEN, deleted_at: null } },
-    }
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(
-        gzipBase64(rawPullBody({ entries: [entry] })),
-        { 'X-Sync-Content-Encoding': 'gzip-base64' }
-      )
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, entries: [{ record: { value: 'hello', score: 42 } }] })
-  })
-
-  test('returns correct token from compressed payload', async () => {
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(
-        gzipBase64(rawPullBody()),
-        { 'X-Sync-Content-Encoding': 'gzip-base64' }
-      )
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, token: TOKEN })
-  })
-
-  test('large payload survives compression', async () => {
-    const entries = Array.from({ length: 500 }, (_, i) => ({
-      record: { id: `rec-${i}`, value: `value-${i}`.repeat(20) },
-      meta: { ids: { id: `rec-${i}` }, lifecycle: { created_at: TOKEN, updated_at: TOKEN, deleted_at: null } },
-    }))
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(
-        gzipBase64(rawPullBody({ entries })),
-        { 'X-Sync-Content-Encoding': 'gzip-base64' }
-      )
-    )
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: true, entries: expect.arrayContaining([expect.objectContaining({ record: expect.objectContaining({ id: 'rec-0' }) })]) })
-    expect((result as Extract<SyncPullResponse, { ok: true }>).entries).toHaveLength(500)
-  })
-})
-
-// ---
-
-describe('since query param', () => {
-  test('no since param on first pull', async () => {
-    const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify(rawPullBody()))
-    )
-
-    await callPull(makePull(), null)
-
-    const url = (fetchSpy.mock.calls[0][0] as Request).url
-    expect(new URL(url).searchParams.get('since')).toBeNull()
-  })
-
-  test('since param set to previous token on subsequent pull', async () => {
-    const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify(rawPullBody()))
-    )
-
-    await callPull(makePull(), TOKEN)
-
-    const url = (fetchSpy.mock.calls[0][0] as Request).url
-    expect(new URL(url).searchParams.get('since')).toBe(String(TOKEN))
-  })
-})
-
-// ---
-
-describe('request headers', () => {
-  test('outgoing request includes gzip-base64 accept encoding header', async () => {
-    const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce(
-      mockResponse(JSON.stringify(rawPullBody()))
-    )
-
-    const pull = handlePull(() => new Request('https://api.example.com/sync', {
-      headers: { 'X-Sync-Accept-Encoding': 'gzip-base64' }
-    }))
-    await callPull(pull)
-
-    const req = fetchSpy.mock.calls[0][0] as Request
-    expect(req.headers.get('X-Sync-Accept-Encoding')).toBe('gzip-base64')
-  })
-})
-
-// ---
-
-describe('failure responses', () => {
-  test('network TypeError returns retryable fetch failure', async () => {
-    jest.spyOn(global, 'fetch').mockRejectedValueOnce(new TypeError('network error'))
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: false, failureType: 'fetch', isRetryable: true })
-  })
-
-  test('AbortError returns abort failure', async () => {
-    const abortError = new DOMException('aborted', 'AbortError')
-    jest.spyOn(global, 'fetch').mockRejectedValueOnce(abortError)
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: false, failureType: 'abort' })
-  })
-
-  test('5xx returns retryable fetch failure', async () => {
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(null, { status: 500 }))
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: false, failureType: 'fetch', isRetryable: true })
-  })
-
-  test('4xx (non-retryable) returns non-retryable fetch failure', async () => {
-    jest.spyOn(global, 'fetch').mockResolvedValueOnce(new Response(null, { status: 403 }))
-
-    const result = await callPull(makePull())
-
-    expect(result).toMatchObject({ ok: false, failureType: 'fetch', isRetryable: false })
-  })
-})

package/test/integration/sync/repositories/content-likes.test.ts

@@ -1,99 +0,0 @@
-jest.mock('@/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('@/services/sync/repository-proxy', () => ({ db: {} }))
-
-import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
-import ContentLike from '@/services/sync/models/ContentLike'
-import LikesRepository from '@/services/sync/repositories/content-likes'
-
-let db: Database
-let repo: LikesRepository
-
-beforeEach(() => {
-  db = makeDatabase()
-  const { store } = makeStore(ContentLike, db)
-  repo = new LikesRepository(store)
-})
-
-afterEach(async () => {
-  await resetDatabase(db)
-})
-
-// ---
-
-describe('like / unlike', () => {
-  test('like creates a record for the contentId', async () => {
-    await repo.like(100)
-
-    const result = await repo['store'].readOne(ContentLike.generateId(100))
-    expect(result).not.toBeNull()
-    expect(result!.content_id).toBe(100)
-  })
-
-  test('unlike removes the record', async () => {
-    await repo.like(200)
-    await repo.unlike(200)
-
-    const result = await repo['store'].readOne(ContentLike.generateId(200))
-    expect(result).toBeNull()
-  })
-
-  test('liking same content twice is idempotent', async () => {
-    await repo.like(300)
-    await repo.like(300)
-
-    const all = await repo['store'].readAll()
-    expect(all).toHaveLength(1)
-  })
-})
-
-describe('isLiked', () => {
-  test('returns true when content is liked', async () => {
-    await repo.like(400)
-
-    const result = await repo.isLiked(400)
-    expect(result.data).toBe(true)
-  })
-
-  test('returns false when content is not liked', async () => {
-    const result = await repo.isLiked(9999)
-    expect(result.data).toBe(false)
-  })
-
-  test('returns false after unliking', async () => {
-    await repo.like(500)
-    await repo.unlike(500)
-
-    const result = await repo.isLiked(500)
-    expect(result.data).toBe(false)
-  })
-})
-
-describe('areLiked', () => {
-  test('returns boolean array in same order as input', async () => {
-    await repo.like(600)
-    await repo.like(602)
-    // 601 not liked
-
-    const result = await repo.areLiked([600, 601, 602])
-    expect(result.data).toEqual([true, false, true])
-  })
-
-  test('returns all false when nothing liked', async () => {
-    const result = await repo.areLiked([1, 2, 3])
-    expect(result.data).toEqual([false, false, false])
-  })
-
-  test('returns all true when all liked', async () => {
-    await repo.like(700)
-    await repo.like(701)
-
-    const result = await repo.areLiked([700, 701])
-    expect(result.data).toEqual([true, true])
-  })
-
-  test('empty array returns empty array', async () => {
-    const result = await repo.areLiked([])
-    expect(result.data).toEqual([])
-  })
-})

package/test/integration/sync/repositories/practices.test.ts

@@ -1,179 +0,0 @@
-jest.mock('@/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('@/services/sync/repository-proxy', () => ({ db: {} }))
-
-import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
-import Practice from '@/services/sync/models/Practice'
-import PracticesRepository from '@/services/sync/repositories/practices'
-
-let db: Database
-let repo: PracticesRepository
-
-beforeEach(() => {
-  db = makeDatabase()
-  const { store } = makeStore(Practice, db)
-  repo = new PracticesRepository(store)
-})
-
-afterEach(async () => {
-  await resetDatabase(db)
-})
-
-// ---
-
-describe('trackAutoPractice', () => {
-  test('creates auto practice on first call', async () => {
-    await repo.trackAutoPractice(100, '2024-01-15', 300)
-
-    const result = await repo.getAutoPracticesOnDate('2024-01-15')
-    expect(result.data).toHaveLength(1)
-    expect(result.data[0].duration_seconds).toBe(300)
-    expect(result.data[0].auto).toBe(true)
-    expect(result.data[0].content_id).toBe(100)
-  })
-
-  test('increments duration on subsequent calls for same content/date', async () => {
-    await repo.trackAutoPractice(100, '2024-01-15', 300)
-    await repo.trackAutoPractice(100, '2024-01-15', 200)
-
-    const result = await repo.getAutoPracticesOnDate('2024-01-15')
-    expect(result.data).toHaveLength(1)
-    expect(result.data[0].duration_seconds).toBe(500)
-  })
-
-  test('separate records for different dates', async () => {
-    await repo.trackAutoPractice(100, '2024-01-15', 300)
-    await repo.trackAutoPractice(100, '2024-01-16', 200)
-
-    const day1 = await repo.getAutoPracticesOnDate('2024-01-15')
-    const day2 = await repo.getAutoPracticesOnDate('2024-01-16')
-    expect(day1.data).toHaveLength(1)
-    expect(day2.data).toHaveLength(1)
-    expect(day1.data[0].duration_seconds).toBe(300)
-    expect(day2.data[0].duration_seconds).toBe(200)
-  })
-
-  test('caps duration at 59999 seconds', async () => {
-    await repo.trackAutoPractice(100, '2024-01-15', 59990)
-    await repo.trackAutoPractice(100, '2024-01-15', 100)
-
-    const result = await repo.getAutoPracticesOnDate('2024-01-15')
-    expect(result.data[0].duration_seconds).toBe(59999)
-  })
-})
-
-describe('recordManualPractice', () => {
-  test('creates manual practice with correct fields', async () => {
-    await repo.recordManualPractice('2024-01-20', 1800, {
-      title: 'Blues scales',
-      instrument_id: 1,
-      category_id: 2,
-    })
-
-    const result = await repo['store'].readAll()
-    expect(result).toHaveLength(1)
-
-    const practice = result[0]
-    expect(practice.auto).toBe(false)
-    expect(practice.date).toBe('2024-01-20')
-    expect(practice.duration_seconds).toBe(1800)
-    expect(practice.title).toBe('Blues scales')
-    expect(practice.instrument_id).toBe(1)
-    expect(practice.category_id).toBe(2)
-    expect(practice.id.startsWith('manual:')).toBe(true)
-  })
-
-  test('caps duration at 59999 seconds', async () => {
-    await repo.recordManualPractice('2024-01-20', 999999)
-
-    const result = await repo['store'].readAll()
-    expect(result[0].duration_seconds).toBe(59999)
-  })
-
-  test('multiple manual practices on same date create separate records', async () => {
-    await repo.recordManualPractice('2024-01-20', 600)
-    await repo.recordManualPractice('2024-01-20', 900)
-
-    const result = await repo['store'].readAll()
-    expect(result).toHaveLength(2)
-    expect(result.every(r => r.auto === false)).toBe(true)
-  })
-})
-
-describe('updateDetails', () => {
-  test('updates duration and title', async () => {
-    const created = await repo.recordManualPractice('2024-01-25', 600, { title: 'Old title' })
-    const id = created.data.id
-
-    await repo.updateDetails(id, { duration_seconds: 900, title: 'New title' })
-
-    const record = await repo['store'].readOne(id)
-    expect(record!.duration_seconds).toBe(900)
-    expect(record!.title).toBe('New title')
-  })
-
-  test('preserves existing values when fields not provided', async () => {
-    const created = await repo.recordManualPractice('2024-01-25', 600, {
-      title: 'Keep me',
-      category_id: 3,
-    })
-    const id = created.data.id
-
-    await repo.updateDetails(id, { duration_seconds: 1200 })
-
-    const record = await repo['store'].readOne(id)
-    expect(record!.title).toBe('Keep me')
-    expect(record!.category_id).toBe(3)
-  })
-})
-
-describe('getAutoPracticesOnDate', () => {
-  test('returns only auto practices for the given date', async () => {
-    await repo.trackAutoPractice(100, '2024-02-01', 300)
-    await repo.recordManualPractice('2024-02-01', 600)   // manual — should not appear
-
-    const result = await repo.getAutoPracticesOnDate('2024-02-01')
-    expect(result.data).toHaveLength(1)
-    expect(result.data[0].auto).toBe(true)
-  })
-
-  test('returns empty array when no practices on date', async () => {
-    const result = await repo.getAutoPracticesOnDate('2099-01-01')
-    expect(result.data).toHaveLength(0)
-  })
-})
-
-describe('sumPracticeMinutesForContent', () => {
-  test('sums across multiple practice records', async () => {
-    await repo.trackAutoPractice(200, '2024-01-01', 600)   // 10 min
-    await repo.trackAutoPractice(200, '2024-01-02', 900)   // 15 min
-
-    const minutes = await repo.sumPracticeMinutesForContent([200])
-    expect(minutes).toBe(25)
-  })
-
-  test('sums only for specified contentIds', async () => {
-    await repo.trackAutoPractice(300, '2024-01-01', 600)
-    await repo.trackAutoPractice(301, '2024-01-01', 600)
-
-    const minutes = await repo.sumPracticeMinutesForContent([300])
-    expect(minutes).toBe(10)
-  })
-
-  test('returns 0 for empty contentIds array', async () => {
-    const minutes = await repo.sumPracticeMinutesForContent([])
-    expect(minutes).toBe(0)
-  })
-
-  test('returns 0 when no practices for contentIds', async () => {
-    const minutes = await repo.sumPracticeMinutesForContent([9999])
-    expect(minutes).toBe(0)
-  })
-
-  test('rounds to nearest minute', async () => {
-    await repo.trackAutoPractice(400, '2024-01-01', 90)  // 1.5 min → rounds to 2
-
-    const minutes = await repo.sumPracticeMinutesForContent([400])
-    expect(minutes).toBe(2)
-  })
-})