musora-content-services 2.167.2 → 2.167.3

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

@@ -1,172 +0,0 @@
-import { Database } from '@nozbe/watermelondb'
-import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
-import { SyncTelemetry, SeverityLevel } from '@/services/sync/telemetry/index'
-import SyncContext from '@/services/sync/context/index'
-import {
-  BaseSessionProvider,
-  BaseConnectivityProvider,
-  BaseVisibilityProvider,
-  NullTabsProvider,
-  BaseDurabilityProvider,
-} 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 ---
-
-function makeDummySentry() {
-  return {
-    captureException: jest.fn(),
-    captureMessage: jest.fn(),
-    addBreadcrumb: jest.fn(),
-    startSpan: jest.fn((options: any, callback: any) => {
-      const mockSpan = {
-        _spanId: 'mock-span-id-0000',
-        _parentSpanId: undefined as string | undefined,
-        end: jest.fn(),
-        setStatus: jest.fn(),
-        setData: jest.fn(),
-        setAttribute: jest.fn(),
-      }
-      return callback ? callback(mockSpan) : mockSpan
-    }),
-    logger: {
-      debug: jest.fn(),
-      info: jest.fn(),
-      warn: jest.fn(),
-      error: jest.fn(),
-      trace: jest.fn(),
-      fatal: jest.fn(),
-      fmt: jest.fn(),
-    },
-  }
-}
-
-export function makeTelemetry(userScope: SyncUserScope) {
-  return new SyncTelemetry(userScope, {
-    Sentry: makeDummySentry(),
-    level: SeverityLevel.FATAL, // silence output in tests
-    pretty: false,
-  })
-}
-
-// --- Context providers ---
-
-class TestSessionProvider extends BaseSessionProvider {
-  getClientId() { return 'test-client-id' }
-}
-
-class TestConnectivityProvider extends BaseConnectivityProvider {
-  private online = true
-  getValue() { return this.online }
-  setOnline(v: boolean) { this.online = v; this['notifyListeners']() }
-}
-
-class TestVisibilityProvider extends BaseVisibilityProvider {
-  getValue() { return true }
-}
-
-class TestDurabilityProvider extends BaseDurabilityProvider {
-  getValue() { return true }
-  failed() {}
-}
-
-export function makeContext() {
-  return new SyncContext({
-    session: new TestSessionProvider(),
-    connectivity: new TestConnectivityProvider(),
-    visibility: new TestVisibilityProvider(),
-    tabs: new NullTabsProvider(),
-    durability: new TestDurabilityProvider(),
-  })
-}
-
-export const TEST_USER_ID = 1
-
-export function makeUserScope(): SyncUserScope {
-  return {
-    initialId: TEST_USER_ID,
-    getCurrentId: () => TEST_USER_ID,
-  }
-}
-
-// --- Database ---
-
-export function makeDatabase(opts: { useIncrementalIndexedDB?: boolean } = {}) {
-  const adapter = new LokiJSAdapter({
-    schema,
-    useWebWorker: false,
-    useIncrementalIndexedDB: opts.useIncrementalIndexedDB ?? false,
-    dbName: `test_${Date.now()}_${Math.random()}`,
-    extraLokiOptions: { autosave: false },
-  })
-
-  return new Database({
-    adapter,
-    modelClasses: Object.values(modelClasses),
-  })
-}
-
-// --- Pull / Push mocks ---
-
-export function makePullMock(overrides: Partial<Extract<SyncPullResponse, { ok: true }>> = {}) {
-  return jest.fn().mockResolvedValue({
-    ok: true,
-    entries: [],
-    token: Date.now(),
-    intendedUserId: TEST_USER_ID,
-    previousToken: null,
-    ...overrides,
-  } as Extract<SyncPullResponse, { ok: true }>)
-}
-
-export function makePushMock(overrides: Partial<Extract<SyncPushResponse, { ok: true }>> = {}) {
-  return jest.fn().mockResolvedValue({
-    ok: true,
-    results: [],
-    ...overrides,
-  } as Extract<SyncPushResponse, { ok: true }>)
-}
-
-// --- SyncStore ---
-
-export function makeStore<TModel extends BaseModel>(
-  model: ModelClass<TModel>,
-  db: Database,
-  config: Partial<SyncStoreConfig<TModel>> = {}
-) {
-  const userScope = makeUserScope()
-  const context = makeContext()
-  const telemetry = makeTelemetry(userScope)
-  const retry = new SyncRetry(context, telemetry)
-  const runScope = new SyncRunScope()
-
-  const store = new SyncStore<TModel>(
-    {
-      model,
-      pull: makePullMock(),
-      push: makePushMock(),
-      ...config,
-    },
-    userScope,
-    context,
-    db,
-    retry,
-    runScope,
-    telemetry
-  )
-
-  return { store, userScope, context, telemetry, retry, runScope }
-}
-
-export async function resetDatabase(db: Database) {
-  await db.write(async () => {
-    await db.unsafeResetDatabase()
-  })
-}

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

@@ -1,303 +0,0 @@
-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/models/user-award-progress.test.ts

@@ -1,82 +0,0 @@
-jest.mock('../../../../src/services/sync/manager', () => ({ default: class SyncManager {} }))
-jest.mock('../../../../src/services/sync/repository-proxy', () => ({ db: {} }))
-
-import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../helpers/index'
-import UserAwardProgress from '../../../../src/services/sync/models/UserAwardProgress'
-import UserAwardProgressRepository from '../../../../src/services/sync/repositories/user-award-progress'
-let db: Database
-let repo: UserAwardProgressRepository
-beforeEach(() => {
-  db = makeDatabase()
-  const { store } = makeStore(UserAwardProgress, db)
-  repo = new UserAwardProgressRepository(store)
-})
-afterEach(async () => {
-  await resetDatabase(db)
-})
-describe('UserAwardProgress model', () => {
-  describe('getters', () => {
-    test('award_id returns raw string value', async () => {
-      await repo.recordAwardProgress('test-award-id', 50)
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.award_id).toBe('test-award-id')
-    })
-    test('progress_percentage returns raw number value', async () => {
-      await repo.recordAwardProgress('test-award-id', 75)
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.progress_percentage).toBe(75)
-    })
-    test('completed_at returns null when not set', async () => {
-      await repo.recordAwardProgress('test-award-id', 50)
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.completed_at).toBeNull()
-    })
-    test('progress_data parses JSON when set', async () => {
-      const progressData = { step: 1, total: 5 }
-      await repo.recordAwardProgress('test-award-id', 50, { progressData })
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.progress_data).toEqual(progressData)
-    })
-    test('progress_data returns null when not set', async () => {
-      await repo.recordAwardProgress('test-award-id', 50)
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.progress_data).toBeNull()
-    })
-    test('completion_data parses JSON when set', async () => {
-      const completionData = {
-        content_title: 'Blues Foundations',
-        completed_at: '2024-01-01T00:00:00Z',
-        days_user_practiced: 14,
-        practice_minutes: 180,
-      }
-      await repo.recordAwardProgress('test-award-id', 100, { completionData })
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.completion_data).toEqual(completionData)
-    })
-    test('completion_data returns null when not set', async () => {
-      await repo.recordAwardProgress('test-award-id', 50)
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.completion_data).toBeNull()
-    })
-  })
-  describe('setters via validators', () => {
-    test.todo('progress_percentage throws SyncValidationError when value exceeds 100')
-    test('completed_at accepts null', async () => {
-      await repo.recordAwardProgress('test-award-id', 50, { completedAt: null })
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.completed_at).toBeNull()
-    })
-    test('completion_data serialises to JSON when set', async () => {
-      const completionData = {
-        content_title: 'Test',
-        completed_at: '2024-01-01T00:00:00Z',
-        days_user_practiced: 5,
-        practice_minutes: 60,
-      }
-      await repo.recordAwardProgress('test-award-id', 100, { completionData })
-      const result = await repo.getByAwardId('test-award-id')
-      expect(result.data?.completion_data).toEqual(completionData)
-    })
-  })
-})