lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

run.mjs (8634B)


      1 import assert from 'node:assert/strict';
      2 import {createRequire} from 'node:module';
      3 import {createServer} from 'node:http';
      4 import {readFile} from 'node:fs/promises';
      5 import {resolve} from 'node:path';
      6 
      7 const [tools,packageDir,engine='chromium']=process.argv.slice(2);
      8 assert(tools&&packageDir&&['chromium','firefox','webkit'].includes(engine));
      9 const require=createRequire(resolve(tools,'package.json'));
     10 const playwright=require('playwright');
     11 const {wsServer:WebSocketServer}=require(resolve(tools,'node_modules/playwright-core/lib/utilsBundle.js'));
     12 const wss=new WebSocketServer({noServer:true}),sockets=new Set(),sources=new Map(),observed=[],upgrades=[];
     13 process.on('uncaughtExceptionMonitor',()=>console.error(JSON.stringify({engine,upgrades,observed})));
     14 const observer=`
     15 const ActualWebSocket=globalThis.WebSocket,actualOpen=IDBFactory.prototype.open;
     16 const observedSockets=[],databases=[];
     17 globalThis.WebSocket=class extends ActualWebSocket {constructor(...args){super(...args);observedSockets.push(this);}};
     18 globalThis.browserSocketCount=()=>observedSockets.length;
     19 IDBFactory.prototype.open=function(...args){
     20   const request=actualOpen.apply(this,args);
     21   request.addEventListener('success',()=>databases.push(request.result),{once:true});
     22   return request;
     23 };
     24 globalThis.assertStorageCallbacksClosed=()=>{
     25   for(const db of databases)if(db.onversionchange||db.onclose)throw Error('explicit close retained database callback');
     26 };
     27 async function verifyCleanup(){
     28   await new Promise(resolve=>setTimeout(resolve,80));
     29   for(const socket of observedSockets){
     30     if(socket.onopen||socket.onmessage||socket.onerror||socket.onclose)throw Error('retained original socket callback');
     31     if(socket.readyState!==ActualWebSocket.CLOSED)throw Error('original socket remains open');
     32   }
     33   assertStorageCallbacksClosed();
     34   return {sockets:observedSockets.length,databases:databases.length};
     35 }`;
     36 const execute=`
     37 const {default:init,advertisements,verify_client,verify_publications,verify_listing,verify_listing_publications}=await import('./fixture.js');await init();
     38 const route='/'+context,endpoint=base.replace('http:','ws:')+route;
     39 const response=await fetch(base+'/advertisements'+route,{method:'POST',body:advertisements(endpoint)});
     40 if(!response.ok)throw Error('fixture advertisement setup');
     41 const result=JSON.parse(await verify_client(endpoint,'ordinary_browser_'+context));
     42 const events=await fetch(base+'/events'+route).then(response=>response.text());
     43 await verify_publications(events,JSON.stringify(result.messages));
     44 const publicRoute='/listing/'+context;
     45 const listing=JSON.parse(await verify_listing(base.replace('http:','ws:')+publicRoute,'ordinary_public_'+context));
     46 const publicEvents=await fetch(base+'/events'+publicRoute).then(response=>response.text());
     47 verify_listing_publications(publicEvents,listing.revision);
     48 result.listing=listing;
     49 result.disposed=await verifyCleanup();return result;`;
     50 const worker=`${observer}
     51 self.onmessage=async event=>{try{const base=event.data,context='worker';self.postMessage(await(async()=>{${execute}})());}
     52 catch(error){self.postMessage({error:String(error)});}};`;
     53 const server=createServer(async(req,res)=>{
     54   try{
     55     if(req.url==='/'){res.setHeader('content-type','text/html');res.end('<!doctype html><title>Ordinary Radroots browser client</title>');return;}
     56     if(req.url==='/worker.js'){res.setHeader('content-type','text/javascript');res.end(worker);return;}
     57     if(req.url==='/advertisements/main'||req.url==='/advertisements/worker'){
     58       assert.equal(req.method,'POST');let body='';for await(const chunk of req){body+=chunk;assert(Buffer.byteLength(body)<=64*1024);}
     59       const raw=JSON.parse(body);assert.equal(raw.length,2);const values=raw.map(value=>JSON.parse(value));
     60       for(const value of values)assert.equal(value.kind,10050);
     61       sources.set(req.url.replace('/advertisements',''),values);res.end('ok');return;
     62     }
     63     if(['/events/main','/events/worker','/events/listing/main','/events/listing/worker'].includes(req.url)){
     64       const route=req.url.replace('/events','');res.setHeader('content-type','application/json');
     65       res.end(JSON.stringify(observed.filter(item=>item.route===route&&item.message[0]==='EVENT').map(item=>item.rawEvent)));return;
     66     }
     67     const name=new Map([['/fixture.js','fixture.js'],['/fixture_bg.wasm','fixture_bg.wasm']]).get(req.url);
     68     if(!name){res.statusCode=404;res.end();return;}
     69     res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript');res.end(await readFile(resolve(packageDir,name)));
     70   }catch(error){res.statusCode=500;res.end('fixture setup failed');console.error(error);}
     71 });
     72 server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));});
     73 server.on('upgrade',(req,socket,head)=>{
     74   const publicRoute=['/listing/main','/listing/worker'].includes(req.url);
     75   assert(publicRoute||sources.has(req.url));upgrades.push(req.url);
     76   wss.handleUpgrade(req,socket,head,ws=>{
     77     ws.on('error',()=>{});
     78     ws.on('message',(data,binary)=>{
     79       assert(!binary);const raw=data.toString(),message=JSON.parse(raw);
     80       observed.push({route:req.url,message,rawEvent:message[0]==='EVENT'?raw.slice('["EVENT",'.length,-1):undefined});
     81       if(message[0]==='REQ'){
     82         assert(!publicRoute,'public listing must not query a private route');
     83         assert.equal(message[2].kinds[0],10050);assert.equal(message[2].authors.length,1);
     84         for(const value of sources.get(req.url))if(value.pubkey===message[2].authors[0])ws.send(JSON.stringify(['EVENT',message[1],value]));
     85         ws.send(JSON.stringify(['EOSE',message[1]]));
     86       }else if(message[0]==='EVENT'){
     87         assert.equal(message[1].kind,publicRoute?30402:1059);
     88         const firstPublic=publicRoute&&observed.filter(item=>item.route===req.url&&item.message[0]==='EVENT').length===1;
     89         ws.send(JSON.stringify(['OK',message[1].id,!firstPublic,firstPublic?'blocked: measured loopback rejection':'']));
     90       }else assert.equal(message[0],'CLOSE');
     91     });
     92   });
     93 });
     94 await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
     95 const base=`http://127.0.0.1:${server.address().port}`;let browser;
     96 const watchdog=setTimeout(()=>{void browser?.close();},120000);watchdog.unref();
     97 try{
     98   const automation=engine==='firefox'?'webdriver_bidi':'playwright_default';
     99   const options=engine==='firefox'?{headless:true,channel:'moz-firefox-nightly',executablePath:playwright.firefox.executablePath()}:{headless:true};
    100   browser=await playwright[engine].launch(options);let page=await browser.newPage();const errors=[];
    101   page.on('pageerror',error=>errors.push(error.message));await page.goto(base);await page.addScriptTag({content:observer});
    102   const main=await page.evaluate(new Function('base',`return(async()=>{const context='main';${execute}})();`),base);
    103   console.error(JSON.stringify({phase:'main_completed',engine,result:main}));
    104   await page.close();page=await browser.newPage();page.on('pageerror',error=>errors.push(error.message));await page.goto(base);
    105   const dedicated=await page.evaluate(base=>new Promise((resolve,reject)=>{
    106     const worker=new Worker('./worker.js',{type:'module'});
    107     worker.onerror=event=>{worker.terminate();reject(Error(event.message));};
    108     worker.onmessage=event=>{worker.terminate();event.data.error?reject(Error(event.data.error)):resolve(event.data);};worker.postMessage(base);
    109   }),base);
    110   assert.equal(main.passed.length,7);assert.deepEqual(main.passed,dedicated.passed);assert.deepEqual(errors,[]);
    111   assert.equal(main.listing.passed.length,4);assert.deepEqual(main.listing.passed,dedicated.listing.passed);
    112   for(const context of ['main','worker']){
    113     const publications=observed.filter(item=>item.route==='/'+context&&item.message[0]==='EVENT');
    114     assert.equal(publications.length,4);assert.equal(new Set(publications.map(item=>item.message[1].id)).size,4);
    115     assert.equal(upgrades.filter(route=>route==='/'+context).length,2);
    116     const publicEvents=observed.filter(item=>item.route==='/listing/'+context&&item.message[0]==='EVENT');
    117     assert.equal(publicEvents.length,2);assert.equal(publicEvents[0].rawEvent,publicEvents[1].rawEvent);
    118     assert.equal(upgrades.filter(route=>route==='/listing/'+context).length,2);
    119   }
    120   console.log(JSON.stringify({engine,automation,version:browser.version(),main,dedicated,pageErrors:errors,upgrades,observed}));
    121 }finally{
    122   clearTimeout(watchdog);await browser?.close();for(const client of wss.clients)client.terminate();for(const socket of sockets)socket.destroy();
    123   await new Promise(resolve=>wss.close(resolve));await new Promise(resolve=>server.close(resolve));
    124 }