// Stage 10 (and the part of stage 11 it needs): the Bridge's session behavior, without a DOM. In the Bridge the // Mojo pane is the literal translation of the pseudo, computed and never stored; the views that read a program // (trace, checker, tests, proof) work on the hub's pseudo; a pane that is not in step is not stepped; "Edit in // Developer" copies the generated Mojo out and records that it was generated. import test from 'node:test'; import assert from 'node:assert/strict'; import { Session } from '../dist/core/session.js'; import { PROBLEMS, stateForProblem, problemById } from '../dist/core/catalog.js'; import { SyncHub } from '../core/dist/sync/hub.js'; import { normalize } from '../dist/core/state.js'; import { GENERATED_HEADER } from '../core/dist/sync/header.js'; globalThis.localStorage = { getItem() { return null; }, setItem() { }, removeItem() { } }; const open = (id, area = 'bridge') => new Session(stateForProblem(problemById(id)), { area, storageId: null }); test('in the Bridge the Mojo pane is the generated Mojo, not the stored Mojo; elsewhere it is the state\'s own', () => { const own = stateForProblem(problemById('count-base')).sources.mojo; assert.ok(own && !own.startsWith('# Generated'), 'the exercise has its own Mojo'); const bridge = open('count-base', 'bridge'); assert.ok(bridge.source('mojo').startsWith(GENERATED_HEADER), 'the Bridge shows the literal translation, header first'); assert.equal(bridge.source('mojo'), bridge.derivedMojo().source); assert.equal(bridge.state.sources.mojo, own, 'the stored Mojo is untouched'); assert.equal(open('count-base', 'dev').source('mojo'), own); assert.equal(open('count-base', 'hw').source('mojo'), own); assert.equal(new Session(stateForProblem(problemById('count-base')), { storageId: null }).source('mojo'), own, 'a session with no area (an embed of one pane) shows the state\'s own Mojo'); }); test('the Bridge\'s Mojo follows an edit in any linked pane, and every view of it reads the generated source', () => { const s = open('count-base'); const before = s.source('mojo'); s.setSource('pseudo', s.source('pseudo').replace('Total <- 0', 'Total <- 3')); assert.notEqual(s.source('mojo'), before); assert.match(s.source('mojo'), /total = 3/); // the checker, the stepper and the tests read it s.setLang('mojo'); assert.equal(s.parsedMojo().program.source ?? s.source('mojo'), s.source('mojo')); assert.deepEqual(s.parsedMojo().diagnostics.filter((d) => d.severity === 'error'), []); const tr = s.trace(); assert.ok(tr && !tr.error, 'the generated Mojo steps in the interpreter'); assert.ok(tr.output.some((l) => /3|4|5|6|7|8|9/.test(l)), 'and prints a count that includes the changed start'); assert.ok(s.tests().length >= 0); // an edit in lingo reaches it too const lingo = s.source('lingo'); assert.match(lingo, /Start with Total at 3\./, 'the English was regenerated from the pseudo'); s.setSource('lingo', lingo.replace('Start with Total at 3.', 'Start with Total at 10.')); assert.match(s.source('mojo'), /total = 10/); }); test('trace steps the pseudo, not a stale pane', () => { const s = open('count-base'); s.setLang('lingo'); assert.equal(s.traceLang(), 'lingo', 'an in-step lingo pane is stepped as English'); s.setSource('pseudo', 'FUNCTION BROKEN(\nRETURN'); // pseudo has errors: lingo is now stale assert.equal(s.linkState('lingo').kind, 'stale'); assert.equal(s.traceLang(), 'pseudo', 'lingo holds text the pseudo has moved on from'); }); test('prove and tests work on the hub\'s pseudo, with the speco woven', () => { const s = open('count-base-proved'); s.setLang('lingo'); s.setSource('lingo', s.source('lingo').replace('Add 1 to Total.', 'Add 1 to Total.')); // no change: nothing to do const lingo = s.source('lingo'); s.setSource('lingo', lingo + '\n'); // an edit in English assert.equal(s.state.sync.authority, 'lingo'); assert.match(s.source('pseudo'), /ENSURE/, 'the contracts are in the pseudo the English lowered to'); const proof = s.proof(); assert.ok(proof && proof.report.counts.total > 0, 'there is something to prove'); assert.equal(proof.report.counts.broken, 0); assert.ok(s.tests().length > 0, 'tests are generated from the pseudo'); }); test('Edit in Developer copies the generated Mojo into the state and records that it was generated', () => { const s = open('count-base'); const generated = s.derivedMojo().source; assert.ok(s.wouldReplaceMojo(), 'the exercise\'s own Mojo would be replaced: the shell asks first'); assert.equal(s.state.mojoOrigin, undefined); assert.ok(s.adoptGeneratedMojo()); assert.equal(s.state.sources.mojo, generated); assert.equal(s.state.mojoOrigin, 'generated'); assert.equal(s.state.lang, 'mojo'); assert.equal(s.wouldReplaceMojo(), false, 'it already holds this program'); // the Developer area shows it, and the first edit makes it theirs const dev = new Session(s.state, { area: 'dev', storageId: null }); assert.equal(dev.source('mojo'), generated); dev.setSource('mojo', generated + '\n# mine\n'); assert.equal(dev.state.mojoOrigin, 'generated-edited'); dev.setSource('mojo', generated + '\n# mine again\n'); assert.equal(dev.state.mojoOrigin, 'generated-edited'); // a state with no pseudo has nothing to adopt const empty = new Session(normalize({ v: 3 }), { area: 'bridge', storageId: null }); assert.equal(empty.adoptGeneratedMojo(), false); assert.equal(empty.state.mojoOrigin, undefined); }); test('mojoOrigin is validated, and is only ever set on Mojo the student did not write', () => { assert.equal(normalize({ v: 3, mojoOrigin: 'generated' }).mojoOrigin, 'generated'); assert.equal(normalize({ v: 3, mojoOrigin: 'generated-edited' }).mojoOrigin, 'generated-edited'); assert.equal(normalize({ v: 3, mojoOrigin: 'hand-written' }).mojoOrigin, undefined); const s = open('count-base', 'dev'); s.setSource('mojo', s.source('mojo') + '\n# note\n'); assert.equal(s.state.mojoOrigin, undefined, 'editing the exercise\'s own Mojo does not make it generated'); }); test('line maps reach the Mojo: a pseudo line finds its Mojo lines and back', () => { const s = open('count-base'); const maps = s.lineMaps(); const pseudo = s.source('pseudo').split('\n'); const at = pseudo.findIndex((l) => /Total <- Total \+ 1/.test(l)) + 1; const mojoLines = SyncHub.relate(maps, 'pseudo', at, 'mojo'); assert.ok(mojoLines.length, 'the line has a Mojo line'); assert.match(s.source('mojo').split('\n')[mojoLines[0] - 1], /total = total \+ 1/); assert.ok(SyncHub.relate(maps, 'mojo', mojoLines[0], 'pseudo').includes(at)); // lingo line -> pseudo line, for a problem whose lingo was authored const lingo = s.source('lingo').split('\n'); const l = lingo.findIndex((t) => /add 1 to Count/.test(t)) + 1; const p = SyncHub.relate(maps, 'lingo', l, 'pseudo'); assert.ok(Array.isArray(p)); }); test('every Bridge problem opens with generated Mojo that names itself and checks clean', () => { let n = 0; for (const p of PROBLEMS) { if (p.area !== 'bridge') continue; const s = new Session(stateForProblem(p), { area: 'bridge', storageId: null }); if (!s.source('pseudo').trim()) continue; const m = s.source('mojo'); if (!m) continue; // pseudo that does not read (five-bugs, by design) assert.ok(m.startsWith(GENERATED_HEADER), p.id); n++; } assert.ok(n >= 12, `${n} problems`); });