import test from 'node:test'; import assert from 'node:assert/strict'; import {readFile} from 'node:fs/promises'; import {createContext, runInContext} from 'node:vm'; import {shallowReactive, isReactive} from 'vue'; // Exercise orchestration with fake APIs and time. No server or game is contacted. const source = await readFile(new URL('../src/controller.js', import.meta.url), 'utf8'); const dom = await readFile(new URL('../../ranch_web/static/dom.js', import.meta.url), 'utf8'); const paths = await readFile(new URL('../../ranch_web/static/paths.js', import.meta.url), 'utf8'); const keys = ['login','incubator','bag','ranch','daily','hatching','mainline','battles','gifts','commissions','exploration','maps','statistics','plans','yields']; const plain = value => JSON.parse(JSON.stringify(value)); const settle = async () => { for (let i = 0; i < 40; i++) await Promise.resolve(); }; function deferred() { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return {promise, resolve, reject}; } class Element extends EventTarget { constructor(tag = 'div') { super(); Object.assign(this, {tagName:tag.toUpperCase(), children:[], dataset:{}, value:'', hidden:false, isConnected:true, textContent:'', attributes:{}}); this.classList = {add(){}, toggle(){}}; } append(...nodes) { this.children.push(...nodes); } replaceChildren(...nodes) { this.children = nodes; } setAttribute(key, value) { this.attributes[key] = value; } querySelector(selector) { return selector === ':invalid' ? this.invalid : null; } querySelectorAll() { return []; } remove() { this.isConnected = false; } focus() {} click() {} close() { this.open = false; } } async function fixture(t) { const h = {calls:[], pages:[], notices:[], confirms:[], files:[], overrides:{}, now:100000, timers:new Map(), timerId:0}; h.accounts = new Map(['a', 'b'].map(id => [id, {id, label:id, connected:true, running:false, demo:true, revision:0, player:{name:id}}])); h.configs = new Map(['a', 'b'].map(id => [id, {interval:30, policy:{egg_rules:{}}, log_visible:true, log_sizes:[420,140]}])); h.base = { auth:() => ({required:false, access_mode:'local'}), meta:() => ({version:'2.0.0', nested:{}}), schema:() => ({pages:[]}), accounts:() => [...h.accounts.values()].map(value => structuredClone(value)), config:id => ({config:structuredClone(h.configs.get(id)), revision:h.accounts.get(id).revision}), save:(id, config) => { h.configs.set(id, structuredClone(config)); h.accounts.get(id).revision++; return h.base.config(id); }, status:id => structuredClone(h.accounts.get(id)), view:(id, key) => ({data:{columns:[{key:'id'}], rows:[], marker:`${id}/${key}`}, loading:false}), action:(id, operation) => { if (operation === 'start' || operation === 'stop') h.accounts.get(id).running = operation === 'start'; return {id:`${id}/${operation}`, status:'succeeded', result:{}}; }, logs:() => ({entries:[], next:0}), remove:id => { h.accounts.delete(id); }, job:() => ({status:'succeeded', result:{}}), }; const api = new Proxy({}, {get:(_, name) => (...args) => { h.calls.push({name, args:structuredClone(args), at:h.now}); return Promise.resolve().then(() => { const fn = h.overrides[name] || h.base[name]; if (!fn) throw new Error(`Unexpected API call: ${String(name)}`); return fn(...args); }); }}); class PageView { constructor(account, key, options) { Object.assign(this, {account, key, options, root:new Element(), query:{}, data:null, renders:[], selected:[]}); this.login = key === 'login' ? {clearPassword(){}, update(){}} : null; h.pages.push(this); } render(data) { this.data = data; this.renders.push(data); } clearError() {} showError(message) { this.error = message; } selectedRows() { return this.selected; } destroy() { this.destroyed = true; } } const document = Object.assign(new EventTarget(), { hidden:false, body:new Element('body'), activeElement:null, querySelector:selector => { if (selector.startsWith('meta[')) return null; if (selector === '#action-dialog') return {open:true, close(){}}; if (selector === '#notice') return null; throw new Error(`Unexpected shell DOM query: ${selector}`); }, querySelectorAll:() => [], createElement:tag => new Element(tag), createTextNode:text => Object.assign(new Element(), {textContent:text}), }); const context = createContext({ shallowReactive, api, PageView, PAGES:keys.map(key => [key,key]), document, window:new EventTarget(), location:{origin:'http://console.invalid', replace:target => { h.redirect = target; }}, structuredClone, AbortController, URL, Blob, Node:Element, Date:class extends Date { static now() { return h.now; } }, setTimeout:(callback, delay = 0) => { const id = ++h.timerId; h.timers.set(id, {callback, at:h.now + delay}); return id; }, clearTimeout:id => h.timers.delete(id), notice:(message, error) => h.notices.push({message,error}), confirm:() => Promise.resolve(h.confirms.length ? h.confirms.shift() : true), dialog:() => Promise.resolve(h.confirms.length ? h.confirms.shift() : null), filePicker:() => Promise.resolve(h.files.shift() || null), fileBase64:async () => 'Zml4dHVyZQ==', request:async path => { h.detailPath = path; return {details:{safe:true}}; }, }); runInContext(dom.replace(/^export /gm, ''), context); runInContext(paths.replace(/^export /gm, ''), context); runInContext(source.replace(/^import .+;\r?\n/gm, '').replace('export function createConsoleController', 'function createConsoleController'), context); h.controller = runInContext('createConsoleController()', context); h.document = document; h.context = context; h.advance = async duration => { const until = h.now + duration; for (;;) { const next = [...h.timers].filter(([,timer]) => timer.at <= until).sort((a,b) => a[1].at - b[1].at)[0]; if (!next) break; h.now = next[1].at; h.timers.delete(next[0]); next[1].callback(); await settle(); } h.now = until; await settle(); }; h.findPage = (key, id = h.controller.state.activeId) => h.pages.find(page => page.key === key && page.account.id === id); t.after(() => h.controller.dispose()); await h.controller.init(new Element()); await settle(); assert.equal(h.controller.state.error, null); assert.equal(h.controller.state.ready, true); return h; } test('exports the contract, keeps snapshots raw and skips APIs on shell pages', async t => { const h = await fixture(t), c = h.controller; assert.deepEqual(Object.keys(c).sort(), ['state','init','navigate','selectAccount','command','refresh','setInterval','retrySave','setLogDebug','inspectLog','dispose'].sort()); assert.ok(isReactive(c.state)); assert.equal(isReactive(c.state.accounts), false); assert.equal(isReactive(c.state.meta.nested), false); assert.equal(c.state.currentConfig.policy, undefined); assert.ok(Object.isFrozen(c.state.currentConfig)); for (const key of ['overview','accounts','activity','system']) await c.navigate(key); assert.equal(h.calls.filter(call => call.name === 'view').length, 0); for (const key of keys) await c.navigate(key); assert.deepEqual(h.calls.filter(call => call.name === 'view').map(call => call.args[1]), keys); }); test('serializes edits added during an in-flight save and renders only the visible page', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); await c.navigate('bag'); const bag = h.findPage('bag'); await c.navigate('hatching'); const page = h.findPage('hatching'); const hiddenRenders = bag.renders.length; h.overrides.save = (id, config) => h.calls.filter(call => call.name === 'save').length === 1 ? pending.promise : h.base.save(id, config); c.setInterval(60); const saving = c.retrySave(); await settle(); c.setInterval(120); await settle(); assert.equal(h.calls.filter(call => call.name === 'save').length, 1); pending.resolve({config:{...h.configs.get('a'), interval:60}, revision:1}); await saving; await settle(); const saves = h.calls.filter(call => call.name === 'save'); assert.deepEqual(saves.map(call => call.args[1].interval), [60,120]); assert.equal(c.state.currentConfig.dirty, false); assert.equal(c.state.interval, 120); assert.equal(bag.renders.length, hiddenRenders); assert.ok(page.renders.length > 1); await c.navigate('bag'); assert.ok(bag.renders.length > hiddenRenders); }); test('conflict rebasing retains explicit edits and respects server defaults and linked rules', async t => { const h = await fixture(t), c = h.controller; await c.navigate('bag'); const page = h.findPage('bag'); page.options.edit(page.account, ['policy','egg_rules','7','enabled'], true, {}, { rule_path:['policy','egg_rules','7'], rule_defaults:{action:'feed', priority:1}, }); h.overrides.save = () => Promise.reject(Object.assign(new Error('conflict'), {status:409})); h.configs.set('a', {interval:30, policy:{external:true, egg_rules:{7:{action:'feed', priority:8}}}}); h.accounts.get('a').revision = 8; await c.retrySave(); assert.ok(c.state.saveError); assert.equal(c.state.currentConfig.dirty, true); h.overrides.save = h.base.save; await c.retrySave(); const policy = h.configs.get('a').policy; assert.deepEqual(plain(policy.egg_rules[7]), {action:'feed', priority:8, enabled:true}); assert.equal(policy.feed, true); assert.equal(policy.collect, true); assert.equal(policy.external, true); assert.equal(c.state.saveError, null); }); test('stop suppresses an unsent start waiting for a save after switching accounts', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); h.overrides.save = () => pending.promise; c.setInterval(60); const saving = c.retrySave(); await settle(); const starting = c.command('start', 'a'); await settle(); await c.selectAccount('b'); await c.command('stop', 'a'); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['a','stop']]); pending.resolve({config:{...h.configs.get('a'), interval:60}, revision:1}); await Promise.all([saving, starting]); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['a','stop']]); assert.equal(c.state.accounts.find(account => account.id === 'a').running, false); assert.equal(c.state.activeId, 'b'); }); test('a delayed start stays bound to its original account when switching accounts without stop', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); h.overrides.save = () => pending.promise; c.setInterval(60); const saving = c.retrySave(); await settle(); const starting = c.command('start', 'a'); await settle(); await c.selectAccount('b'); assert.equal(h.calls.filter(call => call.name === 'action').length, 0); pending.resolve({config:{...h.configs.get('a'), interval:60}, revision:1}); await Promise.all([saving, starting]); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['a','start']]); assert.equal(c.state.activeId, 'b'); }); test('discards hidden-page responses and coalesces generation changes without overlapping views', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); let reads = 0; h.overrides.view = () => ++reads === 1 ? pending.promise : {data:{marker:'fresh'}}; const navigation = c.navigate('bag'); await settle(); const page = h.findPage('bag'); page.query.search = 'new'; page.generation = 1; const reloading = page.options.load(page, true); await settle(); assert.equal(reads, 1); pending.resolve({data:{marker:'stale'}}); await Promise.all([navigation,reloading]); assert.deepEqual(page.renders.map(data => data.marker), ['fresh']); const hidden = deferred(); h.overrides.view = () => hidden.promise; const second = c.navigate('ranch'); await settle(); await c.navigate('overview'); hidden.resolve({data:{marker:'hidden'}}); await second; assert.equal(h.findPage('ranch').renders.length, 0); }); test('removes the captured account without changing a newer selection, then selects after active removal', async t => { const h = await fixture(t), c = h.controller, confirmation = deferred(); h.confirms.push(confirmation.promise); const removing = c.command('remove-account', 'a'); await settle(); await c.selectAccount('b'); confirmation.resolve(true); await removing; assert.equal(c.state.activeId, 'b'); assert.deepEqual(plain(c.state.accounts.map(account => account.id)), ['b']); await c.command('remove-account', 'b'); assert.equal(c.state.activeId, null); assert.equal(c.state.accounts.length, 0); assert.equal(c.state.page, 'login'); const second = await fixture(t); await second.controller.command('remove-account', 'a'); assert.equal(second.controller.state.activeId, 'b'); assert.equal(second.controller.state.page, 'login'); }); test('stop suppresses an unsent start waiting for an unselected account config', async t => { const h = await fixture(t), c = h.controller, config = deferred(); h.overrides.config = id => id === 'b' ? config.promise : h.base.config(id); const starting = c.command('start', 'b'); await settle(); assert.equal(h.calls.filter(call => call.name === 'config' && call.args[0] === 'b').length, 1); assert.equal(h.calls.filter(call => call.name === 'action').length, 0); await c.command('stop', 'b'); config.resolve(h.base.config('b')); await starting; assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['b','stop']]); assert.equal(c.state.accounts.find(account => account.id === 'b').running, false); assert.equal(c.state.activeId, 'a'); }); test('starting is synchronous and an older start cannot clear a newer pending start', async t => { const h = await fixture(t), c = h.controller, config = deferred(), response = deferred(); const summary = () => c.state.accounts.find(account => account.id === 'b'); h.overrides.config = id => id === 'b' ? config.promise : h.base.config(id); h.overrides.action = (id, operation) => operation === 'start' ? response.promise : h.base.action(id, operation); const first = c.command('start', 'b'); assert.equal(summary().starting, true); assert.equal(summary().running, false); const stopping = c.command('stop', 'b'); assert.equal(summary().starting, false); const second = c.command('start', 'b'); assert.equal(summary().starting, true); await stopping; config.resolve(h.base.config('b')); await first; await settle(); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['b','stop'],['b','start']]); assert.equal(summary().starting, true); assert.equal(summary().running, false); h.accounts.get('b').running = true; response.resolve({id:'latest-start', status:'succeeded', result:{}}); await second; assert.equal(summary().starting, false); assert.equal(summary().running, true); }); test('stop on another account does not suppress a delayed start', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); h.overrides.save = () => pending.promise; c.setInterval(60); const saving = c.retrySave(); await settle(); const starting = c.command('start', 'a'); await settle(); await c.command('stop', 'b'); pending.resolve({config:{...h.configs.get('a'), interval:60}, revision:1}); await Promise.all([saving, starting]); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['b','stop'],['a','start']]); }); test('stop preserves server tracking for a start whose request was already sent', async t => { const h = await fixture(t), c = h.controller, response = deferred(); h.overrides.action = (id, operation) => operation === 'start' ? response.promise : h.base.action(id, operation); h.overrides.job = () => ({id:'sent-start', status:'succeeded', result:{outcome:'server-result'}}); const starting = c.command('start', 'a'); await settle(); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['a','start']]); await c.command('stop', 'a'); response.resolve({id:'sent-start', status:'queued', operation:'start'}); assert.deepEqual(plain(await starting), {outcome:'server-result'}); assert.equal(h.calls.filter(call => call.name === 'job' && call.args[1] === 'sent-start').length, 1); assert.deepEqual(h.calls.filter(call => call.name === 'action').map(call => call.args.slice(0,2)), [['a','start'],['a','stop']]); }); test('jobs finish independently of blocked summaries; disposing rejects no unhandled job promises', async t => { const h = await fixture(t), c = h.controller, summaries = deferred(); h.overrides.accounts = () => summaries.promise; h.overrides.action = () => ({id:'job', status:'queued', operation:'stop'}); let polls = 0; h.overrides.job = () => ++polls === 1 ? {id:'job',status:'running'} : {id:'job',status:'succeeded',result:{}}; const stopping = c.command('stop', 'a'); await settle(); assert.equal(c.state.jobs.length, 1); await h.advance(1000); await stopping; assert.equal(c.state.jobs.length, 0); await h.advance(7000); assert.equal(h.calls.filter(call => call.name === 'accounts').length, 2); h.overrides.job = () => ({id:'job',status:'running'}); const disposedCommand = c.command('stop', 'b'); await settle(); c.dispose(); await disposedCommand; await settle(); const count = h.calls.length; await h.advance(20000); assert.equal(h.calls.length, count); assert.equal(h.timers.size, 0); summaries.resolve([]); await settle(); }); test('caps logs at 500, discards old debug responses and pauses hidden-document page and log reads', async t => { const h = await fixture(t), c = h.controller, pending = deferred(); h.overrides.logs = (_, after, debug) => debug ? {entries:Array.from({length:650}, (_, id) => ({id, message:'debug'})), next:650} : pending.promise; await h.advance(3000); const debug = c.setLogDebug(true); await settle(); pending.resolve({entries:[{id:9000,message:'old'}],next:9001}); await debug; assert.equal(c.state.logs.length, 500); assert.equal(c.state.logs.some(entry => entry.message === 'old'), false); assert.equal(c.state.logs[0].id, 150); await c.navigate('bag'); h.document.hidden = true; const before = h.calls.filter(call => call.name === 'view' || call.name === 'logs').length; await h.advance(16000); assert.equal(h.calls.filter(call => call.name === 'view' || call.name === 'logs').length, before); });