lib

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

run.mjs (10172B)


      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 // Use the already locked browser harness's server implementation; no new
     12 // product dependency, relay implementation or protocol client is introduced.
     13 const {wsServer: WebSocketServer} = require(resolve(tools, 'node_modules/playwright-core/lib/utilsBundle.js'));
     14 const wss = new WebSocketServer({noServer: true});
     15 const sockets = new Set();
     16 const upgrades = [];
     17 const observed = [];
     18 process.on('uncaughtExceptionMonitor',()=>console.error(JSON.stringify({engine,upgrades,observed})));
     19 const vectors = JSON.parse(await readFile('contracts/conformance/vectors/event/verified_admission.v1.json','utf8'));
     20 const event = vectors.vectors[1].input.event;
     21 
     22 const observer = `
     23 const ActualWebSocket=globalThis.WebSocket, observedSockets=[];
     24 const actualTimeout=globalThis.setTimeout,actualClear=globalThis.clearTimeout,activeTimers=new Set();
     25 globalThis.setTimeout=(callback,delay,...args)=>{
     26   let id;id=actualTimeout.call(globalThis,(...values)=>{activeTimers.delete(id);callback(...values);},delay,...args);activeTimers.add(id);return id;
     27 };
     28 globalThis.clearTimeout=id=>{activeTimers.delete(id);return actualClear.call(globalThis,id);};
     29 globalThis.WebSocket=class extends ActualWebSocket {
     30   constructor(...args){super(...args);observedSockets.push(this);}
     31 };
     32 globalThis.waitForBrowserSocketClose=async route=>{
     33   const socket=observedSockets.findLast(socket=>socket.url.endsWith('/'+route));
     34   if(!socket)throw Error('missing actual socket: '+route);
     35   const deadline=performance.now()+5000;
     36   while(socket.readyState!==ActualWebSocket.CLOSED){
     37     if(performance.now()>=deadline)throw Error('socket did not close: '+route);
     38     await new Promise(resolve=>setTimeout(resolve,10));
     39   }
     40 };
     41 globalThis.forceBrowserSocketBackpressure=()=>{
     42   Object.defineProperty(observedSockets.at(-1),'bufferedAmount',{get(){return 4*1024*1024;}});
     43 };
     44 async function verifyCleanup(checkTimers=true,expectedStalls=2){
     45   await new Promise(resolve=>setTimeout(resolve,80));
     46   for(const socket of observedSockets){
     47     if(socket.onopen||socket.onmessage||socket.onerror||socket.onclose)throw Error('retained socket callback');
     48     if(socket.readyState!==ActualWebSocket.CLOSED)throw Error('retained open socket: '+socket.url+' state='+socket.readyState);
     49   }
     50   const inert=['unpolled','cancelled-owner','revoked-owner','expired-owner','closed-owner'];
     51   if(observedSockets.some(socket=>inert.some(route=>socket.url.endsWith('/'+route))))throw Error('inert or expired connection performed I/O');
     52   if(observedSockets.filter(socket=>socket.url.endsWith('/stall')).length!==expectedStalls)throw Error('missing original pending handshake attempts');
     53   if(checkTimers && activeTimers.size)throw Error('retained browser socket timer: '+activeTimers.size);
     54   return observedSockets.length;
     55 }`;
     56 const execute = `
     57 const {default:init,verify_socket,verify_scope,verify_shared_session,fixture_event}=await import('./fixture.js');await init();
     58 const passed=Array.from(await verify_socket(base));const directDisposed=await verifyCleanup();
     59 const scope=Array.from(await verify_scope(base));const scopeDisposed=await verifyCleanup(true,3);
     60 const shared=Array.from(await verify_shared_session(base));const disposed=await verifyCleanup(false,3);
     61 return {passed,scope,shared,directDisposed,scopeDisposed,disposed,expectedRaw:fixture_event()};`;
     62 const worker = `${observer}
     63 self.onmessage=async event=>{try{const base=event.data;const run=async()=>{${execute}};self.postMessage(await run());}
     64 catch(error){self.postMessage({error:String(error)});}};`;
     65 const server = createServer(async (req, res) => {
     66   try {
     67     if(req.url==='/'){res.setHeader('content-type','text/html');res.end('<!doctype html><title>Browser socket fixture</title>');return;}
     68     if(req.url==='/worker.js'){res.setHeader('content-type','text/javascript');res.end(worker);return;}
     69     const name = new Map([['/fixture.js','fixture.js'],['/fixture_bg.wasm','fixture_bg.wasm']]).get(req.url);
     70     if(!name){res.statusCode=404;res.end();return;}
     71     res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript');
     72     res.end(await readFile(resolve(packageDir,name)));
     73   } catch {res.statusCode=500;res.end();}
     74 });
     75 server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));});
     76 server.on('upgrade',(req,socket,head)=>{
     77   upgrades.push(req.url);
     78   if(req.url==='/stall')return; // Original pending HTTP upgrade, closed by its owner.
     79   wss.handleUpgrade(req,socket,head,ws=>{
     80     ws.on('error',()=>{});
     81     if(req.url==='/echo')ws.on('message',(data,binary)=>{observed.push({route:req.url,binary,bytes:data.length});ws.send(data,{binary});});
     82     else if(req.url==='/oversize')ws.send('a'.repeat(1025));
     83     else if(req.url==='/unicode')ws.send('é'.repeat(800));
     84     else if(req.url==='/binary-large')ws.send(Buffer.alloc(1025));
     85     else if(req.url==='/items')for(let i=0;i<257;i++)ws.send('');
     86     else if(req.url==='/bytes')for(let i=0;i<9;i++)ws.send(Buffer.alloc(512*1024));
     87     else if(req.url==='/disconnect'){ws.send('before close');ws.close(1000,'peer done');}
     88     else if(req.url.startsWith('/shared-'))ws.on('message',(data,binary)=>{
     89       if(binary)return;
     90       const wire=data.toString(),message=JSON.parse(wire);
     91       observed.push({route:req.url,wire});
     92       if(message[0]==='REQ'){
     93         if(req.url==='/shared-disconnect'){ws.close(1000,'history interrupted');return;}
     94         if(req.url==='/shared-observer')return;
     95         ws.send(JSON.stringify(['EVENT',message[1],event]));
     96         ws.send(JSON.stringify(['EOSE',message[1]]));
     97       }else if(message[0]==='EVENT'){
     98         if(req.url==='/shared-noack')return;
     99         if(req.url==='/shared-badack'){ws.send(JSON.stringify(['OK',message[1].id+'00',true,'']));return;}
    100         ws.send(JSON.stringify(['OK','11'.repeat(32),true,'unrelated']));
    101         ws.send(JSON.stringify(['OK',message[1].id,req.url!=='/shared-negative','']));
    102       }
    103     });
    104   });
    105 });
    106 await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
    107 const base=`ws://127.0.0.1:${server.address().port}`;
    108 let browser;
    109 const deadline=setTimeout(()=>{void browser?.close();},120000);deadline.unref();
    110 try {
    111   // The locked Juggler driver asserts when worker WebSocket-open events lack
    112   // its page request record. Use its supported BiDi channel with the exact same
    113   // cached Firefox executable; retain every real worker/product assertion.
    114   const automation=engine==='firefox'?'webdriver_bidi':'playwright_default';
    115   const options=engine==='firefox'?{headless:true,channel:'moz-firefox-nightly',executablePath:playwright.firefox.executablePath()}:{headless:true};
    116   browser=await playwright[engine].launch(options);
    117   let page=await browser.newPage();
    118   const errors=[],expectedUserAgentDiagnostics=[];
    119   const expectedDiagnostics=new Set([
    120     `Firefox can’t establish a connection to the server at ${base}/stall.`,
    121     `The connection to ${base}/stall was interrupted while the page was loading.`,
    122   ]);
    123   const onPageError=error=>{
    124     // BiDi reports these user-agent diagnostics as script errors for the two
    125     // deliberately interrupted handshakes. Retain the exact messages separately;
    126     // every other error still fails, including exceptions from product code.
    127     if(engine==='firefox' && automation==='webdriver_bidi' && expectedDiagnostics.has(error.message))expectedUserAgentDiagnostics.push(error.message);
    128     else errors.push(error.message);
    129   };
    130   page.on('pageerror',onPageError);
    131   await page.goto(`http://127.0.0.1:${server.address().port}/`);
    132   await page.addScriptTag({content:observer});
    133   const main=await page.evaluate(new Function('base',`return (async()=>{${execute}})();`),base);
    134   console.error(JSON.stringify({phase:'main_completed',engine,result:main}));
    135   // Each context first proves disposal on its original objects. WebKit can
    136   // retain the network tasks for cancelled HTTP upgrades after DOM close; six
    137   // such deliberately stalled tasks otherwise block the next connection.
    138   // Isolate page and worker fixture resources without renewing any deadline or
    139   // claiming that local disposal proves a remote/network-task close handshake.
    140   await page.close();
    141   page=await browser.newPage();
    142   page.on('pageerror',onPageError);
    143   await page.goto(`http://127.0.0.1:${server.address().port}/`);
    144   const dedicated=await page.evaluate(base=>new Promise((resolve,reject)=>{
    145     const worker=new Worker('./worker.js',{type:'module'});
    146     worker.onerror=event=>{worker.terminate();reject(Error(event.message));};
    147     worker.onmessage=event=>{worker.terminate();event.data.error?reject(Error(event.data.error)):resolve(event.data);};
    148     worker.postMessage(base);
    149   }),base);
    150   assert.equal(main.passed.length,19);
    151   assert.equal(main.shared.length,7);
    152   assert.equal(main.scope.length,4);
    153   assert.deepEqual(main,dedicated);
    154   assert.deepEqual(errors,[]);
    155   assert(!upgrades.includes('/unpolled'));
    156   const publications=observed.filter(item=>item.wire?.startsWith('["EVENT",'));
    157   assert.equal(publications.length,8);
    158   for(const publication of publications)assert.equal(publication.wire,`["EVENT",${main.expectedRaw}]`);
    159   // A deadline may expire before the user agent transmits an HTTP upgrade.
    160   assert(upgrades.filter(path=>path==='/stall').length<=6);
    161   assert(expectedUserAgentDiagnostics.length<=12);
    162   console.log(JSON.stringify({engine,automation,version:browser.version(),main,dedicated,pageErrors:errors,expectedUserAgentDiagnostics,upgrades,observed}));
    163 } finally {
    164   clearTimeout(deadline);
    165   await browser?.close();
    166   for(const client of wss.clients)client.terminate();
    167   for(const socket of sockets)socket.destroy();
    168   await new Promise(resolve=>wss.close(resolve));
    169   await new Promise(resolve=>server.close(resolve));
    170 }