features

tests/bytes.spec.ts

@@ -0,0 +1,217 @@
+// What one keystroke does to the file, read off the disk rather than off the screen.
+//
+// Every other suite here asks the app what it thinks. This one asks the fixture what was written,
+// because the promise this project actually makes is about bytes: saving must not change a byte the
+// user did not edit. Four rounds of adversarial review found nine, five, three and three data loss
+// bugs behind a green gate, and the ones that hurt most were all the same shape. A unit test built
+// a document by hand, asked the serializer to write it, got the right answer, and shipped. The
+// document a keystroke really produces was different, because between the key and the serializer
+// sits prosemirror-view reparsing its own DOM, and nothing in the unit suite has a DOM.
+//
+// So these tests type into a running editor and then read the file. They are slow and there are
+// few of them on purpose: one per way the app has been caught rewriting bytes nobody touched.
+
+import { expect, test, type Page } from "@playwright/test";
+import { putCaret } from "./caret";
+import { ask, change, installTauriShim } from "./disk";
+
+const HANDBOOK = "/Users/you/Documents/Handbook";
+const README = `${HANDBOOK}/README.md`;
+
+const row = (path: string) => `.tree-row[data-path="${path}"]`;
+
+/** Longer than the 500ms autosave debounce in src/document.ts, with room for the write itself. */
+const SAVED = 1500;
+
+/** Opens the README with the given bytes in it and waits for them to be on screen. */
+async function open(page: Page, source: string): Promise<void> {
+  await page.addInitScript(installTauriShim);
+  await page.addInitScript(() => {
+    localStorage.clear();
+    localStorage.setItem("margindocs-recents", JSON.stringify(["/Users/you/Documents/Handbook"]));
+  });
+  await page.goto("/");
+  await expect(page.locator(row(HANDBOOK))).toBeVisible();
+  await page.locator(row(README)).click();
+  await expect(page.locator(".prose")).toBeVisible();
+
+  // Written from outside rather than typed, so the app has not registered a self-write and this is
+  // a file it has only ever read.
+  await change(page, "write", README, source);
+  await expect.poll(() => ask<string>(page, "read", README)).toBe(source);
+}
+
+/** What is on disk now. */
+function disk(page: Page): Promise<string> {
+  return ask<string>(page, "read", README);
+}
+
+test("a vite server serving somebody else's copy cannot pass this suite", async ({ page }) => {
+  // playwright.config.ts sets `reuseExistingServer`, so the suite talks to whatever already answers
+  // on the port. A stale server left behind by another checkout serves that checkout, and every
+  // assertion below would then be about a file this repository does not contain. Cheap to check and
+  // it has already caught one: the paragraph's whitespace contract is the newest thing in the
+  // schema, so a server without it is a server not serving this tree.
+  await open(page, "hello\n");
+  const paragraph = await page.evaluate(() => {
+    const view = (document.querySelector(".prose") as HTMLElement & { pmViewDesc?: { node: { type: { schema: { nodes: Record<string, { spec: Record<string, unknown> }> } } } } }).pmViewDesc;
+    if (!view) return null;
+    return view.node.type.schema.nodes.paragraph.spec;
+  });
+  expect(paragraph).not.toBeNull();
+  expect(paragraph?.whitespace).toBe("pre");
+  expect(JSON.stringify(paragraph?.parseDOM)).toContain("preserveWhitespace");
+});
+
+test("one character into a hand wrapped paragraph is a one character diff", async ({ page }) => {
+  // The bug a user meets first, because a hand wrapped file is what a text editor leaves behind.
+  // prosemirror-view reparses the paragraph's own DOM after a keystroke and asks the schema how to
+  // read its whitespace; with the default answer every soft wrap in the paragraph came back a
+  // `hardBreak`, and the save put a backslash at the end of every line the user had wrapped. The
+  // whole file, from one character. src/model/schema.ts carries the field that stops it, and only
+  // a running editor proves the field is reaching the parse: the serializer never saw the fault.
+  const source = "# Title\n\none wrapped\nline here\n\nsecond one\nalso wrapped\n";
+  await open(page, source);
+
+  const paragraph = page.locator(".prose p").first();
+  await putCaret(paragraph, 3);
+  await page.keyboard.type("Z");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe("# Title\n\noneZ wrapped\nline here\n\nsecond one\nalso wrapped\n");
+});
+
+test("joining two hand wrapped paragraphs keeps every wrap in both of them", async ({ page }) => {
+  // The same field, read by prosemirror-transform's `join` rather than by the parser, which is why
+  // it is worth its own test: a fix that only taught the parser would leave this one rewriting both
+  // paragraphs on a single Backspace.
+  await open(page, "one\ntwo\n\nthree\nfour\n");
+
+  await putCaret(page.locator(".prose p").nth(1), "start");
+  await page.keyboard.press("Backspace");
+  await page.waitForTimeout(SAVED);
+
+  const after = await disk(page);
+  expect(after).not.toContain("\\");
+  expect(after).toBe("one\ntwothree\nfour\n");
+});
+
+test("a line break the user asks for mid paragraph reaches the file", async ({ page }) => {
+  // The control for the two tests below. A trailing break is written as nothing, and a change that
+  // reached this one instead would be taking away the gesture rather than tidying up after it.
+  await open(page, "alpha beta\n");
+
+  await putCaret(page.locator(".prose p").first(), 5);
+  await page.keyboard.press("Shift+Enter");
+  await page.waitForTimeout(SAVED);
+
+  // The escaped space is old, documented and stable on reparse: mdast will not let a hard break be
+  // followed by a literal space, and this test is about the break, not about the spelling.
+  expect(await disk(page)).toBe("alpha\\\n&#x20;beta\n");
+});
+
+test("a break with nothing under it is written as nothing, and the next character makes it real", async ({
+  page,
+}) => {
+  // There is no markdown for a paragraph that ends on a blank line, so the honest spelling of a
+  // trailing break is no spelling. It used to be written `\` on a line of its own, which reads back
+  // as a literal backslash in the user's words: a character they never typed, in their file, from a
+  // key they pressed and had not finished using yet.
+  await open(page, "hello there\n");
+
+  await putCaret(page.locator(".prose p").first(), "end");
+  await page.keyboard.press("Shift+Enter");
+  await page.waitForTimeout(SAVED);
+  expect(await disk(page)).toBe("hello there\n");
+
+  await page.keyboard.type("q");
+  await page.waitForTimeout(SAVED);
+  expect(await disk(page)).toBe("hello there\\\nq\n");
+});
+
+test("a break left trailing by a deletion is written as nothing too", async ({ page }) => {
+  // The route no keystroke guard covers: the break was legal where it was put, and a Delete took
+  // the text out from under it. The answer lives in the serializer for exactly this reason.
+  await open(page, "para\n");
+
+  await putCaret(page.locator(".prose p").first(), "end");
+  await page.keyboard.type("xy");
+  await page.keyboard.press("ArrowLeft");
+  await page.keyboard.press("Shift+Enter");
+  await page.keyboard.press("Delete");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe("paraxy\n");
+});
+
+test("typing into a raw block does not swallow the list above it", async ({ page }) => {
+  // An edited raw block has to be written back somewhere the reparse will find it again, and a
+  // list directly above one leaves it nowhere: every indent that keeps the list readable puts the
+  // block in a fence or in the list. The save gives up the edit rather than the file.
+  const source = "- one\n- two\n\n<div>\nraw\n</div>\n\nafter\n";
+  await open(page, source);
+
+  await putCaret(page.locator(".prose pre").first(), "start");
+  await page.keyboard.type("    ");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe(source);
+  await expect(page.locator(".prose ul li")).toHaveText(["one", "two"]);
+});
+
+test("an edit in the prose does not eat bytes off the end of a raw block", async ({ page }) => {
+  // Preserved source running to the end of the file was trimmed of its trailing blank lines on the
+  // way out, so a keystroke somewhere else deleted characters inside somebody's html.
+  await open(page, "para\n\n<pre>\nkeep\n\n\n");
+
+  await putCaret(page.locator(".prose p").first(), "end");
+  await page.keyboard.type("Z");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe("paraZ\n\n<pre>\nkeep\n\n\n");
+});
+
+test("a tight list inside a quote is not blown apart by an edit", async ({ page }) => {
+  // remark calls a list spread when the blank line is after the last item; CommonMark does not, and
+  // inside a quote that line is a `>` the list token runs over. Believing remark put a blank line
+  // between every item on the save after next.
+  await open(page, "> - one\n> - two\n>\n> > nested\n");
+
+  await putCaret(page.locator(".prose blockquote li p").first(), "end");
+  await page.keyboard.type("Z");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe("> - oneZ\n> - two\n>\n> > nested\n");
+});
+
+test("a printable character over a rectangle of cells writes nothing", async ({ page }) => {
+  // A rectangle is a selection of containers, not of text. ProseMirror offered the character to
+  // every cell range in it and `insertText` replaced all four, so one keypress emptied cells the
+  // user could see they had not aimed at.
+  const source = "| a | b |\n| - | - |\n| c | d |\n";
+  await open(page, source);
+
+  const cells = page.locator(".prose table td, .prose table th");
+  const first = await cells.nth(0).boundingBox();
+  const last = await cells.nth(3).boundingBox();
+  await page.mouse.move(first!.x + first!.width / 2, first!.y + first!.height / 2);
+  await page.mouse.down();
+  await page.mouse.move(last!.x + last!.width / 2, last!.y + last!.height / 2, { steps: 8 });
+  await page.mouse.up();
+  // The gesture really made a rectangle. Without this the test passes on a suite where the drag
+  // silently did nothing, which is the shape of guard this project has shipped four times.
+  await expect(page.locator(".prose .selectedCell")).toHaveCount(4);
+
+  await page.keyboard.type("Z");
+  await page.waitForTimeout(SAVED);
+
+  expect(await disk(page)).toBe(source);
+  await expect(page.locator(".prose table")).toContainText("d");
+});
+
+test("opening a document and looking at it writes nothing", async ({ page }) => {
+  const source = "# Title\n\none wrapped\nline here\n\n<div>\nraw\n</div>\n\n- a\n- b\n";
+  await open(page, source);
+  await page.waitForTimeout(SAVED * 2);
+  expect(await disk(page)).toBe(source);
+});