@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/src/lib/runtime.ts

@@ -0,0 +1,150 @@
+import fs from 'node:fs'
+import { loadCatalog } from './catalog/load'
+import { type SchemaRegistry } from './catalog/schema'
+import type { Catalog } from './catalog/types'
+import { validateAppConfig, validateCatalog } from './catalog/validate'
+import {
+  parseConsoleLogLevel,
+  parsePassthroughAsDefault,
+  parseRequestLogTtlSeconds,
+  parseResolverHistoryLimit,
+  parseUnmockedUsers,
+  resolveCatalogDir,
+  type ConsoleLogLevel,
+  type UnmockedUsers,
+} from './config'
+import { fixtureFilePath, FixtureError, loadFixture, type Fixture } from './mock-engine/fixtures'
+import {
+  compileResolver,
+  resolverFilePath,
+  type CompiledResolver,
+} from './mock-engine/resolver'
+
+export interface Runtime {
+  catalog: Catalog
+  catalogDir: string
+  passthroughAsDefault: boolean
+  unmockedUsers: UnmockedUsers
+  consoleLogLevel: ConsoleLogLevel
+  timeoutMs: number
+  schemas: SchemaRegistry
+  resolverHistoryLimit: number
+  loadFixture: (systemSlug: string, endpointName: string, scenario: string) => Fixture
+  getCompiledResolver: (
+    systemSlug: string,
+    endpointName: string,
+    slug: string,
+  ) => CompiledResolver | null
+}
+
+let runtime: Runtime | null = null
+
+function resolverKey(systemSlug: string, endpointName: string, slug: string): string {
+  return `${systemSlug}/${endpointName}/${slug}`
+}
+
+// Compiles every endpoint's <slug>.ts resolvers at startup, aggregating
+// failures into the same fail-fast error list as catalog/config problems.
+// Also patches each resolver-backed scenario's UI label and summary from the
+// compiled module's optional `description`/`summary` exports (label = slug
+// otherwise).
+export function compileResolvers(
+  catalog: Catalog,
+  catalogDir: string,
+): { resolvers: Map<string, CompiledResolver>; errors: string[] } {
+  const resolvers = new Map<string, CompiledResolver>()
+  const errors: string[] = []
+  for (const system of catalog.systems) {
+    for (const endpoint of system.endpoints) {
+      for (const slug of endpoint.resolverScenarios) {
+        const label = `${system.slug}/${endpoint.name}/${slug}.ts`
+        try {
+          const source = fs.readFileSync(
+            resolverFilePath(catalogDir, system.slug, endpoint.name, slug),
+            'utf8',
+          )
+          const compiled = compileResolver(source, label)
+          resolvers.set(resolverKey(system.slug, endpoint.name, slug), compiled)
+          const meta = (endpoint.scenarios[slug] ??= { label: slug })
+          if (compiled.description) meta.label = compiled.description
+          if (compiled.summary) meta.summary = compiled.summary
+        } catch (err) {
+          errors.push(err instanceof Error ? err.message : String(err))
+        }
+      }
+    }
+  }
+  return { resolvers, errors }
+}
+
+// Dev-mode counterpart to compileResolvers: re-reads and re-compiles a single
+// endpoint's <slug>.ts per call so edits apply live. A compile error here
+// surfaces as a request-time 500 rather than a startup failure.
+function devCompileResolver(
+  catalog: Catalog,
+  catalogDir: string,
+  systemSlug: string,
+  endpointName: string,
+  slug: string,
+): CompiledResolver | null {
+  const endpoint = catalog.systems
+    .find((s) => s.slug === systemSlug)
+    ?.endpoints.find((e) => e.name === endpointName)
+  if (!endpoint?.resolverScenarios.includes(slug)) return null
+  const source = fs.readFileSync(resolverFilePath(catalogDir, systemSlug, endpointName, slug), 'utf8')
+  return compileResolver(source, `${systemSlug}/${endpointName}/${slug}.ts`)
+}
+
+// Startup validation gate: the first request (or page render) that touches
+// the runtime fails hard if catalog, fixtures, and app config are out of sync.
+export function getRuntime(): Runtime {
+  if (runtime) return runtime
+  const passthroughAsDefault = parsePassthroughAsDefault(process.env.PASSTHROUGH_AS_DEFAULT)
+  const unmockedUsers = parseUnmockedUsers(process.env.UNMOCKED_USERS)
+  const consoleLogLevel = parseConsoleLogLevel(process.env.MOCK_CONSOLE_LOG_LEVEL)
+  const resolverHistoryLimit = parseResolverHistoryLimit(process.env.RESOLVER_HISTORY_LIMIT)
+  // Validate REQUEST_LOG_TTL_DURATION at the same startup gate as the other
+  // config; the value itself is re-parsed by ensureIndexes (which runs on first
+  // DB connect, independent of the runtime), so we discard it here.
+  parseRequestLogTtlSeconds(process.env.REQUEST_LOG_TTL_DURATION)
+
+  const catalogDir = resolveCatalogDir(process.env.CATALOG_PATH)
+  const catalog = loadCatalog(catalogDir)
+  const { errors: catalogErrors, fixtures, schemas } = validateCatalog(catalog, catalogDir)
+  const configErrors = validateAppConfig(catalog, process.env, passthroughAsDefault)
+  const { resolvers, errors: resolverErrors } = compileResolvers(catalog, catalogDir)
+  const errors = [...catalogErrors, ...configErrors, ...resolverErrors]
+  if (errors.length > 0) {
+    throw new Error(`catalog validation failed:\n - ${errors.join('\n - ')}`)
+  }
+
+  // Fixtures are re-read from disk per request in development so edits apply
+  // live; in production they're served from the cache built during startup
+  // validation, so a file deleted or corrupted after startup can't 500 a request.
+  const isDev = process.env.NODE_ENV !== 'production'
+  runtime = {
+    catalog,
+    catalogDir,
+    passthroughAsDefault,
+    unmockedUsers,
+    consoleLogLevel,
+    timeoutMs: Number(process.env.PASSTHROUGH_TIMEOUT_MS ?? 30000),
+    schemas,
+    resolverHistoryLimit,
+    loadFixture: isDev
+      ? (systemSlug, endpointName, scenario) =>
+          loadFixture(catalogDir, systemSlug, endpointName, scenario)
+      : (systemSlug, endpointName, scenario) => {
+          const file = fixtureFilePath(catalogDir, systemSlug, endpointName, scenario)
+          const cached = fixtures.get(file)
+          if (!cached) throw new FixtureError(`fixture not found: ${file}`)
+          return cached
+        },
+    getCompiledResolver: isDev
+      ? (systemSlug, endpointName, slug) =>
+          devCompileResolver(catalog, catalogDir, systemSlug, endpointName, slug)
+      : (systemSlug, endpointName, slug) =>
+          resolvers.get(resolverKey(systemSlug, endpointName, slug)) ?? null,
+  }
+  return runtime
+}

package/.next/standalone/src/lib/scenarios.ts

@@ -0,0 +1,52 @@
+import type { EndpointDef } from './catalog/types'
+import { REAL_LABEL } from './config'
+
+export const DEFAULT_SCENARIO = 'default'
+export const REAL_SCENARIO = 'real'
+
+export function implicitScenario(passthroughAsDefault: boolean): string {
+  return passthroughAsDefault ? REAL_SCENARIO : DEFAULT_SCENARIO
+}
+
+export function scenariosWithPassthrough(
+  endpoint: EndpointDef,
+  passthroughAsDefault: boolean,
+): Record<string, string> {
+  const labels: Record<string, string> = {}
+  for (const [slug, meta] of Object.entries(endpoint.scenarios)) labels[slug] = meta.label
+  const { default: defaultLabel, ...rest } = labels
+  const declared =
+    defaultLabel === undefined ? labels : { [DEFAULT_SCENARIO]: defaultLabel, ...rest }
+  return passthroughAsDefault
+    ? { [REAL_SCENARIO]: REAL_LABEL, ...declared }
+    : { ...declared, [REAL_SCENARIO]: REAL_LABEL }
+}
+
+/**
+ * Single source of truth for "is this step selectable on this endpoint" — a
+ * declared scenario (fixture- or resolver-backed; both live in
+ * endpoint.scenarios) or the implicit `real` passthrough. Used by every
+ * write/validation path so the UI and API stay consistent with the router.
+ */
+export function isScenarioDeclared(endpoint: EndpointDef, scenario: string): boolean {
+  return scenario === REAL_SCENARIO || scenario in endpoint.scenarios
+}
+
+export function danglingScenarioLabel(slug: string): string {
+  return `${slug} — unavailable`
+}
+
+export function scenarioOptionsWithDangling(
+  offered: Record<string, string>,
+  selection: string | string[] | undefined,
+): { options: Record<string, string>; unavailable: string[] } {
+  const selected = selection === undefined ? [] : Array.isArray(selection) ? selection : [selection]
+  const options = { ...offered }
+  const unavailable: string[] = []
+  for (const slug of selected) {
+    if (slug in options || unavailable.includes(slug)) continue
+    options[slug] = danglingScenarioLabel(slug)
+    unavailable.push(slug)
+  }
+  return { options, unavailable }
+}

package/.next/standalone/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/.next/standalone/tests/api/catalog-route.test.ts

@@ -0,0 +1,72 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+let passthroughAsDefault = false
+vi.mock('../../src/lib/runtime', () => ({
+  getRuntime: () => ({
+    passthroughAsDefault,
+    catalog: {
+      systems: [
+        {
+          name: 'Hello System',
+          slug: 'hello-system',
+          baseUrlEnv: 'HELLO_SYSTEM_URL',
+          endpoints: [
+            {
+              name: 'oauth_token',
+              displayName: 'OAuth Token',
+              method: 'POST',
+              path: '/oauth/token',
+              mockType: 'global',
+              scenarios: { default: { label: 'Token' }, expired: { label: 'Expired' } },
+              resolverScenarios: [],
+            },
+            {
+              name: 'profiled_endpoint',
+              displayName: 'Profiled Endpoint',
+              method: 'POST',
+              path: '/profiled',
+              profileIdSelector: '$.customerId',
+              scenarios: { default: { label: 'Success' }, by_amount: { label: 'Routes by amount' } },
+              resolverScenarios: ['by_amount'],
+            },
+          ],
+        },
+      ],
+    },
+  }),
+}))
+
+const { GET } = await import('../../src/app/ui/api/catalog/route')
+
+beforeEach(() => {
+  passthroughAsDefault = false
+})
+
+describe('GET /ui/api/catalog', () => {
+  it('projects systems and endpoints with mockType and resolverScenarios', async () => {
+    const res = await GET()
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.systems).toHaveLength(1)
+    const [system] = body.systems
+    expect(system.slug).toBe('hello-system')
+    expect(system.endpoints[0]).toEqual({
+      name: 'oauth_token',
+      displayName: 'OAuth Token',
+      method: 'POST',
+      path: '/oauth/token',
+      mockType: 'global',
+      resolverScenarios: [],
+      scenarios: { default: 'Token', expired: 'Expired' },
+    })
+    // mockType defaults to 'profiled', resolverScenarios preserved
+    expect(system.endpoints[1].mockType).toBe('profiled')
+    expect(system.endpoints[1].resolverScenarios).toEqual(['by_amount'])
+  })
+
+  it('does not leak fixture bodies', async () => {
+    const res = await GET()
+    const body = await res.json()
+    expect(JSON.stringify(body)).not.toContain('json')
+  })
+})

package/.next/standalone/tests/api/global-mocks-route.test.ts

@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const listGlobalMockScenariosMock = vi.fn()
+const upsertGlobalMockScenarioMock = vi.fn()
+const clearGlobalMockScenarioMock = vi.fn()
+
+vi.mock('../../src/lib/profiles/store', () => ({
+  getDb: vi.fn(async () => ({})),
+  listGlobalMockScenarios: (...a: unknown[]) => listGlobalMockScenariosMock(...a),
+  upsertGlobalMockScenario: (...a: unknown[]) => upsertGlobalMockScenarioMock(...a),
+  clearGlobalMockScenario: (...a: unknown[]) => clearGlobalMockScenarioMock(...a),
+}))
+
+vi.mock('../../src/lib/runtime', () => ({
+  getRuntime: () => ({
+    passthroughAsDefault: false,
+    catalog: {
+      systems: [
+        {
+          name: 'Hello System',
+          slug: 'hello-system',
+          baseUrlEnv: 'HELLO_SYSTEM_URL',
+          endpoints: [
+            {
+              name: 'oauth_token',
+              displayName: 'OAuth Token',
+              method: 'POST',
+              path: '/oauth/token',
+              mockType: 'global',
+              scenarios: { default: 'Token', expired: 'Expired' },
+              resolverScenarios: [],
+            },
+            {
+              name: 'account_balance',
+              displayName: 'Account Balance',
+              method: 'POST',
+              path: '/accounts/balance',
+              mockType: 'global',
+              scenarios: { default: 'Settled', pending: 'Pending', dynamic: 'dynamic' },
+              resolverScenarios: ['dynamic'],
+            },
+            {
+              name: 'profiled_endpoint',
+              displayName: 'Profiled Endpoint',
+              method: 'POST',
+              path: '/profiled',
+              profileIdSelector: '$.customerId',
+              scenarios: { default: 'Success' },
+              resolverScenarios: [],
+            },
+          ],
+        },
+      ],
+    },
+  }),
+}))
+
+const listRoute = await import('../../src/app/ui/api/global-mocks/route')
+const detailRoute = await import('../../src/app/ui/api/global-mocks/[system]/[endpoint]/route')
+
+const params = (system: string, endpoint: string) => ({
+  params: Promise.resolve({ system, endpoint }),
+})
+const putReq = (body: unknown) =>
+  new Request('http://x/ui/api/global-mocks/hello-system/oauth_token', {
+    method: 'PUT',
+    body: JSON.stringify(body),
+  })
+
+beforeEach(() => {
+  listGlobalMockScenariosMock.mockReset()
+  upsertGlobalMockScenarioMock.mockReset()
+  clearGlobalMockScenarioMock.mockReset()
+})
+
+describe('GET /ui/api/global-mocks', () => {
+  it('returns the stored overrides', async () => {
+    listGlobalMockScenariosMock.mockResolvedValue([
+      { system: 'hello-system', endpoint: 'oauth_token', scenario: 'expired' },
+    ])
+    const res = await listRoute.GET()
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({
+      scenarios: [{ system: 'hello-system', endpoint: 'oauth_token', scenario: 'expired' }],
+    })
+  })
+})
+
+describe('PUT /ui/api/global-mocks/{system}/{endpoint}', () => {
+  it('sets a declared scenario on a global endpoint', async () => {
+    const res = await detailRoute.PUT(putReq({ scenario: 'expired' }), params('hello-system', 'oauth_token'))
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({
+      system: 'hello-system',
+      endpoint: 'oauth_token',
+      scenario: 'expired',
+    })
+    expect(upsertGlobalMockScenarioMock).toHaveBeenCalledWith(expect.anything(), {
+      system: 'hello-system',
+      endpoint: 'oauth_token',
+      scenario: 'expired',
+    })
+  })
+
+  it('404s for an unknown endpoint', async () => {
+    const res = await detailRoute.PUT(putReq({ scenario: 'expired' }), params('hello-system', 'ghost'))
+    expect(res.status).toBe(404)
+    expect(upsertGlobalMockScenarioMock).not.toHaveBeenCalled()
+  })
+
+  it('400s for a non-global endpoint', async () => {
+    const res = await detailRoute.PUT(
+      putReq({ scenario: 'default' }),
+      params('hello-system', 'profiled_endpoint'),
+    )
+    expect(res.status).toBe(400)
+    expect(upsertGlobalMockScenarioMock).not.toHaveBeenCalled()
+  })
+
+  it('400s for an undeclared scenario', async () => {
+    const res = await detailRoute.PUT(putReq({ scenario: 'nope' }), params('hello-system', 'oauth_token'))
+    expect(res.status).toBe(400)
+  })
+
+  it('sets "dynamic" on a resolver-backed global endpoint', async () => {
+    const res = await detailRoute.PUT(
+      putReq({ scenario: 'dynamic' }),
+      params('hello-system', 'account_balance'),
+    )
+    expect(res.status).toBe(200)
+    expect(upsertGlobalMockScenarioMock).toHaveBeenCalledWith(expect.anything(), {
+      system: 'hello-system',
+      endpoint: 'account_balance',
+      scenario: 'dynamic',
+    })
+  })
+
+  it('400s for "dynamic" on a global endpoint without a resolver', async () => {
+    const res = await detailRoute.PUT(
+      putReq({ scenario: 'dynamic' }),
+      params('hello-system', 'oauth_token'),
+    )
+    expect(res.status).toBe(400)
+    expect(upsertGlobalMockScenarioMock).not.toHaveBeenCalled()
+  })
+
+  it('400s for a missing scenario field', async () => {
+    const res = await detailRoute.PUT(putReq({}), params('hello-system', 'oauth_token'))
+    expect(res.status).toBe(400)
+  })
+
+  it('400s for malformed JSON', async () => {
+    const bad = new Request('http://x', { method: 'PUT', body: '{not json' })
+    const res = await detailRoute.PUT(bad, params('hello-system', 'oauth_token'))
+    expect(res.status).toBe(400)
+  })
+})
+
+describe('DELETE /ui/api/global-mocks/{system}/{endpoint}', () => {
+  it('clears the override and returns 204', async () => {
+    const res = await detailRoute.DELETE(new Request('http://x', { method: 'DELETE' }), params('hello-system', 'oauth_token'))
+    expect(res.status).toBe(204)
+    expect(clearGlobalMockScenarioMock).toHaveBeenCalledWith(expect.anything(), 'hello-system', 'oauth_token')
+  })
+
+  it('404s for an unknown endpoint', async () => {
+    const res = await detailRoute.DELETE(new Request('http://x', { method: 'DELETE' }), params('hello-system', 'ghost'))
+    expect(res.status).toBe(404)
+    expect(clearGlobalMockScenarioMock).not.toHaveBeenCalled()
+  })
+})

package/.next/standalone/tests/api/profiles-reset-route.test.ts

@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const resetScenarioProgressMock = vi.fn()
+const resetDynamicHistoryMock = vi.fn()
+const writeAdminLogMock = vi.fn()
+
+vi.mock('../../src/lib/profiles/store', () => ({
+  getDb: vi.fn(async () => ({})),
+  resetScenarioProgress: (...a: unknown[]) => resetScenarioProgressMock(...a),
+}))
+vi.mock('../../src/lib/dynamic/history-store', () => ({
+  resetDynamicHistory: (...a: unknown[]) => resetDynamicHistoryMock(...a),
+}))
+vi.mock('../../src/lib/logs/admin-log', () => ({
+  writeAdminLog: (...a: unknown[]) => writeAdminLogMock(...a),
+}))
+
+const route = await import('../../src/app/ui/api/profiles/[profileId]/reset/route')
+const params = (profileId: string) => ({ params: Promise.resolve({ profileId }) })
+
+beforeEach(() => {
+  resetScenarioProgressMock.mockReset()
+  resetDynamicHistoryMock.mockReset()
+  writeAdminLogMock.mockReset()
+})
+
+describe('POST /ui/api/profiles/{id}/reset', () => {
+  it('resets a single endpoint when given one', async () => {
+    const req = new Request('http://x', { method: 'POST', body: JSON.stringify({ endpoint: 'hello_world' }) })
+    const res = await route.POST(req, params('c1'))
+    expect(res.status).toBe(204)
+    expect(resetScenarioProgressMock).toHaveBeenCalledWith(expect.anything(), 'c1', 'hello_world')
+    expect(resetDynamicHistoryMock).toHaveBeenCalledWith(expect.anything(), 'profile', 'c1', 'hello_world')
+    expect(writeAdminLogMock).toHaveBeenCalledWith(expect.anything(), 'c1', 'progress_reset', 'hello_world')
+  })
+
+  it('resets the whole profile when no endpoint and no body', async () => {
+    const res = await route.POST(new Request('http://x', { method: 'POST' }), params('c1'))
+    expect(res.status).toBe(204)
+    expect(resetScenarioProgressMock).toHaveBeenCalledWith(expect.anything(), 'c1', undefined)
+    expect(resetDynamicHistoryMock).toHaveBeenCalledWith(expect.anything(), 'profile', 'c1', undefined)
+    expect(writeAdminLogMock).toHaveBeenCalledWith(expect.anything(), 'c1', 'progress_reset', undefined)
+  })
+
+  it('treats malformed JSON as a whole-profile reset', async () => {
+    const res = await route.POST(new Request('http://x', { method: 'POST', body: '{bad' }), params('c1'))
+    expect(res.status).toBe(204)
+    expect(resetScenarioProgressMock).toHaveBeenCalledWith(expect.anything(), 'c1', undefined)
+  })
+})

package/.next/standalone/tests/api/profiles-route.test.ts

@@ -0,0 +1,132 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const getProfileMock = vi.fn()
+const upsertProfileMock = vi.fn()
+const deleteProfileMock = vi.fn()
+const writeAdminLogMock = vi.fn()
+
+vi.mock('../../src/lib/profiles/store', () => ({
+  getDb: vi.fn(async () => ({})),
+  getProfile: (...a: unknown[]) => getProfileMock(...a),
+  upsertProfile: (...a: unknown[]) => upsertProfileMock(...a),
+  deleteProfile: (...a: unknown[]) => deleteProfileMock(...a),
+}))
+vi.mock('../../src/lib/logs/admin-log', () => ({
+  writeAdminLog: (...a: unknown[]) => writeAdminLogMock(...a),
+}))
+vi.mock('../../src/lib/runtime', () => ({
+  getRuntime: () => ({
+    passthroughAsDefault: false,
+    catalog: {
+      systems: [
+        {
+          name: 'Hello System',
+          slug: 'hello-system',
+          baseUrlEnv: 'HELLO_SYSTEM_URL',
+          endpoints: [
+            {
+              name: 'hello_world',
+              displayName: 'Hello World',
+              method: 'POST',
+              path: '/hello/world',
+              profileIdSelector: '$.customerId',
+              scenarios: { default: 'Success', failure: 'Failure' },
+            },
+          ],
+        },
+      ],
+    },
+  }),
+}))
+
+const route = await import('../../src/app/ui/api/profiles/[profileId]/route')
+const params = (profileId: string) => ({ params: Promise.resolve({ profileId }) })
+const jsonReq = (method: string, body: unknown) =>
+  new Request('http://x', { method, body: JSON.stringify(body) })
+
+beforeEach(() => {
+  getProfileMock.mockReset()
+  upsertProfileMock.mockReset()
+  deleteProfileMock.mockReset()
+  writeAdminLogMock.mockReset()
+})
+
+describe('GET /ui/api/profiles/{id}', () => {
+  it('returns the profile', async () => {
+    getProfileMock.mockResolvedValue({ profileId: 'c1', endpointScenarios: {} })
+    const res = await route.GET(new Request('http://x'), params('c1'))
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ profileId: 'c1', endpointScenarios: {} })
+  })
+
+  it('404s when the profile is absent', async () => {
+    getProfileMock.mockResolvedValue(null)
+    const res = await route.GET(new Request('http://x'), params('missing'))
+    expect(res.status).toBe(404)
+  })
+})
+
+describe('PUT /ui/api/profiles/{id}', () => {
+  it('upserts a validated profile, writes an admin log, and returns the stored profile', async () => {
+    upsertProfileMock.mockResolvedValue(undefined)
+    getProfileMock.mockResolvedValue({
+      profileId: 'c1',
+      displayName: 'run',
+      endpointScenarios: { hello_world: 'failure' },
+    })
+    const res = await route.PUT(
+      jsonReq('PUT', { displayName: 'run', endpointScenarios: { hello_world: 'failure' } }),
+      params('c1'),
+    )
+    expect(res.status).toBe(200)
+    expect(upsertProfileMock).toHaveBeenCalledWith(expect.anything(), {
+      profileId: 'c1',
+      displayName: 'run',
+      endpointScenarios: { hello_world: 'failure' },
+    })
+    expect(writeAdminLogMock).toHaveBeenCalledWith(expect.anything(), 'c1', 'profile_saved')
+    expect((await res.json()).endpointScenarios).toEqual({ hello_world: 'failure' })
+  })
+
+  it('400s on an undeclared scenario', async () => {
+    const res = await route.PUT(
+      jsonReq('PUT', { endpointScenarios: { hello_world: 'ghost' } }),
+      params('c1'),
+    )
+    expect(res.status).toBe(400)
+    expect(upsertProfileMock).not.toHaveBeenCalled()
+  })
+
+  it('400s on an unknown endpoint', async () => {
+    const res = await route.PUT(
+      jsonReq('PUT', { endpointScenarios: { nope: 'default' } }),
+      params('c1'),
+    )
+    expect(res.status).toBe(400)
+  })
+
+  it('400s on malformed JSON', async () => {
+    const res = await route.PUT(new Request('http://x', { method: 'PUT', body: '{bad' }), params('c1'))
+    expect(res.status).toBe(400)
+  })
+
+  it('treats a missing endpointScenarios as empty', async () => {
+    upsertProfileMock.mockResolvedValue(undefined)
+    getProfileMock.mockResolvedValue({ profileId: 'c1', endpointScenarios: {} })
+    const res = await route.PUT(jsonReq('PUT', {}), params('c1'))
+    expect(res.status).toBe(200)
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: {} }),
+    )
+  })
+})
+
+describe('DELETE /ui/api/profiles/{id}', () => {
+  it('deletes and returns 204', async () => {
+    deleteProfileMock.mockResolvedValue(undefined)
+    const res = await route.DELETE(new Request('http://x', { method: 'DELETE' }), params('c1'))
+    expect(res.status).toBe(204)
+    expect(deleteProfileMock).toHaveBeenCalledWith(expect.anything(), 'c1')
+  })
+})

package/.next/standalone/tests/bin/args.test.ts

@@ -0,0 +1,42 @@
+import { createRequire } from 'node:module'
+import { describe, expect, it } from 'vitest'
+
+const require = createRequire(import.meta.url)
+const { parseArgs, HELP } = require('../../bin/args.js') as {
+  parseArgs: (argv: string[]) => {
+    catalogPath?: string
+    port?: string
+    help: boolean
+    version: boolean
+  }
+  HELP: string
+}
+
+describe('parseArgs', () => {
+  it('reads a positional catalog path', () => {
+    expect(parseArgs(['./catalog']).catalogPath).toBe('./catalog')
+  })
+
+  it('reads --port and -p', () => {
+    expect(parseArgs(['--port', '8080']).port).toBe('8080')
+    expect(parseArgs(['-p', '8080']).port).toBe('8080')
+    expect(parseArgs(['--port=8080']).port).toBe('8080')
+  })
+
+  it('reads catalog path alongside a port', () => {
+    const opts = parseArgs(['./catalog', '--port', '4000'])
+    expect(opts.catalogPath).toBe('./catalog')
+    expect(opts.port).toBe('4000')
+  })
+
+  it('does not treat a flag as the catalog path', () => {
+    expect(parseArgs(['--help']).catalogPath).toBeUndefined()
+    expect(parseArgs(['--help']).help).toBe(true)
+    expect(parseArgs(['--version']).version).toBe(true)
+  })
+
+  it('exposes help text mentioning usage', () => {
+    expect(HELP).toContain('mock-server')
+    expect(HELP).toContain('CATALOG_PATH')
+  })
+})