LangBot/web/tests/unit/websocket-client.test.mjs

import assert from 'node:assert/strict';
import test from 'node:test';
import fs from 'node:fs';
import ts from 'typescript';
function load(file,deps={},globals={}) {
 const source=fs.readFileSync(new URL('../../src/app/infra/websocket/'+file,import.meta.url),'utf8').replaceAll('import.meta.env.VITE_API_BASE_URL','undefined');
 const code=ts.transpileModule(source,{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2022}}).outputText;
 const m={exports:{}};new Function('require','module','exports',...Object.keys(globals),code)(id=>deps[id],m,m.exports,...Object.values(globals));return m.exports;
}
const urls=load('url.ts');
test('OSS and Cloud URLs follow HTTP backend scheme, port and prefix',()=>{
 for(const [base,page,expected] of [
 [undefined,'http://localhost:3000/home','ws://localhost:3000/api/ws'],
 [undefined,'https://cloud.test/home','wss://cloud.test/api/ws'],
 ['http://localhost:5300','http://localhost:3000','ws://localhost:5300/api/ws'],
 ['https://api.test/root/','https://ui.test','wss://api.test/root/api/ws'],
 ['/backend/','https://ui.test/home','wss://ui.test/backend/api/ws'],
 ['https://api.test','http://ui.test','wss://api.test/api/ws'],
 ]) assert.equal(urls.backendWebSocketURL(base,page,'/api/ws').toString(),expected);
});
function setup(){
 let workspace='one',next=0;const timers=new Map(),win=new EventTarget(),doc=new EventTarget();win.location={href:'https://cloud.test/home'};doc.visibilityState='visible';
 class WS{
 static CONNECTING=0;static OPEN=1;static instances=[];readyState=0;
 constructor(url){this.url=url;WS.instances.push(this)}
 send(p){this.sent=JSON.parse(p)} close(){this.readyState=3} closed(){this.readyState=3;this.onclose?.()}
 open(){this.readyState=1;this.onopen?.()} receive(data){this.onmessage?.({data:JSON.stringify(data)})}
 }
 const {WebSocketClient}=load('WebSocketClient.ts',{'./url':urls,'@/app/infra/http/workspaceContext':{getActiveWorkspaceUuid:()=>workspace}},{
 window:win,document:doc,WebSocket:WS,localStorage:{getItem:()=> 'token'},
 setTimeout:fn=>{timers.set(++next,fn);return next},clearTimeout:id=>timers.delete(id),setInterval:()=>1,clearInterval:()=>{},console:{warn(){},error(){},debug(){}},
 });
 return {client:new WebSocketClient('pipeline'),WS,win,timers,setWorkspace:v=>workspace=v};
}
test('only authenticated sockets are connected; disposal removes recovery',async()=>{
 const {client,WS,win}=setup(),pending=client.connect(),ws=WS.instances[0];ws.open();assert.equal(client.isConnected(),false);assert.equal(ws.sent.workspace_uuid,'one');
 ws.receive({type:'connected',connection_id:'id'});assert.equal(await pending,'id');assert(client.isConnected());client.disconnect();ws.closed();win.dispatchEvent(new Event('focus'));assert.equal(WS.instances.length,1);
});
test('closed handshakes settle and transient retries survive more than five failures',async()=>{
 const {client,WS,timers}=setup();const first=client.connect().catch(()=>{});WS.instances[0].closed();await first;
 for(let i=0;i<7;i++){const [id,fn]=[...timers][0];timers.delete(id);fn();WS.instances.at(-1).closed();await Promise.resolve()}
 assert.equal(WS.instances.length,8);assert.equal(timers.size,1);client.disconnect();assert.equal(timers.size,0);
});
test('stale closes do not affect replacement sockets and workspace changes block recovery',async()=>{
 const {client,WS,win,setWorkspace}=setup();const pending=client.connect().catch(()=>{}),old=WS.instances[0];client.disconnect();
 const current=client.connect(),ws=WS.instances[1];old.closed();await pending;ws.open();ws.receive({type:'connected',connection_id:'new'});await current;
 assert(client.isConnected());setWorkspace('two');ws.closed();win.dispatchEvent(new Event('focus'));assert.equal(WS.instances.length,2);client.disconnect();
});
test('authentication rejection does not reconnect',async()=>{
 const {client,WS,timers,win}=setup();const pending=client.connect().catch(()=>{}),ws=WS.instances[0];ws.open();ws.receive({type:'error',message:'Unauthorized'});ws.closed();await pending;
 win.dispatchEvent(new Event('focus'));assert.equal(timers.size,0);assert.equal(WS.instances.length,1);client.disconnect();
});