80 lines
9.4 KiB
TypeScript
80 lines
9.4 KiB
TypeScript
/** Isolated PostgreSQL acceptance. Does not call models or access production. */
|
|
import assert from 'node:assert/strict'
|
|
import { randomUUID } from 'node:crypto'
|
|
import { mkdir, writeFile } from 'node:fs/promises'
|
|
import path from 'node:path'
|
|
|
|
async function main() {
|
|
const target = new URL(process.env.DATABASE_URL || '')
|
|
assert.equal(target.hostname, '127.0.0.1'); assert.equal(target.port, '55446'); assert.equal(target.pathname, '/detail_text_recovery_20261016')
|
|
assert.equal(process.env.NEXT_BUILD, '1', 'Run in the isolated harness environment')
|
|
const { prisma } = await import('../lib/prisma')
|
|
try {
|
|
for (const sql of [
|
|
'CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY,"isSuperAdmin" BOOLEAN NOT NULL,"isActive" BOOLEAN NOT NULL,status TEXT,"archivedAt" TIMESTAMPTZ)',
|
|
'CREATE TABLE IF NOT EXISTS detail_generator_projects (id TEXT PRIMARY KEY,owner_id TEXT NOT NULL,document JSONB NOT NULL,revision INTEGER NOT NULL,created_at TIMESTAMPTZ DEFAULT NOW(),updated_at TIMESTAMPTZ DEFAULT NOW(),deleted_at TIMESTAMPTZ)',
|
|
"CREATE TABLE IF NOT EXISTS detail_generator_jobs (id TEXT PRIMARY KEY,project_id TEXT NOT NULL,owner_id TEXT NOT NULL,kind TEXT NOT NULL,status TEXT NOT NULL,payload JSONB DEFAULT '{}',checkpoint JSONB DEFAULT '{}',fingerprint TEXT,project_revision INTEGER NOT NULL,idempotency_key TEXT,lease_token TEXT,lease_expires_at TIMESTAMPTZ,progress INTEGER DEFAULT 0,error TEXT,request_id TEXT,created_at TIMESTAMPTZ DEFAULT NOW(),updated_at TIMESTAMPTZ DEFAULT NOW(),started_at TIMESTAMPTZ,completed_at TIMESTAMPTZ)",
|
|
'CREATE TABLE IF NOT EXISTS ai_model_verifications (id TEXT PRIMARY KEY,actor_id TEXT NOT NULL,status TEXT NOT NULL,request_id TEXT,evidence JSONB DEFAULT \'{}\')',
|
|
"CREATE TABLE IF NOT EXISTS ai_model_audit (id TEXT PRIMARY KEY,action TEXT NOT NULL,details JSONB NOT NULL)",
|
|
]) await prisma.$executeRawUnsafe(sql)
|
|
const { prepareDetailTextRecovery } = await import('../lib/detail-generator/repository')
|
|
const { detailTextDispatchKey } = await import('../lib/detail-generator/text-recovery')
|
|
const owner = randomUUID(), other = randomUUID(), projectId = randomUUID(), id = randomUUID(), requestId = randomUUID()
|
|
const source = { stage: 'product-analysis', dispatchPending: true, dispatchKey: `${id}-product-analysis` }
|
|
const facts = JSON.stringify({ facts: ['SKU-REAL'], warnings: ['材质未提供'] })
|
|
await prisma.$executeRawUnsafe("INSERT INTO users (id,\"isSuperAdmin\",\"isActive\",status) VALUES ($1,TRUE,TRUE,'active'),($2,TRUE,TRUE,'active')", owner, other)
|
|
await prisma.$executeRawUnsafe("INSERT INTO detail_generator_projects (id,owner_id,document,revision) VALUES ($1,$2,'{}',1)", projectId, owner)
|
|
await prisma.$executeRawUnsafe("INSERT INTO detail_generator_jobs (id,project_id,owner_id,kind,status,checkpoint,project_revision,idempotency_key,request_id) VALUES ($1,$2,$3,'analyze','unknown',$4::jsonb,1,$5,$6)", id, projectId, owner, JSON.stringify(source), randomUUID(), requestId)
|
|
const assertions: string[] = []
|
|
const unchanged = async () => { const rows = await prisma.$queryRawUnsafe<any[]>('SELECT status FROM detail_generator_jobs WHERE id=$1', id); assert.equal(rows[0].status, 'unknown') }
|
|
await assert.rejects(prepareDetailTextRecovery(id, other, 'query'), (error: any) => error.status === 404); await unchanged(); assertions.push('foreign-owner-denied')
|
|
await prisma.$executeRawUnsafe('UPDATE users SET "isSuperAdmin"=FALSE WHERE id=$1', owner)
|
|
await assert.rejects(prepareDetailTextRecovery(id, owner, 'query'), (error: any) => error.status === 403); await unchanged()
|
|
await prisma.$executeRawUnsafe('UPDATE users SET "isSuperAdmin"=TRUE WHERE id=$1', owner); assertions.push('current-database-revocation-denied')
|
|
await assert.rejects(prepareDetailTextRecovery(id, owner, 'query', randomUUID()), (error: any) => error.code === 'recovery_request_conflict'); await unchanged(); assertions.push('original-id-cannot-be-replaced')
|
|
await prisma.$executeRawUnsafe('UPDATE detail_generator_projects SET revision=2 WHERE id=$1', projectId)
|
|
await assert.rejects(prepareDetailTextRecovery(id, owner, 'query'), (error: any) => error.code === 'revision_conflict'); await unchanged()
|
|
await prisma.$executeRawUnsafe('UPDATE detail_generator_projects SET revision=1 WHERE id=$1', projectId); assertions.push('project-revision-fenced')
|
|
const raced = await Promise.allSettled([prepareDetailTextRecovery(id, owner, 'query'), prepareDetailTextRecovery(id, owner, 'query')])
|
|
assert.equal(raced.filter(value => value.status === 'fulfilled').length, 1)
|
|
const admitted = (raced.find(value => value.status === 'fulfilled') as PromiseFulfilledResult<any>).value
|
|
assert.equal(admitted.status, 'running'); assert.ok(admitted.leaseToken); assert.equal(admitted.checkpoint.textRecovery.mode, 'query-only')
|
|
assertions.push('two-concurrent-queries-admit-exactly-one-lease')
|
|
const ready = { stage: 'selling-points', dispatchPending: false, facts, recoveredText: { stage: 'product-analysis', requestId, dispatchKey: `${id}-product-analysis` } }
|
|
await prisma.$executeRawUnsafe("UPDATE detail_generator_jobs SET status='unknown',checkpoint=$2::jsonb,lease_token=NULL,lease_expires_at=NULL WHERE id=$1", id, JSON.stringify(ready))
|
|
const noop = await prepareDetailTextRecovery(id, owner, 'query'); assert.equal(noop.status, 'unknown'); assert.equal(noop.leaseToken, null); assertions.push('repeated-recovered-analysis-query-is-no-op')
|
|
const blocker = randomUUID()
|
|
await prisma.$executeRawUnsafe("INSERT INTO ai_model_verifications (id,actor_id,status) VALUES ($1,$2,'unknown')", blocker, owner)
|
|
await assert.rejects(prepareDetailTextRecovery(id, owner, 'continue'), (error: any) => error.code === 'user_capacity'); await unchanged(); assertions.push('unknown-model-test-blocks-new-copy')
|
|
const { aiModelExecutionOccupiesSlot } = await import('../lib/ai-model-execution-slot')
|
|
const occupied = async () => Number((await prisma.$queryRawUnsafe<any[]>(`SELECT COUNT(*)::int AS count FROM ai_model_verifications v WHERE ${aiModelExecutionOccupiesSlot('v')}`))[0].count)
|
|
await prisma.$executeRawUnsafe('UPDATE ai_model_verifications SET request_id=$2 WHERE id=$1', blocker, requestId)
|
|
assert.equal(await occupied(), 1); assertions.push('unknown-without-completion-proof-keeps-slot')
|
|
const audit = randomUUID(), proof = { executionGroupId: blocker, originalRequestId: requestId, verificationIds: [blocker] }
|
|
for (const incorrect of [{ ...proof, executionGroupId: randomUUID() }, { ...proof, originalRequestId: randomUUID() }, { ...proof, verificationIds: [randomUUID()] }]) {
|
|
await prisma.$executeRawUnsafe("INSERT INTO ai_model_audit(id,action,details) VALUES ($1,'model.verification-execution-ended',$2::jsonb)", audit, JSON.stringify(incorrect))
|
|
assert.equal(await occupied(), 1)
|
|
await prisma.$executeRawUnsafe('DELETE FROM ai_model_audit WHERE id=$1', audit)
|
|
}
|
|
assertions.push('other-execution-request-or-row-proof-cannot-release-slot')
|
|
await prisma.$executeRawUnsafe("INSERT INTO ai_model_audit(id,action,details) VALUES ($1,'model.verification-execution-ended',$2::jsonb)", audit, JSON.stringify(proof))
|
|
assert.equal(await occupied(), 0); assertions.push('audited-ended-unknown-releases-only-execution-slot')
|
|
await prisma.$executeRawUnsafe("UPDATE ai_model_verifications SET status='running' WHERE id=$1", blocker)
|
|
assert.equal(await occupied(), 1); assertions.push('running-execution-cannot-use-old-completion-proof')
|
|
await prisma.$executeRawUnsafe('DELETE FROM ai_model_audit WHERE id=$1', audit)
|
|
await prisma.$executeRawUnsafe('DELETE FROM ai_model_verifications WHERE id=$1 AND actor_id=$2', blocker, owner)
|
|
const continued = await prepareDetailTextRecovery(id, owner, 'continue')
|
|
assert.equal(continued.status, 'queued'); assert.equal(continued.requestId, null); assert.equal(continued.checkpoint.facts, facts); assertions.push('explicit-continuation-keeps-facts-clears-old-request-id')
|
|
await assert.rejects(prepareDetailTextRecovery(id, owner, 'continue'), (error: any) => error.code === 'recovery_not_available'); assertions.push('duplicate-continuation-cannot-enqueue-again')
|
|
await prisma.$executeRawUnsafe("UPDATE detail_generator_jobs SET status='failed',checkpoint=$2::jsonb WHERE id=$1", id, JSON.stringify({ stage: 'outline', dispatchKey: `${id}-outline`, dispatchPending: false, facts }))
|
|
const retried = await prepareDetailTextRecovery(id, owner, 'continue')
|
|
assert.equal(retried.checkpoint.facts, facts); assert.equal(retried.requestId, null)
|
|
assert.notEqual(detailTextDispatchKey(id, 'outline', retried.checkpoint), `${id}-outline`); assertions.push('known-ended-copy-retry-has-one-persisted-new-idempotency-key')
|
|
const count = await prisma.$queryRawUnsafe<any[]>('SELECT COUNT(*) AS count FROM detail_generator_jobs WHERE project_id=$1', projectId)
|
|
assert.equal(Number(count[0].count), 1); assertions.push('original-job-identity-retained')
|
|
const receipt = { at: new Date().toISOString(), database: 'isolated-local-postgresql', assertions, count: assertions.length, paidCalls: 0, productionWrites: 0 }
|
|
const output = path.resolve('output/ai-text-acceptance-20261016'); await mkdir(output, { recursive: true }); await writeFile(path.join(output, 'database-acceptance.json'), JSON.stringify(receipt, null, 2)); console.log(JSON.stringify(receipt))
|
|
} finally { await prisma.$disconnect() }
|
|
}
|
|
main().catch(error => { console.error(error instanceof Error ? error.message : 'Isolated acceptance failed'); process.exitCode = 1 })
|