@bilal-fazlani/mock-server 0.2.1 → 0.3.0

package/.next/standalone/tests/profiles/actions.test.ts

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const upsertProfileMock = vi.fn()
+const deleteProfileMock = vi.fn()
+vi.mock('../../src/lib/profiles/store', () => ({
+  getDb: vi.fn(async () => ({})),
+  upsertProfile: (...args: unknown[]) => upsertProfileMock(...args),
+  deleteProfile: (...args: unknown[]) => deleteProfileMock(...args),
+}))
+
+const resetDynamicHistoryMock = vi.fn()
+vi.mock('../../src/lib/dynamic/history-store', () => ({
+  resetDynamicHistory: (...args: unknown[]) => resetDynamicHistoryMock(...args),
+}))
+
+const redirectMock = vi.fn((url: string) => {
+  throw new Error(`REDIRECT:${url}`)
+})
+vi.mock('next/navigation', () => ({
+  redirect: (url: string) => redirectMock(url),
+}))
+
+const revalidatePathMock = vi.fn()
+vi.mock('next/cache', () => ({
+  revalidatePath: (path: string) => revalidatePathMock(path),
+}))
+
+let passthroughAsDefault = false
+vi.mock('../../src/lib/runtime', () => ({
+  getRuntime: () => ({
+    catalog: {
+      systems: [
+        {
+          name: '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' },
+            },
+          ],
+        },
+      ],
+    },
+    get passthroughAsDefault() {
+      return passthroughAsDefault
+    },
+  }),
+}))
+
+const { saveProfile } = await import('../../src/app/ui/profiles/actions')
+const { deleteProfileAction } = await import('../../src/app/ui/profiles/actions')
+const { resetDynamicHistoryAction } = await import('../../src/app/ui/profiles/actions')
+
+function formData(fields: Record<string, string>): FormData {
+  const fd = new FormData()
+  for (const [k, v] of Object.entries(fields)) fd.set(k, v)
+  return fd
+}
+
+beforeEach(() => {
+  upsertProfileMock.mockClear()
+  deleteProfileMock.mockClear()
+  resetDynamicHistoryMock.mockClear()
+  redirectMock.mockClear()
+  revalidatePathMock.mockClear()
+  passthroughAsDefault = false
+})
+
+describe('saveProfile', () => {
+  it('drops a "default" pick — nothing stored for that endpoint (delta save)', async () => {
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'default' })),
+    ).rejects.toThrow('REDIRECT:')
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: {} }),
+    )
+  })
+
+  it('stores an explicit non-default pin', async () => {
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'failure' })),
+    ).rejects.toThrow('REDIRECT:')
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: { hello_world: 'failure' } }),
+    )
+  })
+
+  it('rejects an undeclared scenario name', async () => {
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'ghost' })),
+    ).rejects.toThrow(/not declared/)
+    expect(upsertProfileMock).not.toHaveBeenCalled()
+  })
+
+  it('stores "real" when passthrough is not the configured default', async () => {
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'real' })),
+    ).rejects.toThrow('REDIRECT:')
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: { hello_world: 'real' } }),
+    )
+  })
+
+  it('drops a "real" pick when passthrough is the configured default', async () => {
+    passthroughAsDefault = true
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'real' })),
+    ).rejects.toThrow('REDIRECT:')
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: {} }),
+    )
+  })
+
+  it('stores "default" when passthrough is the configured default', async () => {
+    passthroughAsDefault = true
+    await expect(
+      saveProfile(formData({ profileId: 'c1', 'scenario:hello_world': 'default' })),
+    ).rejects.toThrow('REDIRECT:')
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ endpointScenarios: { hello_world: 'default' } }),
+    )
+  })
+
+  it('uses a random UUID when profileId is missing', async () => {
+    await expect(saveProfile(formData({}))).rejects.toThrow('REDIRECT:')
+
+    expect(upsertProfileMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        profileId: expect.stringMatching(
+          /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+        ),
+      }),
+    )
+  })
+})
+
+describe('deleteProfileAction', () => {
+  it('deletes a profile and redirects to the list', async () => {
+    await expect(deleteProfileAction(formData({ profileId: ' c1 ' }))).rejects.toThrow(
+      'REDIRECT:',
+    )
+    expect(deleteProfileMock).toHaveBeenCalledWith(expect.anything(), 'c1')
+    expect(redirectMock).toHaveBeenCalledWith('/ui')
+  })
+
+  it('requires a profileId before deleting', async () => {
+    await expect(deleteProfileAction(formData({ profileId: ' ' }))).rejects.toThrow(
+      /profileId is required/,
+    )
+    expect(deleteProfileMock).not.toHaveBeenCalled()
+  })
+})
+
+describe('resetDynamicHistoryAction', () => {
+  it('resets the dynamic history for a profile/endpoint pair', async () => {
+    await resetDynamicHistoryAction('hello_world', formData({ profileId: 'c1' }))
+    expect(resetDynamicHistoryMock).toHaveBeenCalledWith(
+      expect.anything(),
+      'profile',
+      'c1',
+      'hello_world',
+    )
+    expect(revalidatePathMock).toHaveBeenCalledWith('/ui/profiles/c1')
+  })
+
+  it('requires a profileId before resetting', async () => {
+    await expect(
+      resetDynamicHistoryAction('hello_world', formData({ profileId: ' ' })),
+    ).rejects.toThrow(/profileId and endpoint are required/)
+    expect(resetDynamicHistoryMock).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest'
+import type { Catalog } from '../../src/lib/catalog/types'
+import {
+  InvalidScenarioSelectionError,
+  parseEndpointScenariosFromJson,
+} from '../../src/lib/profiles/api-scenarios'
+
+const catalog: 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: { label: 'Success' }, failure: { label: 'Failure' }, slow: { label: 'Slow' } },
+          resolverScenarios: [],
+        },
+        {
+          name: 'resolver_ep',
+          displayName: 'Resolver Endpoint',
+          method: 'GET',
+          path: '/resolver',
+          profileIdSelector: '$.customerId',
+          scenarios: { default: { label: 'Success' }, by_amount: { label: 'Routes by amount' } },
+          resolverScenarios: ['by_amount'],
+        },
+      ],
+    },
+  ],
+}
+
+describe('parseEndpointScenariosFromJson', () => {
+  it('keeps an explicit non-implicit single selection', () => {
+    const out = parseEndpointScenariosFromJson({ hello_world: 'failure' }, catalog, 'default')
+    expect(out).toEqual({ hello_world: 'failure' })
+  })
+
+  it('drops a selection equal to the implicit scenario (delta save)', () => {
+    const out = parseEndpointScenariosFromJson({ hello_world: 'default' }, catalog, 'default')
+    expect(out).toEqual({})
+  })
+
+  it('keeps a multi-step sequence and collapses a one-step sequence', () => {
+    expect(
+      parseEndpointScenariosFromJson({ hello_world: ['failure', 'slow'] }, catalog, 'default'),
+    ).toEqual({ hello_world: ['failure', 'slow'] })
+    expect(
+      parseEndpointScenariosFromJson({ hello_world: ['failure'] }, catalog, 'default'),
+    ).toEqual({ hello_world: 'failure' })
+  })
+
+  it('accepts the implicit "real" passthrough as a declared selection', () => {
+    expect(
+      parseEndpointScenariosFromJson({ hello_world: 'real' }, catalog, 'default'),
+    ).toEqual({ hello_world: 'real' })
+  })
+
+  it('rejects a non-object input', () => {
+    expect(() => parseEndpointScenariosFromJson([], catalog, 'default')).toThrow(
+      InvalidScenarioSelectionError,
+    )
+  })
+
+  it('rejects an unknown endpoint name', () => {
+    expect(() => parseEndpointScenariosFromJson({ ghost: 'default' }, catalog, 'default')).toThrow(
+      /unknown endpoint "ghost"/,
+    )
+  })
+
+  it('rejects an undeclared scenario', () => {
+    expect(() =>
+      parseEndpointScenariosFromJson({ hello_world: 'nope' }, catalog, 'default'),
+    ).toThrow(/not declared/)
+  })
+
+  it('accepts a resolver-backed slug on an endpoint that declares it', () => {
+    expect(
+      parseEndpointScenariosFromJson({ resolver_ep: 'by_amount' }, catalog, 'default'),
+    ).toEqual({ resolver_ep: 'by_amount' })
+  })
+
+  it('accepts a resolver-backed slug as a sequence step', () => {
+    expect(
+      parseEndpointScenariosFromJson({ resolver_ep: ['by_amount', 'default'] }, catalog, 'default'),
+    ).toEqual({ resolver_ep: ['by_amount', 'default'] })
+  })
+
+  it('rejects a resolver-backed slug on an endpoint that does not declare it', () => {
+    expect(() =>
+      parseEndpointScenariosFromJson({ hello_world: 'by_amount' }, catalog, 'default'),
+    ).toThrow(/not declared/)
+  })
+
+  it('rejects a sequence with a non-string step', () => {
+    expect(() =>
+      parseEndpointScenariosFromJson({ hello_world: ['failure', 3] }, catalog, 'default'),
+    ).toThrow(InvalidScenarioSelectionError)
+  })
+})

package/.next/standalone/tests/profiles/form.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from 'vitest'
+import type { Catalog } from '../../src/lib/catalog/types'
+import { parseEndpointScenarios } from '../../src/lib/profiles/form'
+
+const catalog: 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: { label: 'Success' }, failure: { label: 'Failure' }, timeout: { label: 'Timeout' } },
+          resolverScenarios: [],
+        },
+        {
+          name: 'goodbye_world',
+          displayName: 'Goodbye World',
+          method: 'POST',
+          path: '/goodbye/world',
+          profileIdSelector: '$.customerId',
+          scenarios: { default: { label: 'Success' } },
+          resolverScenarios: [],
+        },
+        {
+          name: 'resolver_ep',
+          displayName: 'Resolver Endpoint',
+          method: 'GET',
+          path: '/resolver',
+          profileIdSelector: '$.customerId',
+          scenarios: { default: { label: 'Success' }, by_amount: { label: 'Routes by amount' } },
+          resolverScenarios: ['by_amount'],
+        },
+      ],
+    },
+  ],
+}
+
+function form(entries: Record<string, string>): FormData {
+  const fd = new FormData()
+  for (const [k, v] of Object.entries(entries)) fd.set(k, v)
+  return fd
+}
+
+describe('parseEndpointScenarios', () => {
+  it('keeps single selections that deviate from the implicit scenario', () => {
+    const result = parseEndpointScenarios(form({ 'scenario:hello_world': 'failure' }), catalog, 'default')
+    expect(result).toEqual({ hello_world: 'failure' })
+  })
+
+  it('drops single selections equal to the implicit scenario (delta save)', () => {
+    const result = parseEndpointScenarios(form({ 'scenario:hello_world': 'default' }), catalog, 'default')
+    expect(result).toEqual({})
+  })
+
+  it('parses a sequence field into an ordered array', () => {
+    const result = parseEndpointScenarios(
+      form({ 'scenarioSequence:hello_world': JSON.stringify(['timeout', 'failure', 'default']) }),
+      catalog,
+      'default',
+    )
+    expect(result).toEqual({ hello_world: ['timeout', 'failure', 'default'] })
+  })
+
+  it('prefers the sequence field over a radio value for the same endpoint', () => {
+    const result = parseEndpointScenarios(
+      form({
+        'scenarioSequence:hello_world': JSON.stringify(['timeout', 'default']),
+        'scenario:hello_world': 'failure',
+      }),
+      catalog,
+      'default',
+    )
+    expect(result).toEqual({ hello_world: ['timeout', 'default'] })
+  })
+
+  it('normalizes a one-step sequence to a single selection with delta save', () => {
+    expect(
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify(['failure']) }),
+        catalog,
+        'default',
+      ),
+    ).toEqual({ hello_world: 'failure' })
+    expect(
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify(['default']) }),
+        catalog,
+        'default',
+      ),
+    ).toEqual({})
+  })
+
+  it('treats an empty sequence as no selection', () => {
+    expect(
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify([]) }),
+        catalog,
+        'default',
+      ),
+    ).toEqual({})
+  })
+
+  it('accepts "real" as a sequence step', () => {
+    expect(
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify(['real', 'default']) }),
+        catalog,
+        'default',
+      ),
+    ).toEqual({ hello_world: ['real', 'default'] })
+  })
+
+  it('rejects a sequence containing an undeclared scenario', () => {
+    expect(() =>
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify(['ghost', 'default']) }),
+        catalog,
+        'default',
+      ),
+    ).toThrow(/ghost/)
+  })
+
+  it('rejects a malformed sequence payload', () => {
+    expect(() =>
+      parseEndpointScenarios(form({ 'scenarioSequence:hello_world': 'not-json' }), catalog, 'default'),
+    ).toThrow(/sequence/)
+    expect(() =>
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:hello_world': JSON.stringify([42]) }),
+        catalog,
+        'default',
+      ),
+    ).toThrow(/sequence/)
+  })
+
+  it('rejects an undeclared single selection', () => {
+    expect(() =>
+      parseEndpointScenarios(form({ 'scenario:hello_world': 'ghost' }), catalog, 'default'),
+    ).toThrow(/ghost/)
+  })
+
+  it('accepts a resolver-backed slug on an endpoint that declares it', () => {
+    expect(
+      parseEndpointScenarios(form({ 'scenario:resolver_ep': 'by_amount' }), catalog, 'default'),
+    ).toEqual({ resolver_ep: 'by_amount' })
+  })
+
+  it('accepts a resolver-backed slug as a sequence step', () => {
+    expect(
+      parseEndpointScenarios(
+        form({ 'scenarioSequence:resolver_ep': JSON.stringify(['by_amount', 'default']) }),
+        catalog,
+        'default',
+      ),
+    ).toEqual({ resolver_ep: ['by_amount', 'default'] })
+  })
+
+  it('rejects a resolver-backed slug on an endpoint that does not declare it', () => {
+    expect(() =>
+      parseEndpointScenarios(form({ 'scenario:hello_world': 'by_amount' }), catalog, 'default'),
+    ).toThrow(/by_amount/)
+  })
+
+  it('handles multiple endpoints independently', () => {
+    const result = parseEndpointScenarios(
+      form({
+        'scenarioSequence:hello_world': JSON.stringify(['timeout', 'default']),
+        'scenario:goodbye_world': 'real',
+      }),
+      catalog,
+      'default',
+    )
+    expect(result).toEqual({ hello_world: ['timeout', 'default'], goodbye_world: 'real' })
+  })
+})

package/.next/standalone/tests/profiles/request-log-ttl-index.test.ts

@@ -0,0 +1,62 @@
+import { Db, MongoClient } from 'mongodb'
+import { MongoMemoryServer } from 'mongodb-memory-server'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+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')
+})
+
+afterAll(async () => {
+  await client.close()
+  await mongod.stop()
+})
+
+beforeEach(async () => {
+  await db.collection('requestLogs').drop().catch(() => {})
+})
+
+async function tsIndexTtl(db: Db): Promise<number | undefined> {
+  const indexes = await db.collection('requestLogs').indexes()
+  const ts = indexes.find((i) => JSON.stringify(i.key) === JSON.stringify({ ts: 1 }))
+  return ts?.expireAfterSeconds
+}
+
+describe('requestLogs TTL index reconciliation', () => {
+  it('creates the ts_1 TTL index with the given retention', async () => {
+    await ensureIndexes(db, 100)
+    expect(await tsIndexTtl(db)).toBe(100)
+  })
+
+  it('migrates an existing TTL index in place when the value changes, keeping documents', async () => {
+    await ensureIndexes(db, 100)
+    await db.collection('requestLogs').insertOne({ logId: 'a', ts: new Date() })
+
+    await ensureIndexes(db, 200)
+
+    expect(await tsIndexTtl(db)).toBe(200)
+    expect(await db.collection('requestLogs').countDocuments()).toBe(1)
+  })
+
+  it('is a no-op when the value is unchanged', async () => {
+    await ensureIndexes(db, 100)
+    await ensureIndexes(db, 100)
+    expect(await tsIndexTtl(db)).toBe(100)
+  })
+
+  it('replaces a pre-existing non-TTL ts_1 index with a TTL one', async () => {
+    await db.collection('requestLogs').createIndex({ ts: 1 })
+    expect(await tsIndexTtl(db)).toBeUndefined()
+
+    await ensureIndexes(db, 100)
+
+    expect(await tsIndexTtl(db)).toBe(100)
+  })
+})