musora-content-services 2.167.1 → 2.167.3

package/test/unit/sync/context.test.ts

@@ -1,51 +0,0 @@
-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/effects/logout-warning.test.ts

@@ -1,158 +0,0 @@
-import createLogoutWarningEffect from '@/services/sync/effects/logout-warning'
-import type SyncStore from '@/services/sync/store/index'
-import { makeContext } from '../helpers/index'
-
-// ---
-
-function makeMockStore(model: any = { table: 'test' }) {
-  let handler: ((records: any[]) => void) | null = null
-
-  const store = {
-    model,
-    collection: {
-      query: jest.fn().mockReturnValue({
-        observe: jest.fn().mockReturnValue({
-          subscribe: (h: (records: any[]) => void) => {
-            handler = h
-            return { unsubscribe: () => { handler = null } }
-          },
-        }),
-      }),
-    },
-  } as unknown as SyncStore
-
-  const push = (records: any[]) => handler?.(records)
-
-  return { store, push }
-}
-
-// ---
-
-describe('notification on unsynced records', () => {
-  test('notifyCallback called when unsynced records appear', () => {
-    const notify = jest.fn()
-    const { store, push } = makeMockStore()
-
-    createLogoutWarningEffect(notify)(makeContext(), [store])
-    push([{ id: 'rec-1' }])
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-
-  test('notifyCallback called with the model class of the store', () => {
-    const notify = jest.fn()
-    const model = { table: 'content_progress' }
-    const { store, push } = makeMockStore(model)
-
-    createLogoutWarningEffect(notify)(makeContext(), [store])
-    push([{ id: 'rec-1' }])
-
-    expect(notify.mock.calls[0][0]).toContain(model)
-  })
-
-  test('notifyCallback called with empty array when records go back to zero', () => {
-    const notify = jest.fn()
-    const { store, push } = makeMockStore()
-
-    createLogoutWarningEffect(notify)(makeContext(), [store])
-    push([{ id: 'rec-1' }])
-    push([])
-
-    expect(notify).toHaveBeenCalledTimes(2)
-    expect(notify.mock.calls[1][0]).toHaveLength(0)
-  })
-
-  test('model removed from unsyncedModels when records cleared', () => {
-    const notify = jest.fn()
-    const model = { table: 'content_progress' }
-    const { store, push } = makeMockStore(model)
-
-    createLogoutWarningEffect(notify)(makeContext(), [store])
-    push([{ id: 'rec-1' }])
-    push([])
-
-    expect(notify.mock.calls[1][0]).not.toContain(model)
-  })
-})
-
-// ---
-
-describe('multiple stores', () => {
-  test('tracks unsynced models across stores independently', () => {
-    const notify = jest.fn()
-    const modelA = { table: 'content_progress' }
-    const modelB = { table: 'content_likes' }
-    const storeA = makeMockStore(modelA)
-    const storeB = makeMockStore(modelB)
-
-    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
-
-    storeA.push([{ id: 'rec-1' }])
-    storeB.push([{ id: 'rec-2' }])
-
-    const lastCall = notify.mock.calls[notify.mock.calls.length - 1][0]
-    expect(lastCall).toContain(modelA)
-    expect(lastCall).toContain(modelB)
-  })
-
-  test('clears only the model whose records were resolved', () => {
-    const notify = jest.fn()
-    const modelA = { table: 'content_progress' }
-    const modelB = { table: 'content_likes' }
-    const storeA = makeMockStore(modelA)
-    const storeB = makeMockStore(modelB)
-
-    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
-
-    storeA.push([{ id: 'rec-1' }])
-    storeB.push([{ id: 'rec-2' }])
-    storeA.push([]) // storeA resolved
-
-    const lastCall = notify.mock.calls[notify.mock.calls.length - 1][0]
-    expect(lastCall).not.toContain(modelA)
-    expect(lastCall).toContain(modelB)
-  })
-
-  test('notifies once per store event regardless of other stores', () => {
-    const notify = jest.fn()
-    const storeA = makeMockStore({ table: 'a' })
-    const storeB = makeMockStore({ table: 'b' })
-
-    createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
-
-    storeA.push([{ id: '1' }])
-    storeA.push([{ id: '1' }])
-    storeB.push([{ id: '2' }])
-
-    expect(notify).toHaveBeenCalledTimes(3)
-  })
-})
-
-// ---
-
-describe('teardown', () => {
-  test('teardown unsubscribes all store subscriptions', () => {
-    const notify = jest.fn()
-    const { store, push } = makeMockStore()
-
-    const teardown = createLogoutWarningEffect(notify)(makeContext(), [store])
-    teardown()
-    push([{ id: 'rec-1' }])
-
-    expect(notify).not.toHaveBeenCalled()
-  })
-
-  test('teardown unsubscribes all stores', () => {
-    const notify = jest.fn()
-    const storeA = makeMockStore({ table: 'a' })
-    const storeB = makeMockStore({ table: 'b' })
-
-    const teardown = createLogoutWarningEffect(notify)(makeContext(), [storeA.store, storeB.store])
-    teardown()
-
-    storeA.push([{ id: '1' }])
-    storeB.push([{ id: '2' }])
-
-    expect(notify).not.toHaveBeenCalled()
-  })
-})

package/test/unit/sync/effects/push-failure-notification.test.ts

@@ -1,196 +0,0 @@
-import createPushFailureNotificationEffect, { NOTIFICATION_COOLDOWN, MUTE_PERIOD } from '@/services/sync/effects/push-failure-notification'
-import type SyncStore from '@/services/sync/store/index'
-import { makeContext } from '../helpers/index'
-
-// ---
-
-beforeEach(() => {
-  jest.useFakeTimers()
-})
-
-afterEach(() => {
-  jest.useRealTimers()
-})
-
-// ---
-
-function makeMockStore() {
-  const listeners = new Map<string, (() => void)[]>()
-
-  const store = {
-    on: jest.fn().mockImplementation((event: string, handler: () => void) => {
-      const list = listeners.get(event) ?? []
-      list.push(handler)
-      listeners.set(event, list)
-      return () => {
-        const idx = list.indexOf(handler)
-        if (idx >= 0) list.splice(idx, 1)
-      }
-    }),
-  } as unknown as SyncStore
-
-  const emit = (event: string) => listeners.get(event)?.forEach(h => h())
-
-  return { store, emit }
-}
-
-function makeEffect(notify = jest.fn()) {
-  const effect = createPushFailureNotificationEffect(notify)
-  return { effect, notify }
-}
-
-// ---
-
-describe('notification triggering', () => {
-  test('notifyCallback called when failedPush fires', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-
-  test('notifyCallback called with mute function', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    expect(notify.mock.calls[0][0]).toHaveProperty('mute')
-    expect(typeof notify.mock.calls[0][0].mute).toBe('function')
-  })
-
-  test('failedPush on any store triggers notification', () => {
-    const s1 = makeMockStore()
-    const s2 = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [s1.store, s2.store])
-
-    s2.emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-})
-
-// ---
-
-describe('cooldown', () => {
-  test('second failedPush within cooldown does not notify again', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-
-  test('notifies again after cooldown expires', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(2)
-  })
-
-  test('does not notify just before cooldown expires', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN - 1)
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-})
-
-// ---
-
-describe('mute', () => {
-  test('mute() prevents further notifications', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    const { mute } = notify.mock.calls[0][0]
-    mute()
-
-    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-
-  test('notifications resume after mute period expires', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    const { mute } = notify.mock.calls[0][0]
-    mute()
-
-    jest.advanceTimersByTime(MUTE_PERIOD + NOTIFICATION_COOLDOWN)
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(2)
-  })
-
-  test('mute does not suppress notification already in progress', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    effect(makeContext(), [store])
-    emit('failedPush')
-
-    expect(notify).toHaveBeenCalledTimes(1)
-  })
-})
-
-// ---
-
-describe('teardown', () => {
-  test('teardown prevents further notifications', () => {
-    const { store, emit } = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    const teardown = effect(makeContext(), [store])
-    teardown()
-
-    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
-    emit('failedPush')
-
-    expect(notify).not.toHaveBeenCalled()
-  })
-
-  test('teardown unsubscribes all stores', () => {
-    const s1 = makeMockStore()
-    const s2 = makeMockStore()
-    const { effect, notify } = makeEffect()
-
-    const teardown = effect(makeContext(), [s1.store, s2.store])
-    teardown()
-
-    jest.advanceTimersByTime(NOTIFICATION_COOLDOWN)
-    s1.emit('failedPush')
-    s2.emit('failedPush')
-
-    expect(notify).not.toHaveBeenCalled()
-  })
-})

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

@@ -1,106 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/helpers/TestModel.ts

@@ -1,44 +0,0 @@
-import { appSchema, tableSchema } from '@nozbe/watermelondb'
-import { Database } from '@nozbe/watermelondb'
-import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-import BaseModel from '@/services/sync/models/Base'
-
-export const TEST_TABLE = 'test_items'
-
-export const testSchema = appSchema({
-  version: 1,
-  tables: [
-    tableSchema({
-      name: TEST_TABLE,
-      columns: [
-        { name: 'server_record_id', type: 'number' },
-        { name: 'value', type: 'string' },
-        { name: 'score', type: 'number' },
-        { name: 'created_at', type: 'number' },
-        { name: 'updated_at', type: 'number' },
-      ],
-    }),
-  ],
-})
-
-export default class TestModel extends BaseModel {
-  static table = TEST_TABLE
-
-  get value() { return this._getRaw('value') as string }
-  get score() { return this._getRaw('score') as number }
-
-  set value(v: string) { this._setRaw('value', v) }
-  set score(v: number) { this._setRaw('score', v) }
-}
-
-export function makeTestDatabase(opts: { useIncrementalIndexedDB?: boolean; dbName?: string } = {}) {
-  const adapter = new LokiJSAdapter({
-    schema: testSchema,
-    useWebWorker: false,
-    useIncrementalIndexedDB: opts.useIncrementalIndexedDB ?? false,
-    dbName: opts.dbName ?? `test_store_${Date.now()}_${Math.random()}`,
-    extraLokiOptions: { autosave: false },
-  })
-
-  return new Database({ adapter, modelClasses: [TestModel] })
-}