mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
923 lines
55 KiB
JavaScript
923 lines
55 KiB
JavaScript
// Page tests for how a session ends and comes back: the finished screen and
|
|
// its buttons, Stop and Stop with a handoff, and a page that loses its server
|
|
// and finds it again after a resume. Run with:
|
|
// node --test scripts/test-web-console-page-session.mjs
|
|
//
|
|
// Each test drives the real console in a real Chrome or Edge through
|
|
// scripts/page-test-helpers.mjs: one browser for the file, a fresh console
|
|
// session per test.
|
|
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { pageSuite, openSession, itemCard, drawn, textOf, tempProject } from "./page-test-helpers.mjs";
|
|
import { cli, until } from "./web-console-test-helpers.mjs";
|
|
import { STOP_HANDOFF_REPLY, HOME_REPLY } from "../src/web-console/public/answers.js";
|
|
// How long the page waits without contact before it calls itself offline:
|
|
// the page's own constant, so this file never drifts from it.
|
|
import { GONE_AFTER_MS } from "../src/web-console/public/screens/core.js";
|
|
|
|
const suite = pageSuite(test);
|
|
|
|
|
|
// The banner the page raises when it loses its server mid-session.
|
|
const LOST_CONTACT = /Lost contact with Plan2Code\. Nothing you have typed is lost\./;
|
|
|
|
// A plan session on the person's turn, the way an agent opens one: one text
|
|
// question and the agent listening.
|
|
const PLAN_QUESTION = {
|
|
items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name for the export." }],
|
|
agent: { status: "waiting" },
|
|
};
|
|
|
|
// The agent's side of `stop`, leaving the browser context open (s.stop()
|
|
// closes it, which would hide what the page does next).
|
|
async function stopServer(s) {
|
|
cli(["stop", "--session", s.sid], { cwd: s.project });
|
|
assert.ok(await until(async () => !(await s.answers()), 5000), "the server still answers after stop");
|
|
}
|
|
|
|
// The one send `wait` hands the agent; fails the test when nothing arrived.
|
|
function collect(s) {
|
|
const got = s.wait(10);
|
|
assert.equal(got.code, 0, `nothing was sent (wait exit ${got.code}): ${got.message || ""}`);
|
|
return got;
|
|
}
|
|
|
|
// Local helper: checks `fn` keeps returning true for `ms`. A sleep would
|
|
// prove nothing; this fails the moment the page shows what it must not.
|
|
async function holds(fn, ms) {
|
|
const end = Date.now() + ms;
|
|
while (Date.now() < end) {
|
|
if (!(await fn())) return false;
|
|
await new Promise((r) => setTimeout(r, 100));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
test("the finished screen shows the next command with --web, copies it, turns Send off, and Back to the dashboard reaches the agent", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.context.grantPermissions(["clipboard-read", "clipboard-write"], { origin: new URL(s.url).origin });
|
|
s.post({
|
|
settle: true,
|
|
finish: {
|
|
headline: "The plan is written",
|
|
body: "Everything is under `specs/audit-export/`. Read `PLAN.md` first.",
|
|
command: "/plan2code-2-document",
|
|
dashboard: true,
|
|
},
|
|
});
|
|
const main = s.page.locator("#main");
|
|
await main.getByRole("heading", { name: "The plan is written" }).waitFor();
|
|
|
|
const shown = main.locator("code").filter({ hasText: /^\/plan2code-2-document --web$/ });
|
|
assert.equal(await shown.count(), 1, "the command is shown once, with --web appended");
|
|
// The Copy that belongs to this command: the innermost block holding both,
|
|
// whatever wraps them.
|
|
// (`has` is matched inside each candidate, so these start from the page.)
|
|
const code = s.page.locator("code").filter({ hasText: /^\/plan2code-2-document --web$/ });
|
|
const copy = s.page.getByRole("button", { name: "Copy", exact: true });
|
|
await main.locator("*", { has: code }).filter({ has: copy }).last().getByRole("button", { name: "Copy", exact: true }).click();
|
|
await s.page.waitForFunction(async () => (await navigator.clipboard.readText()) === "/plan2code-2-document --web");
|
|
assert.equal(await s.page.evaluate(() => navigator.clipboard.readText()), "/plan2code-2-document --web");
|
|
|
|
assert.equal(await s.page.locator("#btn-send").isDisabled(), true, "Send is still on after the finish");
|
|
|
|
await main.getByRole("button", { name: "Back to the dashboard" }).click();
|
|
const got = collect(s);
|
|
assert.equal(got.type, "submit");
|
|
assert.deepEqual(
|
|
got.actions.map(({ i, type }) => ({ i, type })),
|
|
[{ i: "__dashboard", type: "dashboard" }]
|
|
);
|
|
});
|
|
|
|
// What a person sees break: no Continue here on a finish that names a skill, one
|
|
// beside a git command or a pause, one at the red meter level, or a press that
|
|
// reaches the agent as anything but the dashboard's own launch.
|
|
test("Continue here shows beside a skill's next step while the meter is not red and sends a launch with the skill and spec", async (t) => {
|
|
const browser = await suite.browser();
|
|
const next = { headline: "The plan is documented", command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true };
|
|
const s = await openSession(browser, { t, workflow: "document", payload: { agent: { status: "working", activity: "Writing" } } });
|
|
s.post({ finish: next });
|
|
const main = s.page.locator("#main");
|
|
const go = main.getByRole("button", { name: "Continue here" });
|
|
await go.waitFor();
|
|
assert.equal(await go.count(), 1);
|
|
|
|
await go.click();
|
|
const got = collect(s);
|
|
assert.deepEqual(got.actions, [
|
|
{ i: "__launch", type: "launch", skill: "plan2code-3-implement", workflow: "implement", spec: "specs/audit-export" },
|
|
]);
|
|
assert.equal(got.reply, "Start Implement (/plan2code-3-implement) for specs/audit-export, right here in this session.");
|
|
// The hop's resume is the dashboard's: the skill's workflow and the spec.
|
|
assert.match(got.resume, /--workflow implement --spec specs\/audit-export$/);
|
|
await main.getByRole("button", { name: "Starting the next step…" }).waitFor();
|
|
assert.equal(await main.getByRole("button", { name: "Back to the dashboard" }).isDisabled(), true, "one press locks the other buttons");
|
|
|
|
// No skill to continue into: a git command, or a pause.
|
|
const git = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
git.post({ finish: { headline: "Quick task done", command: "git add -A && git commit -m x -m y", dashboard: true } });
|
|
await git.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
|
|
assert.equal(await git.page.getByRole("button", { name: "Continue here" }).count(), 0, "a git command is not a skill");
|
|
const paused = await openSession(browser, { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
paused.post({ finish: { headline: "Paused at Phase 2", command: "/plan2code-3-implement specs/audit-export/overview.md" } });
|
|
await paused.page.locator("#main").getByRole("heading", { name: "Paused at Phase 2" }).waitFor();
|
|
assert.equal(await paused.page.getByRole("button", { name: "Continue here" }).count(), 0, "a pause is not continued");
|
|
});
|
|
|
|
test("Update CHANGELOG first shows beside Commit it now only when the finish asks for it, and sends __changelog", async (t) => {
|
|
const browser = await suite.browser();
|
|
const base = { headline: "Quick task done", command: "git add -A && git commit -m x -m y", commit: true, dashboard: true };
|
|
const plain = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
plain.post({ finish: base });
|
|
await plain.page.locator("#main").getByRole("button", { name: "Commit it now" }).waitFor();
|
|
assert.equal(await plain.page.getByRole("button", { name: "Update CHANGELOG first" }).count(), 0, "no flag, no button");
|
|
|
|
const s = await openSession(browser, { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
s.post({ finish: { ...base, changelog: true } });
|
|
const main = s.page.locator("#main");
|
|
const go = main.getByRole("button", { name: "Update CHANGELOG first" });
|
|
await go.waitFor();
|
|
assert.equal(await main.getByRole("button", { name: "Commit it now" }).count(), 1);
|
|
await go.click();
|
|
assert.deepEqual(collect(s).actions.map(({ i, type }) => ({ i, type })), [{ i: "__changelog", type: "changelog" }]);
|
|
await main.getByRole("button", { name: "Opening Changelog…" }).waitFor();
|
|
assert.equal(await main.getByRole("button", { name: "Commit it now" }).isDisabled(), true, "one press locks the other buttons");
|
|
});
|
|
|
|
test("Continue here is hidden once the session meter is red, and the command and fresh-session advice stay", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
// Ten points: a thirty-task phase scores ten, the red level.
|
|
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
|
|
await s.page.locator("#meter-pill[data-level='red']").waitFor();
|
|
s.post({ finish: { headline: "Phase 1 is done", command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true } });
|
|
const main = s.page.locator("#main");
|
|
await main.getByRole("heading", { name: "Phase 1 is done" }).waitFor();
|
|
assert.equal(await main.getByRole("button", { name: "Continue here" }).count(), 0, "Continue here at red");
|
|
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code-3-implement specs\/audit-export\/overview\.md --web$/ }).count(), "the command stays");
|
|
assert.equal(await closeGuide(s).count(), 1, "the fresh-session advice stays");
|
|
});
|
|
|
|
// Under the desktop app (PLAN2CODE_IN_APP=1) the fresh-session advice in the
|
|
// meter's popover and the dashboard's red banner must point at the app's own
|
|
// New Session, never a command to copy into a terminal that is not there:
|
|
// the popover's is a button filled with the user's highlight color.
|
|
test("under the app, the meter popover and the dashboard's red banner point at New Session, not a command", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
});
|
|
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
|
|
const pill = s.page.locator("#meter-pill[data-level='red']");
|
|
await pill.waitFor();
|
|
await pill.click();
|
|
const fresh = s.page.locator("#meter-fresh");
|
|
const press = fresh.getByRole("button", { name: "Start a New Session" });
|
|
await press.waitFor();
|
|
assert.equal(await fresh.locator(".meter-fresh-text").count(), 0, "the button is the whole note, no sentence around it");
|
|
// The page's highlight, resolved the same way the button's fill is.
|
|
const [fill, highlight] = await press.evaluate((n) => {
|
|
const probe = document.createElement("i");
|
|
probe.style.color = "var(--accent)";
|
|
n.append(probe);
|
|
const color = getComputedStyle(probe).color;
|
|
probe.remove();
|
|
return [getComputedStyle(n).backgroundColor, color];
|
|
});
|
|
assert.equal(fill, highlight, "filled with the user's highlight color");
|
|
assert.equal(await fresh.locator("code").count(), 0, "no command to copy under the app");
|
|
});
|
|
|
|
// The desktop app's frame, as the page sees it: a parent that keeps every
|
|
// message posted to it, for the test to read back.
|
|
const FAKE_APP_FRAME = () => {
|
|
window.__toApp = [];
|
|
Object.defineProperty(window, "parent", { configurable: true, get: () => ({ postMessage: (m) => window.__toApp.push(m) }) });
|
|
};
|
|
const toApp = (s, kind) => s.page.evaluate((k) => window.__toApp.filter((m) => m.plan2code === k), kind);
|
|
|
|
test("under the app, the meter popover's Start a New Session button asks the app for its New Session", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
init: FAKE_APP_FRAME,
|
|
});
|
|
s.post({ run: { event: "implement-phase", id: "phase-1", tasks: 30 } });
|
|
const pill = s.page.locator("#meter-pill[data-level='red']");
|
|
await pill.waitFor();
|
|
await pill.click();
|
|
await s.page.locator("#meter-fresh").getByRole("button", { name: "Start a New Session" }).click();
|
|
await until(async () => (await toApp(s, "new-session")).length === 1, 5000);
|
|
assert.deepEqual(await toApp(s, "new-session"), [{ plan2code: "new-session" }], "a named request, nothing else in it");
|
|
});
|
|
|
|
test("under the app, the not running line's continue is a button that asks the app to type it, and the page hands the app its highlight", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
clock: true,
|
|
payload: { items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
init: FAKE_APP_FRAME,
|
|
});
|
|
const looks = await toApp(s, "looks");
|
|
assert.ok(looks.length >= 1, "the page told the app its highlight");
|
|
assert.deepEqual(looks.at(-1).accent, ["#619fe5", "#1a2533", "#0c1117", "#3d5978"], "the default highlight, in its dark shades");
|
|
|
|
await s.page.clock.fastForward(200_000);
|
|
await lineSays(s, /^Plan2Code is not running right now\./);
|
|
const press = s.page.locator("#agent-text .agent-key-btn");
|
|
assert.equal(await press.textContent(), "continue");
|
|
await press.click();
|
|
await until(async () => (await toApp(s, "agent-continue")).length === 1, 5000);
|
|
assert.ok(await press.isDisabled(), "held off, so a double press does not type it twice");
|
|
});
|
|
|
|
// The app's webview opens no new windows, so a link off the page asks the
|
|
// console to open it in the default browser instead, and says where to paste
|
|
// it when that fails.
|
|
const FEEDBACK_URL = "https://github.com/jparkerweb/plan2code/issues/new/choose";
|
|
|
|
test("under the app, a link off the page goes to the default browser through the console, not a new window", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION, env: { PLAN2CODE_IN_APP: "1" }, init: FAKE_APP_FRAME });
|
|
const asked = [];
|
|
await s.page.route("**/open-link", async (route) => {
|
|
asked.push(route.request().postDataJSON());
|
|
await route.fulfill({ status: 200, contentType: "application/json", body: JSON.stringify({ ok: true, url: FEEDBACK_URL }) });
|
|
});
|
|
let popups = 0;
|
|
s.page.context().on("page", () => popups++);
|
|
await s.page.locator("#btn-feedback").click();
|
|
await until(async () => asked.length === 1, 5000);
|
|
assert.deepEqual(asked, [{ url: FEEDBACK_URL }]);
|
|
await new Promise((r) => setTimeout(r, 300));
|
|
assert.equal(popups, 0, "no window opened inside the app");
|
|
});
|
|
|
|
test("under the app, a link the console cannot open is shown to paste into a browser", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION, env: { PLAN2CODE_IN_APP: "1" }, init: FAKE_APP_FRAME });
|
|
await s.page.route("**/open-link", (route) => route.fulfill({ status: 500, contentType: "application/json", body: "{}" }));
|
|
await s.page.locator("#btn-feedback").click();
|
|
await s.page.waitForFunction((u) => document.getElementById("banner").textContent.includes(u), FEEDBACK_URL, { timeout: 5000 });
|
|
assert.match(await s.page.locator("#banner").innerText(), /paste it into your browser/i);
|
|
});
|
|
|
|
test("outside the app, a link off the page opens as a plain link, with no detour through the console", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
let asked = 0;
|
|
await s.page.route("**/open-link", (route) => {
|
|
asked++;
|
|
return route.fulfill({ status: 200, contentType: "application/json", body: "{}" });
|
|
});
|
|
const popup = s.page.context().waitForEvent("page", { timeout: 5000 });
|
|
await s.page.locator("#btn-feedback").click();
|
|
await (await popup).close();
|
|
assert.equal(asked, 0);
|
|
});
|
|
|
|
test("outside the app, the not running line's continue stays a word to type", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
clock: true,
|
|
payload: { items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } },
|
|
});
|
|
await s.page.clock.fastForward(200_000);
|
|
await lineSays(s, /^Plan2Code is not running right now\./);
|
|
assert.equal(await s.page.locator("#agent-text .agent-key-btn").count(), 0);
|
|
assert.equal(await s.page.locator("#agent-text strong.agent-key").textContent(), "continue");
|
|
});
|
|
|
|
test("Stop session, confirmed, sends __stop with no handoff", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.click("#btn-stop");
|
|
await s.page.locator("#stop-go").click();
|
|
const got = collect(s);
|
|
assert.equal(got.type, "submit");
|
|
const stop = got.actions.find((a) => a.i === "__stop");
|
|
assert.deepEqual(stop, { i: "__stop", type: "stop" });
|
|
});
|
|
|
|
test("Stop with a handoff sends __stop with handoff, and the paused finish and stop that follow end on the paused screen, not an error", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.click("#btn-stop");
|
|
const handoff = s.page.locator("#stop-handoff");
|
|
assert.equal(await handoff.isVisible(), true, "the handoff choice is offered off the dashboard");
|
|
await handoff.click();
|
|
const got = collect(s);
|
|
assert.equal(got.type, "submit");
|
|
const stop = got.actions.find((a) => a.i === "__stop");
|
|
assert.deepEqual(stop, { i: "__stop", type: "stop", handoff: true });
|
|
|
|
// What the agent does next (console-stop.md): a paused finish without
|
|
// --wait and no dashboard, then `stop`.
|
|
s.post({
|
|
settle: true,
|
|
finish: {
|
|
headline: "Paused at the naming question",
|
|
body: "Your place is saved, and a handoff is waiting on the dashboard. The naming question is still open.",
|
|
command: "/plan2code-1-plan",
|
|
},
|
|
});
|
|
const main = s.page.locator("#main");
|
|
await main.getByRole("heading", { name: "Paused at the naming question" }).waitFor();
|
|
await stopServer(s);
|
|
|
|
// The page needs GONE_AFTER_MS without contact before it would call the
|
|
// server lost. Through that window and past it, the paused screen stays.
|
|
const settled = async () =>
|
|
!LOST_CONTACT.test(await s.page.locator("#banner").innerText()) &&
|
|
!(await s.page.locator("#planny").getAttribute("class")).includes("is-gone");
|
|
assert.ok(await holds(settled, GONE_AFTER_MS + 3000), "the page raised a lost-contact state after a paused finish");
|
|
assert.match(await main.innerText(), /Session paused/i);
|
|
assert.match(await textOf(s.page.locator("#agent-text")), /^Paused\./);
|
|
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code-1-plan --web$/ }).count(), "the resume command is gone");
|
|
});
|
|
|
|
// Someone who presses Stop and steps away comes back to an answer: the
|
|
// wrapping-up dialog turns into Done once the stop lands and stays up until
|
|
// it is closed, rather than quietly going away.
|
|
test("the wrapping-up dialog says Done when the stop lands, and stays until closed", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.click("#btn-stop");
|
|
await s.page.locator("#stop-go").click();
|
|
const dlg = s.page.locator("#stopping-modal");
|
|
await dlg.waitFor();
|
|
assert.equal(await s.page.locator("#stopping-title").textContent(), "Wrapping up");
|
|
assert.doesNotMatch(await dlg.innerText(), /close the (window|tab)/i, "no advice to close the page mid-stop");
|
|
|
|
collect(s);
|
|
s.post({ settle: true, finish: { headline: "Paused at the naming question", body: "Your place is saved.", command: "/plan2code-1-plan" } });
|
|
await s.page.locator("#main").getByRole("heading", { name: "Paused at the naming question" }).waitFor();
|
|
await s.page.locator("#stopping-title").getByText("Done", { exact: true }).waitFor();
|
|
assert.equal(await s.page.locator("#stop-steps li.is-done").count(), 3, "every step ticked");
|
|
assert.ok(await holds(async () => dlg.isVisible(), 2000), "Done stays up on its own");
|
|
await s.page.locator("#stopping-hide").getByText("Close", { exact: true }).click();
|
|
await dlg.waitFor({ state: "hidden" });
|
|
});
|
|
|
|
test("a page that loses its server goes offline, and after a resume it shows the session again with the unsent answer still typed", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
const field = () => itemCard(s.page, "q1").locator("textarea, input[type=text]").first();
|
|
await field().fill("audit-export");
|
|
// Typed, not sent: the page mirrors it to the server's draft.json, which
|
|
// is what a page on a new port reads back (localStorage is per origin).
|
|
const draftFile = path.join(s.session, "draft.json");
|
|
assert.ok(
|
|
await until(() => fs.existsSync(draftFile) && fs.readFileSync(draftFile, "utf8").includes("audit-export"), 5000),
|
|
"the typed answer never reached the server's draft"
|
|
);
|
|
|
|
await stopServer(s);
|
|
await s.page.waitForFunction(() => document.getElementById("planny").classList.contains("is-gone"), null, {
|
|
timeout: GONE_AFTER_MS + 10000,
|
|
});
|
|
assert.match(await textOf(s.page.locator("#agent-text")), /^Not connected\. Your answers are saved\./);
|
|
assert.match(await s.page.locator("#banner").innerText(), LOST_CONTACT);
|
|
assert.equal(await s.page.locator("#btn-send").isDisabled(), true, "Send is on with no server");
|
|
|
|
const resumed = cli(["open", "--resume", s.sid, "--workflow", "plan", "--no-open"], { cwd: s.project }).json;
|
|
assert.ok(resumed && resumed.url, "the resume printed no url");
|
|
await s.page.goto(resumed.url, { waitUntil: "domcontentloaded" });
|
|
await drawn(s.page);
|
|
await itemCard(s.page, "q1").getByText("What to call it").first().waitFor();
|
|
assert.equal(await field().inputValue(), "audit-export", "the unsent answer was lost across the resume");
|
|
assert.equal(await s.page.locator("#planny").evaluate((n) => n.classList.contains("is-gone")), false);
|
|
});
|
|
|
|
// The status line beside Planny, and its "What to check" button when it has
|
|
// one. The button opens Help on the stuck tab.
|
|
const statusLine = (s) => s.page.locator("#agent-text");
|
|
const whatToCheck = (s) => statusLine(s).getByRole("button", { name: "What to check" });
|
|
async function lineSays(s, re) {
|
|
await s.page.waitForFunction((src) => new RegExp(src).test(document.getElementById("agent-text").textContent), re.source, { timeout: 10000 });
|
|
return textOf(statusLine(s));
|
|
}
|
|
|
|
test("the quiet, not running and not connected lines offer What to check, opening Help on the stuck tab, and the plain lines do not", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
clock: true,
|
|
payload: { headline: { stage: "Phase 1", cleared: 0, total: 3 }, agent: { status: "working", activity: "Task 1 of 3: the reader" } },
|
|
});
|
|
// Working, and heard from just now: the plain working line.
|
|
await lineSays(s, /Task 1 of 3: the reader/);
|
|
assert.equal(await whatToCheck(s).count(), 0, "the working line is plain");
|
|
// Quiet for 30 s: the approval hint, with the button.
|
|
await s.page.clock.fastForward(40_000);
|
|
await lineSays(s, /waiting on an approval in your terminal/);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the approval hint carries What to check");
|
|
// Quiet for two minutes: still working, and the button stays.
|
|
await s.page.clock.fastForward(100_000);
|
|
await lineSays(s, /^Still working on it\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the quiet working line carries What to check");
|
|
|
|
// Back to real time, and the agent asks something: the person's turn is plain.
|
|
await s.page.clock.setSystemTime(Date.now());
|
|
s.post({ items: [{ id: "q1", kind: "text", title: "What to call it", body: "A short name." }], agent: { status: "waiting" } });
|
|
await lineSays(s, /^Your turn: 1 question waiting\./);
|
|
assert.equal(await whatToCheck(s).count(), 0, "the your-turn line is plain");
|
|
// Nobody listening for three minutes: not running, with the button.
|
|
await s.page.clock.fastForward(200_000);
|
|
await lineSays(s, /^Plan2Code is not running right now\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the not running line carries What to check");
|
|
await whatToCheck(s).click();
|
|
await s.page.locator("#help-modal[open]").waitFor();
|
|
assert.equal(await s.page.locator("#help-tab-stuck").getAttribute("aria-selected"), "true", "Help opened on the stuck tab");
|
|
await s.page.keyboard.press("Escape");
|
|
await s.page.locator("#help-modal[open]").waitFor({ state: "detached" });
|
|
|
|
// Answered and sent, never collected, and nobody listening: the saved line.
|
|
await s.page.clock.setSystemTime(Date.now());
|
|
s.post({ agent: { status: "waiting" } });
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
|
|
assert.equal(await whatToCheck(s).count(), 0, "the sent line is plain");
|
|
await s.page.clock.fastForward(200_000);
|
|
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the saved-and-waiting line carries What to check");
|
|
|
|
// No server at all: not connected, with the button.
|
|
await stopServer(s);
|
|
for (let i = 0; i < 20 && !(await s.page.locator("#planny.is-gone").count()); i++) {
|
|
await s.page.clock.fastForward(GONE_AFTER_MS);
|
|
await new Promise((r) => setTimeout(r, 250));
|
|
}
|
|
await lineSays(s, /^Not connected\. Your answers are saved\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the not connected line carries What to check");
|
|
});
|
|
|
|
// An agent sitting in `wait` pings every five seconds and collects a send at
|
|
// once, so answers still uncollected after a minute of its silence mean
|
|
// nothing is listening: the wake-up help shows then, not after three minutes.
|
|
test("answers a waiting agent never collects bring up the saved-and-waiting line after a minute of silence, not before", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", clock: true, payload: PLAN_QUESTION });
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
|
|
await s.page.clock.fastForward(30_000);
|
|
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
|
|
await s.page.clock.fastForward(40_000);
|
|
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the line carries What to check");
|
|
});
|
|
|
|
// An agent that asked and carried on working collects at its next `wait`, so
|
|
// a minute is no proof against it; three minutes of silence is, whatever
|
|
// longer quiet allowance it gave itself before it went.
|
|
test("answers a working agent has not collected bring up the saved-and-waiting line after three minutes, not its long quiet allowance", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "implement", clock: true, payload: PLAN_QUESTION });
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await lineSays(s, /^Sent\. Waiting for Plan2Code\./);
|
|
// Its last word before it went quiet: working, with half an hour to spare.
|
|
s.post({ agent: { status: "working", activity: "Task 1 of 3: the reader", quietMinutes: 30 } });
|
|
await lineSays(s, /Task 1 of 3: the reader/);
|
|
await s.page.clock.fastForward(70_000);
|
|
await lineSays(s, /Task 1 of 3: the reader/);
|
|
await s.page.clock.fastForward(130_000);
|
|
await lineSays(s, /^Plan2Code is not running\. Your answers are saved and waiting for it\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the line carries What to check");
|
|
});
|
|
|
|
// A failed Send says why at once, rather than one line for every cause and
|
|
// the real state only showing once the page's own timers catch up.
|
|
test("a Send that finds the server gone says so at once, with the reconnect help", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await stopServer(s);
|
|
await s.page.click("#btn-send");
|
|
await s.page.waitForFunction(() => document.getElementById("planny").classList.contains("is-gone"), null, { timeout: 3000 });
|
|
assert.match(await s.page.locator("#banner").innerText(), LOST_CONTACT);
|
|
assert.match(await textOf(statusLine(s)), /^Not connected\. Your answers are saved\./);
|
|
assert.equal(await whatToCheck(s).count(), 1, "the not connected line carries What to check");
|
|
});
|
|
|
|
test("a Send the server refuses shows the server's reason", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.route("**/submit", (route) =>
|
|
route.fulfill({ status: 500, contentType: "application/json", body: JSON.stringify({ error: "the disk is full" }) })
|
|
);
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await s.page.waitForFunction(() => /the disk is full/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
|
|
assert.match(await s.page.locator("#banner").innerText(), /Nothing was lost/);
|
|
});
|
|
|
|
test("a Send the server refuses as too large says to remove an attachment, not to try the same send again", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.route("**/submit", (route) =>
|
|
route.fulfill({ status: 413, contentType: "application/json", body: JSON.stringify({ error: "too large" }) })
|
|
);
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await s.page.waitForFunction(() => /remove an attachment/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
|
|
assert.doesNotMatch(await s.page.locator("#banner").innerText(), /try Send again/);
|
|
});
|
|
|
|
test("a Send lost on the way, with the server still up, says the console is there and to send again", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.route("**/submit", (route) => route.abort());
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
await s.page.waitForFunction(() => /console is still up/.test(document.getElementById("banner").textContent), null, { timeout: 3000 });
|
|
assert.equal(await s.page.locator("#planny").evaluate((n) => n.classList.contains("is-gone")), false, "not called gone");
|
|
});
|
|
|
|
test("an answered finish offer comes back unanswered on a later finish, once the first finish has gone", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
const finishWith = (headline) => s.post({ finish: { headline, command: "/plan2code-3-implement specs/audit-export/overview.md", dashboard: true } });
|
|
const main = s.page.locator("#main");
|
|
finishWith("Phase 1 is done");
|
|
await main.getByRole("heading", { name: "Phase 1 is done" }).waitFor();
|
|
await main.getByRole("button", { name: "Back to the dashboard" }).click();
|
|
assert.deepEqual(collect(s).actions.map(({ i }) => i), ["__dashboard"]);
|
|
await lineSays(s, /^Opening the dashboard…/);
|
|
// The agent takes the press somewhere that clears the finish, and a later
|
|
// phase ends: that finish starts with its own offer unanswered.
|
|
s.post({ finish: null, agent: { status: "working", activity: "Task 1 of 1" } });
|
|
await lineSays(s, /Task 1 of 1/);
|
|
finishWith("Phase 2 is done");
|
|
await main.getByRole("heading", { name: "Phase 2 is done" }).waitFor();
|
|
await lineSays(s, /^Done\. Head back to the dashboard, or close this tab\./);
|
|
assert.equal(await main.getByRole("button", { name: "Back to the dashboard" }).count(), 1, "the later finish offers the way back again");
|
|
});
|
|
|
|
test("a finished session never puts a sent answer back on its form", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await itemCard(s.page, "q1").locator("textarea").fill("audit-export");
|
|
await s.page.click("#btn-send");
|
|
collect(s);
|
|
// Collected and left open, then the session ends: nothing more can be sent,
|
|
// so the answer stays sent rather than coming back to edit. It would show
|
|
// once the finish goes away (a review taken up), as an answer ready to send.
|
|
s.post({ finish: { headline: "The plan is written", command: "/plan2code-2-document" }, agent: { status: "waiting" } });
|
|
await s.page.locator("#main").getByRole("heading", { name: "The plan is written" }).waitFor();
|
|
s.post({ finish: null, agent: { status: "waiting" } });
|
|
await s.page.locator("#main").getByRole("heading", { name: "The plan is written" }).waitFor({ state: "detached" });
|
|
const q1 = s.page.locator("#sidebar").getByRole("button", { name: /What to call it/ });
|
|
await q1.click();
|
|
await itemCard(s.page, "q1").waitFor();
|
|
const mark = q1.locator(".rail-mark");
|
|
assert.notEqual(await mark.getAttribute("title"), "ready to send", "the sent answer came back on the form");
|
|
const box = itemCard(s.page, "q1").locator("textarea");
|
|
assert.notEqual((await box.count()) ? await box.inputValue() : "", "audit-export", "the sent answer is back in its box");
|
|
});
|
|
|
|
test("the footer keeps its workspace label on the dashboard, and the label opens the Workspace dialog", async (t) => {
|
|
const project = tempProject();
|
|
const name = path.basename(project);
|
|
const s = await openSession(await suite.browser(), { t, workflow: "dashboard", project });
|
|
// Past Planny's wake-up and, on this console home's first run, the Welcome.
|
|
await s.page.getByRole("button", { name: "Skip the intro" }).click();
|
|
await s.page.locator("#main").getByRole("heading", { name: "What are we doing today?" }).waitFor();
|
|
const welcomeDone = s.page.getByRole("button", { name: "Start building" });
|
|
if (await welcomeDone.isVisible()) await welcomeDone.click();
|
|
await welcomeDone.waitFor({ state: "hidden" });
|
|
const foot = s.page.locator("footer.footer");
|
|
const where = s.page.locator("#footer-where");
|
|
await where.waitFor();
|
|
// The dashboard drops the summary and Send, never the label.
|
|
assert.equal(await foot.evaluate((f) => f.classList.contains("is-dash")), true, "the dashboard's footer is marked is-dash");
|
|
assert.equal(await s.page.locator("#footer-summary").isVisible(), false, "the summary shows on the dashboard");
|
|
assert.equal(await s.page.locator("#btn-send").isVisible(), false, "Send shows on the dashboard");
|
|
assert.match(await textOf(where), new RegExp(`^${name}`), "the label names the project");
|
|
assert.equal(await where.getAttribute("title"), "Open workspace");
|
|
assert.match(await where.getAttribute("aria-label"), new RegExp(`^Open workspace: ${name}`));
|
|
// A click opens the Workspace dialog on the session's folders; leaving the
|
|
// label leaves it as it was (no copied state to undo).
|
|
await where.click();
|
|
await s.page.locator("#workspace-modal[open]").waitFor();
|
|
assert.match(await textOf(s.page.locator("#workspace-list")), new RegExp(name));
|
|
await s.page.keyboard.press("Escape");
|
|
await s.page.locator("#workspace-modal[open]").waitFor({ state: "detached" });
|
|
await s.page.locator("body").click({ position: { x: 5, y: 5 } });
|
|
assert.match(await textOf(where), new RegExp(`^${name}`), "the label changed after a click away");
|
|
});
|
|
|
|
test("a workflow page uses its modules: the full footer, the session meter, @ suggestions and the tab icon", async (t) => {
|
|
const project = tempProject();
|
|
const name = path.basename(project);
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", project, payload: PLAN_QUESTION });
|
|
// Off the dashboard the footer is whole (workspace.js names the label).
|
|
assert.equal(await s.page.locator("footer.footer").evaluate((f) => f.classList.contains("is-dash")), false);
|
|
assert.equal(await s.page.locator("#btn-send").isVisible(), true);
|
|
// meter.js: the pill shows once a frame carries the meter.
|
|
await s.page.locator("#meter-pill").waitFor();
|
|
assert.ok((await textOf(s.page.locator("#meter-words"))).length, "the meter pill has no words");
|
|
// mentions.js: an @ in a text box offers the workspace's folders.
|
|
const box = itemCard(s.page, "q1").locator("textarea");
|
|
await box.click();
|
|
await box.pressSequentially("See @");
|
|
await s.page.locator("#mention-pop").waitFor();
|
|
assert.match(await textOf(s.page.locator("#mention-pop")), new RegExp(name));
|
|
// favicon.js: the person's move puts a bar on the tab icon.
|
|
await s.page.waitForFunction(() => document.querySelector('link[rel="icon"][type="image/svg+xml"]').href.startsWith("data:image/svg+xml"));
|
|
});
|
|
|
|
// The dashboard, past Planny's wake-up and the first-run Welcome.
|
|
async function pastTheIntro(s) {
|
|
const skip = s.page.getByRole("button", { name: "Skip the intro" });
|
|
await skip.click();
|
|
await s.page.locator("#main").getByRole("heading", { name: "What are we doing today?" }).waitFor();
|
|
const welcomeDone = s.page.getByRole("button", { name: "Start building" });
|
|
if (await welcomeDone.isVisible()) await welcomeDone.click();
|
|
await welcomeDone.waitFor({ state: "hidden" });
|
|
}
|
|
|
|
// What a person sees break: a handoff offered where there is nothing to hand off.
|
|
test("the stop dialog offers a handoff in a workflow and one plain Stop on the dashboard", async (t) => {
|
|
const plan = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
|
|
await plan.page.click("#btn-stop");
|
|
const modal = plan.page.locator("#stop-modal");
|
|
await modal.waitFor();
|
|
assert.match(await textOf(modal), /Stop with a handoff/);
|
|
assert.match(await textOf(modal.locator("#stop-go")), /Just stop and save/);
|
|
|
|
const dash = await openSession(await suite.browser(), { t, workflow: "dashboard", payload: { agent: { status: "waiting" } } });
|
|
await pastTheIntro(dash);
|
|
await dash.page.click("#btn-stop");
|
|
await dash.page.locator("#stop-modal").waitFor();
|
|
assert.equal(await dash.page.locator("#stop-handoff").isVisible(), false, "the dashboard offers a handoff");
|
|
assert.match(await textOf(dash.page.locator("#stop-go")), /Stop\s+Ends the console session\./);
|
|
assert.doesNotMatch(await textOf(dash.page.locator("#stop-modal")), /Stop with a handoff/);
|
|
});
|
|
|
|
// What the agent would misread: a handoff stop that carries the plain stop's words.
|
|
test("Stop with a handoff sends its own reply line beside the stop, and a plain stop sends another", async (t) => {
|
|
const handoff = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
|
|
await handoff.page.click("#btn-stop");
|
|
await handoff.page.locator("#stop-handoff").click();
|
|
const got = collect(handoff);
|
|
assert.deepEqual(got.actions.find((a) => a.i === "__stop"), { i: "__stop", type: "stop", handoff: true });
|
|
assert.ok(got.reply.includes(STOP_HANDOFF_REPLY), `the handoff stop's words: ${got.reply}`);
|
|
|
|
const plain = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "waiting" }, items: PLAN_QUESTION.items } });
|
|
await plain.page.click("#btn-stop");
|
|
await plain.page.locator("#stop-go").click();
|
|
const sent = collect(plain);
|
|
assert.equal(sent.actions.find((a) => a.i === "__stop").handoff, undefined);
|
|
assert.ok(!sent.reply.includes(STOP_HANDOFF_REPLY), "a plain stop asked for a handoff");
|
|
});
|
|
|
|
// A finish that offers a review, a commit and the dashboard, on a build.
|
|
const OFFERS = { headline: "Quick task done", command: "/plan2code-5-git", review: true, commit: true, dashboard: true };
|
|
const closeGuide = (s) => s.page.getByRole("region", { name: "Before you close this" });
|
|
|
|
// What a person sees break: "Safe to close" printed under "Review requested", or the review offer coming back after a reload.
|
|
test("Before you close this shows while a review is on offer, goes while it is asked, and the asked offer stays locked after a reload", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "quick-task", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
s.post({ finish: OFFERS });
|
|
const main = s.page.locator("#main");
|
|
const reviewNow = main.getByRole("button", { name: "Review it now" });
|
|
await reviewNow.waitFor();
|
|
assert.equal(await closeGuide(s).count(), 1, "a review only on offer must not hide the guide");
|
|
assert.match(await textOf(main), /The review is optional\./);
|
|
|
|
await reviewNow.click();
|
|
const got = collect(s);
|
|
assert.deepEqual(got.actions.map(({ i, type }) => ({ i, type })), [{ i: "__review", type: "review" }]);
|
|
await main.getByRole("button", { name: "Review requested…" }).waitFor();
|
|
assert.equal(await closeGuide(s).count(), 0, "the guide shows while a review is starting");
|
|
assert.equal(await main.getByRole("button", { name: "No thanks, I am done" }).count(), 0);
|
|
|
|
// The press is remembered: the buttons do not come back on a reload.
|
|
await s.page.reload({ waitUntil: "domcontentloaded" });
|
|
await drawn(s.page);
|
|
await main.getByRole("button", { name: "Review requested…" }).waitFor();
|
|
assert.equal(await main.getByRole("button", { name: "Review it now" }).count(), 0);
|
|
assert.equal(await closeGuide(s).count(), 0, "the guide came back on a reload");
|
|
});
|
|
|
|
// What a person sees break: the guide missing while a commit or the dashboard
|
|
// is starting (it would say "start a new one" under "Opening Git"), or missing
|
|
// once they said they are done or the server is gone.
|
|
test("Before you close this goes while a commit or the dashboard is starting, and stays once they are done or the server is gone", async (t) => {
|
|
const browser = await suite.browser();
|
|
const finishPage = async (opts) => {
|
|
const s = await openSession(browser, { t, workflow: "quick-task", ...opts, payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
s.post({ finish: OFFERS });
|
|
await s.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
|
|
assert.equal(await closeGuide(s).count(), 1, "a plain finish shows the guide");
|
|
return s;
|
|
};
|
|
const cases = [
|
|
["Commit it now", "__commit", "Opening Git…", 0],
|
|
["Back to the dashboard", "__dashboard", "Opening the dashboard…", 0],
|
|
["No thanks, I am done", "__done", null, 1],
|
|
];
|
|
for (const [button, id, asked, guides] of cases) {
|
|
const s = await finishPage({});
|
|
await s.page.locator("#main").getByRole("button", { name: button }).click();
|
|
assert.deepEqual(collect(s).actions.map((a) => a.i), [id]);
|
|
if (asked) await s.page.locator("#main").getByRole("button", { name: asked }).waitFor();
|
|
assert.equal(await closeGuide(s).count(), guides, `the guide after ${button}`);
|
|
}
|
|
// A review asked, then the server gone: nothing is starting any more.
|
|
const gone = await finishPage({ clock: true });
|
|
await gone.page.locator("#main").getByRole("button", { name: "Review it now" }).click();
|
|
collect(gone);
|
|
assert.equal(await closeGuide(gone).count(), 0);
|
|
await stopServer(gone);
|
|
for (let i = 0; i < 20 && !(await gone.page.locator("#planny.is-gone").count()); i++) {
|
|
await gone.page.clock.fastForward(GONE_AFTER_MS);
|
|
await new Promise((r) => setTimeout(r, 250));
|
|
}
|
|
await closeGuide(gone).waitFor();
|
|
});
|
|
|
|
// What a person sees break: a finished screen with no Before you close this,
|
|
// a pause that promises the wrong thing, or the guide's own text going wrong.
|
|
test("every finished shape shows Before you close this with its three rows, and a pause names the resume command", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "implement", payload: { agent: { status: "working", activity: "Task 1 of 1" } } });
|
|
const main = s.page.locator("#main");
|
|
const shapes = [
|
|
["A skill next", { command: "/plan2code-4-finalize" }, /A new session starts from clean context/, /Paste the command above in the new session, or start from the dashboard with \/plan2code\./],
|
|
["A terminal command next", { command: "git status" }, /A new session starts from clean context/, /Run the command above in your terminal, then start the next step/],
|
|
["Nothing left", {}, /A new session starts from clean context/, /In the new session, start from the dashboard with \/plan2code\./],
|
|
["Paused here", { command: "/plan2code-3-implement specs/x/overview.md" }, /Your saved place is picked up by the resume command above\./, /Paste the command above/],
|
|
];
|
|
for (const [headline, rest, fresh, carry] of shapes) {
|
|
s.post({ finish: { headline, ...rest } });
|
|
await main.getByRole("heading", { name: headline }).waitFor();
|
|
const guide = closeGuide(s);
|
|
assert.equal(await guide.count(), 1, `${headline}: one guide`);
|
|
assert.equal(await guide.locator("li").count(), 3, `${headline}: three rows`);
|
|
const text = await textOf(guide);
|
|
for (const label of ["Before you close this", "Safe to close", "Start fresh", "Carry on"]) assert.ok(text.includes(label), `${headline}: says "${label}"`);
|
|
assert.match(text, fresh, `${headline}: the Start fresh sentence`);
|
|
assert.match(text, carry, `${headline}: the Carry on sentence`);
|
|
assert.ok(!text.includes("—"), `${headline}: the guide carries an em dash`);
|
|
}
|
|
// With a stop warning up, a pause's command starts the work again.
|
|
s.post({ stopWarning: "Answers since the last save will not be kept." });
|
|
await closeGuide(s).getByText(/The command above starts it again\./).waitFor();
|
|
assert.equal(await s.page.locator("#btn-home").isVisible(), false, "a finished screen carries its own way back");
|
|
});
|
|
|
|
// Under the app the same three rows point at the app's own controls instead:
|
|
// New Session for "Start fresh", the top bar's dashboard button for "Carry
|
|
// on", and no stray command to copy into a shell that is not there.
|
|
test("under the app, Before you close this points at New Session, and never at a \"new conversation\" that does not exist there", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
});
|
|
const main = s.page.locator("#main");
|
|
s.post({ finish: { headline: "A skill next", command: "/plan2code-4-finalize" } });
|
|
await main.getByRole("heading", { name: "A skill next" }).waitFor();
|
|
const guide = closeGuide(s);
|
|
const text = await textOf(guide);
|
|
assert.ok(text.includes("Press New Session at the top of the window to start the agent fresh."), "Start fresh points at New Session");
|
|
assert.ok(text.includes("Paste the command above into the terminal panel, or start from the dashboard with /plan2code."), "Carry on names the terminal panel");
|
|
assert.ok(!text.includes("new session") && !text.includes("new conversation"), "no classic-mode wording under the app");
|
|
// The extra "To start something else..." paragraph a classic finish also
|
|
// shows is left out here: the row above already says it once.
|
|
assert.equal(await main.getByText("To start something else, run").count(), 0, "no second mention of the same command");
|
|
|
|
// Nothing left to run: the all-done shape still offers the command (the
|
|
// app's terminal panel is a real terminal the agent runs in, so pasting it
|
|
// there works), worded for the one panel rather than a new conversation.
|
|
s.post({ finish: { headline: "AGENTS.md is updated" } });
|
|
await main.getByText(/paste .* into the terminal panel below/).waitFor();
|
|
assert.ok(await main.locator("code").filter({ hasText: /^\/plan2code --web$/ }).count(), "the command is still offered");
|
|
|
|
// The live dashboard button's own note, under it, also points at New
|
|
// Session instead of typing `/clear` by hand.
|
|
s.post({ finish: { headline: "A skill next, with a live dashboard offer", command: "/plan2code-4-finalize", dashboard: true } });
|
|
await main.getByRole("button", { name: "Back to the dashboard" }).waitFor();
|
|
assert.ok(await main.getByText("press New Session at the top of the window for a clean start instead").count(), "the dashboard note points at New Session");
|
|
assert.equal(await main.getByText("type `/clear`", { exact: false }).count(), 0, "no hand-typed /clear under the app");
|
|
});
|
|
|
|
// Once the console server itself is gone (not just finished), the review and
|
|
// dashboard offers' own "new conversation" fallback text must say the same:
|
|
// paste into the terminal panel, under the app, and never claim a command is
|
|
// needed to reconnect, since the app's own bar already does that on its own.
|
|
test("under the app, a gone session's review and dashboard fallbacks name the terminal panel, and reconnect needs no command", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "quick-task",
|
|
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
clock: true,
|
|
});
|
|
s.post({ finish: OFFERS });
|
|
await s.page.locator("#main").getByRole("heading", { name: "Quick task done" }).waitFor();
|
|
await s.page.locator("#main").getByRole("button", { name: "Review it now" }).click();
|
|
collect(s);
|
|
await stopServer(s);
|
|
for (let i = 0; i < 20 && !(await s.page.locator("#planny.is-gone").count()); i++) {
|
|
await s.page.clock.fastForward(GONE_AFTER_MS);
|
|
await new Promise((r) => setTimeout(r, 250));
|
|
}
|
|
const main = s.page.locator("#main");
|
|
await main.getByText(/paste this into the terminal panel/i).first().waitFor();
|
|
assert.equal(await main.getByText(/new conversation/i).count(), 0, "no classic-mode wording under the app");
|
|
await main.getByText("Plan2Code will try to reconnect the console on its own; if it cannot, the app's bar offers Reconnect the console.").waitFor();
|
|
assert.equal(await main.getByText(/run this in a new conversation/i).count(), 0, "no stray reconnect command under the app");
|
|
});
|
|
|
|
// What a person sees break: the triangle leaving answers behind, or sending a
|
|
// finish-style stop instead of the way home.
|
|
test("the top bar's back triangle asks first, then sends __dashboard with the typed answers and the home reply", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await itemCard(s.page, "q1").locator("textarea, input[type=text]").first().fill("audit-export");
|
|
await s.page.click("#btn-home");
|
|
const modal = s.page.locator("#home-modal");
|
|
await modal.waitFor();
|
|
assert.match(await textOf(modal), /Leave this workflow\?/);
|
|
assert.match(await textOf(modal.locator("#home-blurb")), /The answer you have ready goes with it\./);
|
|
await modal.locator("#home-cancel").click();
|
|
await modal.waitFor({ state: "hidden" });
|
|
assert.equal(s.wait(1).code === 0, false, "Cancel sent something");
|
|
|
|
await s.page.click("#btn-home");
|
|
await modal.locator("#home-go").click();
|
|
const got = collect(s);
|
|
assert.deepEqual(got.actions.map(({ i, type }) => ({ i, type })), [{ i: "q1", type: "answer" }, { i: "__dashboard", type: "dashboard" }]);
|
|
assert.ok(got.reply.includes("audit-export") && got.reply.endsWith(HOME_REPLY), `the reply carries the answer, then the home line: ${got.reply}`);
|
|
await s.page.waitForFunction(() => document.getElementById("btn-home").disabled);
|
|
});
|
|
|
|
// What a person sees break: Commit it now, or Changelog's commit offer, hops
|
|
// into Git without the dashboard, and the board opens over the last skill's
|
|
// staged answer, its selected question and its open tab.
|
|
test("a hop into Git from another skill starts the page clean: nothing staged, nothing selected, the questions view", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "changelog",
|
|
payload: {
|
|
items: [{ id: "q1", kind: "choice", title: "Which version", body: "The next version number.",
|
|
options: [{ k: "A", text: "A patch release" }, { k: "B", text: "A minor release" }] }],
|
|
docs: [{ id: "notes", title: "Release notes", blocks: [{ id: "b1", md: "## Draft\n\nTwo fixes." }] }],
|
|
agent: { status: "waiting" },
|
|
},
|
|
});
|
|
// The page's own state, from the module app.js loaded (same URL, same instance).
|
|
const local = () =>
|
|
s.page.evaluate(async () => {
|
|
const { page } = await import("/state.js");
|
|
return { workflow: page.S.workflow, staged: page.local.staged, selected: page.selected, view: page.view };
|
|
});
|
|
await itemCard(s.page, "q1").getByText("A minor release").click();
|
|
await s.page.locator(".view-tab", { hasText: "Release notes" }).click();
|
|
const before = await local();
|
|
assert.deepEqual(Object.keys(before.staged), ["q1"], "the answer was never staged");
|
|
assert.equal(before.selected, "q1");
|
|
assert.notEqual(before.view, "questions", "the Release notes tab never opened");
|
|
const draftFile = path.join(s.session, "draft.json");
|
|
assert.ok(await until(() => fs.existsSync(draftFile) && fs.readFileSync(draftFile, "utf8").includes('"q1"'), 5000), "the staged answer never reached the draft");
|
|
|
|
// What Commit it now and Changelog's commit offer run.
|
|
cli(["open", "--resume", s.sid, "--no-open", "--workflow", "git"], { cwd: s.project });
|
|
await s.page.waitForFunction(async () => (await import("/state.js")).page.S.workflow === "git", null, { timeout: 10000 });
|
|
// Long enough for the page's draft push (600 ms after a save) to have run.
|
|
await new Promise((r) => setTimeout(r, 1500));
|
|
const after = await local();
|
|
assert.deepEqual(after.staged, {}, `the page kept the last skill's staged answer: ${JSON.stringify(after.staged)}`);
|
|
assert.equal(after.selected, null, `the page kept the last skill's selection: ${after.selected}`);
|
|
assert.equal(after.view, "questions", `the page kept the last skill's tab: ${after.view}`);
|
|
const stored = await s.page.evaluate((key) => JSON.parse(localStorage.getItem(key) || "{}").staged || {}, `p2c-console:${s.sid}`);
|
|
assert.deepEqual(stored, {}, "the browser's copy kept the staged answer");
|
|
const draft = fs.existsSync(draftFile) ? JSON.parse(fs.readFileSync(draftFile, "utf8")) : {};
|
|
assert.deepEqual(draft.staged || {}, {}, "the server's draft kept the staged answer");
|
|
});
|
|
|
|
// What a person sees break: Back to default in Preferences does nothing.
|
|
test("Back to default in Preferences returns the theme to follow the system and clears the chosen look", async (t) => {
|
|
const s = await openSession(await suite.browser(), { t, workflow: "plan", payload: PLAN_QUESTION });
|
|
await s.page.click("#btn-looks");
|
|
await s.page.locator('input[name="looks-theme"][value="dark"]').check();
|
|
await s.page.waitForFunction(() => document.documentElement.getAttribute("data-theme") === "dark");
|
|
await s.page.click("#looks-reset");
|
|
await s.page.waitForFunction(() => !document.documentElement.hasAttribute("data-theme"));
|
|
assert.equal(await s.page.locator('input[name="looks-theme"][value="system"]').isChecked(), true, "the system choice is ticked again");
|
|
});
|
|
|
|
// Planny's own spoken line said "close this tab": under the app there is no
|
|
// tab, only the one window.
|
|
test("under the app, Planny's finished line says to close the window, not the tab", async (t) => {
|
|
const s = await openSession(await suite.browser(), {
|
|
t,
|
|
workflow: "implement",
|
|
payload: { agent: { status: "working", activity: "Task 1 of 1" } },
|
|
env: { PLAN2CODE_IN_APP: "1" },
|
|
});
|
|
s.post({ finish: { headline: "All done", dashboard: true } });
|
|
await s.page.locator("#main").getByRole("heading", { name: "All done" }).waitFor();
|
|
const line = await lineSays(s, /close this window/);
|
|
assert.doesNotMatch(line, /close this tab/, "no classic-mode wording under the app");
|
|
});
|