Baseline: tree as shared

This commit is contained in:
alexm committed 2026-10-05 03:03:38 +00:00
commit 31f2fb8a5a
1679 files changed
+1024562

No files matched your search

+229
View File
@@ -0,0 +1,229 @@
// Stage 14: saved versions. A version holds what the student edits (sources, link bookkeeping, where the Mojo came
// from, call, input, setup, machine, build) and not where they are looking (layout, step, open tab). Switching and
// Reset save unsaved work first, so neither loses anything; the cap holds; a link carries no versions, a file may.
import test from 'node:test';
import assert from 'node:assert/strict';
import { Session } from '../dist/core/session.js';
import { stateForProblem, problemById } from '../dist/core/catalog.js';
import { resolveSaved, editsFingerprint, normalize, encodeState, decodeState, saveLocal } from '../dist/core/state.js';
import {
listVersions, saveVersion, renameVersion, deleteVersion, restoreVersion, editsOf, hasUnsavedEdits, versionKey, currentVersion,
exportVersions, importVersions, cleanVersion, storagePressure, MAX_VERSIONS, PRESSURE_CHARS, newWorkspaceId,
} from '../dist/core/versions.js';
function fakeStorage() {
const m = new Map();
return {
getItem: (k) => m.get(k) ?? null, setItem: (k, v) => m.set(k, String(v)), removeItem: (k) => m.delete(k),
key: (i) => [...m.keys()][i] ?? null, get length() { return m.size; }, _m: m,
};
}
let store;
test.beforeEach(() => { store = fakeStorage(); globalThis.localStorage = store; });
const problem = (id = 'count-base') => stateForProblem(problemById(id));
const open = (state, area = 'bridge', opts = {}) => new Session(state, { area, storageId: null, original: opts.original, stale: opts.stale });
const withLingo = (st, text) => { const s = structuredClone(st); s.sources.lingo = text; return s; };
test('save, list, rename, delete and restore round-trip', () => {
const st = problem();
const key = versionKey(st);
assert.equal(key, 'pplus.versions.count-base');
assert.deepEqual(listVersions(key), []);
const a = saveVersion(key, 'first', st, 'bridge', { now: 1000 });
const edited = withLingo(st, 'Start with Total at 0.');
const b = saveVersion(key, 'second', edited, 'dev', { now: 2000 });
assert.ok(a.ok && b.ok);
assert.deepEqual(listVersions(key).map((v) => [v.name, v.area]), [['second', 'dev'], ['first', 'bridge']], 'newest first, with the area it was saved in');
assert.equal(renameVersion(key, a.version.id, 'original'), true);
assert.equal(listVersions(key)[1].name, 'original');
const back = restoreVersion(key, b.version.id, st);
assert.equal(back.sources.lingo, 'Start with Total at 0.');
assert.equal(restoreVersion(key, 'nope', st), null);
assert.equal(deleteVersion(key, b.version.id), true);
assert.equal(listVersions(key).length, 1);
assert.equal(deleteVersion(key, 'nope'), false);
deleteVersion(key, a.version.id);
assert.equal(store.getItem(key), null, 'an empty list leaves nothing behind');
});
test('a version holds the edited fields, sync, mojoOrigin and machine, and not the layout, step or tab', () => {
const st = problem();
Object.assign(st, { input: '3\n', call: 'COUNT_BASE("A", "AA")', setup: 'x', machine: 'm', build: 'default', mojoOrigin: 'generated', sync: { authority: 'lingo', stale: {}, names: {} }, layout: { bridge: { split: 0.3 } }, t: 7, lang: 'matho', view: 'flow', title: 'T' });
const e = editsOf(st);
assert.deepEqual(Object.keys(e).sort(), ['build', 'call', 'input', 'machine', 'mojoOrigin', 'setup', 'sources', 'sync']);
for (const k of ['layout', 't', 'lang', 'view', 'title', 'problem', 'base', 'edited']) assert.ok(!(k in e), k);
});
test('restoring changes the edits but not the layout, the step or the open tab; a field the version lacks does not linger', () => {
const key = 'pplus.versions.count-base';
const plain = problem();
const v = saveVersion(key, 'plain', plain, 'bridge').version;
const now = withLingo(plain, 'something else');
Object.assign(now, { call: 'X()', mojoOrigin: 'generated-edited', sync: { authority: 'lingo', stale: {}, names: {} }, layout: { bridge: { split: 0.7 } }, t: 9, lang: 'lingo', view: 'flow' });
const r = restoreVersion(key, v.id, now);
assert.equal(r.sources.lingo, plain.sources.lingo);
assert.equal(r.call, plain.call);
assert.ok(!('mojoOrigin' in r) && !('sync' in r));
assert.deepEqual([r.layout, r.t, r.lang, r.view], [now.layout, 9, 'lingo', 'flow']);
});
test('switching with unsaved edits saves "Before switching" first; switching without edits does not', () => {
const st = problem();
const s = open(structuredClone(st), 'bridge', { original: st });
const keep = s.saveVersion('plain'); assert.ok(keep.ok);
assert.equal(s.hasUnsavedEdits(), false, 'the problem as written has nothing to lose');
s.setSource('lingo', 'Start with Total at 5.');
assert.equal(s.hasUnsavedEdits(), true);
const was = s.state.sources.lingo;
assert.ok(s.restoreVersion(keep.version.id));
const names = s.versions().map((v) => v.name);
assert.equal(names.length, 2);
assert.ok(names.some((n) => /^Before switching \(/.test(n)), names.join('|'));
assert.ok(s.versions().find((v) => v.auto).edits.sources.lingo === was, 'the automatic version holds the work that was replaced');
assert.equal(s.state.sources.lingo, st.sources.lingo);
// now the work is exactly a saved version: switching again adds nothing
assert.equal(s.hasUnsavedEdits(), false);
const before = s.versions().length;
const other = s.versions().find((v) => v.auto);
assert.ok(s.restoreVersion(other.id));
assert.equal(s.versions().length, before);
});
test('Reset saves the work first as "Before reset", and does nothing extra when there is nothing to lose', () => {
const st = problem();
const s = open(structuredClone(st), 'dev', { original: st });
assert.ok(s.reset(problem()));
assert.deepEqual(s.versions(), []);
s.setSource('mojo', s.source('mojo') + '\n# mine');
assert.ok(s.reset(problem()));
const [v] = s.versions();
assert.match(v.name, /^Before reset \(/);
assert.ok(v.auto && v.edits.sources.mojo.endsWith('# mine'));
assert.ok(!s.source('mojo').includes('# mine'));
});
test('the cap holds: automatic versions make room, and named ones are never dropped to do it', () => {
const key = 'pplus.versions.count-base', st = problem();
for (let i = 0; i < MAX_VERSIONS; i++) assert.ok(saveVersion(key, `v${i}`, st, 'bridge', { now: 1000 + i, auto: i < 3 }).ok);
assert.equal(listVersions(key).length, MAX_VERSIONS);
const r = saveVersion(key, 'more', st, 'bridge', { now: 9999 });
assert.ok(r.ok);
assert.equal(r.dropped.length, 1);
assert.equal(r.dropped[0].name, 'v0', 'the oldest automatic one went');
assert.equal(listVersions(key).length, MAX_VERSIONS);
for (let i = 0; i < 2; i++) saveVersion(key, `x${i}`, st, 'bridge', { now: 10000 + i });
assert.equal(listVersions(key).length, MAX_VERSIONS);
const full = saveVersion(key, 'no room', st, 'bridge', { now: 20000 });
assert.deepEqual(full, { ok: false, reason: 'cap' });
assert.equal(listVersions(key).length, MAX_VERSIONS);
});
test('a refused save stops the switch: nothing changes and nothing is lost', () => {
const st = problem();
const s = open(structuredClone(st), 'bridge', { original: st });
const keep = s.saveVersion('plain');
for (let i = 0; i < MAX_VERSIONS - 1; i++) saveVersion(s.versionKey(), `n${i}`, st, 'bridge', { now: 5 + i });
s.setSource('lingo', 'Start with Total at 6.');
assert.equal(s.restoreVersion(keep.version.id), false);
assert.equal(s.state.sources.lingo, 'Start with Total at 6.');
});
test('a stale problem: "See the new version" keeps the edits as a version and opens the problem as it is now', () => {
const original = problem();
const saved = withLingo(original, 'My own start.');
saved.base = 'deadbeef'; saved.edited = true; // made against another version of the problem
const { state, stale } = resolveSaved(original, saved);
assert.equal(stale, true);
const s = open(state, 'bridge', { original, stale });
assert.equal(s.stale, true);
assert.ok(s.seeNewVersion());
assert.equal(s.stale, false);
assert.equal(s.state.sources.lingo, original.sources.lingo, 'the problem as it is now');
const [v] = s.versions();
assert.equal(v.name, 'My edits, before the problem changed');
assert.ok(!v.auto);
assert.equal(v.edits.sources.lingo, 'My own start.');
assert.equal(editsFingerprint(s.state), editsFingerprint(original));
});
test('work from a share link has no problem: it gets a workspace id when first saved, and the list is found again by it', async () => {
const shared = normalize({ ...problem(), v: 3 }); shared.problem = undefined; shared.title = 'From a link';
const blob = await encodeState(shared);
const s = open(await decodeState(blob), 'bridge');
assert.equal(s.versionKey(), null);
assert.deepEqual(s.versions(), []);
assert.equal(s.hasUnsavedEdits(), true, 'work with no original has something to save once it has text');
const r = s.saveVersion('mine');
assert.ok(r.ok);
assert.match(s.state.workspace, /^w[0-9a-f]{16}$/);
assert.equal(s.versionKey(), `pplus.versions.ws.${s.state.workspace}`);
const again = open(await decodeState(await encodeState(s.state)), 'dev');
assert.deepEqual(again.versions().map((v) => v.name), ['mine'], 'the same work in another area finds the same versions');
});
test('the same work in each area shares one list', () => {
const st = problem();
const a = open(structuredClone(st), 'bridge', { original: st }), b = open(structuredClone(st), 'dev', { original: st }), c = open(structuredClone(st), 'hw', { original: st });
a.saveVersion('from the Bridge');
assert.deepEqual(b.versions().map((v) => [v.name, v.area]), [['from the Bridge', 'bridge']]);
assert.equal(c.versions().length, 1);
});
test('a file with versions restores them in a fresh storage, never over a version with the same id', () => {
const key = 'pplus.versions.ws.wabc12345678', st = problem();
saveVersion(key, 'one', st, 'bridge', { now: 1 }); saveVersion(key, 'two', withLingo(st, 'x'), 'dev', { now: 2 });
const file = JSON.parse(JSON.stringify(exportVersions(key)));
const fresh = fakeStorage();
assert.deepEqual(importVersions(key, file, fresh), { added: 2, skipped: 0 });
assert.deepEqual(listVersions(key, fresh).map((v) => v.name), ['two', 'one']);
// renamed in the fresh browser; importing the file again must not undo that
renameVersion(key, file[0].id, 'renamed here', fresh);
assert.deepEqual(importVersions(key, file, fresh), { added: 0, skipped: 2 });
assert.equal(listVersions(key, fresh).find((v) => v.id === file[0].id).name, 'renamed here');
});
test('a damaged or hostile version in a file is dropped or cleaned, never trusted', () => {
assert.equal(cleanVersion(null), null);
assert.equal(cleanVersion({ id: '../x', name: 'n', at: 1, area: 'bridge', edits: {} }), null);
assert.equal(cleanVersion({ id: 'ok', name: 'n', at: 1, area: 'nowhere', edits: {} }), null);
const v = cleanVersion({ id: 'ok', name: 'n'.repeat(500), at: 1, area: 'bridge', edits: { sources: { pseudo: 'x', evil: 'y' }, layout: { bridge: { split: 0.1 } }, t: 4, mojoOrigin: 'hand-written' } });
assert.equal(v.name.length, 120);
assert.deepEqual(Object.keys(v.edits), ['sources']);
assert.deepEqual(v.edits.sources, { pseudo: 'x' });
const key = 'pplus.versions.count-base';
assert.deepEqual(importVersions(key, 'nonsense'), { added: 0, skipped: 0 });
assert.deepEqual(importVersions(key, [{ id: 1 }]), { added: 0, skipped: 1 });
});
test('the drop-down warns when storage is nearly full', () => {
assert.equal(storagePressure(store).nearlyFull, false);
store.setItem('big', 'x'.repeat(PRESSURE_CHARS));
assert.equal(storagePressure(store).nearlyFull, true);
});
test('a browser that refuses storage still keeps versions for the tab, and a full one says so instead of losing them', () => {
const key = 'pplus.versions.count-base', st = problem();
assert.ok(saveVersion(key, 'tab only', st, 'bridge', { store: null }).ok);
assert.deepEqual(listVersions(key, null).map((v) => v.name), ['tab only']);
const full = { getItem: () => null, setItem() { throw new Error('quota'); }, removeItem() { } };
assert.deepEqual(saveVersion(key, 'x', st, 'bridge', { store: full }), { ok: false, reason: 'storage' });
});
test('a version is not in the state, a link or the problem\'s own save', async () => {
const s = open(problem(), 'bridge');
s.saveVersion('v');
assert.ok(!/versions?/i.test(JSON.stringify(s.state).replace(/"version"/g, '')));
assert.ok(!/"edits"/.test(await encodeState(s.state)));
assert.equal(newWorkspaceId().length, 17);
assert.equal(currentVersion(s.versionKey(), s.state)?.name, 'v', 'the work is exactly the version just saved');
});
test('a session keeps its own copy of the problem: editing the work never edits "the problem as written"', () => {
const st = problem();
const s = open(st, 'bridge', { original: st }); // the very same object, as when a problem opens with no save
s.setSource('lingo', 'Start with Total at 5.');
assert.notEqual(st.sources.lingo, 'Start with Total at 5.' === st.sources.lingo ? '' : 'x');
assert.equal(s.hasUnsavedEdits(), true, 'the edit shows against the problem as written');
assert.equal(s.state.sources.lingo, 'Start with Total at 5.');
});