musora-content-services 2.155.0 → 2.155.2

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

@@ -0,0 +1,314 @@
+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/store/cross-user-protection.test.ts

@@ -0,0 +1,217 @@
+import { Database } from '@nozbe/watermelondb'
+import { makeTelemetry, makeContext, makePullMock, makePushMock } from '../helpers/index'
+import TestModel, { makeTestDatabase } from '../helpers/TestModel'
+import SyncStore from '@/services/sync/store/index'
+import SyncRetry from '@/services/sync/retry'
+import SyncRunScope from '@/services/sync/run-scope'
+import type { SyncUserScope } from '@/services/sync/index'
+import { SyncError } from '@/services/sync/errors/index'
+
+// ---
+
+let db: Database
+
+function makeStore(userScope: SyncUserScope, pull = makePullMock()) {
+  const context = makeContext()
+  const telemetry = makeTelemetry(userScope)
+  const retry = new SyncRetry(context, telemetry)
+  const runScope = new SyncRunScope()
+
+  return new SyncStore<TestModel>(
+    { model: TestModel, pull, push: makePushMock() },
+    userScope,
+    context,
+    db,
+    retry,
+    runScope,
+    telemetry
+  )
+}
+
+function makeScope(overrides: Partial<SyncUserScope> = {}): SyncUserScope {
+  return {
+    initialId: 1,
+    getCurrentId: () => 1,
+    ...overrides,
+  }
+}
+
+function makePullResponse(overrides: Partial<{ intendedUserId: number }> = {}) {
+  return jest.fn().mockResolvedValue({
+    ok: true,
+    entries: [],
+    token: Date.now(),
+    previousToken: null,
+    intendedUserId: 1,
+    ...overrides,
+  })
+}
+
+beforeEach(() => {
+  db = makeTestDatabase()
+})
+
+afterEach(async () => {
+  await db.write(async () => db.unsafeResetDatabase())
+})
+
+// ---
+
+describe('write protection (paranoidWrite)', () => {
+  describe('same user', () => {
+    test('write proceeds when getCurrentId matches initialId', async () => {
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => 1 }))
+      const result = await store.insertOne(r => { r.value = 'hello' })
+      store.destroy()
+
+      expect(result.value).toBe('hello')
+    })
+  })
+
+  describe('different user', () => {
+    test('throws SyncError when getCurrentId returns different id', async () => {
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => 2 }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(SyncError)
+      store.destroy()
+    })
+
+    test('error message indicates cross-user write', async () => {
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => 2 }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(
+        'Aborted cross-user write operation'
+      )
+      store.destroy()
+    })
+  })
+
+  describe('null getCurrentId without fetchCurrentId', () => {
+    test('throws SyncError', async () => {
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => null }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(SyncError)
+      store.destroy()
+    })
+
+    test('error message indicates cross-user write', async () => {
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => null }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(
+        'Aborted cross-user write operation'
+      )
+      store.destroy()
+    })
+  })
+
+  describe('fetchCurrentId fallback', () => {
+    test('fetchCurrentId is called when getCurrentId returns null', async () => {
+      const fetchCurrentId = jest.fn().mockResolvedValue(1)
+      const store = makeStore(makeScope({ initialId: 1, getCurrentId: () => null, fetchCurrentId }))
+
+      await store.insertOne(r => { r.value = 'hello' })
+      store.destroy()
+
+      expect(fetchCurrentId).toHaveBeenCalledTimes(1)
+    })
+
+    test('write proceeds when fetchCurrentId resolves to same id', async () => {
+      const store = makeStore(makeScope({
+        initialId: 1,
+        getCurrentId: () => null,
+        fetchCurrentId: () => Promise.resolve(1),
+      }))
+
+      const result = await store.insertOne(r => { r.value = 'resolved' })
+      store.destroy()
+
+      expect(result.value).toBe('resolved')
+    })
+
+    test('throws when fetchCurrentId resolves to different id', async () => {
+      const store = makeStore(makeScope({
+        initialId: 1,
+        getCurrentId: () => null,
+        fetchCurrentId: () => Promise.resolve(2),
+      }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(
+        'Aborted cross-user write operation'
+      )
+      store.destroy()
+    })
+
+    test('throws SyncError when fetchCurrentId rejects', async () => {
+      const store = makeStore(makeScope({
+        initialId: 1,
+        getCurrentId: () => null,
+        fetchCurrentId: () => Promise.reject(new Error('network error')),
+      }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toBeInstanceOf(SyncError)
+      store.destroy()
+    })
+
+    test('error message indicates fetchCurrentId failed', async () => {
+      const store = makeStore(makeScope({
+        initialId: 1,
+        getCurrentId: () => null,
+        fetchCurrentId: () => Promise.reject(new Error('network error')),
+      }))
+
+      await expect(store.insertOne(r => { r.value = 'hello' })).rejects.toThrow(
+        'Aborted cross-user write operation after fetchCurrentId failed'
+      )
+      store.destroy()
+    })
+  })
+})
+
+// ---
+
+describe('pull protection (intendedUserId)', () => {
+  test('pull succeeds when intendedUserId matches initialId', async () => {
+    const store = makeStore(makeScope({ initialId: 1 }), makePullResponse({ intendedUserId: 1 }))
+
+    await expect(store.pull('test')).resolves.not.toThrow()
+    store.destroy()
+  })
+
+  test('throws SyncError when intendedUserId does not match initialId', async () => {
+    const store = makeStore(makeScope({ initialId: 1 }), makePullResponse({ intendedUserId: 2 }))
+
+    await expect(store.pull('test')).rejects.toThrow(SyncError)
+    store.destroy()
+  })
+
+  test('throws when intendedUserId does not match currentId', async () => {
+    const store = makeStore(
+      makeScope({ initialId: 1, getCurrentId: () => 2 }),
+      makePullResponse({ intendedUserId: 1 })
+    )
+
+    await expect(store.pull('test')).rejects.toThrow(SyncError)
+    store.destroy()
+  })
+
+  test('error message indicates intended user mismatch', async () => {
+    const store = makeStore(makeScope({ initialId: 1 }), makePullResponse({ intendedUserId: 2 }))
+
+    await expect(store.pull('test')).rejects.toThrow('Intended user ID does not match')
+    store.destroy()
+  })
+
+  test('throws SyncError when getCurrentId is null and fetchCurrentId rejects during pull', async () => {
+    const store = makeStore(
+      makeScope({
+        initialId: 1,
+        getCurrentId: () => null,
+        fetchCurrentId: () => Promise.reject(new Error('auth error')),
+      }),
+      makePullResponse({ intendedUserId: 1 })
+    )
+
+    await expect(store.pull('test')).rejects.toThrow(SyncError)
+    store.destroy()
+  })
+})

package/test/unit/sync/store/push-coalescer.test.ts

@@ -0,0 +1,156 @@
+import PushCoalescer from '@/services/sync/store/push-coalescer'
+import type BaseModel from '@/services/sync/models/Base'
+import type { SyncPushResponse } from '@/services/sync/fetch'
+
+const BASE_TIME = 1700000000000
+const SUCCESS_RESPONSE: SyncPushResponse = { ok: true, results: [] }
+
+class TestSetup {
+  coalescer = new PushCoalescer()
+
+  record(id: string, timeOffset = 0): BaseModel {
+    return { id, updated_at: BASE_TIME + timeOffset } as unknown as BaseModel
+  }
+
+  mockPusher() {
+    return jest.fn().mockReturnValue(new Promise(() => {}))
+  }
+
+  controllablePusher() {
+    let resolve!: (value: SyncPushResponse) => void
+    let reject!: (error: Error) => void
+
+    const promise = new Promise<SyncPushResponse>((res, rej) => {
+      resolve = res
+      reject = rej
+    })
+
+    return {
+      pusher: jest.fn().mockReturnValue(promise),
+      resolve: () => resolve(SUCCESS_RESPONSE),
+      reject: (error: Error) => reject(error)
+    }
+  }
+}
+
+let setup: TestSetup
+beforeEach(() => {
+  setup = new TestSetup()
+})
+
+describe('coalescing behavior', () => {
+  describe('when to coalesce', () => {
+    test('identical records return same promise', () => {
+      const records = [setup.record('rec-1')]
+      const pusher = setup.mockPusher()
+
+      const p1 = setup.coalescer.push(records, pusher)
+      const p2 = setup.coalescer.push(records, pusher)
+
+      expect(p1).toBe(p2)
+      expect(pusher).toHaveBeenCalledTimes(1)
+    })
+
+    test('same timestamp coalesces', () => {
+      const pusher = setup.mockPusher()
+      const p1 = setup.coalescer.push([setup.record('rec-1')], pusher)
+      const p2 = setup.coalescer.push([setup.record('rec-1')], pusher)
+
+      expect(p1).toBe(p2)
+      expect(pusher).toHaveBeenCalledTimes(1)
+    })
+
+    test('all records must match for multi-record coalescing', () => {
+      const pusher = setup.mockPusher()
+      const records = [setup.record('rec-1'), setup.record('rec-2')]
+
+      const p1 = setup.coalescer.push(records, pusher)
+      const p2 = setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2')], pusher)
+
+      expect(p1).toBe(p2)
+      expect(pusher).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('when NOT to coalesce', () => {
+    test('newer timestamp triggers new push', () => {
+      const pusher = setup.mockPusher()
+
+      setup.coalescer.push([setup.record('rec-1')], pusher)
+      setup.coalescer.push([setup.record('rec-1', 1)], pusher) // +1ms newer
+
+      expect(pusher).toHaveBeenCalledTimes(2)
+    })
+
+    test('different record IDs trigger separate pushes', () => {
+      const pusher = setup.mockPusher()
+
+      setup.coalescer.push([setup.record('rec-1')], pusher)
+      setup.coalescer.push([setup.record('rec-2')], pusher)
+
+      expect(pusher).toHaveBeenCalledTimes(2)
+    })
+
+    test('partial record match prevents coalescing', () => {
+      const pusher = setup.mockPusher()
+
+      setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2')], pusher)
+      setup.coalescer.push([setup.record('rec-1'), setup.record('rec-2', 1)], pusher) // rec-2 newer
+
+      expect(pusher).toHaveBeenCalledTimes(2)
+    })
+  })
+})
+
+describe('intent lifecycle', () => {
+  test('cleans up after successful push', async () => {
+    const { pusher, resolve } = setup.controllablePusher()
+    const records = [setup.record('rec-1')]
+
+    setup.coalescer.push(records, pusher)
+    resolve()
+    await Promise.resolve() // flush cleanup
+
+    // Should trigger new push since intent was cleaned up
+    const newPusher = setup.mockPusher()
+    setup.coalescer.push(records, newPusher)
+    expect(newPusher).toHaveBeenCalled()
+  })
+
+  test('cleans up after failed push', async () => {
+    const { pusher, reject } = setup.controllablePusher()
+    const records = [setup.record('rec-1')]
+
+    const promise = setup.coalescer.push(records, pusher)
+    promise.catch(() => {}) // prevent unhandled rejection
+
+    reject(new Error('push failed'))
+    await Promise.resolve()
+
+    const newPusher = setup.mockPusher()
+    setup.coalescer.push(records, newPusher)
+    expect(newPusher).toHaveBeenCalled()
+  })
+
+  test('coalesces while intent is in-flight', () => {
+    const { pusher } = setup.controllablePusher()
+    const records = [setup.record('rec-1')]
+
+    const p1 = setup.coalescer.push(records, pusher)
+    const p2 = setup.coalescer.push(records, setup.mockPusher())
+
+    expect(p1).toBe(p2) // Same promise returned
+  })
+})
+
+describe('edge cases', () => {
+  test('empty record arrays coalesce', () => {
+    const pusher = setup.mockPusher()
+
+    const p1 = setup.coalescer.push([], pusher)
+    const p2 = setup.coalescer.push([], pusher)
+
+    expect(p1).toBe(p2)
+    expect(pusher).toHaveBeenCalledTimes(1)
+  })
+})

package/test/unit/sync/store/store-idb.test.ts

@@ -17,10 +17,10 @@
 import { IDBFactory } from 'fake-indexeddb'
 import { makeTelemetry, makeContext, makeUserScope, makePullMock, makePushMock, TEST_USER_ID } from '../helpers/index'
 import TestModel, { makeTestDatabase } from '../helpers/TestModel'
-import SyncStore from '../../../../src/services/sync/store/index'
-import SyncRetry from '../../../../src/services/sync/retry'
-import SyncRunScope from '../../../../src/services/sync/run-scope'
-import type { SyncPullResponse } from '../../../../src/services/sync/fetch'
+import SyncStore from '@/services/sync/store/index'
+import SyncRetry from '@/services/sync/retry'
+import SyncRunScope from '@/services/sync/run-scope'
+import type { SyncPullResponse } from '@/services/sync/fetch'
 
 // Fresh IDB instance per test — prevents cross-test transaction leakage
 beforeEach(() => {