219 lines
8 KiB
TypeScript
219 lines
8 KiB
TypeScript
import {
|
|
assertEquals,
|
|
assertRejects,
|
|
} from 'https://deno.land/std@0.224.0/assert/mod.ts'
|
|
import type { GenerateMeetingDocumentRequest } from '../_shared/meeting-document-contract.ts'
|
|
import {
|
|
buildProviderRequest,
|
|
type GenerationFailureCode,
|
|
generateMeetingDocument,
|
|
mapDatabaseError,
|
|
type MeetingDocumentStore,
|
|
parseClaim,
|
|
PROVIDER_MAX_TOKENS,
|
|
type ProviderOutcome,
|
|
type ProviderRequest,
|
|
type RpcResult,
|
|
} from './generation.ts'
|
|
|
|
const actorId = '44444444-4444-4444-8444-444444444444'
|
|
const request: GenerateMeetingDocumentRequest = {
|
|
meetingId: '11111111-1111-4111-8111-111111111111',
|
|
templateId: '22222222-2222-4222-8222-222222222222',
|
|
idempotencyKey: '33333333-3333-4333-8333-333333333333',
|
|
title: 'Weekly summary',
|
|
model: 'claude-haiku-4-5-20251001',
|
|
}
|
|
|
|
const claimedPayload = {
|
|
claimed: true,
|
|
status: 'processing',
|
|
documentId: null,
|
|
meetingTitle: 'Weekly sync',
|
|
documentTitle: 'Weekly summary',
|
|
templateType: 'custom',
|
|
systemPrompt: 'Summarize.',
|
|
transcript: 'A: hello',
|
|
model: 'claude-haiku-4-5-20251001',
|
|
}
|
|
|
|
const providerBody = {
|
|
content: [{ type: 'text', text: 'Generated body' }],
|
|
usage: { input_tokens: 10, output_tokens: 20 },
|
|
}
|
|
|
|
interface Harness {
|
|
store: MeetingDocumentStore
|
|
providerCalls: ProviderRequest[]
|
|
failures: GenerationFailureCode[]
|
|
commits: number
|
|
logs: string[]
|
|
}
|
|
|
|
function harness(options: {
|
|
claim?: RpcResult
|
|
provider?: () => Promise<ProviderOutcome>
|
|
commit?: () => Promise<RpcResult>
|
|
findDocument?: RpcResult
|
|
} = {}): Harness & { run: () => ReturnType<typeof generateMeetingDocument> } {
|
|
const state: Harness = {
|
|
store: undefined as unknown as MeetingDocumentStore,
|
|
providerCalls: [],
|
|
failures: [],
|
|
commits: 0,
|
|
logs: [],
|
|
}
|
|
state.store = {
|
|
claim: () => Promise.resolve(options.claim ?? { data: claimedPayload, error: null }),
|
|
markFailed: (_actor, _key, code) => {
|
|
state.failures.push(code)
|
|
return Promise.resolve(null)
|
|
},
|
|
commit: () => {
|
|
state.commits += 1
|
|
return options.commit?.() ?? Promise.resolve({
|
|
data: { idempotent: false, document: { id: 'doc-1' } },
|
|
error: null,
|
|
})
|
|
},
|
|
findDocument: () => Promise.resolve(options.findDocument ?? { data: { id: 'doc-1' }, error: null }),
|
|
}
|
|
let clock = 1_000
|
|
return Object.assign(state, {
|
|
run: () => generateMeetingDocument(actorId, request, {
|
|
store: state.store,
|
|
provider: {
|
|
generate: (payload: ProviderRequest) => {
|
|
state.providerCalls.push(payload)
|
|
return options.provider?.() ?? Promise.resolve<ProviderOutcome>({ kind: 'ok', body: providerBody })
|
|
},
|
|
},
|
|
now: () => (clock += 250),
|
|
log: (message: string) => { state.logs.push(message) },
|
|
}),
|
|
})
|
|
}
|
|
|
|
Deno.test('a claim rejected for quota never reaches the provider', async () => {
|
|
const h = harness({
|
|
claim: { data: null, error: { code: 'P0001', message: 'generation_quota_exceeded' } },
|
|
})
|
|
assertEquals(await h.run(), { status: 429, body: { error: 'quota_exceeded' } })
|
|
assertEquals(h.providerCalls.length, 0)
|
|
assertEquals(h.commits, 0)
|
|
})
|
|
|
|
Deno.test('regression r1-17: an unexpected error after claim releases the in-flight quota unit', async () => {
|
|
const h = harness({ commit: () => Promise.reject(new Error('socket hang up')) })
|
|
await assertRejects(() => h.run(), Error, 'socket hang up')
|
|
assertEquals(h.failures, ['commit_failed'])
|
|
})
|
|
|
|
Deno.test('an unexpected provider adapter error also releases the claim', async () => {
|
|
const h = harness({ provider: () => Promise.reject(new TypeError('boom')) })
|
|
await assertRejects(() => h.run(), TypeError)
|
|
assertEquals(h.failures, ['commit_failed'])
|
|
assertEquals(h.commits, 0)
|
|
})
|
|
|
|
Deno.test('successful generation commits once and returns the document', async () => {
|
|
const h = harness()
|
|
assertEquals(await h.run(), {
|
|
status: 200,
|
|
body: { document: { id: 'doc-1' }, idempotent: false },
|
|
})
|
|
assertEquals(h.providerCalls.length, 1)
|
|
assertEquals(h.failures, [])
|
|
})
|
|
|
|
Deno.test('provider failures mark the claim failed with the matching code', async () => {
|
|
const cases: Array<[ProviderOutcome, number, string, GenerationFailureCode]> = [
|
|
[{ kind: 'timeout' }, 504, 'provider_timeout', 'provider_timeout'],
|
|
[{ kind: 'network_error' }, 502, 'provider_request_failed', 'provider_request_failed'],
|
|
[{ kind: 'http_error', status: 529 }, 502, 'provider_request_failed', 'provider_request_failed'],
|
|
[{ kind: 'ok', body: null }, 502, 'provider_invalid_response', 'provider_invalid_response'],
|
|
]
|
|
for (const [outcome, status, error, failure] of cases) {
|
|
const h = harness({ provider: () => Promise.resolve(outcome) })
|
|
assertEquals(await h.run(), { status, body: { error } })
|
|
assertEquals(h.failures, [failure])
|
|
assertEquals(h.commits, 0)
|
|
}
|
|
})
|
|
|
|
Deno.test('commit quota rejection marks quota_exceeded and returns 429', async () => {
|
|
const h = harness({
|
|
commit: () => Promise.resolve({ data: null, error: { code: 'P0001', message: 'generation_quota_exceeded' } }),
|
|
})
|
|
assertEquals(await h.run(), { status: 429, body: { error: 'quota_exceeded' } })
|
|
assertEquals(h.failures, ['quota_exceeded'])
|
|
})
|
|
|
|
Deno.test('other commit errors mark commit_failed and return 500', async () => {
|
|
const h = harness({
|
|
commit: () => Promise.resolve({ data: null, error: { code: '55000', message: 'not committable' } }),
|
|
})
|
|
assertEquals(await h.run(), { status: 500, body: { error: 'commit_failed' } })
|
|
assertEquals(h.failures, ['commit_failed'])
|
|
})
|
|
|
|
Deno.test('claim without prompt or transcript is released', async () => {
|
|
const h = harness({ claim: { data: { ...claimedPayload, transcript: null }, error: null } })
|
|
assertEquals(await h.run(), { status: 500, body: { error: 'internal_error' } })
|
|
assertEquals(h.failures, ['commit_failed'])
|
|
assertEquals(h.providerCalls.length, 0)
|
|
})
|
|
|
|
Deno.test('replays return the stored document or a conflict without provider work', async () => {
|
|
const succeeded = harness({
|
|
claim: {
|
|
data: { ...claimedPayload, claimed: false, status: 'succeeded', documentId: 'doc-1', systemPrompt: null, transcript: null },
|
|
error: null,
|
|
},
|
|
})
|
|
assertEquals(await succeeded.run(), {
|
|
status: 200,
|
|
body: { document: { id: 'doc-1' }, idempotent: true },
|
|
})
|
|
|
|
const inProgress = harness({
|
|
claim: { data: { ...claimedPayload, claimed: false, systemPrompt: null, transcript: null }, error: null },
|
|
})
|
|
assertEquals(await inProgress.run(), { status: 409, body: { error: 'generation_in_progress' } })
|
|
|
|
const failed = harness({
|
|
claim: { data: { ...claimedPayload, claimed: false, status: 'failed', systemPrompt: null, transcript: null }, error: null },
|
|
})
|
|
assertEquals(await failed.run(), { status: 409, body: { error: 'generation_failed' } })
|
|
|
|
for (const h of [succeeded, inProgress, failed]) {
|
|
assertEquals(h.providerCalls.length, 0)
|
|
assertEquals(h.failures, [])
|
|
}
|
|
})
|
|
|
|
Deno.test('parseClaim rejects a null claimed flag', () => {
|
|
assertEquals(parseClaim({ ...claimedPayload, claimed: null }), null)
|
|
assertEquals(parseClaim(claimedPayload)?.claimed, true)
|
|
})
|
|
|
|
Deno.test('mapDatabaseError keeps the HTTP contract', () => {
|
|
const log = () => {}
|
|
assertEquals(mapDatabaseError({ code: '42501' }, log).status, 403)
|
|
assertEquals(mapDatabaseError({ code: 'P0002' }, log).status, 404)
|
|
assertEquals(mapDatabaseError({ code: '22023' }, log).status, 400)
|
|
assertEquals(mapDatabaseError({ code: 'P0001', message: 'generation_quota_exceeded' }, log), {
|
|
status: 429,
|
|
body: { error: 'quota_exceeded' },
|
|
})
|
|
assertEquals(mapDatabaseError(null, log), { status: 500, body: { error: 'internal_error' } })
|
|
})
|
|
|
|
Deno.test('buildProviderRequest bounds output and wraps the template prompt', () => {
|
|
const payload = buildProviderRequest({ ...claimedPayload, status: 'processing' } as Parameters<typeof buildProviderRequest>[0])
|
|
assertEquals(payload.max_tokens, PROVIDER_MAX_TOKENS)
|
|
assertEquals(payload.stream, false)
|
|
assertEquals(payload.model, 'claude-haiku-4-5-20251001')
|
|
assertEquals(payload.messages.length, 1)
|
|
assertEquals(payload.system.includes('Summarize.'), true)
|
|
})
|