tricu

packages.test.mjs (10730B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {readFile} from 'node:fs/promises';
 import {createHash} from 'node:crypto';
 import {packageIndex,packageReleases,environmentProfile} from '../dist/packages.js';
 import {decodeBundle,loadBundle} from '../dist/bundle.js';
 import {Graph} from '../dist/graph.js';
 import {BROWSER_BUDGET} from '../dist/execution.js';
 const read=name=>readFile(new URL('../'+name,import.meta.url));
 
 test('named versions and demo environments are validated and pinned',async()=>{
  const releases=packageIndex(JSON.parse(await read('packages.json')));
  const catalogue=JSON.parse(await read('catalogue.json'));
  const environments=JSON.parse(await read('environments.json'));
  const compiler=JSON.parse(await read('compiler.json'));
  assert.equal(environments.compiler,compiler.hash);
  for(const entry of catalogue){
   const release=releases.find(r=>r.demo===entry.id&&r.hash===entry.hash);assert.ok(release);
   if(entry.environment===undefined){assert.equal(entry.preparation,'native');continue;}
   const {profile}=environmentProfile(environments,entry.environment);
   if(profile){
    const bytes=await read('bundles/'+profile.hash+'.arboricx');
    assert.equal(createHash('sha256').update(bytes).digest('hex'),profile.hash);
    const values=loadBundle(new Graph(),decodeBundle(bytes));
    for(const name of profile.names)assert.ok(values.has(name),name);
   }
  }
 });
 test('index and environment boundaries reject malformed paths, pins, duplicates and profiles',()=>{
  const r={name:'demo',version:'0.1',title:'A demo',hash:'a'.repeat(64),manifest:'b'.repeat(64)};
  assert.equal(packageIndex({schema:1,releases:[r]})[0].name,'demo');
  for(const change of [{name:'../x'},{version:'x/y'},{hash:'A'.repeat(64)},{manifest:'x'},{title:[]},{demo:'x/y'}])assert.throws(()=>packageIndex({schema:1,releases:[{...r,...change}]}));
  assert.throws(()=>packageIndex({schema:1,releases:[r,r]}),/Duplicate/);
  assert.throws(()=>packageIndex({schema:2,releases:[r]}));
  const descriptor={schema:1,compiler:'a'.repeat(64),profiles:{empty:null}};
  assert.equal(environmentProfile(descriptor,'empty').profile,null);
  assert.throws(()=>environmentProfile(descriptor,'toString'),/Unknown/);
  for(const names of [['bad name'],['x','x'],Array(129).fill('x'),['../x']])assert.throws(()=>environmentProfile({...descriptor,profiles:{test:{hash:r.hash,names}}},'test'));
 });
 test('browser execution has no application ceilings and retains GC',()=>{
  assert.deepEqual(BROWSER_BUDGET,{nodes:Infinity,fuel:Infinity,stack:Infinity});
  const open=new Graph(BROWSER_BUDGET,{threshold:2});let root=open.leaf;
  for(let i=0;i<100;i++){root=open.stem(root);open.collect([root]);}
  assert.ok(open.stats.nodes>10);assert.ok(open.stats.collections>0);
 });
 
 test('published native libraries have authenticated complete interfaces and no fabricated demo source',async()=>{
  const releases=packageIndex(JSON.parse(await read('packages.json')));
  const expected={
   'tricu-base':['append','matchResult','showNumber'],
   'tricu-file-io':['io','bind','readFile','sha256Hex','putStr','abortIO'],
   'arboricx-inspection':['inspectBundle','renderSummary','describeError'],
  };
  for(const [name,names] of Object.entries(expected))for(const version of ['0.1.0','0.1.1']){
   const release=releases.find(r=>r.name===name&&r.version===version);assert.ok(release);assert.equal(release.demo,undefined);
   const bytes=await read('bundles/'+release.hash+'.arboricx');
   assert.equal(createHash('sha256').update(bytes).digest('hex'),release.hash);
   assert.deepEqual([...loadBundle(new Graph(),decodeBundle(bytes)).keys()].sort(),names.sort());
  }
 });
 
 test('showcase packages retain browser-bounded complete library roots and native-only server identity',async()=>{
  const releases=packageIndex(JSON.parse(await read('packages.json')));
  for(const [name,required] of Object.entries({
   'arboricx-server':['arboricxServer','arboricxRouter','bundleHashValid?'],
   'tricu-http':['parseRequestLine','response','httpHandlerIO'],
   'tricu-intensional-contracts':['fullTree?','powerOfTwo?','sortedList?'],
   'tricu-graphs':['graphSort','graphCycle'],
   'tricu-parser':['parserBind','parserCommit','parserMatchReply','parserEof'],
   'tricu-formatter':['formatTri'],
  })){
   const release=releases.find(r=>r.name===name);assert.ok(release);assert.equal(release.demo,undefined);
   const bytes=await read('bundles/'+release.hash+'.arboricx');
   assert.equal(createHash('sha256').update(bytes).digest('hex'),release.hash);
   assert.ok(bytes.length<=16777216);
   const bundle=decodeBundle(bytes);assert.ok(bundle.nodes.length<=100000);
   const exports=loadBundle(new Graph(),bundle);
   for(const name of required)assert.ok(exports.has(name),name);
   if(release.name==='arboricx-server')assert.match(release.title,/native sockets and filesystem/);
  }
 });
 
 test('native parser demo source and goldens are authenticated with an editable native module environment',async()=>{
  const catalogue=JSON.parse(await read('catalogue.json')),demo=catalogue.find(e=>e.id==='parser');
  const goldens=JSON.parse(await read('parser-demo.json'));
  assert.equal(demo.preparation,'native');assert.equal(demo.environment,'empty');
  assert.equal(createHash('sha256').update(demo.source).digest('hex'),demo.sourceSha256);
  assert.equal(demo.source,await read('demos/parser.tri').then(b=>b.toString()));
  assert.equal(goldens.hash,demo.hash);assert.equal(goldens.sourceSha256,demo.sourceSha256);
  assert.ok(goldens.haskellCases.some(c=>c.record.status==='error'&&c.record.committed));
  assert.ok(goldens.haskellCases.some(c=>c.export==='parsePrefix'&&c.record.status==='ok'&&c.record.remaining));
 });
 
 test('both indexed compiler packages retain their exact independently authenticated artifacts',async()=>{
  const releases=packageIndex(JSON.parse(await read('packages.json'))),descriptor=JSON.parse(await read('compiler.json'));
  for(const [name,path,entrypoint] of [
   ['tricu-compiler','test/fixtures/compiler-library.arboricx','source_unit.compileStableModuleDefinitions'],
   ['tricu-source-builder','bootstrap/build-stable.arboricx','sourceBuildGraph'],
  ]){
   const reference=await readFile(new URL('../../../'+path,import.meta.url));
   const referenceHash=createHash('sha256').update(reference).digest('hex');
   const release=releases.find(r=>r.name===name&&r.hash===referenceHash);assert.ok(release);assert.equal(release.demo,undefined);
   const bytes=await read('bundles/'+release.hash+'.arboricx');
   assert.ok(bytes.equals(reference),'indexed current artifact matches authenticated reference');
   assert.equal(createHash('sha256').update(bytes).digest('hex'),release.hash);
   const {COMPILER_BUNDLE_LIMIT}=await import('../dist/bundle.js');
   const bundle=decodeBundle(bytes,COMPILER_BUNDLE_LIMIT);assert.ok(bundle.nodes.length<=100000);
   assert.ok(bundle.exports.some(e=>e.name===entrypoint));
   if(name==='tricu-compiler')assert.equal(release.hash,descriptor.hash);
   else{assert.equal(bundle.exports.length,1);assert.match(release.title,/native application compiler/);}
  }
 });
 
 test('new practical libraries expose complete interfaces and lexer reference source is authenticated',async()=>{
  const releases=packageIndex(JSON.parse(await read('packages.json')));
  for(const [name,required] of Object.entries({
   'tricu-math':['add','divMod','inRange','decimal','printable'],
   'tricu-lexer':['lexerScanWhile','lexerAdvance','lexerDispatch','lexerToken'],
   'tricu-binary':['readU8','readBytes','binaryUtf8?','errInvalidBinaryInput'],
   'tricu-list-traversal':['listContinue','listStop','listFoldUntil','listFoldTailUntil'],
   'tricu-patterns':['match','otherwise','cond','guard'],
  })){
   const release=releases.find(r=>r.name===name);assert.ok(release);assert.equal(release.demo,undefined);
   const bytes=await read('bundles/'+release.hash+'.arboricx');
   assert.equal(createHash('sha256').update(bytes).digest('hex'),release.hash);
   const names=decodeBundle(bytes).exports.map(e=>e.name);
   for(const name of required)assert.ok(names.includes(name),name);
   if(name==='tricu-list-traversal'||name==='tricu-patterns')assert.deepEqual(names.sort(),required.sort());
  }
  const demo=JSON.parse(await read('catalogue.json')).find(e=>e.id==='lexer'),goldens=JSON.parse(await read('lexer-demo.json'));
  assert.equal(demo.preparation,'native');assert.equal(demo.environment,'empty');
  assert.equal(demo.source,await read('demos/lexer.tri').then(b=>b.toString()));
  assert.equal(createHash('sha256').update(demo.source).digest('hex'),demo.sourceSha256);
  assert.equal(goldens.hash,demo.hash);assert.equal(goldens.sourceSha256,demo.sourceSha256);
  assert.ok(goldens.haskellCases.some(c=>c.record.line===2&&c.record.offset===3));
  assert.ok(goldens.haskellCases.some(c=>c.record.remaining==='é'));
 });
 
 test('release choices are newest-first, numeric, independent of publication order and non-mutating',()=>{
  const versions=['0.1.0','0.10.0','0.2.0','1.0.0-rc.2','1.0.0-rc.10','1.0.0','1.0.0-alpha','1.0.0-1'];
  const releases=versions.map(version=>({name:'demo',version,hash:'a'.repeat(64),manifest:'b'.repeat(64),title:version}));
  const expected=['1.0.0','1.0.0-rc.10','1.0.0-rc.2','1.0.0-alpha','1.0.0-1','0.10.0','0.2.0','0.1.0'];
  for(const input of [releases,[...releases].reverse()]){
   const snapshot=[...input];
   assert.deepEqual(packageReleases([...input,{...input[0],name:'other',version:'99.0.0'}],'demo').map(r=>r.version),expected);
   assert.deepEqual(input,snapshot);
  }
  assert.deepEqual(packageReleases(releases,'missing'),[]);
  const labels=['build2','build10','0.1.0'].map(version=>({...releases[0],version}));
  assert.deepEqual(packageReleases(labels,'demo').map(r=>r.version),['0.1.0','build10','build2']);
 });
 
 test('every catalogue demo is editable, source-authenticated and explicitly imports indexed manifests',async()=>{
  const catalogue=JSON.parse(await read('catalogue.json')),index=packageIndex(JSON.parse(await read('packages.json')));
  assert.equal(catalogue.length,16);
  assert.equal(catalogue[0].id,'names-values');
  assert.ok(!catalogue.some(e=>e.id==='intro'));
  for(const demo of catalogue){
   assert.equal(demo.environment,'empty',demo.id);
   assert.equal(demo.source,(await read('demos/'+demo.id+'.tri')).toString());
   assert.equal(createHash('sha256').update(demo.source).digest('hex'),demo.sourceSha256);
   assert.match(demo.source,/^!export /m);
   for(const line of demo.source.split('\n').filter(s=>s.startsWith('!import '))){
    const match=line.match(/^!import ([0-9a-f]{64}) (?:\*|as [A-Za-z_][A-Za-z0-9_]*)$/);assert.ok(match,line);
    assert.ok(index.some(r=>r.manifest===match[1]),line);
   }
   assert.doesNotMatch(demo.source,/Tree graph|copy it into Compiler|source is read-only|input box uses JSON/);
  }
 });