musora-content-services 2.167.2 → 2.167.3

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

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

@@ -1,209 +0,0 @@
-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/infrastructure/FetchRequestExecutor.test.ts

@@ -1,88 +0,0 @@
-import { FetchRequestExecutor } from '../../../src/infrastructure/http'
-describe('FetchRequestExecutor', () => {
-  let executor: FetchRequestExecutor
-  beforeEach(() => {
-    executor = new FetchRequestExecutor()
-  })
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-  describe('successful responses', () => {
-    test('returns parsed JSON when content-type is application/json', async () => {
-      const mockData = { id: 1, name: 'test' }
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        headers: { get: jest.fn().mockReturnValue('application/json') },
-        json: jest.fn().mockResolvedValue(mockData),
-        text: jest.fn(),
-      })
-      const result = await executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
-      expect(result).toEqual(mockData)
-    })
-    test('returns text when content-type is not application/json', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        headers: { get: jest.fn().mockReturnValue('text/plain') },
-        json: jest.fn(),
-        text: jest.fn().mockResolvedValue('plain text response'),
-      })
-      const result = await executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
-      expect(result).toBe('plain text response')
-    })
-  })
-  describe('error responses', () => {
-    test('throws HttpError with correct shape when response is not ok', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-        headers: { get: jest.fn().mockReturnValue('application/json') },
-        json: jest.fn().mockResolvedValue({ message: 'not found' }),
-        text: jest.fn(),
-      })
-      await expect(
-        executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
-      ).rejects.toMatchObject({
-        status: 404,
-        statusText: 'Not Found',
-        url: 'https://api.example.com/test',
-        method: 'GET',
-        body: { message: 'not found' },
-      })
-    })
-    test('error body is parsed as JSON when response body is valid JSON', async () => {
-      const errorBody = { message: 'validation failed', code: 422 }
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: false,
-        status: 422,
-        statusText: 'Unprocessable Entity',
-        headers: { get: jest.fn() },
-        json: jest.fn().mockResolvedValue(errorBody),
-        text: jest.fn(),
-      })
-      await expect(
-        executor.execute('https://api.example.com/test', { method: 'POST', headers: {} })
-      ).rejects.toMatchObject({
-        body: errorBody,
-      })
-    })
-    test('error body falls back to text when response body is not JSON', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: { get: jest.fn() },
-        json: jest.fn().mockRejectedValue(new Error('invalid json')),
-        text: jest.fn().mockResolvedValue('Internal Server Error'),
-      })
-      await expect(
-        executor.execute('https://api.example.com/test', { method: 'GET', headers: {} })
-      ).rejects.toMatchObject({
-        body: 'Internal Server Error',
-      })
-    })
-  })
-})
-
-
-

package/test/integration/initializeTestDB.ts

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