tricu

auto-interpretation.test.mjs (3803B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {Graph} from '../dist/graph.js';
 import {makeLiteral,readableText,valueText,view,outputType,natural,list,DECODED_LIST_LIMIT} from '../dist/codecs.js';
 import {autoInterpretation} from '../dist/auto-interpretation.js';
 const n=value=>({type:'number',value:String(value)}),s=value=>({type:'string',value});
 const auto=literal=>{const g=new Graph(),h=makeLiteral(g,literal);return autoInterpretation(type=>Promise.resolve(view(g,h,type)),()=>false);};
 test('Auto chooses readable text, naturals, decoded lists, Boolean and source',async()=>{
  for(const text of ['hello','λ雪🙂','a\nb\t','👨‍👩‍👧‍👦'])assert.deepEqual(await auto(s(text)),{type:'string',value:text});
  assert.deepEqual(await auto(n(42)),{type:'number',value:'42'});
  assert.deepEqual(await auto(s('')),{type:'number',value:'0'});
  assert.deepEqual(await auto({type:'bool',value:false}),{type:'number',value:'0'});
  assert.deepEqual(await auto({type:'bool',value:true}),{type:'bool',value:true});
  assert.deepEqual(await auto({type:'list',value:[s('hello'),n(42),n(2n**100n),s('')]}),{type:'values',value:[s('hello'),n(42),n(2n**100n),n(0)]});
  const bytes=Array(33).fill(128);assert.deepEqual(await auto({type:'bytes',value:bytes}),{type:'values',value:bytes.map(n)});
  assert.equal((await auto({type:'tree',value:'21100'})).type,'tricu');
 });
 test('readability is a preference, not a claim about types; explicit Text stays available',async()=>{
  for(const text of ['', '\0', '\x01', '\u202e', '\ue000','\u0378'])assert.equal(readableText(text),false,JSON.stringify(text));
  // The same list admits Unicode, byte and number-list views. Prefer readable text.
  assert.deepEqual(await auto({type:'list',value:[n(65),n(66)]}),{type:'string',value:'AB'});
  const g=new Graph(),h=makeLiteral(g,s('\0'));assert.deepEqual(view(g,h,'string'),s('\0'));
  assert.notEqual((await auto(s('\0'))).type,'string');
 });
 test('decoded lists preserve large natural values and fail closed on unsupported items/bounds',()=>{
  const g=new Graph();
  const h=makeLiteral(g,{type:'list',value:[s('a'),n(2n**100n)]});
  assert.equal(valueText(view(g,h,'values')),`["a" ${2n**100n}]`);
  assert.throws(()=>view(g,makeLiteral(g,{type:'list',value:[{type:'bool',value:true}]}),'values'),/number/);
  const boundary=list(g,Array(DECODED_LIST_LIMIT).fill(natural(g,42n)));
  assert.equal(view(g,boundary,'values').value.length,4096);
  assert.throws(()=>view(g,g.fork(g.leaf,boundary),'values'),/limit/);
  assert.throws(()=>view(g,boundary,'list'),/limit/); // Tiny graph previews stay bounded.
  assert.throws(()=>view(g,list(g,[list(g,Array(4097).fill(natural(g,65n)))]),'values'),/number bit/);
  assert.throws(()=>outputType('record'),/Unsupported/);
 });
 test('Auto stops on fatal errors, falls back once, and does not hide a failed tree observation',async()=>{
  const calls=[],fatal=Error('disposed');
  await assert.rejects(autoInterpretation(async type=>{calls.push(type);throw fatal;},()=>true),/disposed/);
  assert.deepEqual(calls,['string']);
  const attempted=[];
  await assert.rejects(autoInterpretation(async type=>{attempted.push(type);throw Error('observation failed');},()=>false),/observation failed/);
  assert.deepEqual(attempted,['string','number','values','bool','bytes','tricu']);
 });
 
 test('100 mixed FizzBuzz results decode explicitly and through Auto',async()=>{
  const expected=Array.from({length:100},(_,i)=>{const n=i+1;return n%15===0?s('fizzbuzz'):n%5===0?s('buzz'):n%3===0?s('fizz'):{type:'number',value:String(n)};});
  const literal={type:'list',value:expected},g=new Graph(),root=makeLiteral(g,literal);
  assert.deepEqual(view(g,root,'values'),{type:'values',value:expected});
  assert.deepEqual(await auto(literal),{type:'values',value:expected});
 });