musora-content-services 2.158.3 → 2.159.0

package/test/integration/content-progress/offlineContentProgress.test.ts

@@ -0,0 +1,226 @@
+import { initializeTestDB } from '../initializeTestDB'
+import {
+  contentStatusCompletedManyOffline,
+  contentStatusCompletedOffline,
+  contentStatusResetOffline,
+  contentStatusStartedOffline,
+  duplicateProgressToALaCarteOffline,
+  recordWatchSessionOffline,
+} from '../../../src/services/offline/progress'
+import { getProgressState } from '../../../src/services/contentProgress.js'
+import { COLLECTION_ID_SELF, COLLECTION_TYPE } from '../../../src/services/sync/models/ContentProgress'
+import db from '../../../src/services/sync/repository-proxy'
+
+jest.mock('../../../src/services/sanity.js', () => require('./__mocks__/mocks').mockSanity())
+jest.mock('../../../src/services/content-org/learning-paths.ts', () => require('./__mocks__/mocks').mockLearningPaths())
+jest.mock('../../../src/services/awards/internal/content-progress-observer', () => require('./__mocks__/mocks').mockContentProgressObserver())
+jest.mock('../../../src/services/progress-events', () => require('./__mocks__/mocks').mockProgressEvents())
+
+jest.mock('../../../src/services/userActivity', () => ({
+  trackUserPractice: jest.fn().mockResolvedValue(undefined),
+}))
+
+const meta = { brand: 'drumeo', type: 'lesson', parent_id: 0 }
+const collectionSelf = { type: COLLECTION_TYPE.SELF, id: COLLECTION_ID_SELF }
+const collectionLP = (id: number) => ({ type: COLLECTION_TYPE.LEARNING_PATH, id })
+
+const flushPromises = async () => {
+  for (let i = 0; i < 200; i++) {
+    await new Promise(resolve => setImmediate(resolve))
+  }
+}
+
+const hierarchyFor = (contentId: number) => ({
+  topLevelId: contentId,
+  parents: {},
+  children: {},
+  metadata: { [contentId]: meta },
+})
+
+const ctx = initializeTestDB()
+
+// ─── contentStatusCompletedOffline ────────────────────────────────────────────
+
+describe('contentStatusCompletedOffline', () => {
+  test('sets state to completed in DB', async () => {
+    await contentStatusCompletedOffline(500, null, hierarchyFor(500))
+    expect(await getProgressState(500)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+
+  test('sets progress_percent to 100 in DB', async () => {
+    await contentStatusCompletedOffline(500, null, hierarchyFor(500))
+    const record = await db.contentProgress.getOneProgressByContentId(500, null)
+    expect(record.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+
+  test('defaults to SELF collection when null is passed', async () => {
+    await contentStatusCompletedOffline(500, null, hierarchyFor(500))
+    const record = await db.contentProgress.getOneProgressByContentId(500, null)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+// ─── contentStatusCompletedManyOffline ────────────────────────────────────────
+
+describe('contentStatusCompletedManyOffline', () => {
+  test('sets all ids to completed state in DB', async () => {
+    const hierarchy = {
+      topLevelId: 501,
+      parents: {},
+      children: {},
+      metadata: { 501: meta, 502: meta, 503: meta },
+    }
+    await contentStatusCompletedManyOffline([501, 502, 503], null, hierarchy)
+    expect(await getProgressState(501)).toBe('completed')
+    expect(await getProgressState(502)).toBe('completed')
+    expect(await getProgressState(503)).toBe('completed')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+
+  test('each record has progress_percent of 100', async () => {
+    const hierarchy = {
+      topLevelId: 501,
+      parents: {},
+      children: {},
+      metadata: { 501: meta, 502: meta },
+    }
+    await contentStatusCompletedManyOffline([501, 502], null, hierarchy)
+    const r1 = await db.contentProgress.getOneProgressByContentId(501, null)
+    const r2 = await db.contentProgress.getOneProgressByContentId(502, null)
+    expect(r1.data?.progress_percent).toBe(100)
+    expect(r2.data?.progress_percent).toBe(100)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+// ─── contentStatusStartedOffline ──────────────────────────────────────────────
+
+describe('contentStatusStartedOffline', () => {
+  test('sets state to started in DB', async () => {
+    await contentStatusStartedOffline(600, null, hierarchyFor(600))
+    expect(await getProgressState(600)).toBe('started')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+
+  test('sets progress_percent to 0 in DB', async () => {
+    await contentStatusStartedOffline(600, null, hierarchyFor(600))
+    const record = await db.contentProgress.getOneProgressByContentId(600, null)
+    expect(record.data?.progress_percent).toBe(0)
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+  })
+})
+
+// ─── contentStatusResetOffline ────────────────────────────────────────────────
+
+describe('contentStatusResetOffline', () => {
+  test('removes record from DB so getProgressState returns empty string', async () => {
+    await contentStatusCompletedOffline(700, null, hierarchyFor(700))
+    expect(await getProgressState(700)).toBe('completed')
+    await contentStatusResetOffline(700)
+    expect(await getProgressState(700)).toBe('')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('save-content-progress')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+  })
+
+  test('defaults to SELF collection when called without collection', async () => {
+    await db.contentProgress.recordProgress(701, null, 80, meta, undefined, { skipPush: true })
+    await contentStatusResetOffline(701)
+    expect(await getProgressState(701)).toBe('')
+    expect(ctx.pushSpies.contentProgress).toHaveBeenCalledWith('reset-status')
+  })
+})
+
+// ─── recordWatchSessionOffline ────────────────────────────────────────────────
+
+describe('recordWatchSessionOffline', () => {
+  const mockUserActivity = jest.requireMock('../../../src/services/userActivity')
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('writes progress to DB and calls trackUserPractice', async () => {
+    await recordWatchSessionOffline(234, 200, 100, 30, hierarchyFor(234))
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(mockUserActivity.trackUserPractice).toHaveBeenCalledWith(234, 30, expect.any(Object))
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('normalizes string contentId to number in DB', async () => {
+    await recordWatchSessionOffline('234' as any, 200, 100, 30, hierarchyFor(234))
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.content_id).toBe(234)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('full duration (200/200) clamps to 99 — never reaches 100 via watch', async () => {
+    await recordWatchSessionOffline(234, 200, 200, 60, hierarchyFor(234))
+    const record = await db.contentProgress.getOneProgressByContentId(234, null)
+    expect(record.data?.progress_percent).toBe(99)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('passes instrumentId and categoryId through to trackUserPractice', async () => {
+    await recordWatchSessionOffline(234, 200, 100, 30, hierarchyFor(234), {
+      instrumentId: 7,
+      categoryId: 9,
+    })
+    expect(mockUserActivity.trackUserPractice).toHaveBeenCalledWith(
+      234,
+      30,
+      expect.objectContaining({ instrumentId: 7, categoryId: 9 }),
+    )
+  })
+})
+
+// ─── duplicateProgressToALaCarteOffline ───────────────────────────────────────
+
+describe('duplicateProgressToALaCarteOffline', () => {
+  test('writes SELF records for a-la-carte collection', async () => {
+    await duplicateProgressToALaCarteOffline({ 101: 50 }, { 101: meta }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.collection_type).toBe(COLLECTION_TYPE.SELF)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('LP collection excludes the LP id itself from duplication', async () => {
+    await duplicateProgressToALaCarteOffline({ 200: 50, 101: 75 }, { 200: meta, 101: meta }, collectionLP(200))
+    await flushPromises()
+    const lpRecord = await db.contentProgress.getOneProgressByContentId(200, null)
+    const lessonRecord = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(lpRecord.data).toBeNull()
+    expect(lessonRecord.data?.progress_percent).toBe(75)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('lower progress than existing is filtered — existing stays unchanged', async () => {
+    await db.contentProgress.recordProgress(101, null, 80, meta, undefined, { skipPush: true })
+    await duplicateProgressToALaCarteOffline({ 101: 50 }, { 101: meta }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(80)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('equal progress passes and record is updated', async () => {
+    await db.contentProgress.recordProgress(101, null, 50, meta, undefined, { skipPush: true })
+    await duplicateProgressToALaCarteOffline({ 101: 50 }, { 101: meta }, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data?.progress_percent).toBe(50)
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+
+  test('empty progresses results in no new records', async () => {
+    await duplicateProgressToALaCarteOffline({}, {}, collectionSelf)
+    await flushPromises()
+    const record = await db.contentProgress.getOneProgressByContentId(101, null)
+    expect(record.data).toBeNull()
+    expect(ctx.pushSpies.contentProgress).not.toHaveBeenCalled()
+  })
+})

package/test/integration/forums.test.ts

@@ -0,0 +1,209 @@
+import { getActiveDiscussions } from '@/services/forums/forums'
+
+const mockGet = jest.fn()
+
+jest.mock('@/infrastructure/http/HttpClient', () => ({
+  HttpClient: jest.fn().mockImplementation(() => ({
+    get: mockGet,
+  })),
+}))
+
+function makeThread(overrides = {}) {
+  return {
+    id: 1,
+    slug: 'test-thread',
+    title: 'Test Thread',
+    locked: false,
+    pinned: false,
+    state: 'open',
+    category_id: 10,
+    post_count: 1,
+    is_read: false,
+    author: {
+      id: 100,
+      display_name: 'Jane Doe',
+      profile_picture_url: 'https://example.com/avatar.jpg',
+      access_level: 'member',
+      signature: null,
+    },
+    last_post: {
+      id: 200,
+      content: 'Hello world',
+      created_at: '2024-01-01T00:00:00Z',
+      created_at_human: '1 day ago',
+      author: null,
+      like_count: 0,
+      is_liked: false,
+    },
+    ...overrides,
+  }
+}
+
+function makePaginatedResponse(threads = [makeThread()]) {
+  return {
+    data: threads,
+    meta: {
+      current_page: 1,
+      per_page: 10,
+      total: threads.length,
+      last_page: 1,
+    },
+  }
+}
+
+describe('getActiveDiscussions', () => {
+  test('returns transformed data and meta', async () => {
+    mockGet.mockResolvedValue(makePaginatedResponse())
+
+    const result = await getActiveDiscussions('drumeo')
+
+    expect(result.data).toHaveLength(1)
+    expect(result.meta).toBeDefined()
+    expect(result.meta.current_page).toBe(1)
+  })
+
+  test('maps thread fields correctly', async () => {
+    mockGet.mockResolvedValue(makePaginatedResponse())
+
+    const result = await getActiveDiscussions('drumeo')
+    const thread = result.data[0]
+
+    expect(thread.id).toBe(1)
+    expect(thread.url).toBe('forums/threads/10/1')
+    expect(thread.title).toBe('Test Thread')
+    expect(thread.post).toBe('Hello world')
+    expect(thread.author.id).toBe(100)
+    expect(thread.author.name).toBe('Jane Doe')
+    expect(thread.author.avatar).toBe('https://example.com/avatar.jpg')
+  })
+
+  test('maps author avatar to empty string when profile_picture_url is null', async () => {
+    const thread = makeThread({
+      author: { id: 1, display_name: 'No Avatar', profile_picture_url: null, access_level: 'member', signature: null },
+    })
+    mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+    const result = await getActiveDiscussions('drumeo')
+
+    expect(result.data[0].author.avatar).toBe('')
+  })
+
+  test('filters out threads with null last_post', async () => {
+    const threads = [makeThread({ last_post: null }), makeThread({ id: 2 })]
+    mockGet.mockResolvedValue(makePaginatedResponse(threads))
+
+    const result = await getActiveDiscussions('drumeo')
+
+    expect(result.data).toHaveLength(1)
+    expect(result.data[0].id).toBe(2)
+  })
+
+  test('filters out threads with null author', async () => {
+    const threads = [makeThread({ author: null }), makeThread({ id: 2 })]
+    mockGet.mockResolvedValue(makePaginatedResponse(threads))
+
+    const result = await getActiveDiscussions('drumeo')
+
+    expect(result.data).toHaveLength(1)
+    expect(result.data[0].id).toBe(2)
+  })
+
+  test('passes brand, page and limit to the HTTP call', async () => {
+    mockGet.mockResolvedValue(makePaginatedResponse())
+
+    await getActiveDiscussions('pianote', { page: 3, limit: 25 })
+
+    expect(mockGet).toHaveBeenCalledWith(
+      '/api/forums/v1/threads/latest?brand=pianote&page=3&limit=25'
+    )
+  })
+
+  test('defaults page to 1 and limit to 10', async () => {
+    mockGet.mockResolvedValue(makePaginatedResponse())
+
+    await getActiveDiscussions('drumeo')
+
+    expect(mockGet).toHaveBeenCalledWith(
+      '/api/forums/v1/threads/latest?brand=drumeo&page=1&limit=10'
+    )
+  })
+
+  describe('stripHtml', () => {
+    test('removes blockquote and its content', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: 'Before<blockquote>quoted text</blockquote>After', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('BeforeAfter')
+    })
+
+    test('removes iframes and their content', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: 'Before<iframe src="x">content</iframe>After', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('BeforeAfter')
+    })
+
+    test('converts <br> to space to prevent word concatenation', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: 'word1<br>word2<br/>word3', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('word1 word2 word3')
+    })
+
+    test('converts closing block-level tags to spaces', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: '<p>word1</p><div>word2</div>', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('word1 word2')
+    })
+
+    test('decodes HTML entities', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: 'a &amp; b &lt;c&gt; &quot;d&quot; &#39;e&#39; f&nbsp;g', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe("a & b <c> \"d\" 'e' f g")
+    })
+
+    test('removes remaining HTML tags', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: '<strong>bold</strong> and <em>italic</em>', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('bold and italic')
+    })
+
+    test('replaces img tags with spaces', async () => {
+      const thread = makeThread({
+        last_post: { id: 1, content: 'word1<img src="x.jpg">word2', created_at: '', created_at_human: '', author: null, like_count: 0, is_liked: false },
+      })
+      mockGet.mockResolvedValue(makePaginatedResponse([thread]))
+
+      const result = await getActiveDiscussions('drumeo')
+
+      expect(result.data[0].post).toBe('word1 word2')
+    })
+  })
+})

package/test/integration/initializeTestDB.ts

@@ -0,0 +1,80 @@
+import { initializeTestService } from '../initializeTests.js'
+import SyncManager from '@/services/sync/manager'
+import { SyncTelemetry } from '@/services/sync/telemetry'
+import { makeContext, makeDatabase, makeTelemetry, makeUserScope } from '../unit/sync/helpers'
+import db from '@/services/sync/repository-proxy'
+
+export interface PushSpies {
+  contentProgress: jest.SpyInstance
+  practices: jest.SpyInstance
+  likes: jest.SpyInstance
+  userAwardProgress: jest.SpyInstance
+  practiceDayNotes: jest.SpyInstance
+}
+
+export interface TestDBContext {
+  pushSpies: PushSpies
+}
+
+export const waitForPushCall = async (
+  spy: jest.SpyInstance,
+  cause: string,
+  timeoutMs = 2000,
+): Promise<void> => {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    if (spy.mock.calls.some(c => c[0] === cause)) return
+    await new Promise(resolve => setImmediate(resolve))
+  }
+}
+
+export function initializeMockPushes(): PushSpies {
+  return {
+    contentProgress: jest.spyOn(db.contentProgress, 'requestPushUnsynced').mockImplementation(() => {
+    }),
+    practices: jest.spyOn(db.practices, 'requestPushUnsynced').mockImplementation(() => {
+    }),
+    likes: jest.spyOn(db.likes, 'requestPushUnsynced').mockImplementation(() => {
+    }),
+    userAwardProgress: jest.spyOn(db.userAwardProgress, 'requestPushUnsynced').mockImplementation(() => {
+    }),
+    practiceDayNotes: jest.spyOn(db.practiceDayNotes, 'requestPushUnsynced').mockImplementation(() => {
+    }),
+  }
+}
+
+export function initializeTestDB(): TestDBContext {
+  const ctx: TestDBContext = { pushSpies: {} as PushSpies }
+
+  beforeAll(() => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      headers: { get: (key: string) => key === 'X-Sync-Intended-User-Id' ? '1' : null },
+      json: () => Promise.resolve({
+        meta: { since: null, max_updated_at: Date.now(), timestamp: Date.now() },
+        entries: [],
+      }),
+    } as any)
+  })
+
+  let teardown: ((mode?: any) => Promise<void>) | null = null
+
+  beforeEach(() => {
+    initializeTestService()
+    const userScope = makeUserScope()
+    SyncTelemetry.setInstance(makeTelemetry(userScope))
+    const manager = new SyncManager(userScope, makeContext(), () => makeDatabase())
+    teardown = SyncManager.assignAndSetupInstance(manager)
+    ctx.pushSpies = initializeMockPushes()
+  })
+
+  afterEach(async () => {
+    for (let i = 0; i < 200; i++) await new Promise(resolve => setImmediate(resolve))
+    await teardown?.('reset')
+    teardown = null
+    SyncTelemetry.clearInstance()
+    ;(SyncManager as any).instance = null
+  })
+
+  return ctx
+}

package/test/{unit → integration}/sync/fetch.test.ts

@@ -1,6 +1,6 @@
 import * as fflate from 'fflate'
 import { handlePull, type SyncPullResponse } from '@/services/sync/fetch'
-import { makeContext } from './helpers/index'
+import { makeContext } from '../../unit/sync/helpers/index'
 import type { EpochMs } from '@/services/sync/index'
 
 // ---

package/test/{unit → integration}/sync/repositories/content-likes.test.ts

@@ -2,7 +2,7 @@ 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 { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
 import ContentLike from '@/services/sync/models/ContentLike'
 import LikesRepository from '@/services/sync/repositories/content-likes'
 

package/test/{unit → integration}/sync/repositories/practices.test.ts

@@ -2,7 +2,7 @@ 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 { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
 import Practice from '@/services/sync/models/Practice'
 import PracticesRepository from '@/services/sync/repositories/practices'
 

package/test/{unit → integration}/sync/repositories/progress.test.ts

@@ -4,7 +4,7 @@ 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 { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
 import ContentProgress, {
   COLLECTION_TYPE,
   COLLECTION_ID_SELF,

package/test/{unit → integration}/sync/repositories/user-award-progress.test.ts

@@ -8,7 +8,7 @@ jest.mock('../../../../src/services/awards/internal/award-definitions', () => ({
 }))
 
 import { Database } from '@nozbe/watermelondb'
-import { makeDatabase, makeStore, resetDatabase } from '../helpers/index'
+import { makeDatabase, makeStore, resetDatabase } from '../../../unit/sync/helpers/index'
 import UserAwardProgress from '@/services/sync/models/UserAwardProgress'
 import UserAwardProgressRepository from '@/services/sync/repositories/user-award-progress'
 import type { CompletionData, AwardDefinition } from '../../../../src/services/awards/types'

package/test/{unit → integration}/sync/store/cross-user-protection.test.ts

@@ -1,6 +1,6 @@
 import { Database } from '@nozbe/watermelondb'
-import { makeTelemetry, makeContext, makePullMock, makePushMock } from '../helpers/index'
-import TestModel, { makeTestDatabase } from '../helpers/TestModel'
+import { makeTelemetry, makeContext, makePullMock, makePushMock } from '../../../unit/sync/helpers/index'
+import TestModel, { makeTestDatabase } from '../../../unit/sync/helpers/TestModel'
 import SyncStore from '@/services/sync/store/index'
 import SyncRetry from '@/services/sync/retry'
 import SyncRunScope from '@/services/sync/run-scope'

package/test/{unit → integration}/sync/store/store-idb.test.ts

@@ -15,8 +15,8 @@
  */
 
 import { IDBFactory } from 'fake-indexeddb'
-import { makeTelemetry, makeContext, makeUserScope, makePullMock, makePushMock, TEST_USER_ID } from '../helpers/index'
-import TestModel, { makeTestDatabase } from '../helpers/TestModel'
+import { makeTelemetry, makeContext, makeUserScope, makePullMock, makePushMock, TEST_USER_ID } from '../../../unit/sync/helpers/index'
+import TestModel, { makeTestDatabase } from '../../../unit/sync/helpers/TestModel'
 import SyncStore from '@/services/sync/store/index'
 import SyncRetry from '@/services/sync/retry'
 import SyncRunScope from '@/services/sync/run-scope'

package/test/{unit → integration}/sync/store/store.test.ts

@@ -1,6 +1,6 @@
 import { Database } from '@nozbe/watermelondb'
-import { makeTelemetry, makeContext, makeUserScope, makePullMock, makePushMock } from '../helpers/index'
-import TestModel, { makeTestDatabase } from '../helpers/TestModel'
+import { makeTelemetry, makeContext, makeUserScope, makePullMock, makePushMock } from '../../../unit/sync/helpers/index'
+import TestModel, { makeTestDatabase } from '../../../unit/sync/helpers/TestModel'
 import SyncStore from '@/services/sync/store/index'
 import SyncRetry from '@/services/sync/retry'
 import SyncRunScope from '@/services/sync/run-scope'