musora-content-services 2.155.0 → 2.155.2

package/test/unit/sync/fetch.test.ts

@@ -0,0 +1,224 @@
+import * as fflate from 'fflate'
+import { handlePull, type SyncPullResponse } from '@/services/sync/fetch'
+import { makeContext } from './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/unit/sync/helpers/TestModel.ts

@@ -1,7 +1,7 @@
 import { appSchema, tableSchema } from '@nozbe/watermelondb'
 import { Database } from '@nozbe/watermelondb'
 import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-import BaseModel from '../../../../src/services/sync/models/Base'
+import BaseModel from '@/services/sync/models/Base'
 
 export const TEST_TABLE = 'test_items'
 

package/test/unit/sync/helpers/index.ts

@@ -1,22 +1,22 @@
 import { Database } from '@nozbe/watermelondb'
 import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-import { SyncTelemetry, SeverityLevel } from '../../../../src/services/sync/telemetry/index'
-import SyncContext from '../../../../src/services/sync/context/index'
+import { SyncTelemetry, SeverityLevel } from '@/services/sync/telemetry/index'
+import SyncContext from '@/services/sync/context/index'
 import {
   BaseSessionProvider,
   BaseConnectivityProvider,
   BaseVisibilityProvider,
   NullTabsProvider,
   BaseDurabilityProvider,
-} from '../../../../src/services/sync/context/providers/index'
-import SyncRetry from '../../../../src/services/sync/retry'
-import SyncRunScope from '../../../../src/services/sync/run-scope'
-import SyncStore, { type SyncStoreConfig } from '../../../../src/services/sync/store/index'
-import schema from '../../../../src/services/sync/schema/index'
-import * as modelClasses from '../../../../src/services/sync/models/index'
-import type BaseModel from '../../../../src/services/sync/models/Base'
-import type { ModelClass, SyncUserScope } from '../../../../src/services/sync/index'
-import type { SyncPullResponse, SyncPushResponse } from '../../../../src/services/sync/fetch'
+} from '@/services/sync/context/providers/index'
+import SyncRetry from '@/services/sync/retry'
+import SyncRunScope from '@/services/sync/run-scope'
+import SyncStore, { type SyncStoreConfig } from '@/services/sync/store/index'
+import schema from '@/services/sync/schema/index'
+import * as modelClasses from '@/services/sync/models/index'
+import type BaseModel from '@/services/sync/models/Base'
+import type { ModelClass, SyncUserScope } from '@/services/sync/index'
+import type { SyncPullResponse, SyncPushResponse } from '@/services/sync/fetch'
 
 // --- Sentry / Telemetry ---
 
@@ -44,7 +44,7 @@ function makeDummySentry() {
       trace: jest.fn(),
       fatal: jest.fn(),
       fmt: jest.fn(),
-    } as any,
+    },
   }
 }
 

package/test/unit/sync/manager.test.ts

@@ -0,0 +1,303 @@
+import SyncManager from '@/services/sync/manager'
+import { SyncTelemetry } from '@/services/sync/telemetry/index'
+import { SyncError } from '@/services/sync/errors/index'
+import BaseModel from '@/services/sync/models/Base'
+import createStoreConfigs from '@/services/sync/store-configs'
+import { makeTelemetry, makeContext, makeUserScope, makeDatabase } from './helpers/index'
+import type { ModelClass, SyncUserScope } from '@/services/sync/index'
+
+class DummyModelA extends BaseModel { static table = 'dummy_a' }
+class DummyModelB extends BaseModel { static table = 'dummy_b' }
+class UnknownModel extends BaseModel { static table = 'not_a_real_table' }
+
+jest.mock('../../../src/services/awards/internal/content-progress-observer', () => ({
+  contentProgressObserver: {
+    start: jest.fn().mockResolvedValue(undefined),
+    stop: jest.fn(),
+  },
+}))
+
+// ---
+
+function makeMockStrategy() {
+  return {
+    start: jest.fn(),
+    stop: jest.fn(),
+    onTrigger: jest.fn().mockReturnThis(),
+  }
+}
+
+function makeMockEffect() {
+  const teardown = jest.fn()
+  const effect = jest.fn().mockReturnValue(teardown)
+  return { effect, teardown }
+}
+
+function buildManager(opts: {
+  userScope?: SyncUserScope
+  destroy?: jest.Mock
+  abort?: jest.Mock
+} = {}) {
+  const userScope = opts.userScope ?? makeUserScope()
+  const context = makeContext()
+  const teardownDatabase = {
+    ...(opts.destroy && { destroy: opts.destroy }),
+    ...(opts.abort && { abort: opts.abort }),
+  }
+
+  return new SyncManager(userScope, context, () => makeDatabase(), teardownDatabase)
+}
+
+function assignManager(manager: SyncManager) {
+  return SyncManager.assignAndSetupInstance(manager)
+}
+
+function setupManager(opts: Parameters<typeof buildManager>[0] = {}) {
+  const manager = buildManager(opts)
+  const teardown = assignManager(manager)
+  return { manager, teardown }
+}
+
+// ---
+
+beforeEach(() => {
+  SyncTelemetry.setInstance(makeTelemetry(makeUserScope()))
+})
+
+afterEach(() => {
+  SyncTelemetry.clearInstance()
+  ;(SyncManager as any).instance = null
+})
+
+// ---
+
+describe('singleton lifecycle', () => {
+  test('getInstance throws before any setup', () => {
+    expect(() => SyncManager.getInstance()).toThrow(SyncError)
+  })
+
+  test('getInstanceOrNull returns null before any setup', () => {
+    expect(SyncManager.getInstanceOrNull()).toBeNull()
+  })
+
+  test('getInstance returns manager after setup', async () => {
+    const { manager, teardown } = setupManager()
+    expect(SyncManager.getInstance()).toBe(manager)
+    await teardown()
+  })
+
+  test('getInstanceOrNull returns manager after setup', async () => {
+    const { manager, teardown } = setupManager()
+    expect(SyncManager.getInstanceOrNull()).toBe(manager)
+    await teardown()
+  })
+
+  test('assignAndSetupInstance throws if called while instance exists', async () => {
+    const { teardown } = setupManager()
+    expect(() => assignManager(buildManager())).toThrow(SyncError)
+    await teardown()
+  })
+
+  test('getInstance throws after teardown', async () => {
+    const { teardown } = setupManager()
+    await teardown()
+    expect(() => SyncManager.getInstance()).toThrow(SyncError)
+  })
+
+  test('getInstanceOrNull returns null after teardown', async () => {
+    const { teardown } = setupManager()
+    await teardown()
+    expect(SyncManager.getInstanceOrNull()).toBeNull()
+  })
+
+  test('new instance can be set up after teardown', async () => {
+    const { teardown: t1 } = setupManager()
+    await t1()
+
+    const { manager: m2, teardown: t2 } = setupManager()
+    expect(SyncManager.getInstance()).toBe(m2)
+    await t2()
+  })
+})
+
+// ---
+
+describe('store registry', () => {
+  test('all configured model tables have stores', async () => {
+    const { manager, teardown } = setupManager()
+    const configuredTables = createStoreConfigs().map(c => c.model.table)
+    const registeredTables = Object.keys(manager.getAllStores())
+
+    expect(registeredTables.sort()).toEqual(configuredTables.sort())
+    await teardown()
+  })
+
+  test('getStore returns store for a registered model', async () => {
+    const { manager, teardown } = setupManager()
+    const anyConfiguredModel = createStoreConfigs()[0].model as unknown as ModelClass
+    expect(manager.getStore(anyConfiguredModel)).toBeDefined()
+    await teardown()
+  })
+
+  test('getStore throws SyncError for unregistered model', async () => {
+    const { manager, teardown } = setupManager()
+    expect(() => manager.getStore(UnknownModel)).toThrow(SyncError)
+    await teardown()
+  })
+})
+
+// ---
+
+describe('getId', () => {
+  test('successive instances get different ids', async () => {
+    const { manager: m1, teardown: t1 } = setupManager()
+    const id1 = m1.getId()
+    await t1()
+
+    const { manager: m2, teardown: t2 } = setupManager()
+    const id2 = m2.getId()
+    await t2()
+
+    expect(id1).not.toBe(id2)
+  })
+})
+
+// ---
+
+describe('strategy registration', () => {
+  test('strategy.start called during setup', async () => {
+    const manager = buildManager()
+    const strategy = makeMockStrategy()
+    manager.registerStrategies([DummyModelA], [strategy])
+    const teardown = assignManager(manager)
+
+    expect(strategy.start).toHaveBeenCalledTimes(1)
+    await teardown()
+  })
+
+  test('strategy.stop called during teardown', async () => {
+    const manager = buildManager()
+    const strategy = makeMockStrategy()
+    manager.registerStrategies([DummyModelA], [strategy])
+    const teardown = assignManager(manager)
+    await teardown()
+
+    expect(strategy.stop).toHaveBeenCalledTimes(1)
+  })
+
+  test('onTrigger called once per registered model', async () => {
+    const manager = buildManager()
+    const strategy = makeMockStrategy()
+    manager.registerStrategies([DummyModelA, DummyModelB], [strategy])
+    const teardown = assignManager(manager)
+
+    expect(strategy.onTrigger).toHaveBeenCalledTimes(2)
+    await teardown()
+  })
+
+  test('multiple strategies all started and stopped', async () => {
+    const manager = buildManager()
+    const s1 = makeMockStrategy()
+    const s2 = makeMockStrategy()
+    manager.registerStrategies([DummyModelA], [s1, s2])
+    const teardown = assignManager(manager)
+    await teardown()
+
+    expect(s1.start).toHaveBeenCalledTimes(1)
+    expect(s2.start).toHaveBeenCalledTimes(1)
+    expect(s1.stop).toHaveBeenCalledTimes(1)
+    expect(s2.stop).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ---
+
+describe('effect registration', () => {
+  test('effect called with context and stores during setup', async () => {
+    const manager = buildManager()
+    const { effect, teardown: effectTeardown } = makeMockEffect()
+    manager.registerEffects([DummyModelA], [effect])
+    const teardown = assignManager(manager)
+
+    expect(effect).toHaveBeenCalledTimes(1)
+    expect(effect).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.any(Array)
+    )
+
+    await teardown()
+  })
+
+  test('effect receives one store per registered model', async () => {
+    const manager = buildManager()
+    const { effect } = makeMockEffect()
+    manager.registerEffects([DummyModelA, DummyModelB], [effect])
+    const teardown = assignManager(manager)
+
+    const [, stores] = effect.mock.calls[0]
+    expect(stores).toHaveLength(2)
+
+    await teardown()
+  })
+
+  test('effect teardown called during manager teardown', async () => {
+    const manager = buildManager()
+    const { effect, teardown: effectTeardown } = makeMockEffect()
+    manager.registerEffects([DummyModelA], [effect])
+    const teardown = assignManager(manager)
+    await teardown()
+
+    expect(effectTeardown).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ---
+
+describe('teardown modes', () => {
+  test('reset mode resolves', async () => {
+    const { teardown } = setupManager()
+    await expect(teardown('reset')).resolves.toBeUndefined()
+  })
+
+  test('default mode (no arg) resolves', async () => {
+    const { teardown } = setupManager()
+    await expect(teardown()).resolves.toBeUndefined()
+  })
+
+  test('destroyOrReset calls destroy with dbName and adapter', async () => {
+    const destroy = jest.fn().mockResolvedValue(undefined)
+    const { teardown } = setupManager({ destroy })
+    await expect(teardown('destroyOrReset')).resolves.toBeUndefined()
+    expect(destroy).toHaveBeenCalledTimes(1)
+    expect(destroy).toHaveBeenCalledWith(expect.any(String), expect.anything())
+  })
+
+  test('abortWrites rejects when no implementation provided', async () => {
+    const { teardown } = setupManager()
+    await expect(teardown('abortWrites')).rejects.toThrow(
+      'Cannot abort writes to database - implementation not provided'
+    )
+  })
+
+  test('abortWrites calls abort with underlying adapter', async () => {
+    const abort = jest.fn().mockResolvedValue(undefined)
+    const { teardown } = setupManager({ abort })
+    await expect(teardown('abortWrites')).resolves.toBeUndefined()
+    expect(abort).toHaveBeenCalledTimes(1)
+  })
+
+  test('concurrent teardown calls both resolve', async () => {
+    const { teardown } = setupManager()
+    await expect(Promise.all([teardown(), teardown()])).resolves.toBeDefined()
+  })
+})
+
+// ---
+
+describe('abort', () => {
+  test('does not throw', async () => {
+    const { manager, teardown } = setupManager()
+    expect(() => manager.abort('test reason')).not.toThrow()
+    await teardown()
+  })
+})

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

@@ -1,10 +1,10 @@
-jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+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 '../helpers/index'
-import ContentLike from '../../../../src/services/sync/models/ContentLike'
-import LikesRepository from '../../../../src/services/sync/repositories/content-likes'
+import ContentLike from '@/services/sync/models/ContentLike'
+import LikesRepository from '@/services/sync/repositories/content-likes'
 
 let db: Database
 let repo: LikesRepository

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

@@ -1,10 +1,10 @@
-jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+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 '../helpers/index'
-import Practice from '../../../../src/services/sync/models/Practice'
-import PracticesRepository from '../../../../src/services/sync/repositories/practices'
+import Practice from '@/services/sync/models/Practice'
+import PracticesRepository from '@/services/sync/repositories/practices'
 
 let db: Database
 let repo: PracticesRepository

package/test/unit/sync/repositories/progress.test.ts

@@ -1,7 +1,7 @@
 // Break circular dep: sync/index → manager → award chain → UserAwardProgressRepository
 // extends SyncRepository before it's defined in the module evaluation order.
-jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
+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 '../helpers/index'
@@ -9,8 +9,8 @@ import ContentProgress, {
   COLLECTION_TYPE,
   COLLECTION_ID_SELF,
   STATE,
-} from '../../../../src/services/sync/models/ContentProgress'
-import ProgressRepository from '../../../../src/services/sync/repositories/content-progress'
+} from '@/services/sync/models/ContentProgress'
+import ProgressRepository from '@/services/sync/repositories/content-progress'
 
 let db: Database
 let repo: ProgressRepository