224 lines
15 KiB
JavaScript
224 lines
15 KiB
JavaScript
// Row 194 (#1692, D3, T14): after every write that commits, the broker takes the business as a
|
|
// restart would load it, so a created instance binds with no restart. A definition change on a
|
|
// running instance refuses, and a file whose credential references changed isn't reloaded.
|
|
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import { Broker } from '../src/broker.mjs';
|
|
import { busOrganization } from '../src/organization-context.mjs';
|
|
import { startBroker } from '../src/runtime.mjs';
|
|
import { Store } from '../src/store.mjs';
|
|
import { loadBusiness } from '../../organization/src/organization-config.mjs';
|
|
import { resolveInstance } from '../../organization/src/resolve.mjs';
|
|
import { businessDoc, rolesCopy, systemFor, writeJson } from '../../organization/tests/helpers.mjs';
|
|
import { mappingEntry } from '../../library/tests/helpers.mjs';
|
|
|
|
// The bus form of the business file, built as cli bootConfig builds it.
|
|
function busForm(root, rolesDir, id = 'demo') {
|
|
const b = loadBusiness(id, { dir: root, rolesDir });
|
|
const resolved = {};
|
|
for (const instance of Object.keys(b.roles)) resolved[instance] = resolveInstance({ system: systemFor(root), business: b, instance });
|
|
return busOrganization(b, resolved);
|
|
}
|
|
|
|
async function setup(t, mutate) {
|
|
const root = mkdtempSync(join(tmpdir(), 'reload-'));
|
|
const rolesDir = rolesCopy(root);
|
|
const doc = businessDoc(root, 'demo');
|
|
doc.plugins = { harness: ['pi', 'claude-code'] };
|
|
mutate?.(doc);
|
|
const file = writeJson(join(root, 'businesses/demo.json'), doc);
|
|
mkdirSync(join(root, 'data'), { mode: 0o700 });
|
|
const bus = await startBroker({ dataRoot: join(root, 'data'), businesses: { demo: busForm(root, rolesDir) }, organization: { dir: root, rolesDir, system: systemFor(root) } });
|
|
t.after(async () => { await bus.close(); rmSync(root, { recursive: true, force: true }); });
|
|
const reloads = [];
|
|
const reloadBusiness = bus.broker.reloadBusiness.bind(bus.broker);
|
|
bus.broker.reloadBusiness = (id, next) => { reloads.push(structuredClone(next)); reloadBusiness(id, next); };
|
|
const human = bus.broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
|
|
const ask = (verb, args) => bus.broker.request(human, { verb, args });
|
|
const revision = () => ask('instances').revision;
|
|
return { root, rolesDir, file, bus, reloads, ask, revision };
|
|
}
|
|
const code = (fn) => { try { fn(); } catch (e) { return e.code; } return null; };
|
|
let runs = 0;
|
|
const bind = (bus, role) => bus.broker.bindLaunch({ business: 'demo', role, run: `run-${++runs}`, harness: 'pi' });
|
|
|
|
test('T14 a create goes live with no restart: the new instance binds at once and the answer says restart false', async (t) => {
|
|
const f = await setup(t);
|
|
assert.equal(code(() => bind(f.bus, 'sec-1')), 'unknown-role');
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer', launch: true });
|
|
assert.equal(added.restart, false);
|
|
assert.equal(f.reloads.length, 1);
|
|
assert.equal(f.reloads[0].roles['sec-1'].definition, 'security-reviewer');
|
|
assert.ok(bind(f.bus, 'sec-1'));
|
|
});
|
|
|
|
test('T14 every committed verb reloads once, limits.set, routes.set, plugins.set and veto.set included, and a refused one does not', async (t) => {
|
|
const f = await setup(t);
|
|
// Only the instance writer's verbs carry restart (webby-0094 B1); the other writers' answers don't.
|
|
assert.equal(Object.hasOwn(f.ask('limits.set', { revision: f.revision(), limits: { tokens: { instances: { coder: { limit: 100 } } } } }), 'restart'), false);
|
|
assert.equal(f.reloads.length, 1);
|
|
assert.equal(f.reloads[0].launch.limits.tokens.instances.coder.limit, 100);
|
|
f.ask('routes.set', { revision: f.revision(), routes: { coder: { harness: 'claude-code', model: 'claude-sonnet-5-5', thinking: 'low', fallback: null } } });
|
|
assert.equal(f.reloads.length, 2);
|
|
assert.equal(f.reloads[1].roles.coder.vars.harness, 'claude-code');
|
|
f.ask('plugins.set', { revision: f.revision(), plugins: { harness: ['claude-code', 'pi'] } });
|
|
assert.equal(f.reloads.length, 3);
|
|
assert.deepEqual(f.reloads[2].plugins.harness, ['claude-code', 'pi']);
|
|
assert.equal(f.ask('veto.set', { revision: f.revision(), op: 'keep', name: 'coder' }).restart, false);
|
|
assert.equal(f.reloads.length, 4);
|
|
assert.deepEqual(f.reloads[3].launch.keep, ['coder']);
|
|
assert.equal(code(() => f.ask('instances.set', { revision: f.revision(), instance: 'ghost', op: 'change', vars: {} })), 'organization-unknown-instance');
|
|
assert.equal(code(() => f.ask('veto.set', { revision: f.revision(), op: 'keep', name: 'coder' })), 'organization-no-change');
|
|
assert.equal(f.reloads.length, 4);
|
|
});
|
|
|
|
test('T14 a definition change on a running instance refuses instance-running; a vars change still goes live', async (t) => {
|
|
const f = await setup(t);
|
|
f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer', launch: true });
|
|
const cap = bind(f.bus, 'sec-1');
|
|
f.bus.broker.request(cap, { verb: 'role.claim' });
|
|
const before = readFileSync(f.file, 'utf8');
|
|
assert.equal(code(() => f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'change', definition: 'merge-gate' })), 'instance-running');
|
|
assert.equal(readFileSync(f.file, 'utf8'), before);
|
|
const changed = f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'change', vars: { model: 'claude-sonnet-5-5' } });
|
|
assert.equal(changed.restart, false);
|
|
assert.equal(f.reloads.at(-1).roles['sec-1'].vars.model, 'claude-sonnet-5-5');
|
|
});
|
|
|
|
test('T14 a file whose credential references differ from the boot copy is not reloaded and the write answers restart true', async (t) => {
|
|
const f = await setup(t);
|
|
const doc = JSON.parse(readFileSync(f.file, 'utf8'));
|
|
const moved = join(f.root, 'secrets', 'moved-gitea.token');
|
|
writeFileSync(moved, 'placeholder-not-a-token', { mode: 0o600 });
|
|
doc.roles.coder.credentials.gitea.file = moved;
|
|
writeFileSync(f.file, JSON.stringify(doc, null, 2) + '\n', { mode: 0o600 });
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer' });
|
|
assert.equal(added.restart, true);
|
|
assert.equal(f.reloads.length, 0);
|
|
assert.equal(code(() => bind(f.bus, 'sec-1')), 'unknown-role');
|
|
});
|
|
|
|
test('T14 a date-only change to a credential reference still reloads: row 199 issue rewrites the date outside the reload', async (t) => {
|
|
const f = await setup(t);
|
|
const doc = JSON.parse(readFileSync(f.file, 'utf8'));
|
|
doc.roles.coder.credentials.gitea.rotateBy = '2098-06-01';
|
|
doc.roles.coder.credentials.vikunja.expires = '2098-06-01';
|
|
writeFileSync(f.file, JSON.stringify(doc, null, 2) + '\n', { mode: 0o600 });
|
|
const changed = f.ask('instances.set', { revision: f.revision(), instance: 'coder', op: 'change', vars: { harness: 'pi', model: 'claude-sonnet-5-5' } });
|
|
assert.equal(changed.restart, false);
|
|
assert.equal(f.reloads.length, 1);
|
|
assert.equal(f.reloads[0].roles.coder.vars.model, 'claude-sonnet-5-5');
|
|
});
|
|
|
|
// Row 194 (brief item 7, T19, sage-1605, sage-1610 a): a human create of a credentialed definition
|
|
// answers restart true, because credential references are fixed at start. issue refuses until a
|
|
// restart loads the entry. After one, issue works, the status reads valid, and a vars change after
|
|
// the issue goes live: issue rewrites the date, and the fixed-at-start compare ignores dates.
|
|
test('T19 a credentialed create answers restart true; issue works only after a restart, and a later vars change goes live', async (t) => {
|
|
const f = await setup(t);
|
|
mkdirSync(join(f.root, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'rev-2', op: 'add', definition: 'reviewer', tracker: { bot: 'bot-demo-rev-2', botId: 40 } });
|
|
assert.equal(added.restart, true);
|
|
assert.equal(f.reloads.length, 0);
|
|
const issue = { agent: 'rev-2', service: 'gitea', token: 'fake_issued_token_0123456789', date: '2099-01-01' };
|
|
assert.equal(code(() => f.ask('credentials.issue', issue)), 'credential-unknown');
|
|
|
|
mkdirSync(join(f.root, 'data-2'), { mode: 0o700 });
|
|
const bus = await startBroker({ dataRoot: join(f.root, 'data-2'), businesses: { demo: busForm(f.root, f.rolesDir) }, organization: { dir: f.root, rolesDir: f.rolesDir, system: systemFor(f.root) } });
|
|
t.after(() => bus.close());
|
|
const reloads = [];
|
|
const reloadBusiness = bus.broker.reloadBusiness.bind(bus.broker);
|
|
bus.broker.reloadBusiness = (id, next) => { reloads.push(structuredClone(next)); reloadBusiness(id, next); };
|
|
const human = bus.broker.bindHuman({ business: 'demo', human: 'jason', via: 'cli', outsideAgent: true });
|
|
const ask = (verb, args) => bus.broker.request(human, { verb, args });
|
|
ask('credentials.issue', issue);
|
|
assert.equal(bus.credentialStatus('demo', 'rev-2').find(e => e.service === 'gitea').state, 'valid');
|
|
assert.equal(JSON.parse(readFileSync(f.file, 'utf8')).roles['rev-2'].credentials.gitea.rotateBy, '2099-01-01');
|
|
const changed = ask('instances.set', { revision: ask('instances').revision, instance: 'rev-2', op: 'change', vars: { harness: 'pi', model: 'claude-sonnet-5-5' } });
|
|
assert.equal(changed.restart, false);
|
|
assert.equal(reloads.length, 1);
|
|
assert.equal(reloads[0].roles['rev-2'].vars.model, 'claude-sonnet-5-5');
|
|
});
|
|
|
|
// Row 194 b6 (webby-0094 B1, sage-2241): a credentialed create leaves every later reload refused,
|
|
// so each instance-writer verb after it answers restart true: the keep, the chief's hire and fire.
|
|
// Webby's sequence: a keep the running copy never loaded still refuses the chief's fire before step
|
|
// A, from the file, so the kept instance keeps its claim and isn't left firing.
|
|
test('T14 after a refused reload veto.set, instance.hire and instance.fire answer restart true, and a fire of a name kept since refuses before step A', async (t) => {
|
|
const f = await setup(t);
|
|
const roleFile = join(f.rolesDir, 'chief-of-staff.json');
|
|
writeFileSync(roleFile, JSON.stringify({ ...JSON.parse(readFileSync(roleFile, 'utf8')), hireable: ['chief-information-security-officer'] }, null, 2));
|
|
mkdirSync(join(f.root, 'secrets', 'agents'), { recursive: true, mode: 0o700 });
|
|
const chief = bind(f.bus, 'chief');
|
|
f.bus.broker.request(chief, { verb: 'role.claim' });
|
|
const asChief = (verb, args) => f.bus.broker.request(chief, { verb, args });
|
|
const reviewer = bind(f.bus, 'reviewer');
|
|
f.bus.broker.request(reviewer, { verb: 'role.claim' });
|
|
const run = f.ask('instances').instances.reviewer.running;
|
|
assert.equal(run.length, 1);
|
|
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'rev-2', op: 'add', definition: 'reviewer', tracker: { bot: 'bot-demo-rev-2', botId: 40 } });
|
|
assert.equal(added.restart, true);
|
|
const hired = asChief('instance.hire', { name: 'sec-2', definition: 'chief-information-security-officer', reason: 'a security lead' });
|
|
assert.equal(hired.restart, true);
|
|
const kept = f.ask('veto.set', { revision: f.revision(), op: 'keep', name: 'reviewer' });
|
|
assert.equal(kept.restart, true);
|
|
assert.equal(f.reloads.length, 0, 'the running copy still has reviewer unkept');
|
|
|
|
const before = readFileSync(f.file, 'utf8');
|
|
assert.equal(code(() => asChief('instance.fire', { name: 'reviewer', reason: 'the work is done' })), 'instance-kept');
|
|
assert.equal(readFileSync(f.file, 'utf8'), before);
|
|
assert.deepEqual(f.ask('instances').instances.reviewer.running, run, 'step A never ran: the claim is held');
|
|
assert.notEqual(code(() => f.ask('instance.launch', { instance: 'reviewer' })), 'instance-firing');
|
|
|
|
const unkept = f.ask('veto.set', { revision: f.revision(), op: 'unkeep', name: 'reviewer' });
|
|
assert.equal(unkept.restart, true);
|
|
const fired = asChief('instance.fire', { name: 'reviewer', reason: 'the work is done' });
|
|
assert.equal(fired.restart, true);
|
|
assert.equal(JSON.parse(readFileSync(f.file, 'utf8')).launch.instances.includes('reviewer'), false);
|
|
});
|
|
|
|
test('T14 a file whose project root differs from the boot copy is not reloaded, because the Credentials store protects the boot roots', async (t) => {
|
|
const f = await setup(t);
|
|
const doc = JSON.parse(readFileSync(f.file, 'utf8'));
|
|
const moved = join(f.root, 'project-moved');
|
|
mkdirSync(moved);
|
|
doc.projects.stack.root = moved;
|
|
writeFileSync(f.file, JSON.stringify(doc, null, 2) + '\n', { mode: 0o600 });
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer' });
|
|
assert.equal(added.restart, true);
|
|
assert.equal(f.reloads.length, 0);
|
|
});
|
|
|
|
test('T14 a file whose library mapping differs from the boot copy is not reloaded, because the mirror is ensured at start', async (t) => {
|
|
const f = await setup(t, doc => { doc.roles.chief.credentials = { gitea: { ...doc.roles.coder.credentials.gitea } }; doc.projects.books = mappingEntry(); });
|
|
const doc = JSON.parse(readFileSync(f.file, 'utf8'));
|
|
doc.projects.books.branch = 'other';
|
|
writeFileSync(f.file, JSON.stringify(doc, null, 2) + '\n', { mode: 0o600 });
|
|
const added = f.ask('instances.set', { revision: f.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer' });
|
|
assert.equal(added.restart, true);
|
|
assert.equal(f.reloads.length, 0);
|
|
// The same library entry reloads.
|
|
const g = await setup(t, doc => { doc.roles.chief.credentials = { gitea: { ...doc.roles.coder.credentials.gitea } }; doc.projects.books = mappingEntry(); });
|
|
assert.equal(g.ask('instances.set', { revision: g.revision(), instance: 'sec-1', op: 'add', definition: 'security-reviewer' }).restart, false);
|
|
assert.equal(g.reloads.length, 1);
|
|
});
|
|
|
|
test('T14 reloadBusiness refuses an unknown business, a changed human and a document the boot check refuses', (t) => {
|
|
const root = mkdtempSync(join(tmpdir(), 'reload-unit-'));
|
|
t.after(() => rmSync(root, { recursive: true, force: true }));
|
|
const role = { authority: { withinRole: [], crossRole: [] } };
|
|
const demo = { id: 'demo', human: 'jason', arbiters: { technical: 'chief', delivery: 'chief' }, roles: {chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } }, coder: role } };
|
|
const b = new Broker({ store: new Store(root), businesses: { demo } });
|
|
assert.equal(code(() => b.reloadBusiness('other', demo)), 'unknown-business');
|
|
assert.equal(code(() => b.reloadBusiness('demo', { ...demo, human: 'mos' })), 'invalid-business');
|
|
assert.equal(code(() => b.reloadBusiness('demo', { ...demo, roles: { coder: role, tester: role } })), 'invalid-business');
|
|
assert.equal(code(() => b.reloadBusiness('demo', { ...demo, roles: { coder: { authority: { withinRole: ['spend'], crossRole: [] } } } })), 'invalid-authority');
|
|
assert.equal(code(() => b.reloadBusiness('demo', null)), 'invalid-business');
|
|
b.reloadBusiness('demo', { ...demo, roles: { ...demo.roles, 'sec-1': role } });
|
|
assert.ok(b.bindLaunch({ business: 'demo', role: 'sec-1', run: 'run-1', harness: 'pi' }));
|
|
});
|