@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/tests/logs/admin-log.test.ts

@@ -0,0 +1,51 @@
+import { Db, MongoClient } from 'mongodb'
+import { MongoMemoryServer } from 'mongodb-memory-server'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+import { writeAdminLog } from '../../src/lib/logs/admin-log'
+import { listLogSummaries } from '../../src/lib/logs/store'
+import { ensureIndexes } from '../../src/lib/profiles/store'
+
+let mongod: MongoMemoryServer
+let client: MongoClient
+let db: Db
+
+beforeAll(async () => {
+  mongod = await MongoMemoryServer.create()
+  client = new MongoClient(mongod.getUri())
+  await client.connect()
+  db = client.db('test')
+  await ensureIndexes(db)
+})
+
+afterAll(async () => {
+  await client.close()
+  await mongod.stop()
+})
+
+beforeEach(async () => {
+  await db.collection('requestLogs').deleteMany({})
+})
+
+describe('writeAdminLog', () => {
+  it('writes an admin log entry with the action and endpoint', async () => {
+    await writeAdminLog(db, 'p1', 'progress_reset', 'hello_world')
+    const entries = await listLogSummaries(db, {})
+    expect(entries).toHaveLength(1)
+    expect(entries[0].kind).toBe('admin')
+    expect(entries[0].profileId).toBe('p1')
+    expect(entries[0].trace.adminAction).toBe('progress_reset')
+    expect(entries[0].trace.adminEndpoint).toBe('hello_world')
+  })
+
+  it('omits adminEndpoint when not provided', async () => {
+    await writeAdminLog(db, 'p2', 'profile_saved')
+    const entries = await listLogSummaries(db, {})
+    expect(entries[0].trace.adminEndpoint).toBeUndefined()
+  })
+
+  it('never throws when the db write fails', async () => {
+    await expect(
+      writeAdminLog({} as unknown as Db, 'p3', 'profile_saved'),
+    ).resolves.toBeUndefined()
+  })
+})

package/.next/standalone/tests/logs/store.test.ts

@@ -0,0 +1,233 @@
+import { Db, MongoClient } from 'mongodb'
+import { MongoMemoryServer } from 'mongodb-memory-server'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+import {
+  clearLogs,
+  getLogEntry,
+  insertLogEntry,
+  listLogEntries,
+  listLogSummaries,
+  type LogEntry,
+} from '../../src/lib/logs/store'
+import { deleteProfile, ensureIndexes, upsertProfile } from '../../src/lib/profiles/store'
+
+let mongod: MongoMemoryServer
+let client: MongoClient
+let db: Db
+
+beforeAll(async () => {
+  mongod = await MongoMemoryServer.create()
+  client = new MongoClient(mongod.getUri())
+  await client.connect()
+  db = client.db('test')
+  await ensureIndexes(db)
+})
+
+afterAll(async () => {
+  await client.close()
+  await mongod.stop()
+})
+
+beforeEach(async () => {
+  await db.collection('requestLogs').deleteMany({})
+  await db.collection('mockProfiles').deleteMany({})
+})
+
+let seq = 0
+function entry(overrides: Partial<LogEntry> = {}): LogEntry {
+  seq += 1
+  return {
+    logId: `lg_test_${seq}`,
+    ts: new Date(Date.now() + seq * 1000),
+    kind: 'request',
+    profileId: 'c1',
+    system: 'hello-system',
+    endpoint: 'hello_world',
+    method: 'POST',
+    path: '/hello/world',
+    query: '',
+    outcome: 'fixture',
+    trace: { scenario: 'default', scenarioSource: 'implicit' },
+    ...overrides,
+  }
+}
+
+describe('log store', () => {
+  it('inserts and lists entries newest first without _id', async () => {
+    const first = entry()
+    const second = entry()
+    await insertLogEntry(db, first)
+    await insertLogEntry(db, second)
+
+    const listed = await listLogEntries(db, {})
+    expect(listed.map((e) => e.logId)).toEqual([second.logId, first.logId])
+    expect(listed.every((e) => !('_id' in e))).toBe(true)
+  })
+
+  it('filters by profile, endpoint, errors, and log id prefix', async () => {
+    await insertLogEntry(db, entry({ profileId: 'c1', endpoint: 'ep_a', logId: 'lg_aaa111' }))
+    await insertLogEntry(db, entry({ profileId: 'c2', endpoint: 'ep_b', logId: 'lg_bbb222' }))
+    await insertLogEntry(
+      db,
+      entry({ profileId: 'c2', endpoint: 'ep_b', logId: 'lg_bbb333', outcome: 'error', error: { code: 'no_match', message: 'x' } }),
+    )
+
+    expect(await listLogEntries(db, { profileId: 'c1' })).toHaveLength(1)
+    expect(await listLogEntries(db, { endpoint: 'ep_b' })).toHaveLength(2)
+    expect(await listLogEntries(db, { errorsOnly: true })).toHaveLength(1)
+    expect(await listLogEntries(db, { logIdQuery: 'lg_bbb' })).toHaveLength(2)
+    expect(await listLogEntries(db, { logIdQuery: 'LG_BBB333' })).toHaveLength(1)
+    expect(await listLogEntries(db, { logIdQuery: 'bbb' })).toHaveLength(0)
+  })
+
+  it('returns only entries newer than the since cursor', async () => {
+    const a = entry()
+    const b = entry()
+    const c = entry()
+    for (const e of [a, b, c]) await insertLogEntry(db, e)
+
+    const newer = await listLogEntries(db, { sinceId: a.logId })
+    expect(newer.map((e) => e.logId)).toEqual([c.logId, b.logId])
+    expect(await listLogEntries(db, { sinceId: c.logId })).toHaveLength(0)
+  })
+
+  it('falls back to the newest page when the since cursor has expired', async () => {
+    await insertLogEntry(db, entry())
+    const listed = await listLogEntries(db, { sinceId: 'lg_gone', limit: 5 })
+    expect(listed).toHaveLength(1)
+  })
+
+  it('caps results at the limit', async () => {
+    for (let i = 0; i < 5; i++) await insertLogEntry(db, entry())
+    expect(await listLogEntries(db, { limit: 3 })).toHaveLength(3)
+  })
+
+  it('clears all logs or a single profile’s logs', async () => {
+    await insertLogEntry(db, entry({ profileId: 'c1' }))
+    await insertLogEntry(db, entry({ profileId: 'c2' }))
+
+    await clearLogs(db, 'c1')
+    expect(await listLogEntries(db, {})).toHaveLength(1)
+
+    await clearLogs(db)
+    expect(await listLogEntries(db, {})).toHaveLength(0)
+  })
+
+  it('deletes a profile’s logs with the profile', async () => {
+    await upsertProfile(db, { profileId: 'c1', endpointScenarios: {} })
+    await insertLogEntry(db, entry({ profileId: 'c1' }))
+    await insertLogEntry(db, entry({ profileId: 'c2' }))
+
+    await deleteProfile(db, 'c1')
+
+    const remaining = await listLogEntries(db, {})
+    expect(remaining).toHaveLength(1)
+    expect(remaining[0].profileId).toBe('c2')
+  })
+
+  it('creates a 24h TTL index on ts and a unique logId index', async () => {
+    const indexes = await db.collection('requestLogs').indexes()
+    expect(indexes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: { ts: 1 }, expireAfterSeconds: 86400 }),
+        expect.objectContaining({ key: { logId: 1 }, unique: true }),
+        expect.objectContaining({ key: { profileId: 1, ts: -1 } }),
+        expect.objectContaining({ key: { endpoint: 1, ts: -1 } }),
+      ]),
+    )
+  })
+
+  it('sinceId keyset does not skip entries sharing the newest millisecond', async () => {
+    const ts = new Date('2026-07-07T09:00:00.000Z')
+    await insertLogEntry(db, entry({ ts, logId: 'lg_k1' }))
+    await insertLogEntry(db, entry({ ts, logId: 'lg_k2' }))
+    await insertLogEntry(db, entry({ ts, logId: 'lg_k3' }))
+
+    // Cursor at the lexicographically-middle id must still return the newer one.
+    const newer = await listLogEntries(db, { sinceId: 'lg_k2' })
+    expect(newer.map((e) => e.logId)).toEqual(['lg_k3'])
+  })
+
+  it('beforeId returns strictly-older entries, newest first', async () => {
+    const a = entry({ ts: new Date('2026-07-07T09:00:01.000Z'), logId: 'lg_o1' })
+    const b = entry({ ts: new Date('2026-07-07T09:00:02.000Z'), logId: 'lg_o2' })
+    const c = entry({ ts: new Date('2026-07-07T09:00:03.000Z'), logId: 'lg_o3' })
+    for (const e of [a, b, c]) await insertLogEntry(db, e)
+
+    const older = await listLogEntries(db, { beforeId: 'lg_o3' })
+    expect(older.map((e) => e.logId)).toEqual(['lg_o2', 'lg_o1'])
+    expect(await listLogEntries(db, { beforeId: 'lg_o1' })).toHaveLength(0)
+  })
+
+  it('beforeId breaks same-millisecond ties by logId', async () => {
+    const ts = new Date('2026-07-07T09:00:00.000Z')
+    await insertLogEntry(db, entry({ ts, logId: 'lg_t1' }))
+    await insertLogEntry(db, entry({ ts, logId: 'lg_t2' }))
+    await insertLogEntry(db, entry({ ts, logId: 'lg_t3' }))
+
+    const older = await listLogEntries(db, { beforeId: 'lg_t3' })
+    expect(older.map((e) => e.logId)).toEqual(['lg_t2', 'lg_t1'])
+  })
+
+  it('unknown beforeId yields no older results', async () => {
+    await insertLogEntry(db, entry())
+    expect(await listLogEntries(db, { beforeId: 'lg_gone' })).toHaveLength(0)
+  })
+
+  it('unknown beforeId with a logId filter still yields no rows and does not throw', async () => {
+    await insertLogEntry(db, entry({ logId: 'lg_srch_1' }))
+    const rows = await listLogEntries(db, { beforeId: 'lg_gone', logIdQuery: 'lg_srch' })
+    expect(rows).toHaveLength(0)
+  })
+
+  it('listLogSummaries omits payload bodies but keeps status and trace', async () => {
+    await insertLogEntry(
+      db,
+      entry({
+        request: { headers: { 'content-type': 'application/json' }, body: { big: 'x' }, truncated: false },
+        response: { status: 201, headers: { 'x-a': 'b' }, body: { ok: true }, truncated: false },
+        trace: { scenario: 'default', scenarioSource: 'implicit' },
+      }),
+    )
+
+    const [summary] = await listLogSummaries(db, {})
+    // `request` is projected out; assert absence with `in` (the type omits it).
+    expect('request' in summary).toBe(false)
+    expect(summary.response).toEqual({ status: 201 })
+    expect(summary.trace).toEqual({ scenario: 'default', scenarioSource: 'implicit' })
+    expect('_id' in summary).toBe(false)
+  })
+
+  it('getLogEntry returns the full entry or null', async () => {
+    await insertLogEntry(db, entry({ logId: 'lg_full', response: { status: 200, headers: {}, body: { ok: 1 }, truncated: false } }))
+    const full = await getLogEntry(db, 'lg_full')
+    expect(full?.response?.body).toEqual({ ok: 1 })
+    expect(await getLogEntry(db, 'lg_missing')).toBeNull()
+  })
+
+  // Regression: the unfiltered first-page/live list sorts by { ts: -1, logId: -1 }.
+  // Without a matching compound index Mongo COLLSCANs the whole collection into a
+  // blocking in-memory SORT — cheap on a tiny test set but ~13s against a real 24h
+  // collection. Assert the plan is index-ordered (IXSCAN, no SORT stage) so the
+  // supporting index is never dropped.
+  it('serves the unfiltered first page from an index without a blocking sort', async () => {
+    for (let i = 0; i < 50; i++) await insertLogEntry(db, entry())
+
+    const plan = await db
+      .collection('requestLogs')
+      .find({}, { projection: { _id: 0, request: 0 } })
+      .sort({ ts: -1, logId: -1 })
+      .limit(100)
+      .explain('executionStats')
+
+    const stages: string[] = []
+    for (let s = plan.queryPlanner.winningPlan; s; s = s.inputStage) {
+      if (s.stage) stages.push(s.stage)
+    }
+    expect(stages).toContain('IXSCAN')
+    expect(stages).not.toContain('SORT')
+    expect(stages).not.toContain('COLLSCAN')
+    // An index-ordered plan fetches only up to `limit` docs, not the whole set.
+    expect(plan.executionStats.totalDocsExamined).toBeLessThanOrEqual(100)
+  })
+})

package/.next/standalone/tests/mock-engine/fixtures.test.ts

@@ -0,0 +1,33 @@
+import path from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { FixtureError, fixtureFilePath, loadFixture } from '../../src/lib/mock-engine/fixtures'
+
+const catalogDir = path.join(__dirname, '../../catalog')
+
+describe('fixtureFilePath', () => {
+  it('builds <catalogDir>/<system-slug>/<endpoint>/<scenario>.json', () => {
+    expect(fixtureFilePath('/x', 'hello-system', 'hello_world', 'default')).toBe(
+      path.join('/x', 'hello-system', 'hello_world', 'default.json'),
+    )
+  })
+})
+
+describe('loadFixture', () => {
+  it('loads the hello world default fixture with its description', () => {
+    const f = loadFixture(catalogDir, 'hello-system', 'hello_world', 'default')
+    expect(f.status).toBe(200)
+    expect(f.description).toBe('Greeting')
+    expect(f.body).toMatchObject({ status: 'success' })
+  })
+
+  it('loads a failure fixture with a non-2xx status', () => {
+    const f = loadFixture(catalogDir, 'hello-system', 'hello_world', 'failure')
+    expect(f.status).toBe(503)
+  })
+
+  it('throws FixtureError for a missing fixture', () => {
+    expect(() => loadFixture(catalogDir, 'hello-system', 'hello_world', 'nope')).toThrow(
+      FixtureError,
+    )
+  })
+})

package/.next/standalone/tests/mock-engine/resolver.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from 'vitest'
+import {
+  compileResolver,
+  resolverFilePath,
+  ResolverCompileError,
+  ResolverRuntimeError,
+  ResolverTimeoutError,
+  type ResolverInput,
+} from '../../src/lib/mock-engine/resolver'
+
+const input = (over: Partial<ResolverInput> = {}): ResolverInput => ({
+  request: { method: 'POST', path: '/x', pathParams: {}, query: {}, headers: {}, body: null },
+  history: [],
+  profileId: null,
+  ...over,
+})
+
+describe('compileResolver', () => {
+  it('runs a default-exported function and returns its value', () => {
+    const r = compileResolver(
+      `export default (i: { history: string[] }) => i.history.length < 2 ? 'pending' : 'success'`,
+      'x/y',
+    )
+    expect(r.invoke(input(), 100)).toBe('pending')
+    expect(r.invoke(input({ history: ['a', 'b'] }), 100)).toBe('success')
+  })
+
+  it('branches on request content', () => {
+    const r = compileResolver(
+      `export default (i: any) => i.request.body?.amount > 10 ? 'flagged' : 'default'`,
+      'x/y',
+    )
+    expect(r.invoke(input({ request: { ...input().request, body: { amount: 99 } } }), 100)).toBe('flagged')
+  })
+
+  it('throws ResolverCompileError on a syntax error', () => {
+    expect(() => compileResolver('export default (=>', 'x/y')).toThrow(ResolverCompileError)
+  })
+
+  it('throws ResolverCompileError when there is no function export', () => {
+    expect(() => compileResolver('export const foo = 1', 'x/y')).toThrow(ResolverCompileError)
+  })
+
+  it('wraps a thrown error as ResolverRuntimeError', () => {
+    const r = compileResolver(`export default () => { throw new Error('boom') }`, 'x/y')
+    expect(() => r.invoke(input(), 100)).toThrow(ResolverRuntimeError)
+  })
+
+  it('classifies a throw whose message contains "timed out" as ResolverRuntimeError', () => {
+    const r = compileResolver(
+      `export default () => { throw new Error('operation timed out while calling upstream') }`,
+      'x/y',
+    )
+    expect(() => r.invoke(input(), 100)).toThrow(ResolverRuntimeError)
+    expect(() => r.invoke(input(), 100)).not.toThrow(ResolverTimeoutError)
+    expect(() => r.invoke(input(), 100)).toThrow(/operation timed out while calling upstream/)
+  })
+
+  it('interrupts an infinite loop as ResolverTimeoutError', () => {
+    const r = compileResolver(`export default () => { while (true) {} }`, 'x/y')
+    expect(() => r.invoke(input(), 50)).toThrow(ResolverTimeoutError)
+  })
+
+  it('has no access to require, process, or fetch', () => {
+    const r = compileResolver(
+      `export default () => (typeof require) + ',' + (typeof process) + ',' + (typeof fetch)`,
+      'x/y',
+    )
+    expect(r.invoke(input(), 100)).toBe('undefined,undefined,undefined')
+  })
+})
+
+describe('resolverFilePath', () => {
+  it('points at <catalogDir>/<system>/<endpoint>/<slug>.ts', () => {
+    expect(resolverFilePath('/cat', 'sys', 'ep', 'by-amount')).toBe('/cat/sys/ep/by-amount.ts')
+  })
+})
+
+describe('compileResolver description export', () => {
+  it('exposes export const description', () => {
+    const compiled = compileResolver(
+      `export const description = 'Routes by amount'\nexport default () => 'success'`,
+      'sys/ep/by-amount.ts',
+    )
+    expect(compiled.description).toBe('Routes by amount')
+  })
+
+  it('leaves description undefined when absent or not a string', () => {
+    expect(compileResolver(`export default () => 'x'`, 'l').description).toBeUndefined()
+    expect(
+      compileResolver(`export const description = 42\nexport default () => 'x'`, 'l').description,
+    ).toBeUndefined()
+  })
+})
+
+describe('compileResolver summary export', () => {
+  it('exposes export const summary', () => {
+    const compiled = compileResolver(
+      `export const summary = 'Flags amounts over 10'\nexport default () => 'success'`,
+      'l',
+    )
+    expect(compiled.summary).toBe('Flags amounts over 10')
+  })
+
+  it('leaves summary undefined when absent or not a string', () => {
+    expect(compileResolver(`export default () => 'x'`, 'l').summary).toBeUndefined()
+    expect(
+      compileResolver(`export const summary = 42\nexport default () => 'x'`, 'l').summary,
+    ).toBeUndefined()
+  })
+
+  it('names the resolver generically in compile errors', () => {
+    expect(() => compileResolver('const nope =', 'sys/ep/broken.ts')).toThrowError(
+      /sys\/ep\/broken\.ts: failed to transpile resolver/,
+    )
+  })
+})

package/.next/standalone/tests/mock-engine/template.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+import type { RequestContext } from '../../src/lib/catalog/selector'
+import {
+  listPlaceholders,
+  PlaceholderError,
+  resolveTemplate,
+} from '../../src/lib/mock-engine/template'
+
+const now = new Date('2026-07-02T10:20:30.000Z')
+
+function ctx(overrides: Partial<RequestContext> = {}): RequestContext {
+  return { body: null, pathParams: {}, query: new URLSearchParams(), headers: {}, ...overrides }
+}
+
+describe('resolveTemplate', () => {
+  it('resolves body, path, and query placeholders in nested structures', () => {
+    const c = ctx({
+      body: { customerId: 'cus-1' },
+      pathParams: { bookingId: 'bk-9' },
+      query: new URLSearchParams('lang=en'),
+    })
+    const result = resolveTemplate(
+      {
+        customerId: '{{$.customerId}}',
+        nested: { booking: 'id={{path:bookingId}}', lang: '{{query:lang}}' },
+        list: ['{{$.customerId}}', 42, true, null],
+        untouched: 7,
+      },
+      c,
+      now,
+    )
+    expect(result).toEqual({
+      customerId: 'cus-1',
+      nested: { booking: 'id=bk-9', lang: 'en' },
+      list: ['cus-1', 42, true, null],
+      untouched: 7,
+    })
+  })
+
+  it('resolves now formatters deterministically from the injected date', () => {
+    expect(resolveTemplate('{{now:YYYYMMDD}}', ctx(), now)).toBe('20260702')
+    expect(resolveTemplate('{{now:iso}}', ctx(), now)).toBe('2026-07-02T10:20:30.000Z')
+  })
+
+  it('stringifies numeric extracted values inside strings', () => {
+    const c = ctx({ body: { n: 7 } })
+    expect(resolveTemplate('n is {{$.n}}', c, now)).toBe('n is 7')
+  })
+
+  it('throws PlaceholderError naming the placeholder when unresolvable', () => {
+    expect(() => resolveTemplate('{{$.missing}}', ctx({ body: {} }), now)).toThrow(
+      PlaceholderError,
+    )
+    expect(() => resolveTemplate('{{$.missing}}', ctx({ body: {} }), now)).toThrow(
+      /\{\{\$\.missing\}\}/,
+    )
+  })
+
+  it('throws PlaceholderError on malformed placeholder expressions', () => {
+    expect(() => resolveTemplate('{{now:nope}}', ctx(), now)).toThrow(PlaceholderError)
+    expect(() => resolveTemplate('{{banana}}', ctx(), now)).toThrow(PlaceholderError)
+  })
+})
+
+describe('listPlaceholders', () => {
+  it('collects every placeholder expression in a structure', () => {
+    const found = listPlaceholders({
+      a: '{{$.x}}',
+      b: ['{{now:iso}}', { c: 'pre {{path:p}} post' }],
+      d: 12,
+    })
+    expect(found.sort()).toEqual(['$.x', 'now:iso', 'path:p'])
+  })
+})

package/.next/standalone/tests/mongo/embedded.test.ts

@@ -0,0 +1,78 @@
+import { MongoClient } from 'mongodb'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { resolveMongoUri, stopEmbeddedMongo } from '../../src/lib/mongo/embedded'
+
+const ORIGINAL = process.env.MONGODB_CONNECTION_STRING
+
+beforeEach(() => {
+  delete process.env.MONGODB_CONNECTION_STRING
+})
+
+afterEach(async () => {
+  await stopEmbeddedMongo()
+  if (ORIGINAL === undefined) delete process.env.MONGODB_CONNECTION_STRING
+  else process.env.MONGODB_CONNECTION_STRING = ORIGINAL
+})
+
+describe('resolveMongoUri', () => {
+  it('returns the configured connection string without booting embedded', async () => {
+    process.env.MONGODB_CONNECTION_STRING = 'mongodb://configured.example:27017'
+    expect(await resolveMongoUri()).toBe('mongodb://configured.example:27017')
+  })
+
+  it('boots an embedded mongod when no connection string is set', async () => {
+    const uri = await resolveMongoUri()
+    expect(uri).toMatch(/^mongodb:\/\//)
+
+    const client = new MongoClient(uri)
+    await client.connect()
+    const ping = await client.db('admin').command({ ping: 1 })
+    expect(ping.ok).toBe(1)
+    await client.close()
+  })
+
+  it('reuses a single embedded instance across concurrent calls', async () => {
+    const [a, b] = await Promise.all([resolveMongoUri(), resolveMongoUri()])
+    expect(a).toBe(b)
+  })
+})
+
+describe('resolveMongoUri boot failure recovery', () => {
+  afterEach(() => {
+    vi.doUnmock('mongodb-memory-server')
+    vi.resetModules()
+  })
+
+  it('clears the memoized promise on boot failure so the next call retries a fresh boot', async () => {
+    // Simulate a transient failure (e.g. binary download hiccup) on the first
+    // MongoMemoryServer.create() call, then a successful boot on the second.
+    const createMock = vi
+      .fn()
+      .mockRejectedValueOnce(new Error('boom: simulated transient boot failure'))
+      .mockResolvedValueOnce({
+        getUri: () => 'mongodb://127.0.0.1:27099/test',
+        stop: vi.fn(async () => {}),
+      })
+
+    vi.doMock('mongodb-memory-server', () => ({
+      MongoMemoryServer: { create: createMock },
+    }))
+    vi.resetModules()
+
+    // Re-import the module fresh so it picks up the mocked dependency and has
+    // its own isolated `embeddedPromise`/`server` module state.
+    const isolated = await import('../../src/lib/mongo/embedded')
+
+    await expect(isolated.resolveMongoUri()).rejects.toThrow(
+      'boom: simulated transient boot failure',
+    )
+
+    // If the singleton were poisoned, this second call would return the same
+    // cached rejection instead of attempting a fresh boot.
+    const uri = await isolated.resolveMongoUri()
+    expect(uri).toBe('mongodb://127.0.0.1:27099/test')
+    expect(createMock).toHaveBeenCalledTimes(2)
+
+    await isolated.stopEmbeddedMongo()
+  })
+})