tests/studio_queue.test.mjs

import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import { test } from 'node:test';

const contractSource = await readFile(new URL('../static/contract.js', import.meta.url));
const queueSource = await readFile(new URL('../static/queue-client.js', import.meta.url));
const {validateServingResult} = await import(
  `data:text/javascript;base64,${contractSource.toString('base64')}`
);
const {queuedPrediction} = await import(
  `data:text/javascript;base64,${queueSource.toString('base64')}`
);

const wire = 'decision-kai';
const canonical = 'llm-semantic-router/Decision-1.0-Kai-0.6B';
const manifest = 'a'.repeat(64);
const info = {id: wire, repo_id: canonical, manifest_sha256: manifest};
const questions = {
  beta: {type:'noul',instructions:'Is beta true?'},
  alpha: {type:'noul',instructions:'Is alpha true?'},
};
const answers = {
  alpha: {type:'noul',noul:0.2},
  beta: {type:'noul',noul:0.8},
};

test('Studio queue accepts a strict canonical single and batch after queued/running polls', async () => {
  const originalFetch = globalThis.fetch;
  try {
    for(const batch of [false,true]) {
      const payload = batch
        ? {model:wire,states:[{id:'one',state:'First'},{id:'two',state:'Second'}],questions}
        : {model:wire,state:'One request',questions};
      const usage = {input_tokens:12,output_tokens:0};
      const result = batch
        ? {model:canonical,results:[{id:'one',answers,usage},{id:'two',answers,usage}],usage:{input_tokens:24,output_tokens:0}}
        : {model:canonical,answers,usage};
      const accepted = {id:'job-1',model:wire,manifest_sha256:manifest,status:'queued'};
      const phases = [];
      const calls = [];
      const documents = [
        accepted,
        {...accepted,status:'queued'},
        {...accepted,status:'running'},
        {...accepted,status:'succeeded',result},
      ];
      globalThis.fetch = async (url, options={}) => {
        calls.push({url,options});
        return {ok:true,json:async()=>documents.shift()};
      };
      const completed = await queuedPrediction(payload,new AbortController(),info,{
        onProgress: phase=>phases.push(phase),
        validateCompletion: value=>validateServingResult(value,payload,canonical,'pull_queue'),
        pause:async()=>{},
      });
      assert.deepEqual(completed,result);
      assert.deepEqual(phases,['queued','running']);
      assert.equal(calls[0].url,'/api/jobs');
      assert.equal(calls[0].options.method,'POST');
      assert.deepEqual(JSON.parse(calls[0].options.body),payload);
      assert.deepEqual(calls.slice(1).map(call=>call.url),Array(3).fill('/api/jobs/job-1?model=decision-kai'));
      assert.equal(documents.length,0);
    }
  } finally {
    globalThis.fetch = originalFetch;
  }
});