115 lines
6.5 KiB
TypeScript
115 lines
6.5 KiB
TypeScript
import { test } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { EventEmitter, once } from 'node:events'
|
|
import { createServer, type ServerResponse } from 'node:http'
|
|
import { connect } from 'node:net'
|
|
import { setTimeout as delay } from 'node:timers/promises'
|
|
import { createFlowReadBudget, createFlowReadResponseOwner, writeBoundedFlowSse, trackFlowReadSource, withFlowReadSourceWindow } from './traffic-flow-read-budget.js'
|
|
const limits={maxOwners:1,maxReservedBytes:100}
|
|
function fake(){return new EventEmitter() as ServerResponse}
|
|
|
|
test('both independent fences are mandatory; repeated notifications never over-release',async()=>{
|
|
const budget=createFlowReadBudget(limits),response=fake(),owner=createFlowReadResponseOwner(response,budget,limits)
|
|
assert.equal(await owner.run(100,async()=>42),42)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
assert.throws(()=>budget.acquire(1),/занят/)
|
|
response.emit('finish');response.emit('close')
|
|
assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
const response2=fake(),owner2=createFlowReadResponseOwner(response2,budget,limits)
|
|
let finish!:()=>void
|
|
const pending=owner2.run(100,()=>new Promise<void>(resolve=>{finish=resolve}))
|
|
response2.emit('close')
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
assert.throws(()=>budget.acquire(1),/занят/)
|
|
finish();await pending
|
|
assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
})
|
|
|
|
test('nested and sequential callbacks share one response owner with cumulative output admission',async()=>{
|
|
const budget=createFlowReadBudget({maxOwners:10,maxReservedBytes:1000}),response=fake(),owner=createFlowReadResponseOwner(response,budget,limits)
|
|
await owner.run(40,async()=>({payload:'retained'}))
|
|
await owner.run(40,async()=>await owner.run(40,async()=>{owner.retainOutput(4*1024*1024)}))
|
|
await owner.run(40,async()=>{owner.retainOutput(4*1024*1024)})
|
|
await assert.rejects(owner.run(40,async()=>{owner.retainOutput(1)}),/суммарный/)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:40})
|
|
response.emit('close')
|
|
await assert.rejects(owner.run(1,async()=>{}),/закрыт/)
|
|
assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
assert.throws(()=>createFlowReadBudget({maxOwners:NaN,maxReservedBytes:1}),/Invalid/)
|
|
})
|
|
|
|
test('early handler rejection and response abort do not release still-running sibling SQL work',async()=>{
|
|
const budget=createFlowReadBudget(limits),response=fake(),owner=createFlowReadResponseOwner(response,budget,limits)
|
|
let finish!:()=>void,pending:Promise<void>|undefined
|
|
await assert.rejects(owner.run(100,async()=>{
|
|
pending=trackFlowReadSource(async admit=>{admit(1,100);await new Promise<void>(resolve=>{finish=resolve})})
|
|
throw Error('another Promise.all member failed')
|
|
}),/member failed/)
|
|
response.emit('close');await delay(20)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
finish();await pending
|
|
assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
})
|
|
|
|
test('decoded source reservations accumulate across completed SQL reads before another decode',async()=>{
|
|
const budget=createFlowReadBudget(limits),response=fake(),owner=createFlowReadResponseOwner(response,budget,limits)
|
|
let decodes=0
|
|
await assert.rejects(owner.run(100,async()=>{
|
|
await trackFlowReadSource(async admit=>{admit(1,20*1024*1024);decodes++})
|
|
await trackFlowReadSource(async admit=>{admit(1,20*1024*1024);decodes++})
|
|
}),/суммарный/)
|
|
assert.equal(decodes,1)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
response.emit('finish');assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
})
|
|
|
|
test('sequential SSE source windows do not exhaust a stream over time; response still owns the lease',async()=>{
|
|
const budget=createFlowReadBudget(limits),response=fake(),owner=createFlowReadResponseOwner(response,budget,limits)
|
|
let frames=0
|
|
await owner.run(100,async()=>{
|
|
for(let i=0;i<20;i++)await withFlowReadSourceWindow(async()=>{await trackFlowReadSource(async admit=>{admit(50000,20*1024*1024);frames++})})
|
|
})
|
|
assert.equal(frames,20)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
response.emit('close');assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
})
|
|
|
|
test('actual localhost slow response holds one encoded frame and global ownership through abort and pending computation',{timeout:10000},async()=>{
|
|
const budget=createFlowReadBudget(limits)
|
|
let writes=0,completedWrites=0,computing=false,finishCompute!:()=>void,finishHandler!:()=>void
|
|
const handlerDone=new Promise<void>(resolve=>{finishHandler=resolve})
|
|
const server=createServer((_,response)=>{
|
|
const owner=createFlowReadResponseOwner(response,budget,limits)
|
|
void owner.run(100,async()=>{
|
|
try {response.writeHead(200,{'Content-Type':'text/event-stream'});for(let i=0;i<128;i++){writes++;await writeBoundedFlowSse(response,'sample',{payload:'x'.repeat(2*1024*1024)},3*1024*1024);completedWrites++}}
|
|
catch{/* Expected client abort. */}
|
|
computing=true;await new Promise<void>(resolve=>{finishCompute=resolve})
|
|
}).finally(finishHandler)
|
|
})
|
|
await new Promise<void>(resolve=>server.listen(0,'127.0.0.1',resolve))
|
|
const address=server.address();assert.ok(address&&typeof address!=='string')
|
|
const client=connect({host:'127.0.0.1',port:address.port});client.pause()
|
|
try {
|
|
await once(client,'connect');client.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n')
|
|
await delay(300)
|
|
assert.ok(writes>0&&writes<128,'Unread localhost client must block the bounded producer')
|
|
assert.equal(writes-completedWrites,1,'Exactly one encoded frame is outstanding')
|
|
const held=writes;await delay(100);assert.equal(writes,held,'No new snapshot is encoded while write callback is blocked')
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100})
|
|
assert.throws(()=>budget.acquire(1),/занят/)
|
|
client.destroy()
|
|
for(let i=0;i<100&&!computing;i++)await delay(10)
|
|
assert.equal(computing,true)
|
|
assert.deepEqual(budget.stats(),{owners:1,reservedBytes:100},'Abort alone cannot release pending computation')
|
|
finishCompute();await handlerDone
|
|
assert.deepEqual(budget.stats(),{owners:0,reservedBytes:0})
|
|
}finally{client.destroy();finishCompute?.();server.closeAllConnections();await new Promise<void>(resolve=>server.close(()=>resolve()))}
|
|
})
|
|
|
|
test('oversize SSE is refused before enqueue and cannot partially publish',{timeout:5000},async()=>{
|
|
let writes=0
|
|
const response=fake();response.write=(()=>{writes++;return true}) as ServerResponse['write']
|
|
await assert.rejects(writeBoundedFlowSse(response,'sample',{text:'я'.repeat(100)},20),/exceeds/)
|
|
assert.equal(writes,0)
|
|
})
|