2026-10-19 15:28:02 +02:00
import assert from "node:assert/strict" ;
2026-10-19 15:39:25 +02:00
import fsp from "node:fs/promises" ;
2026-10-19 15:28:02 +02:00
import { mkdir , mkdtemp , rm , writeFile } from "node:fs/promises" ;
import { createServer , type Server } from "node:http" ;
import type { AddressInfo } from "node:net" ;
import { tmpdir } from "node:os" ;
import { join } from "node:path" ;
2026-10-19 15:39:25 +02:00
import test , { mock } from "node:test" ;
2026-10-19 16:09:15 +02:00
import { execFileSync } from "node:child_process" ;
2026-10-19 15:28:02 +02:00
import { EMPTY_SHA256 , chunkRecordKey , packContent , sha256Hex } from "cultnet-ts/content" ;
2026-10-19 18:21:51 +02:00
import { closeSync , constants as fsConstants , openSync , symlinkSync } from "node:fs" ;
2026-10-19 15:28:02 +02:00
import {
ContentChunkTooLargeError ,
createContentChunkHandler ,
createDirectoryChunkStore ,
toNodeListener ,
type ContentChunkAnswer ,
type ContentChunkHandlerOptions ,
type ContentChunkStore ,
} from "../src/content" ;
// Chunks come from the packer, so the hashes are the ones a publisher writes.
const packed = async ( text : string ) = > ( await packContent ( "a" , new TextEncoder ( ) . encode ( text ) ) ) . chunks [ 0 ] ! ;
const decode = ( answer : ContentChunkAnswer ) = > new TextDecoder ( ) . decode ( answer . body ? ? new Uint8Array ( ) ) ;
const OK_HEADERS = {
"Content-Type" : "application/octet-stream" ,
"X-Content-Type-Options" : "nosniff" ,
"Cache-Control" : "public, max-age=31536000, immutable, no-transform" ,
"Access-Control-Allow-Origin" : "*" ,
} ;
function spyStore ( chunks : Record < string , Uint8Array > ) : ContentChunkStore & { calls : string [ ] } {
const calls : string [ ] = [ ] ;
return { calls , readChunk : async hash = > { calls . push ( hash ) ; return chunks [ hash ] ; } } ;
}
const ask = ( store : ContentChunkStore , url : string , method = "GET" , options? : ContentChunkHandlerOptions ) = >
createContentChunkHandler ( store , options ) ( { method , url } ) ;
test ( "GET of a stored chunk answers 200 with exactly its bytes and the 200 header set" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const answer = await ask ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) , ` /c?chunkHash= ${ chunk . chunkHash } ` ) ;
assert . equal ( answer . status , 200 ) ;
assert . deepEqual ( answer . body , chunk . payload ) ;
assert . deepEqual ( answer . headers , { . . . OK_HEADERS , "Content-Length" : String ( chunk . payload . length ) } ) ;
} ) ;
test ( "HEAD answers the same status and headers as GET with no body, and HEAD of a corrupt chunk answers 500" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const url = ` /c?chunkHash= ${ chunk . chunkHash } ` ;
const get = await ask ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) , url ) ;
const head = await ask ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) , url , "HEAD" ) ;
assert . equal ( head . status , 200 ) ;
assert . deepEqual ( head . headers , get . headers ) ;
assert . equal ( head . body , undefined ) ;
const corrupt = await ask ( spyStore ( { [ chunk . chunkHash ] : new TextEncoder ( ) . encode ( "hello chunK" ) } ) , url , "HEAD" ) ;
assert . equal ( corrupt . status , 500 ) ;
assert . equal ( corrupt . body , undefined ) ;
} ) ;
test ( "chunkHash 'SHA256:<UPPER HEX> ' answers like the canonical hash; recordKey absent, empty or exact answers 200" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const store = spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ;
const hash = encodeURIComponent ( ` SHA256: ${ chunk . chunkHash . toUpperCase ( ) } ` ) ;
const keys = [ "" , "&recordKey=" , "&recordKey=%20%20" , ` &recordKey= ${ encodeURIComponent ( chunkRecordKey ( chunk . chunkHash ) ) } ` ] ;
for ( const key of keys ) {
const answer = await ask ( store , ` /c?chunkHash= ${ hash } ${ key } ` ) ;
assert . equal ( answer . status , 200 , key ) ;
assert . deepEqual ( answer . body , chunk . payload ) ;
}
assert . deepEqual ( new Set ( store . calls ) , new Set ( [ chunk . chunkHash ] ) ) ;
} ) ;
test ( "a recordKey for another hash, a repeated recordKey, a missing or repeated chunkHash, 63 hex, non-hex, '../x' and '%2e%2e%2f' answer 400 and the store is never called" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const other = await packed ( "another" ) ;
const store = spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ;
const h = chunk . chunkHash ;
const key = encodeURIComponent ( chunkRecordKey ( h ) ) ;
const urls = [
` /c?chunkHash= ${ h } &recordKey= ${ encodeURIComponent ( chunkRecordKey ( other . chunkHash ) ) } ` ,
` /c?chunkHash= ${ h } &recordKey=x ` ,
` /c?chunkHash= ${ h } &recordKey= ${ key } &recordKey= ${ key } ` ,
` /c?recordKey= ${ key } ` ,
"/c" ,
` /c?chunkHash= ${ h } &chunkHash= ${ h } ` ,
` /c?chunkHash= ${ h . slice ( 1 ) } ` ,
` /c?chunkHash= ${ "g" . repeat ( 64 ) } ` ,
"/c?chunkHash=../x" ,
"/c?chunkHash=%2e%2e%2f" ,
"/c?chunkHash=" ,
] ;
for ( const url of urls ) {
const answer = await ask ( store , url ) ;
assert . equal ( answer . status , 400 , url ) ;
assert . equal ( answer . headers [ "Cache-Control" ] , "no-store" ) ;
2026-10-19 15:39:25 +02:00
assert . equal ( answer . headers [ "Content-Type" ] , "text/plain; charset=utf-8" ) ;
assert . equal ( decode ( answer ) , "invalid chunk request" ) ;
2026-10-19 15:28:02 +02:00
}
assert . deepEqual ( store . calls , [ ] ) ;
} ) ;
test ( "a valid unknown hash answers 404 with Cache-Control: no-store" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const answer = await ask ( spyStore ( { } ) , ` /c?chunkHash= ${ chunk . chunkHash } ` ) ;
assert . equal ( answer . status , 404 ) ;
assert . equal ( answer . headers [ "Cache-Control" ] , "no-store" ) ;
assert . equal ( decode ( answer ) , "chunk not found" ) ;
} ) ;
test ( "the empty hash answers 200 with Content-Length 0 from a store that throws when called" , async ( ) = > {
const store : ContentChunkStore = { readChunk : async ( ) = > { throw new Error ( "must not be called" ) ; } } ;
const answer = await ask ( store , ` /c?chunkHash= ${ EMPTY_SHA256 } ` ) ;
assert . equal ( answer . status , 200 ) ;
assert . equal ( answer . headers [ "Content-Length" ] , "0" ) ;
assert . equal ( answer . body ? . length , 0 ) ;
} ) ;
test ( "stored bytes that do not hash to their name answer 500, the body holds none of them, and onServerFault gets hash-mismatch; a throwing hook still yields 500" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const canary = "CANARY-corrupt-bytes" ;
const store = spyStore ( { [ chunk . chunkHash ] : new TextEncoder ( ) . encode ( canary ) } ) ;
const faults : unknown [ ] = [ ] ;
const answer = await ask ( store , ` /c?chunkHash= ${ chunk . chunkHash } ` , "GET" , { onServerFault : f = > faults . push ( f ) } ) ;
assert . equal ( answer . status , 500 ) ;
assert . equal ( decode ( answer ) , "chunk unavailable" ) ;
assert . equal ( JSON . stringify ( answer ) . includes ( canary ) , false ) ;
assert . deepEqual ( faults , [ { chunkHash : chunk.chunkHash , kind : "hash-mismatch" , error : undefined } ] ) ;
const throwing = await ask ( store , ` /c?chunkHash= ${ chunk . chunkHash } ` , "GET" , { onServerFault : ( ) = > { throw new Error ( "hook" ) ; } } ) ;
assert . equal ( throwing . status , 500 ) ;
} ) ;
test ( "a valid 17-byte chunk with maxChunkBytes 16 answers 500 too-large, a store rejection answers 500 store-error, and maxChunkBytes 0, 2^31 and 1.5 throw RangeError" , async ( ) = > {
const chunk = await packed ( "0123456789abcdefg" ) ;
assert . equal ( chunk . payload . length , 17 ) ;
const kinds : string [ ] = [ ] ;
const options = { maxChunkBytes : 16 , onServerFault : ( f : { kind : string } ) = > kinds . push ( f . kind ) } ;
const url = ` /c?chunkHash= ${ chunk . chunkHash } ` ;
assert . equal ( ( await ask ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) , url , "GET" , options ) ) . status , 500 ) ;
const refusing : ContentChunkStore = { readChunk : async ( ) = > { throw new ContentChunkTooLargeError ( 17 ) ; } } ;
assert . equal ( ( await ask ( refusing , url , "GET" , options ) ) . status , 500 ) ;
const failing : ContentChunkStore = { readChunk : async ( ) = > { throw new Error ( "disk" ) ; } } ;
assert . equal ( ( await ask ( failing , url , "GET" , options ) ) . status , 500 ) ;
assert . deepEqual ( kinds , [ "too-large" , "too-large" , "store-error" ] ) ;
assert . equal ( ( await ask ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) , url , "GET" , { maxChunkBytes : 17 } ) ) . status , 200 ) ;
for ( const bad of [ 0 , 2 * * 31 , 1.5 , Number . NaN ] ) assert . throws ( ( ) = > createContentChunkHandler ( spyStore ( { } ) , { maxChunkBytes : bad } ) , RangeError , String ( bad ) ) ;
2026-10-19 15:39:25 +02:00
assert . throws ( ( ) = > createContentChunkHandler ( spyStore ( { } ) , { maxChunkBytes : 0 } ) , /maxChunkBytes/ ) ;
const one = await packed ( "x" ) ;
assert . equal ( ( await ask ( spyStore ( { [ one . chunkHash ] : one . payload } ) , ` /c?chunkHash= ${ one . chunkHash } ` , "GET" , { maxChunkBytes : 1 } ) ) . status , 200 ) ;
2026-10-19 15:28:02 +02:00
assert . doesNotThrow ( ( ) = > createContentChunkHandler ( spyStore ( { } ) , { maxChunkBytes : 2 * * 31 - 1 } ) ) ;
} ) ;
test ( "POST, PUT, DELETE and OPTIONS answer 405 with Allow: GET, HEAD" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const store = spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ;
for ( const method of [ "POST" , "PUT" , "DELETE" , "OPTIONS" , "" ] ) {
const answer = await ask ( store , ` /c?chunkHash= ${ chunk . chunkHash } ` , method ) ;
assert . equal ( answer . status , 405 , method ) ;
assert . equal ( answer . headers . Allow , "GET, HEAD" ) ;
2026-10-19 15:39:25 +02:00
assert . equal ( decode ( answer ) , "method not allowed" ) ;
2026-10-19 15:28:02 +02:00
assert . equal ( answer . headers [ "Access-Control-Allow-Origin" ] , "*" ) ;
}
assert . deepEqual ( store . calls , [ ] ) ;
} ) ;
test ( "'/anything/../etc/passwd?chunkHash=<h>' answers exactly as '/?chunkHash=<h>', and '/<h>' with no query answers 400" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const store = spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ;
const plain = await ask ( store , ` /?chunkHash= ${ chunk . chunkHash } ` ) ;
assert . deepEqual ( await ask ( store , ` /anything/../etc/passwd?chunkHash= ${ chunk . chunkHash } ` ) , plain ) ;
assert . equal ( ( await ask ( store , ` / ${ chunk . chunkHash } ` ) ) . status , 400 ) ;
} ) ;
test ( "error answers carry ACAO * and never echo the request's hash or key" , async ( ) = > {
const canary = "CANARY-request-input" ;
const chunk = await packed ( "hello chunk" ) ;
const urls = [ ` /c?chunkHash= ${ canary } ` , ` /c?chunkHash= ${ chunk . chunkHash } &recordKey= ${ canary } ` , ` / ${ canary } ?chunkHash= ${ chunk . chunkHash } ` ] ;
for ( const url of urls ) {
for ( const answer of [ await ask ( spyStore ( { } ) , url ) , await ask ( spyStore ( { } ) , url , "POST" ) ] ) {
assert . equal ( answer . headers [ "Access-Control-Allow-Origin" ] , "*" ) ;
assert . equal ( answer . headers [ "X-Content-Type-Options" ] , "nosniff" ) ;
assert . equal ( answer . headers [ "Content-Length" ] , String ( answer . body ? . length ) ) ;
assert . equal ( JSON . stringify ( answer ) . includes ( canary ) , false ) ;
}
}
} ) ;
test ( "directory store reads canonical hex and rejects non-canonical names, a directory and an oversized file" , async ( ) = > {
const root = await mkdtemp ( join ( tmpdir ( ) , "cm-content-" ) ) ;
try {
const chunk = await packed ( "0123456789abcdefg" ) ;
const store = createDirectoryChunkStore ( root ) ;
await writeFile ( join ( root , chunk . chunkHash ) , chunk . payload ) ;
assert . deepEqual ( await store . readChunk ( chunk . chunkHash , 17 ) , chunk . payload ) ;
assert . equal ( await store . readChunk ( await sha256Hex ( new Uint8Array ( [ 1 ] ) ) , 17 ) , undefined ) ;
// The root does not exist for these, so only the name check can reject them before a filesystem call.
const nowhere = createDirectoryChunkStore ( join ( root , "missing" ) ) ;
2026-10-19 15:39:25 +02:00
await assert . rejects ( nowhere . readChunk ( chunk . chunkHash . toUpperCase ( ) , 17 ) , /canonical/ ) ;
2026-10-19 15:28:02 +02:00
for ( const name of [ chunk . chunkHash . toUpperCase ( ) , ` sha256: ${ chunk . chunkHash } ` , ` ../ ${ chunk . chunkHash } ` , chunk . chunkHash . slice ( 1 ) , ` ${ chunk . chunkHash } ` ] ) {
await assert . rejects ( nowhere . readChunk ( name , 17 ) , name ) ;
}
await assert . rejects ( store . readChunk ( chunk . chunkHash , 16 ) , ( error : unknown ) = > error instanceof ContentChunkTooLargeError && error . sizeBytes === 17 ) ;
const dirHash = await sha256Hex ( new Uint8Array ( [ 2 ] ) ) ;
await mkdir ( join ( root , dirHash ) ) ;
2026-10-19 15:39:25 +02:00
await assert . rejects ( store . readChunk ( dirHash , 1 << 20 ) , process . platform === "win32" ? Error : /regular file/ ) ;
// Only a missing file is "not found": a root that is a file is a store fault (ENOTDIR on POSIX; Windows reports ENOENT).
if ( process . platform !== "win32" ) await assert . rejects ( createDirectoryChunkStore ( join ( root , chunk . chunkHash ) ) . readChunk ( chunk . chunkHash , 17 ) , { code : "ENOTDIR" } ) ;
2026-10-19 15:28:02 +02:00
// Through the handler: a file whose bytes do not match its name is a 500, and the right bytes are a 200.
const wrongHash = await sha256Hex ( new Uint8Array ( [ 3 ] ) ) ;
await writeFile ( join ( root , wrongHash ) , chunk . payload ) ;
const handler = createContentChunkHandler ( store ) ;
assert . equal ( ( await handler ( { method : "GET" , url : ` /?chunkHash= ${ wrongHash } ` } ) ) . status , 500 ) ;
assert . equal ( ( await handler ( { method : "GET" , url : ` /?chunkHash= ${ chunk . chunkHash } ` } ) ) . status , 200 ) ;
assert . equal ( ( await handler ( { method : "GET" , url : ` /?chunkHash= ${ dirHash } ` } ) ) . status , 500 ) ;
} finally { await rm ( root , { recursive : true , force : true } ) ; }
} ) ;
test ( "over node:http through toNodeListener: GET with Range and Accept-Encoding: gzip gets 200 with the full identity body; HEAD carries Content-Length; a handler rejection answers 500" , async ( ) = > {
const chunk = await packed ( "hello chunk over http" ) ;
const handler = createContentChunkHandler ( spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ) ;
const serve = async ( listener : ReturnType < typeof toNodeListener > , run : ( base : string ) = > Promise < void > ) = > {
const server : Server = createServer ( listener ) ;
await new Promise < void > ( resolve = > server . listen ( 0 , "127.0.0.1" , resolve ) ) ;
try { await run ( ` http://127.0.0.1: ${ ( server . address ( ) as AddressInfo ) . port } ` ) ; }
finally { await new Promise < void > ( resolve = > { server . close ( ( ) = > resolve ( ) ) ; server . closeAllConnections ( ) ; } ) ; }
} ;
await serve ( toNodeListener ( handler ) , async base = > {
const url = ` ${ base } /mount?chunkHash= ${ chunk . chunkHash } ` ;
const get = await fetch ( url , { headers : { Range : "bytes=2-5" , "Accept-Encoding" : "gzip" } } ) ;
assert . equal ( get . status , 200 ) ;
assert . equal ( get . headers . get ( "content-encoding" ) , null ) ;
assert . equal ( get . headers . get ( "accept-ranges" ) , null ) ;
assert . deepEqual ( new Uint8Array ( await get . arrayBuffer ( ) ) , chunk . payload ) ;
const head = await fetch ( url , { method : "HEAD" } ) ;
assert . equal ( head . status , 200 ) ;
assert . equal ( head . headers . get ( "content-length" ) , String ( chunk . payload . length ) ) ;
assert . equal ( ( await head . arrayBuffer ( ) ) . byteLength , 0 ) ;
} ) ;
await serve ( toNodeListener ( async ( ) = > { throw new Error ( "boom" ) ; } ) , async base = > {
const response = await fetch ( ` ${ base } / ` ) ;
assert . equal ( response . status , 500 ) ;
assert . equal ( await response . text ( ) , "chunk unavailable" ) ;
} ) ;
} ) ;
2026-10-19 15:39:25 +02:00
test ( "directory store closes every handle it opens, whether it returns bytes, finds a directory or refuses an oversized file" , async ( ) = > {
const root = await mkdtemp ( join ( tmpdir ( ) , "cm-content-" ) ) ;
const opened : Awaited < ReturnType < typeof fsp.open > > [ ] = [ ] ;
const original = fsp . open ;
const spy = mock . method ( fsp , "open" , async ( . . . args : Parameters < typeof original > ) = > { const handle = await original ( . . . args ) ; opened . push ( handle ) ; return handle ; } ) ;
try {
const chunk = await packed ( "0123456789abcdefg" ) ;
const dirHash = await sha256Hex ( new Uint8Array ( [ 2 ] ) ) ;
await writeFile ( join ( root , chunk . chunkHash ) , chunk . payload ) ;
await mkdir ( join ( root , dirHash ) ) ;
const store = createDirectoryChunkStore ( root ) ;
await store . readChunk ( chunk . chunkHash , 17 ) ;
await assert . rejects ( store . readChunk ( chunk . chunkHash , 16 ) ) ;
await store . readChunk ( dirHash , 17 ) . catch ( ( ) = > undefined ) ;
assert . ok ( opened . length >= 2 , "the store opened its files through node:fs/promises open" ) ;
assert . deepEqual ( opened . map ( handle = > handle . fd ) , opened . map ( ( ) = > - 1 ) ) ;
} finally { spy . mock . restore ( ) ; await rm ( root , { recursive : true , force : true } ) ; }
} ) ;
2026-10-19 16:09:15 +02:00
test ( "a recordKey is compared exactly: padded and re-cased forms of the right key answer 400, tab and newline keys are blank and answer 200" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const store = spyStore ( { [ chunk . chunkHash ] : chunk . payload } ) ;
const key = chunkRecordKey ( chunk . chunkHash ) ;
const q = ( value : string ) = > ` /c?chunkHash= ${ chunk . chunkHash } &recordKey= ${ encodeURIComponent ( value ) } ` ;
2026-10-19 18:21:51 +02:00
for ( const forged of [ ` ${ key } ` , ` ${ key } ` , ` \ t ${ key } ` , key . toUpperCase ( ) , key . replace ( "mesh" , "Mesh" ) , "\uFEFF" , ` \ uFEFF ${ key } ` ] ) {
2026-10-19 16:09:15 +02:00
assert . equal ( ( await ask ( store , q ( forged ) ) ) . status , 400 , JSON . stringify ( forged ) ) ;
}
assert . deepEqual ( store . calls , [ ] ) ;
2026-10-19 18:21:51 +02:00
// U+0085 is white space to C# and not to JS trim(); U+FEFF is the reverse: the blank rule is C#'s, not the platform's.
for ( const blank of [ "\t" , "\n" , "\r\n" , " \t " , "\u0085" , "\u00A0" , " \u0085 " ] ) assert . equal ( ( await ask ( store , q ( blank ) ) ) . status , 200 , JSON . stringify ( blank ) ) ;
2026-10-19 16:09:15 +02:00
assert . equal ( ( await ask ( store , q ( key ) ) ) . status , 200 ) ;
} ) ;
test ( "only the empty chunk's own hash is answered without the store: hashes sharing its prefix or differing in the last digit reach the store" , async ( ) = > {
const flipped = EMPTY_SHA256 . slice ( 0 , - 1 ) + ( EMPTY_SHA256 . endsWith ( "5" ) ? "6" : "5" ) ;
const prefixed = EMPTY_SHA256 . slice ( 0 , 8 ) + "0" . repeat ( 56 ) ;
for ( const hash of [ flipped , prefixed ] ) {
assert . equal ( hash . length , 64 ) ;
const store = spyStore ( { } ) ;
const answer = await ask ( store , ` /c?chunkHash= ${ hash } ` ) ;
assert . equal ( answer . status , 404 , hash ) ;
assert . deepEqual ( store . calls , [ hash ] ) ;
}
} ) ;
test ( "a GET reads the store once and serves the bytes it hashed, not a later read" , async ( ) = > {
const first = await packed ( "first read" ) ;
const second = await packed ( "second read" ) ;
const reads : Uint8Array [ ] = [ first . payload , second . payload ] ;
const store : ContentChunkStore = { readChunk : async ( ) = > reads . shift ( ) } ;
const answer = await ask ( store , ` /c?chunkHash= ${ first . chunkHash } ` ) ;
assert . equal ( answer . status , 200 ) ;
assert . deepEqual ( answer . body , first . payload ) ;
assert . equal ( reads . length , 1 , "the store was read exactly once" ) ;
} ) ;
test ( "a store that reuses its buffer cannot change the bytes after the hash: the answer is the hashed content, from a private copy" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const shared = Buffer . from ( chunk . payload ) ;
// The overwrite lands in a microtask chain that runs after the handler resumes and has started hashing, before the digest resolves.
const store : ContentChunkStore = {
readChunk : async ( ) = > {
let hops = 0 ;
const hop = ( ) : void = > { if ( ++ hops < 4 ) queueMicrotask ( hop ) ; else shared . fill ( 0x58 ) ; } ;
queueMicrotask ( hop ) ;
return shared ;
} ,
} ;
const answer = await ask ( store , ` /c?chunkHash= ${ chunk . chunkHash } ` ) ;
assert . equal ( shared [ 0 ] , 0x58 , "the store's buffer was overwritten while the request was in flight" ) ;
assert . equal ( answer . status , 200 ) ;
assert . deepEqual ( answer . body , chunk . payload ) ;
assert . notEqual ( answer . body ? . buffer , shared . buffer ) ;
} ) ;
2026-10-19 18:21:51 +02:00
test ( "a store that overwrites its buffer on any microtask hop never gets other bytes served under the chunk's name" , async ( ) = > {
const chunk = await packed ( "hello chunk" ) ;
const outcomes = new Set < number > ( ) ;
for ( let overwriteAt = 0 ; overwriteAt <= 10 ; overwriteAt += 1 ) {
const shared = Buffer . from ( chunk . payload ) ;
const store : ContentChunkStore = {
readChunk : async ( ) = > {
let hops = 0 ;
const hop = ( ) : void = > { if ( hops ++ < overwriteAt ) queueMicrotask ( hop ) ; else shared . fill ( 0x58 ) ; } ;
queueMicrotask ( hop ) ;
return shared ;
} ,
} ;
const answer = await ask ( store , ` /c?chunkHash= ${ chunk . chunkHash } ` ) ;
outcomes . add ( answer . status ) ;
const served = answer . status === 200 && Buffer . from ( answer . body ? ? new Uint8Array ( ) ) . equals ( Buffer . from ( chunk . payload ) ) ;
assert . ok ( served || answer . status === 500 , ` overwrite after ${ overwriteAt } hops answered ${ answer . status } with ${ decode ( answer ) } ` ) ;
}
assert . deepEqual ( [ . . . outcomes ] . sort ( ) , [ 200 , 500 ] , "the sweep covers an overwrite before the copy and one after the hash" ) ;
} ) ;
2026-10-19 16:09:15 +02:00
test ( "a FIFO named by a hash is refused as not a regular file at once and holds no thread: other chunks are still served" , { skip : process.platform === "win32" } , async ( ) = > {
const root = await mkdtemp ( join ( tmpdir ( ) , "cm-content-" ) ) ;
2026-10-19 18:31:11 +02:00
let fifoPath : string | undefined ;
2026-10-19 18:34:52 +02:00
const started : Promise < unknown > [ ] = [ ] ;
2026-10-19 16:09:15 +02:00
try {
const chunk = await packed ( "hello chunk" ) ;
await writeFile ( join ( root , chunk . chunkHash ) , chunk . payload ) ;
const fifoHash = await sha256Hex ( new Uint8Array ( [ 9 ] ) ) ;
2026-10-19 18:31:11 +02:00
fifoPath = join ( root , fifoHash ) ;
execFileSync ( "mkfifo" , [ fifoPath ] ) ;
2026-10-19 16:09:15 +02:00
const store = createDirectoryChunkStore ( root ) ;
const within = async < T , > ( work : Promise < T > ) : Promise < T > = > {
2026-10-19 18:34:52 +02:00
started . push ( work . catch ( ( ) = > undefined ) ) ;
2026-10-19 16:09:15 +02:00
let timer : NodeJS.Timeout | undefined ;
try { return await Promise . race ( [ work , new Promise < never > ( ( _ , reject ) = > { timer = setTimeout ( ( ) = > reject ( new Error ( "blocked" ) ) , 3000 ) ; } ) ] ) ; }
finally { clearTimeout ( timer ) ; }
} ;
// More than the libuv pool (4) so a blocking open would starve the pool.
const refusals = Array . from ( { length : 8 } , ( ) = > within ( store . readChunk ( fifoHash , 1 << 20 ) ) . then ( ( ) = > "read" , ( error : Error ) = > error . message ) ) ;
assert . deepEqual ( await Promise . all ( refusals ) , Array ( 8 ) . fill ( "Chunk is not a regular file." ) ) ;
assert . deepEqual ( await within ( store . readChunk ( chunk . chunkHash , 1 << 20 ) ) , chunk . payload ) ;
assert . equal ( ( await within ( createContentChunkHandler ( store ) ( { method : "GET" , url : ` /?chunkHash= ${ fifoHash } ` } ) ) ) . status , 500 ) ;
2026-10-19 18:21:51 +02:00
} finally {
// A reverted non-blocking open leaves pool threads waiting for a writer, which would keep the process alive past the failure.
2026-10-19 18:34:52 +02:00
// A read-write open (synchronous: hashing and async fs calls queue behind the full pool) is a writer; held until every
// started read has settled, it releases the queued opens too, so the revert fails the test in seconds instead of hanging.
const writer = fifoPath ? openSync ( fifoPath , fsConstants . O_RDWR | fsConstants . O_NONBLOCK ) : undefined ;
try { await Promise . all ( started ) ; } finally { if ( writer !== undefined ) closeSync ( writer ) ; }
2026-10-19 18:21:51 +02:00
await rm ( root , { recursive : true , force : true } ) ;
}
} ) ;
test ( "a character device named by a hash is refused as not a regular file, whatever the user id" , { skip : process.platform === "win32" } , async ( ) = > {
const root = await mkdtemp ( join ( tmpdir ( ) , "cm-content-" ) ) ;
try {
const store = createDirectoryChunkStore ( root ) ;
for ( const [ index , device ] of [ "/dev/null" , "/dev/zero" ] . entries ( ) ) {
const hash = await sha256Hex ( new Uint8Array ( [ index ] ) ) ;
symlinkSync ( device , join ( root , hash ) ) ;
await assert . rejects ( store . readChunk ( hash , 1 << 20 ) , { message : "Chunk is not a regular file." } , device ) ;
const seen : string [ ] = [ ] ;
const answer = await createContentChunkHandler ( store , { onServerFault : fault = > seen . push ( fault . kind ) } ) ( { method : "GET" , url : ` /?chunkHash= ${ hash } ` } ) ;
assert . equal ( answer . status , 500 , device ) ;
assert . deepEqual ( seen , [ "store-error" ] , device ) ;
}
2026-10-19 16:09:15 +02:00
} finally { await rm ( root , { recursive : true , force : true } ) ; }
} ) ;