musora-content-services 2.167.2 → 2.167.3

package/test/unit/sync/resolver.test.ts

@@ -1,229 +0,0 @@
-import SyncResolver, { updatedAtComparator } from '@/services/sync/resolver'
-import type { SyncEntry, SyncEntryNonDeleted, EpochMs } from '@/services/sync/index'
-import type BaseModel from '@/services/sync/models/Base'
-
-// ---
-
-const T = 1700000000000
-
-function makeEntry(id: string, overrides: { updatedAt?: number; deletedAt?: number | null } = {}): SyncEntry {
-  const updatedAt = overrides.updatedAt ?? T
-  const deletedAt = overrides.deletedAt !== undefined ? overrides.deletedAt : null
-  return {
-    record: deletedAt ? null : ({ id } as unknown as BaseModel),
-    meta: {
-      ids: { id },
-      lifecycle: {
-        created_at: updatedAt as EpochMs,
-        updated_at: updatedAt as EpochMs,
-        deleted_at: deletedAt as EpochMs | null,
-      },
-    },
-  }
-}
-
-function makeLocal(id: string, updatedAt = T): BaseModel {
-  return { id, updated_at: updatedAt } as unknown as BaseModel
-}
-
-// ---
-
-describe('updatedAtComparator', () => {
-  test('returns SERVER when server updated_at is greater than local', () => {
-    const server = makeEntry('x', { updatedAt: T + 1 })
-    const local = makeLocal('x', T)
-    expect(updatedAtComparator(server as unknown as SyncEntryNonDeleted, local)).toBe('SERVER')
-  })
-
-  test('returns SERVER when timestamps are equal', () => {
-    const server = makeEntry('x', { updatedAt: T })
-    const local = makeLocal('x', T)
-    expect(updatedAtComparator(server as unknown as SyncEntryNonDeleted, local)).toBe('SERVER')
-  })
-
-  test('returns LOCAL when local updated_at is greater than server', () => {
-    const server = makeEntry('x', { updatedAt: T - 1 })
-    const local = makeLocal('x', T)
-    expect(updatedAtComparator(server as unknown as SyncEntryNonDeleted, local)).toBe('LOCAL')
-  })
-})
-
-// ---
-
-describe('againstNone', () => {
-  test('non-deleted entry queued for create', () => {
-    const resolver = new SyncResolver()
-    const entry = makeEntry('rec-1')
-
-    resolver.againstNone(entry)
-
-    expect(resolver.result.entriesForCreate).toHaveLength(1)
-    expect(resolver.result.entriesForCreate[0]).toBe(entry)
-  })
-
-  test('deleted entry ignored', () => {
-    const resolver = new SyncResolver()
-    resolver.againstNone(makeEntry('rec-1', { deletedAt: T }))
-
-    const { entriesForCreate, tuplesForUpdate, idsForDestroy } = resolver.result
-    expect(entriesForCreate).toHaveLength(0)
-    expect(tuplesForUpdate).toHaveLength(0)
-    expect(idsForDestroy).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('againstSynced', () => {
-  test('server deleted → idsForDestroy', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T)
-
-    resolver.againstSynced(local, makeEntry('rec-1', { deletedAt: T }))
-
-    expect(resolver.result.idsForDestroy).toContain('rec-1')
-  })
-
-  test('server newer → tuplesForUpdate', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T)
-    const server = makeEntry('rec-1', { updatedAt: T + 1 })
-
-    resolver.againstSynced(local, server)
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(1)
-    expect(resolver.result.tuplesForUpdate[0][0]).toBe(local)
-    expect(resolver.result.tuplesForUpdate[0][1]).toBe(server)
-  })
-
-  test('server older → no action (stale pull ignored)', () => {
-    const resolver = new SyncResolver()
-    resolver.againstSynced(makeLocal('rec-1', T + 1), makeEntry('rec-1', { updatedAt: T }))
-
-    const { tuplesForUpdate, idsForDestroy } = resolver.result
-    expect(tuplesForUpdate).toHaveLength(0)
-    expect(idsForDestroy).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('againstCreated', () => {
-  test('server deleted → idsForDestroy (local changes discarded)', () => {
-    const resolver = new SyncResolver()
-    resolver.againstCreated(makeLocal('rec-1', T + 1), makeEntry('rec-1', { deletedAt: T }))
-
-    expect(resolver.result.idsForDestroy).toContain('rec-1')
-  })
-
-  test('server newer → tuplesForUpdate', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T)
-    const server = makeEntry('rec-1', { updatedAt: T + 1 })
-
-    resolver.againstCreated(local, server)
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(1)
-    expect(resolver.result.tuplesForUpdate[0][1]).toBe(server)
-  })
-
-  test('server older (clock skew) → no action (record stays dirty)', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T + 1)
-
-    resolver.againstCreated(local, makeEntry('rec-1', { updatedAt: T }))
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(0)
-    expect(resolver.result.idsForDestroy).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('againstUpdated', () => {
-  test('server deleted → idsForDestroy (local changes discarded)', () => {
-    const resolver = new SyncResolver()
-    resolver.againstUpdated(makeLocal('rec-1', T + 1), makeEntry('rec-1', { deletedAt: T }))
-
-    expect(resolver.result.idsForDestroy).toContain('rec-1')
-  })
-
-  test('server newer → tuplesForUpdate', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T)
-    const server = makeEntry('rec-1', { updatedAt: T + 1 })
-
-    resolver.againstUpdated(local, server)
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(1)
-  })
-
-  test('server older (clock skew) → no action (record stays dirty)', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T + 1)
-
-    resolver.againstUpdated(local, makeEntry('rec-1', { updatedAt: T }))
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(0)
-    expect(resolver.result.idsForDestroy).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('againstDeleted', () => {
-  test('server also deleted → idsForDestroy', () => {
-    const resolver = new SyncResolver()
-    resolver.againstDeleted(makeLocal('rec-1', T), makeEntry('rec-1', { deletedAt: T }))
-
-    expect(resolver.result.idsForDestroy).toContain('rec-1')
-  })
-
-  test('server updated_at >= local → tuplesForRestore', () => {
-    const resolver = new SyncResolver()
-    const local = makeLocal('rec-1', T)
-    const server = makeEntry('rec-1', { updatedAt: T })
-
-    resolver.againstDeleted(local, server)
-
-    expect(resolver.result.tuplesForRestore).toHaveLength(1)
-    expect(resolver.result.tuplesForRestore[0][0]).toBe(local)
-    expect(resolver.result.tuplesForRestore[0][1]).toBe(server)
-  })
-
-  test('server older than local deleted_at → idsForDestroy (delete wins)', () => {
-    const resolver = new SyncResolver()
-    resolver.againstDeleted(makeLocal('rec-1', T + 1), makeEntry('rec-1', { updatedAt: T }))
-
-    expect(resolver.result.idsForDestroy).toContain('rec-1')
-    expect(resolver.result.tuplesForRestore).toHaveLength(0)
-  })
-})
-
-// ---
-
-describe('custom comparator', () => {
-  test('custom comparator overrides default updated_at logic', () => {
-    const alwaysLocal = () => 'LOCAL' as const
-    const resolver = new SyncResolver(alwaysLocal)
-    const local = makeLocal('rec-1', T)
-    const server = makeEntry('rec-1', { updatedAt: T + 9999 })
-
-    resolver.againstSynced(local, server)
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(0)
-    expect(resolver.result.idsForDestroy).toHaveLength(0)
-  })
-
-  test('custom comparator SERVER wins over newer local', () => {
-    const alwaysServer = () => 'SERVER' as const
-    const resolver = new SyncResolver(alwaysServer)
-    const local = makeLocal('rec-1', T + 9999)
-    const server = makeEntry('rec-1', { updatedAt: T })
-
-    resolver.againstSynced(local, server)
-
-    expect(resolver.result.tuplesForUpdate).toHaveLength(1)
-  })
-})
-

package/test/unit/sync/retry.test.ts

@@ -1,314 +0,0 @@
-import SyncRetry from '@/services/sync/retry'
-import type SyncContext from '@/services/sync/context/index'
-import type { SyncTelemetry } from '@/services/sync/telemetry/index'
-
-// Subclass exposes sleep as a spy — no `as any` access to private internals
-class TestableSyncRetry extends SyncRetry {
-  readonly sleepSpy = jest.fn().mockResolvedValue(undefined)
-  protected override sleep(ms: number) {
-    return this.sleepSpy(ms)
-  }
-}
-
-// ---
-
-function makeRetry(online = true) {
-  let connectivityListener: ((v: boolean) => void) | null = null
-
-  const connectivity = {
-    getValue: jest.fn().mockReturnValue(online),
-    subscribe: jest.fn().mockImplementation((listener: (v: boolean) => void) => {
-      connectivityListener = listener
-      return () => { connectivityListener = null }
-    }),
-  }
-  const context = { connectivity } as unknown as SyncContext
-  const telemetry = { debug: jest.fn() } as unknown as SyncTelemetry
-  const retry = new TestableSyncRetry(context, telemetry)
-
-  const triggerConnectivity = (isOnline: boolean) => {
-    connectivity.getValue.mockReturnValue(isOnline)
-    connectivityListener?.(isOnline)
-  }
-
-  return { retry, connectivity, telemetry, triggerConnectivity }
-}
-
-const ok = { ok: true as const, results: [] }
-const retryable = { ok: false as const, failureType: 'fetch' as const, isRetryable: true }
-const nonRetryable = { ok: false as const, failureType: 'fetch' as const, isRetryable: false }
-
-// ---
-
-describe('successful request', () => {
-  test('returns result on first attempt', async () => {
-    const { retry } = makeRetry()
-    const result = await retry.request(jest.fn().mockResolvedValue(ok))
-
-    expect(result).toEqual(ok)
-  })
-
-  test('syncFn called exactly once', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(ok)
-
-    await retry.request(syncFn)
-
-    expect(syncFn).toHaveBeenCalledTimes(1)
-  })
-
-  test('does not sleep on first attempt', async () => {
-    const { retry } = makeRetry()
-    await retry.request(jest.fn().mockResolvedValue(ok))
-
-    expect(retry.sleepSpy).not.toHaveBeenCalled()
-  })
-
-  test('passes attempt number 1 to syncFn', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(ok)
-
-    await retry.request(syncFn)
-
-    expect(syncFn).toHaveBeenCalledWith(1)
-  })
-})
-
-// ---
-
-describe('no connectivity', () => {
-  test('returns fetch failure without calling syncFn', async () => {
-    const { retry } = makeRetry(false)
-    const syncFn = jest.fn()
-
-    const result = await retry.request(syncFn)
-
-    expect(result.ok).toBe(false)
-    expect(syncFn).not.toHaveBeenCalled()
-  })
-
-  test('returned failure is non-retryable', async () => {
-    const { retry } = makeRetry(false)
-    const result = await retry.request(jest.fn()) as typeof nonRetryable
-
-    expect(result.isRetryable).toBe(false)
-    expect(result.failureType).toBe('fetch')
-  })
-})
-
-// ---
-
-describe('non-retryable failure', () => {
-  test('returns after single attempt', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(nonRetryable)
-
-    const result = await retry.request(syncFn)
-
-    expect(result).toEqual(nonRetryable)
-    expect(syncFn).toHaveBeenCalledTimes(1)
-  })
-
-  test('does not call onFail', async () => {
-    const { retry } = makeRetry()
-    const onFail = jest.fn()
-
-    await retry.request(jest.fn().mockResolvedValue(nonRetryable), { onFail })
-
-    expect(onFail).not.toHaveBeenCalled()
-  })
-
-  test('does not sleep', async () => {
-    const { retry } = makeRetry()
-    await retry.request(jest.fn().mockResolvedValue(nonRetryable))
-
-    expect(retry.sleepSpy).not.toHaveBeenCalled()
-  })
-})
-
-// ---
-
-describe('retryable failures', () => {
-  test(`retries up to MAX_ATTEMPTS (${SyncRetry.MAX_ATTEMPTS}) times`, async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(retryable)
-
-    await retry.request(syncFn)
-
-    expect(syncFn).toHaveBeenCalledTimes(SyncRetry.MAX_ATTEMPTS)
-  })
-
-  test('calls onFail when attempts exhausted', async () => {
-    const { retry } = makeRetry()
-    const onFail = jest.fn()
-
-    await retry.request(jest.fn().mockResolvedValue(retryable), { onFail })
-
-    expect(onFail).toHaveBeenCalledTimes(1)
-  })
-
-  test('returns last failure result after exhausting attempts', async () => {
-    const { retry } = makeRetry()
-    const result = await retry.request(jest.fn().mockResolvedValue(retryable))
-
-    expect(result).toEqual(retryable)
-  })
-
-  test('passes incrementing attempt numbers to syncFn', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(retryable)
-
-    await retry.request(syncFn)
-
-    Array.from({ length: SyncRetry.MAX_ATTEMPTS }, (_, i) => i + 1).forEach((n, i) => {
-      expect(syncFn).toHaveBeenNthCalledWith(i + 1, n)
-    })
-  })
-
-  test('succeeds after initial failures', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn()
-      .mockResolvedValueOnce(retryable)
-      .mockResolvedValueOnce(retryable)
-      .mockResolvedValue(ok)
-
-    const result = await retry.request(syncFn)
-
-    expect(result).toEqual(ok)
-    expect(syncFn).toHaveBeenCalledTimes(3)
-  })
-
-  test('does not call onFail when success before MAX_ATTEMPTS', async () => {
-    const { retry } = makeRetry()
-    const onFail = jest.fn()
-    const syncFn = jest.fn()
-      .mockResolvedValueOnce(retryable)
-      .mockResolvedValue(ok)
-
-    await retry.request(syncFn, { onFail })
-
-    expect(onFail).not.toHaveBeenCalled()
-  })
-})
-
-// ---
-
-describe('backoff', () => {
-  test('sleep called between retries (once before each retry attempt)', async () => {
-    const { retry } = makeRetry()
-    await retry.request(jest.fn().mockResolvedValue(retryable))
-
-    expect(retry.sleepSpy).toHaveBeenCalledTimes(SyncRetry.MAX_ATTEMPTS - 1)
-  })
-
-  test('sleep called with positive ms', async () => {
-    const { retry } = makeRetry()
-    await retry.request(jest.fn().mockResolvedValue(retryable))
-
-    retry.sleepSpy.mock.calls.forEach(([ms]) => {
-      expect(ms).toBeGreaterThan(0)
-    })
-  })
-
-  test(`sleep duration does not exceed MAX_BACKOFF (${SyncRetry.MAX_BACKOFF}ms)`, async () => {
-    const { retry } = makeRetry()
-    await retry.request(jest.fn().mockResolvedValue(retryable))
-
-    retry.sleepSpy.mock.calls.forEach(([ms]) => {
-      expect(ms).toBeLessThanOrEqual(SyncRetry.MAX_BACKOFF)
-    })
-  })
-
-  test('backoff resets after success — no sleep on subsequent clean request', async () => {
-    const { retry } = makeRetry()
-
-    const syncFn = jest.fn()
-      .mockResolvedValueOnce(retryable)
-      .mockResolvedValue(ok)
-    await retry.request(syncFn)
-
-    retry.sleepSpy.mockClear()
-
-    await retry.request(jest.fn().mockResolvedValue(ok))
-    expect(retry.sleepSpy).not.toHaveBeenCalled()
-  })
-})
-
-// ---
-
-describe('edge cases', () => {
-  test('connectivity goes offline mid-retry — returns no-connectivity response', async () => {
-    const { retry, connectivity } = makeRetry(true)
-
-    // Online for attempt 1, offline for attempt 2
-    connectivity.getValue
-      .mockReturnValueOnce(true)
-      .mockReturnValue(false)
-
-    const syncFn = jest.fn().mockResolvedValue(retryable)
-    const result = await retry.request(syncFn) as typeof nonRetryable
-
-    expect(syncFn).toHaveBeenCalledTimes(1)
-    expect(result.ok).toBe(false)
-    expect(result.isRetryable).toBe(false)
-  })
-
-  test('syncFn throwing propagates the error', async () => {
-    const { retry } = makeRetry()
-    const boom = new Error('network exploded')
-
-    await expect(
-      retry.request(jest.fn().mockRejectedValue(boom))
-    ).rejects.toThrow('network exploded')
-  })
-
-  test('null result returned immediately without retry', async () => {
-    const { retry } = makeRetry()
-    const syncFn = jest.fn().mockResolvedValue(null)
-
-    const result = await retry.request(syncFn)
-
-    expect(result).toBeNull()
-    expect(syncFn).toHaveBeenCalledTimes(1)
-  })
-
-  test('concurrent requests share backoff state', async () => {
-    const { retry } = makeRetry()
-
-    // Two concurrent requests both hitting retryable failures
-    const [r1, r2] = await Promise.all([
-      retry.request(jest.fn().mockResolvedValue(retryable)),
-      retry.request(jest.fn().mockResolvedValue(retryable)),
-    ])
-
-    expect(r1.ok).toBe(false)
-    expect(r2.ok).toBe(false)
-  })
-})
-
-// ---
-
-describe('start / stop', () => {
-  test('start subscribes to connectivity', () => {
-    const { retry, connectivity } = makeRetry()
-    retry.start()
-
-    expect(connectivity.subscribe).toHaveBeenCalledTimes(1)
-  })
-
-  test('stop unsubscribes from connectivity', () => {
-    const { retry, connectivity } = makeRetry()
-    const unsub = jest.fn()
-    connectivity.subscribe.mockReturnValue(unsub)
-
-    retry.start()
-    retry.stop()
-
-    expect(unsub).toHaveBeenCalledTimes(1)
-  })
-
-  test('stop is safe to call before start', () => {
-    const { retry } = makeRetry()
-    expect(() => retry.stop()).not.toThrow()
-  })
-})

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

@@ -1,23 +0,0 @@
-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/stale-record-cleanup.test.ts

@@ -1,107 +0,0 @@
-import { Database } from '@nozbe/watermelondb'
-import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-import schema, { SYNC_TABLES } from '@/services/sync/schema/index'
-import * as modelClasses from '@/services/sync/models/index'
-import { makeStore } from './helpers/index'
-import { repairStaleSyncedRecords } from '@/services/sync/stale-record-cleanup'
-import * as HttpClient from '@/infrastructure/http/HttpClient'
-
-function makeDatabase() {
-  const adapter = new LokiJSAdapter({
-    schema,
-    useWebWorker: false,
-    useIncrementalIndexedDB: false,
-    dbName: `test_stale_${Date.now()}_${Math.random()}`,
-    extraLokiOptions: { autosave: false },
-  })
-  return new Database({ adapter, modelClasses: Object.values(modelClasses) })
-}
-
-let db: Database
-let postMock: jest.SpyInstance
-
-beforeEach(() => {
-  db = makeDatabase()
-  postMock = jest.spyOn(HttpClient, 'POST').mockResolvedValue({})
-})
-
-afterEach(async () => {
-  await db.write(() => db.unsafeResetDatabase())
-  jest.restoreAllMocks()
-})
-
-test('marks stale synced records as updated when server has older updated_at', async () => {
-  const { store } = makeStore(modelClasses.ContentProgress, db)
-
-  const localUpdatedAt = Date.now() - 60_000
-  const serverUpdatedAt = localUpdatedAt - 5_000 // server is behind
-
-  await store.importUpsert([
-    {
-      id: 'stale-1',
-      server_record_id: 0,
-      content_id: 123,
-      content_brand: 'drumeo',
-      content_type: 'lesson',
-      content_parent_id: 0,
-      state: 'started',
-      progress_percent: 50,
-      collection_type: 'self',
-      collection_id: 0,
-      resume_time_seconds: null,
-      last_interacted_a_la_carte: 0,
-      created_at: localUpdatedAt,
-      updated_at: localUpdatedAt,
-      _status: 'synced',
-      _changed: '',
-    } as any,
-  ])
-
-  postMock.mockResolvedValue({
-    [SYNC_TABLES.CONTENT_PROGRESS]: [['stale-1', serverUpdatedAt]],
-  })
-
-  const storesRegistry = { [SYNC_TABLES.CONTENT_PROGRESS]: store }
-  await repairStaleSyncedRecords(storesRegistry)
-
-  const record = await db.read(() => db.get(SYNC_TABLES.CONTENT_PROGRESS).find('stale-1')) as any
-  store.destroy()
-
-  expect(record._raw._status).toBe('updated')
-})
-
-test('leaves records unchanged when server finds no stale entries', async () => {
-  const { store } = makeStore(modelClasses.ContentProgress, db)
-
-  const updatedAt = Date.now() - 60_000
-  await store.importUpsert([
-    {
-      id: 'fine-1',
-      server_record_id: 0,
-      content_id: 456,
-      content_brand: 'drumeo',
-      content_type: 'lesson',
-      content_parent_id: 0,
-      state: 'started',
-      progress_percent: 10,
-      collection_type: 'self',
-      collection_id: 0,
-      resume_time_seconds: null,
-      last_interacted_a_la_carte: 0,
-      created_at: updatedAt,
-      updated_at: updatedAt,
-      _status: 'synced',
-      _changed: '',
-    } as any,
-  ])
-
-  postMock.mockResolvedValue({})
-
-  const storesRegistry = { [SYNC_TABLES.CONTENT_PROGRESS]: store }
-  await repairStaleSyncedRecords(storesRegistry)
-
-  const record = await db.read(() => db.get(SYNC_TABLES.CONTENT_PROGRESS).find('fine-1')) as any
-  store.destroy()
-
-  expect(record._raw._status).toBe('synced')
-})