tricu

compiler-package.test.mjs (2978B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {compilerDescriptor,COMPILER_EXPORT} from '../dist/compiler.js';
 import {BUNDLE_LIMIT} from '../dist/bundle.js';
 const descriptor=JSON.parse(await readFile(new URL('../compiler.json',import.meta.url)));
 const bytes=await readFile(new URL('../bundles/'+descriptor.hash+'.arboricx',import.meta.url));
 let instance=0;
 async function session(message,fetcher,after){
  const saved={fetch:globalThis.fetch,onmessage:globalThis.onmessage,postMessage:globalThis.postMessage};
  let timer;
  try{
   globalThis.fetch=fetcher;
   const messages=[];
   const reply=new Promise((resolve,reject)=>{
    timer=setTimeout(()=>reject(Error('worker test timeout')),5000);
    globalThis.postMessage=data=>{messages.push(data);if(data.type==='loaded'||data.type==='error')resolve(data);};
   });
   await import('../dist/conformance/worker.js?test='+ ++instance);
   globalThis.onmessage({data:message});
   const result=await reply;
   if(after)await after(result,messages);
   return result;
  }finally{
   clearTimeout(timer);
   for(const [key,value] of Object.entries(saved))if(value===undefined)delete globalThis[key];else globalThis[key]=value;
  }
 }
 
 test('stable compiler descriptors reject arrays, wrong backends/entrypoints and malformed pins',()=>{
  assert.equal(compilerDescriptor(descriptor).hash,descriptor.hash);
  for(const raw of [null,[],{...descriptor,schema:2},{...descriptor,backend:'experimental'},{...descriptor,export:'main'},{...descriptor,hash:'A'.repeat(64)}])assert.throws(()=>compilerDescriptor(raw));
 });
 
 test('the indexed compiler loads and downloads exact bytes as an ordinary package without compiling',async()=>{
  const requests=[];
  const fetcher=async url=>{requests.push(String(url));return new Response(bytes);};
  const loaded=await session({type:'load',hash:descriptor.hash},fetcher,async(result,messages)=>{
   assert.equal(result.type,'loaded');assert.ok(result.exports.some(e=>e.name===COMPILER_EXPORT));
   assert.equal(result.source,null);assert.ok(result.nodes<=100000);
   globalThis.onmessage({data:{type:'download'}});
   const download=messages.at(-1);assert.equal(download.type,'downloaded');assert.equal(download.hash,descriptor.hash);
   assert.deepEqual(Buffer.from(download.bytes),bytes);
   assert.equal(messages.some(m=>m.type==='done'),false,'load/download never execute a program');
  });
  assert.equal(loaded.type,'loaded');assert.equal(requests.length,1);
  assert.equal(requests.some(url=>url.endsWith('/compiler.json')),false);
 });
 
 test('ordinary packages retain their byte ceiling and SHA-256 verification',async()=>{
  const wrong=await session({type:'load',hash:'0'.repeat(64)},async()=>new Response(bytes));
  assert.match(wrong.message,/SHA-256 mismatch/);
  const oversized=await session({type:'load',hash:descriptor.hash},async()=>new Response(new Uint8Array(BUNDLE_LIMIT+1)));
  assert.match(oversized.message,/download limit/);
 });