Files
plan2code/scripts/test-web-console-learning.mjs
T

278 lines
14 KiB
JavaScript

// Web console tests, Learning on the server: the dashboard scan's `learning`
// field, Pause for me (`POST /learning/pause`) and the two read-only routes
// (`GET /learning/state`, `GET /learning/lessons`). Run with:
// node --test scripts/test-web-console-learning.mjs
//
// Each session opens in a throwaway project folder, so the repository this runs
// in is never read or written. Learning's store on this machine is the test
// home's (PLAN2CODE_LEARNING_DIR, set by web-console-test-helpers.mjs).
import test from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { spawnSync } from "node:child_process";
import { ENV, HOME, LEARNING_DIR, ROOT, cli, postPatch, readState, sessionUrl } from "./web-console-test-helpers.mjs";
import { learningScan, storeDir, writePause, writeWaiting } from "../src/web-console/learning.mjs";
import { sessionActions } from "../src/web-console/cmd-post-wait.mjs";
import { indentReply, learningAction, learningBannerText, learningReply, lessonsReply } from "../src/web-console/public/answers.js";
const LESSONS = path.join(ROOT, "src", "skill-scripts", "lessons.mjs");
let projects = 0;
function project(files = {}) {
const dir = path.join(HOME, "learning-projects", `p${++projects}`);
fs.mkdirSync(dir, { recursive: true });
for (const [rel, text] of Object.entries(files)) {
fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
fs.writeFileSync(path.join(dir, rel), text);
}
return fs.realpathSync(dir);
}
const SETTINGS = (learning) => ({ ".plan2code/settings.json": JSON.stringify({ format: 1, learning }) + "\n" });
// Every file under a folder, relative, so a test can say nothing was written.
function listing(dir) {
const out = [];
const walk = (d) => {
for (const e of fs.readdirSync(d, { withFileTypes: true })) {
const p = path.join(d, e.name);
if (e.isDirectory()) walk(p);
else out.push(path.relative(dir, p).split(path.sep).join("/"));
}
};
walk(dir);
return out.sort();
}
// A dashboard session opened from `dir`, the way an agent opens one.
function dashboard(t, dir) {
const opened = cli(["open", "--workflow", "dashboard", "--no-open"], { cwd: dir }).json;
const s = { ...opened, ...sessionUrl(opened.url) };
s.post = (pathname, body, headers = {}) =>
fetch(`${s.base}${pathname}`, {
method: "POST",
headers: { "content-type": "application/json", cookie: s.cookie, connection: "close", ...headers },
body: typeof body === "string" ? body : JSON.stringify(body ?? {}),
});
s.get = (pathname) => fetch(`${s.base}${pathname}`, { headers: { cookie: s.cookie, connection: "close" } });
t.after(() => cli(["stop", "--session", s.sid, "--force"], { cwd: dir }));
return s;
}
/* ------------------------------------------------------------ the scan */
test("scan.learning: not set up, off, on and paused, with the waiting count", (t) => {
const none = project();
const s1 = dashboard(t, none);
assert.deepEqual(readState(s1.session).scan.learning, { state: "not-set-up", pausedSince: null, waiting: 0, oldestDays: 0 });
const off = project(SETTINGS("off"));
assert.equal(readState(dashboard(t, off).session).scan.learning.state, "off");
const on = project(SETTINGS("on"));
const noted = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000 - 60000).toISOString();
writeWaiting(on, { id: "20261111-120000-abcdef", type: "lesson", text: "A lesson.", noted });
writeWaiting(on, { id: "20261112-120000-abcdef", type: "lesson", text: "Another.", noted: new Date().toISOString() });
assert.deepEqual(readState(dashboard(t, on).session).scan.learning, { state: "on", pausedSince: null, waiting: 2, oldestDays: 2 });
const paused = project(SETTINGS("on"));
const pause = writePause(paused, true, "2026-11-13T09:00:00.000Z");
const scan = readState(dashboard(t, paused).session).scan.learning;
assert.equal(scan.state, "paused");
assert.equal(scan.pausedSince, pause.since);
});
test("scan.learning is absent for a settings format this console does not know", (t) => {
const dir = project({ ".plan2code/settings.json": JSON.stringify({ format: 99, learning: "on" }) });
const scan = readState(dashboard(t, dir).session).scan;
assert.ok(scan, "the dashboard still scans");
assert.equal("learning" in scan, false, "no learning field, so the page draws no row");
});
test("a failure in Learning's core never fails the scan", () => {
const boom = () => {
throw new Error("the core broke");
};
assert.equal(learningScan(project(), { read: boom }), null);
assert.equal(learningScan(project(), { read: () => ({ state: "unknown", waiting: { count: 1 } }) }), null);
});
test("an unreadable learning store reads as empty: on, not paused, nothing waiting", (t) => {
// A file where the store's folder should be: every read under it fails, and
// the core treats that as an empty store rather than throwing.
const dir = project(SETTINGS("on"));
const store = storeDir(dir);
fs.mkdirSync(path.dirname(store), { recursive: true });
fs.writeFileSync(store, "not a folder");
t.after(() => fs.rmSync(store, { force: true }));
const s = dashboard(t, dir);
assert.deepEqual(readState(s.session).scan.learning, { state: "on", pausedSince: null, waiting: 0, oldestDays: 0 });
});
test("the scan reads without pruning: an old waiting item stays on disk", (t) => {
const dir = project(SETTINGS("on"));
const old = new Date(Date.now() - 40 * 24 * 60 * 60 * 1000).toISOString();
writeWaiting(dir, { id: "20261001-120000-aaaaaa", type: "lesson", text: "Old.", noted: old });
const learning = readState(dashboard(t, dir).session).scan.learning;
assert.equal(learning.waiting, 0, "an item past 30 days is not counted");
assert.ok(fs.existsSync(path.join(storeDir(dir), "waiting", "20261001-120000-aaaaaa.json")), "the console deleted nothing");
});
/* ----------------------------------------------------------- the pause */
test("POST /learning/pause: a foreign Origin is 403 and a bad body is 400", async (t) => {
const s = dashboard(t, project(SETTINGS("on")));
assert.equal((await s.post("/learning/pause", { paused: true }, { origin: "http://evil.example" })).status, 403);
assert.equal((await s.post("/learning/pause", "{not json")).status, 400);
const bad = await s.post("/learning/pause", { paused: "yes" });
assert.equal(bad.status, 400);
assert.deepEqual(await bad.json(), { error: "bad-request" });
});
test("POST /learning/pause is 409 when the project is not on", async (t) => {
for (const files of [{}, SETTINGS("off")]) {
const s = dashboard(t, project(files));
const res = await s.post("/learning/pause", { paused: true });
assert.equal(res.status, 409);
assert.deepEqual(await res.json(), { error: "not-on" });
}
});
test("POST /learning/pause writes pause.json on this machine, nothing in the project, and patches the scan", async (t) => {
const dir = project(SETTINGS("on"));
const before = listing(dir);
const s = dashboard(t, dir);
const res = await s.post("/learning/pause", { paused: true });
assert.equal(res.status, 200);
const body = await res.json();
assert.equal(body.ok, true);
assert.equal(body.learning.state, "paused");
const pauseFile = path.join(storeDir(dir), "pause.json");
assert.ok(pauseFile.startsWith(LEARNING_DIR), "the pause lives under the learning store");
assert.equal(JSON.parse(fs.readFileSync(pauseFile, "utf8")).paused, true);
assert.equal(readState(s.session).scan.learning.state, "paused", "the row repaints from the patched scan");
assert.deepEqual(listing(dir), before, "nothing was written inside the project");
const back = await (await s.post("/learning/pause", { paused: false })).json();
assert.equal(back.learning.state, "on");
assert.equal(fs.existsSync(pauseFile), false);
assert.equal(readState(s.session).scan.learning.state, "on");
});
/* ------------------------------------------------------ the read routes */
test("GET /learning/state answers the scan's object, worked out now", async (t) => {
const dir = project(SETTINGS("on"));
const s = dashboard(t, dir);
writeWaiting(dir, { id: "20261113-120000-bbbbbb", type: "lesson", text: "New.", noted: new Date().toISOString() });
const res = await s.get("/learning/state");
assert.equal(res.status, 200);
assert.deepEqual(await res.json(), { state: "on", pausedSince: null, waiting: 1, oldestDays: 0 });
const unknown = dashboard(t, project({ ".plan2code/settings.json": "{}" }));
assert.deepEqual(await (await unknown.get("/learning/state")).json(), {});
});
test("GET /learning/lessons: general first, then the rest by name; no sub-folders or links out", async (t) => {
const dir = project({
...SETTINGS("on"),
".plan2code/lessons/web-console.md": "# Web console\n\nA lesson.\n",
".plan2code/lessons/general.md": "# General\n\nAnother.\n",
".plan2code/lessons/activities.md": "No heading here.\n",
".plan2code/lessons/notes.txt": "not markdown\n",
".plan2code/lessons/deeper/inside.md": "# Inside\n",
});
// A link pointing outside the folder is never followed.
const outside = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "p2c-learn-out-")), "secret.md");
fs.writeFileSync(outside, "# Secret\n");
let linked = true;
try {
fs.symlinkSync(outside, path.join(dir, ".plan2code", "lessons", "linked.md"), "file");
} catch {
linked = false; // Windows without the symlink right: the rest still holds
}
const s = dashboard(t, dir);
const res = await s.get("/learning/lessons");
assert.equal(res.status, 200);
const { files } = await res.json();
assert.deepEqual(
files.map((f) => f.name),
["general.md", "activities.md", "web-console.md"]
);
assert.equal(files[0].title, "General");
assert.equal(files[1].title, "activities", "no heading: the file's name");
assert.match(files[2].text, /A lesson\./);
if (linked) assert.equal(files.some((f) => f.name === "linked.md"), false, "the link out was not followed");
const empty = dashboard(t, project(SETTINGS("on")));
assert.deepEqual(await (await empty.get("/learning/lessons")).json(), { files: [] });
});
/* ------------------------------------------------- the action and reply */
test("a Learning action reaches the agent whole, and a launch keeps fromBanner", () => {
for (const what of ["review", "switch-on", "switch-off", "move-log", "remove"]) {
const action = learningAction(what);
assert.deepEqual(action, { i: "__learning", type: "learning", do: what });
assert.deepEqual(sessionActions({ actions: [action] }), [{ i: "__learning", do: what }]);
assert.ok(learningReply(what).length > 0, `${what} has a reply`);
assert.doesNotMatch(learningReply(what), /—/);
}
assert.throws(() => learningAction("delete-everything"));
const launch = { i: "__launch", type: "launch", skill: "plan2code-quick-task", workflow: "quick-task", fromBanner: true };
assert.equal(sessionActions({ actions: [launch] })[0].fromBanner, true);
});
test("the waiting banner's line shows only while lessons wait and Learning is on or not set up", () => {
assert.equal(learningBannerText({ state: "on", waiting: 3, oldestDays: 2 }), "3 lessons are waiting for your review (oldest 2 days).");
assert.equal(learningBannerText({ state: "not-set-up", waiting: 1, oldestDays: 1 }), "1 lesson is waiting for your review (oldest 1 day).");
assert.equal(learningBannerText({ state: "on", waiting: 0, oldestDays: 0 }), "");
assert.equal(learningBannerText({ state: "paused", waiting: 4, oldestDays: 0 }), "");
assert.equal(learningBannerText({ state: "off", waiting: 4, oldestDays: 0 }), "");
assert.equal(learningBannerText(undefined), "");
});
/* ---------------------------------------------- the lessons card, end to end */
test("the lessons card from lessons.mjs list goes up on the dashboard, and a Keep comes back as a Keep line and a decisions file decide takes", async (t) => {
const dir = project(SETTINGS("on"));
writeWaiting(dir, { id: "20261113-120000-abcdef", type: "lesson", text: "Run a page test alone first.", why: "A full run hides the race.", kind: "command", about: ["scripts/node-test.mjs"], source: "said", noted: new Date().toISOString() });
const lessons = (args) => {
const res = spawnSync(process.execPath, [LESSONS, ...args], { cwd: dir, env: ENV, encoding: "utf8" });
return { code: res.status, json: JSON.parse(res.stdout || "null"), stderr: res.stderr };
};
const list = lessons(["list"]);
assert.equal(list.code, 0, list.stderr);
const card = list.json.card;
assert.equal(card.kind, "lessons");
assert.deepEqual(card.rows.map((r) => [r.id, r.type, r.choices]), [["20261113-120000-abcdef", "lesson", ["Keep", "Reword", "Drop"]]]);
const s = dashboard(t, dir);
const posted = postPatch(s, { items: [card], agent: { status: "waiting" } }, { cwd: dir });
assert.equal(posted.status, 0, posted.stderr);
const item = readState(s.session).items.find((i) => i.id === card.id);
assert.equal(item.status, "open", "the dashboard takes the lessons card");
// What the page's Send carries: the answer, and the reply its words make.
const v = { type: "answer", kind: "lessons", decisions: [{ id: card.rows[0].id, choice: "Keep" }] };
const reply = `${card.title}: ${indentReply(lessonsReply(item, v))}`;
const res = await s.post("/submit", { actions: [{ i: card.id, ...v }], reply });
assert.equal(res.status, 200);
const waited = cli(["wait", "--session", s.sid, "--seconds", "5"], { cwd: dir });
assert.equal(waited.status, 0, waited.stderr);
const lines = waited.json.reply.split("\n").map((l) => l.trim());
assert.ok(lines.some((l) => l === "Keep: Run a page test alone first."), waited.json.reply);
// The Decisions line is the file lessons.mjs decide takes, unchanged.
const json = lines.find((l) => l.startsWith("Decisions: ")).slice("Decisions: ".length);
const file = path.join(s.session, "decisions.json");
fs.writeFileSync(file, json);
const decided = lessons(["decide", "--file", file]);
assert.equal(decided.code, 0, decided.stderr);
assert.match(decided.json.closing, /^Kept 1\./, JSON.stringify(decided.json));
assert.match(fs.readFileSync(path.join(dir, ".plan2code", "lessons", "general.md"), "utf8"), /Run a page test alone first\./);
});