80 lines
10 KiB
JavaScript
80 lines
10 KiB
JavaScript
'use strict';
|
|
const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
|
|
const {FileArea,SmbClient,MAX_FILE}=require('../../src/modules/storage/files.cjs');
|
|
const {StorageService}=require('../../src/modules/storage/service.cjs');
|
|
const {storageApi}=require('../../src/modules/storage/api.cjs');
|
|
const {validate}=require('../../src/modules/storage/smb-operation.cjs');
|
|
const {makePreviewFiles}=require('../fixtures/storage-preview-files.cjs');
|
|
async function fixture(t){const root=await fs.mkdtemp(path.join(os.tmpdir(),'storage-range-'));t.after(()=>fs.rm(root,{recursive:true,force:true}));return {root,area:new FileArea(root)};}
|
|
async function request(storage,range,{action='file',relative='large.bin',role='operator'}={}){
|
|
const headers={},url=new URL('http://localhost/api/storage/servers/local/'+action+'?path='+encodeURIComponent(relative));let status,bytes;
|
|
await storageApi({storage,user:{username:'tester',role},url,route:url.pathname,method:'GET',request:{headers:range===undefined?{}:{range}},response:{setHeader(name,value){headers[name]=value;},writeHead(value){status=value;},end(value){bytes=value||Buffer.alloc(0);}}});return {headers,status,bytes};
|
|
}
|
|
function countReads(t){let bytes=0,opens=0;const original=fs.open;t.mock.method(fs,'open',async(...args)=>{const handle=await original(...args),read=handle.read.bind(handle);opens++;handle.read=async(...args)=>{const value=await read(...args);bytes+=value.bytesRead;return value;};return handle;});return {get bytes(){return bytes;},get opens(){return opens;}};}
|
|
|
|
for(const preview of [false,true])test(`64 KiB ${preview?'PDF preview':'download'} range reads bounded bytes through the real route, service and FileArea`,async t=>{
|
|
const {root,area}=await fixture(t),relative=preview?'large.pdf':'large.bin',source=Buffer.alloc(16*1024*1024,7);if(preview)source.write('%PDF-1.7');await fs.writeFile(path.join(root,relative),source);
|
|
const storage=new StorageService({store:{secret:()=>({enabled:true})},client:{area:async()=>area}});t.after(()=>storage.stop());const reads=countReads(t);
|
|
const result=await request(storage,'bytes=1048576-1114111',{action:preview?'content':'file',relative});
|
|
assert.equal(result.status,206);assert.equal(result.headers['Content-Range'],'bytes 1048576-1114111/16777216');assert.equal(result.bytes.length,65536);assert.deepEqual(result.bytes,source.subarray(1048576,1114112));
|
|
assert.ok(reads.bytes<100*1024,`range must not read the full file: ${reads.bytes}`);assert.equal(reads.opens,1,'header and requested content must use the same handle');
|
|
});
|
|
|
|
test('suffixes, open ends, invalid ranges and empty downloads preserve complete-size HTTP metadata',async t=>{
|
|
const {root,area}=await fixture(t);await fs.writeFile(path.join(root,'large.bin'),'0123456789');const storage=new StorageService({store:{secret:()=>({enabled:true})},client:{area:async()=>area}});t.after(()=>storage.stop());
|
|
for(const [range,want,contentRange] of [['bytes=-3','789','bytes 7-9/10'],['bytes=7-','789','bytes 7-9/10'],['bytes=7-99','789','bytes 7-9/10'],['bytes=-99','0123456789','bytes 0-9/10']]){const result=await request(storage,range);assert.equal(result.status,206);assert.equal(result.bytes.toString(),want);assert.equal(result.headers['Content-Range'],contentRange);}
|
|
for(const range of ['bytes=-0','bytes=10-','bytes=9-8','bytes=-','bytes=0-1,3-4','items=0-1','bytes=9007199254740992-','bytes=-9007199254740992']){const result=await request(storage,range);assert.equal(result.status,416,range);assert.equal(result.headers['Content-Range'],'bytes */10');assert.equal(result.bytes.length,0);}
|
|
await fs.writeFile(path.join(root,'empty.bin'),'');const empty=await request(storage,undefined,{relative:'empty.bin'});assert.equal(empty.status,200);assert.equal(empty.bytes.length,0);assert.equal((await request(storage,'bytes=0-',{relative:'empty.bin'})).status,416);
|
|
});
|
|
|
|
test('PDF ranges still validate the header and whole-file limits before reading content',async t=>{
|
|
const {root,area}=await fixture(t);await fs.writeFile(path.join(root,'fake.pdf'),'Not a PDF body');await assert.rejects(area.readPreview('fake.pdf',{range:'bytes=5-7'}),error=>error.status===415);
|
|
await fs.writeFile(path.join(root,'huge.bin'),'');await fs.truncate(path.join(root,'huge.bin'),MAX_FILE+1);await assert.rejects(area.readFile('huge.bin',MAX_FILE,{range:'bytes=0-1'}),error=>error.status===413);
|
|
await fs.writeFile(path.join(root,'huge.pdf'),'%PDF-');await fs.truncate(path.join(root,'huge.pdf'),MAX_FILE+1);await assert.rejects(area.readPreview('huge.pdf',{range:'bytes=0-1'}),error=>error.status===413);
|
|
});
|
|
|
|
test('a source that shrinks during range reading is rejected instead of returning partial success',async t=>{
|
|
const {root,area}=await fixture(t),file=path.join(root,'large.bin');await fs.writeFile(file,Buffer.alloc(1024,1));const original=fs.open;let changed=false;
|
|
t.mock.method(fs,'open',async(...args)=>{const handle=await original(...args),read=handle.read.bind(handle);handle.read=async(...args)=>{if(!changed){changed=true;await fs.truncate(file,100);}return read(...args);};return handle;});
|
|
await assert.rejects(area.readFile('large.bin',MAX_FILE,{range:'bytes=512-767'}),error=>error.status===409);
|
|
});
|
|
|
|
for(const change of ['grow','replace'])test(`a source that ${change==='grow'?'grows':'is replaced'} between PDF header and content is rejected`,async t=>{
|
|
const {root,area}=await fixture(t),file=path.join(root,'sample.pdf');await fs.writeFile(file,Buffer.from('%PDF-'+'.'.repeat(1019)));const original=fs.open;let changed=false;
|
|
t.mock.method(fs,'open',async(...args)=>{const handle=await original(...args),read=handle.read.bind(handle);handle.read=async(...args)=>{const result=await read(...args);if(!changed){changed=true;if(change==='grow')await fs.appendFile(file,'x');else{await fs.rename(file,file+'.old');await fs.writeFile(file,Buffer.alloc(1024,1));}}return result;};return handle;});
|
|
await assert.rejects(area.readPreview('sample.pdf',{range:'bytes=100-199'}),error=>error.status===409);
|
|
});
|
|
|
|
test('Office and image ranges retain whole-file validation and text ranges address decoded UTF-8 bytes',async t=>{
|
|
const {root,area}=await fixture(t);await makePreviewFiles(root);
|
|
for(const relative of ['sample.docx','sample.xlsx','sample.png']){
|
|
const full=await area.readPreview(relative),part=await area.readPreview(relative,{range:'bytes=0-7'});
|
|
assert.equal(part.total,full.bytes.length);assert.equal(part.status,206);assert.deepEqual(part.bytes,full.bytes.subarray(0,8));
|
|
}
|
|
const full=await area.readPreview('gbk.txt'),part=await area.readPreview('gbk.txt',{range:'bytes=-3'});assert.equal(part.total,6);assert.deepEqual(part.bytes,full.bytes.subarray(3));assert.equal(part.bytes.toString(),'文');
|
|
await assert.rejects(area.readPreview('bad.png',{range:'bytes=0-1'}),error=>error.status===415);
|
|
const office=await fs.readFile(path.join(root,'sample.docx')),central=office.indexOf(Buffer.from([0x50,0x4b,0x01,0x02]));office.writeUInt32LE(70*1024*1024,central+24);await fs.writeFile(path.join(root,'bomb.docx'),office);
|
|
await assert.rejects(area.readPreview('bomb.docx',{range:'bytes=0-1'}),error=>error.status===413);
|
|
});
|
|
|
|
test('range access keeps relative-path, link, and role restrictions',async t=>{
|
|
const {root,area}=await fixture(t),outside=await fs.mkdtemp(path.join(os.tmpdir(),'storage-range-outside-'));t.after(()=>fs.rm(outside,{recursive:true,force:true}));await fs.writeFile(path.join(outside,'secret.bin'),'private');await fs.symlink(outside,path.join(root,'link'),'junction');
|
|
for(const relative of ['../secret.bin','link/secret.bin','x:stream'])await assert.rejects(area.readFile(relative,MAX_FILE,{range:'bytes=0-1'}),error=>error.status===400);
|
|
const storage={readFile:()=>assert.fail('viewers must not reach storage')};await assert.rejects(request(storage,'bytes=0-1',{role:'viewer'}),error=>error.status===403);
|
|
});
|
|
|
|
test('range metadata and bounded buffers survive real worker IPC while malformed offsets are rejected',async t=>{
|
|
const {root}=await fixture(t);await fs.writeFile(path.join(root,'large.bin'),Buffer.alloc(16*1024*1024,8));const server={root,pidFile:path.join(root,'worker.pid'),enabled:true,version:1},client=new SmbClient({workerPath:path.join(__dirname,'worker-fixture.cjs')}),storage=new StorageService({store:{secret:()=>server},client,operationTimeoutMs:5000});t.after(()=>storage.stop());
|
|
const result=await storage.readFile('local','large.bin',{range:'bytes=-65536'});assert.equal(result.total,16777216);assert.equal(result.start,16711680);assert.equal(result.end,16777215);assert.equal(result.status,206);assert.equal(result.bytes.length,65536);assert.ok(result.bytes.every(byte=>byte===8));
|
|
assert.throws(()=>validate('readFile',{filename:'x',total:10,start:5,end:7,status:206,bytes:Buffer.alloc(1)}),error=>error.status===502);
|
|
const invalid=await storage.readFile('local','large.bin',{range:'bytes=16777216-'});assert.equal(invalid.status,416);assert.equal(invalid.total,16777216);assert.equal(invalid.bytes.length,0);
|
|
});
|
|
|
|
test('production worker dispatch preserves range options and returns unsatisfied totals as metadata',async t=>{
|
|
const {root,area}=await fixture(t);await fs.writeFile(path.join(root,'sample.pdf'),'%PDF-1.7 data');
|
|
let handle,message,exitCode;const vm=require('node:vm'),source=await fs.readFile(path.join(__dirname,'../../src/modules/storage/smb-operation-worker.cjs'),'utf8');
|
|
vm.runInNewContext(source,{require:specifier=>specifier==='./files.cjs'?{SmbClient:class{async area(){return area;}}}:{validate},process:{once(event,handler){assert.equal(event,'message');handle=handler;},send(value,callback){message=value;callback();},exit(code){exitCode=code;}}});
|
|
await handle({server:{},operation:'readPreview',args:['sample.pdf',{range:'bytes=5-7'}]});assert.equal(message.ok,true);assert.equal(message.value.status,206);assert.equal(message.value.total,13);assert.equal(message.value.bytes.toString(),'1.7');assert.equal(exitCode,0);
|
|
await handle({server:{},operation:'readFile',args:['sample.pdf',MAX_FILE,{range:'bytes=99-'}]});assert.equal(message.ok,true);assert.equal(message.value.status,416);assert.equal(message.value.total,13);assert.equal(message.value.bytes.length,0);
|
|
});
|