Files
MikrotikManager/backend/src/services/traffic-flow-read-budget.test.ts
T

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)
})