tests/draft-storage.test.ts

1import { test } from "node:test";
2import assert from "node:assert/strict";
3import {
4  DraftConflict,
5  DraftStorage,
6  type DraftStorageEnvironment,
7} from "../documentation/components/source/draft-storage.ts";
8import {
9  Stack,
10  type Composition,
11} from "../documentation/components/source/composition.ts";
12import { startWorkingCopy } from "../documentation/components/source/working-copy.ts";
13
14const text = (wording: string): Composition => ({
15  kind: "Text",
16  text: wording,
17});
18function disk() {
19  let value: string | null = null;
20  let fail = false;
21  let tail: Promise<unknown> = Promise.resolve();
22  const environment: DraftStorageEnvironment = {
23    read: () => value,
24    write: (next) => {
25      if (fail) throw new Error("Quota exceeded");
26      value = next;
27    },
28    exclusive: <T>(action: () => T) => {
29      const result = tail.then(action);
30      tail = result.catch(() => {});
31      return result;
32    },
33  };
34  return {
35    environment,
36    fail: () => {
37      fail = true;
38    },
39    replace: (next: string) => {
40      value = next;
41    },
42  };
43}
44
45test("two stale editors cannot both overwrite the same draft", async () => {
46  const { environment } = disk();
47  const first = new DraftStorage(environment),
48    second = new DraftStorage(environment);
49  const workspace = await first.create(Stack(text("original")), "Notice");
50  const base = workspace.drafts[0]!;
51  const a = { ...base, copy: startWorkingCopy(Stack(text("first edit"))) };
52  const b = { ...base, copy: startWorkingCopy(Stack(text("second edit"))) };
53  const results = await Promise.allSettled([
54    first.save(a, base),
55    second.save(b, base),
56  ]);
57  assert.equal(results[0]!.status, "fulfilled");
58  assert.equal(results[1]!.status, "rejected");
59  if (results[1]!.status === "rejected")
60    assert.ok(results[1]!.reason instanceof DraftConflict);
61  assert.deepEqual(first.read()!.drafts[0]!.copy.model, a.copy.model);
62});
63
64test("different drafts merge against the latest workspace", async () => {
65  const { environment } = disk();
66  const store = new DraftStorage(environment);
67  await store.create(Stack(text("a")), "A");
68  const workspace = await store.create(Stack(text("b")), "B");
69  const [a, b] = workspace.drafts;
70  await Promise.all([
71    store.save({ ...a!, name: "A revised" }, a),
72    store.save({ ...b!, name: "B revised" }, b),
73  ]);
74  assert.deepEqual(
75    store.read()!.drafts.map((d) => d.name),
76    ["A revised", "B revised"],
77  );
78});
79
80test("write failure retains the prior workspace and a recovered copy preserves history", async () => {
81  const storage = disk();
82  const store = new DraftStorage(storage.environment);
83  const workspace = await store.create(Stack(text("one")), "Notice");
84  const base = workspace.drafts[0]!;
85  const copy = {
86    model: Stack(text("two")),
87    chosen: ["0.0"],
88    undo: [{ model: base.copy.model, chosen: ["0"] }],
89  };
90  const recovered = await store.create(copy.model, "Notice", {
91    copy,
92    width: 540,
93  });
94  assert.equal(recovered.drafts[1]!.name, "Notice (2)");
95  assert.deepEqual(recovered.drafts[1]!.copy, copy);
96  assert.equal(recovered.drafts[1]!.width, 540);
97  storage.fail();
98  await assert.rejects(
99    () => store.save({ ...base, name: "Lost write" }, base),
100    /Quota/,
101  );
102  assert.deepEqual(store.read(), recovered);
103});
104
105test("unreadable existing data is never replaced by creating a draft", async () => {
106  const storage = disk();
107  const store = new DraftStorage(storage.environment);
108  for (const bad of ['{"version":99}', "{broken"]) {
109    storage.replace(bad);
110    await assert.rejects(() => store.create(Stack(), "New"));
111    assert.equal(storage.environment.read(), bad);
112  }
113});
114
115function receipt() {
116  let value: string | null = null;
117  let fail = false;
118  return {
119    read: () => value,
120    write: (next: string | null) => {
121      if (fail) throw new Error("Recovery storage unavailable");
122      value = next;
123    },
124    fail: () => {
125      fail = true;
126    },
127  };
128}
129
130test("last removal survives a new storage instance; restoration merges later work", async () => {
131  const diskState = disk(),
132    recovery = receipt();
133  const store = new DraftStorage(diskState.environment, recovery);
134  const first = (await store.create(Stack(text("one")), "A")).drafts[0]!;
135  const copy = {
136    model: Stack(text("two")),
137    chosen: ["0.0"],
138    undo: [{ model: first.copy.model, chosen: ["0"] }],
139  };
140  const saved = (await store.save({ ...first, copy, width: 420 }, first))
141    .drafts[0]!;
142  const empty = await store.remove(saved);
143  assert.deepEqual(empty, { version: 1, activeId: null, drafts: [] });
144  const reopened = new DraftStorage(diskState.environment, recovery);
145  assert.deepEqual(reopened.lastRemoval()!.draft, saved);
146  const other = (await reopened.create(Stack(text("other")), "B")).drafts[0]!;
147  await reopened.save({ ...other, name: "B revised" }, other);
148  const restored = await reopened.undoRemoval();
149  assert.deepEqual(restored.drafts[0], saved);
150  assert.equal(restored.drafts[1]!.name, "B revised");
151  assert.equal(restored.activeId, saved.id);
152  assert.equal(reopened.lastRemoval(), undefined);
153});
154
155test("removal checks the latest draft before changing the previous receipt", async () => {
156  const diskState = disk(),
157    recovery = receipt();
158  const store = new DraftStorage(diskState.environment, recovery);
159  const a = (await store.create(Stack(), "A")).drafts[0]!;
160  await store.remove(a);
161  const b = (await store.create(Stack(), "B")).drafts[0]!;
162  const originalReceipt = recovery.read();
163  await store.save({ ...b, name: "B revised" }, b);
164  await assert.rejects(() => store.remove(b), DraftConflict);
165  assert.equal(recovery.read(), originalReceipt);
166  assert.equal(store.read()!.drafts[0]!.name, "B revised");
167});
168
169test("failure to save a recovery copy prevents removal", async () => {
170  const diskState = disk(),
171    recovery = receipt();
172  const store = new DraftStorage(diskState.environment, recovery);
173  const workspace = await store.create(Stack(), "A");
174  recovery.fail();
175  await assert.rejects(
176    () => store.remove(workspace.drafts[0]!),
177    /Recovery storage/,
178  );
179  assert.deepEqual(store.read(), workspace);
180});
181
182test("durable write failure restores the prior removal receipt", async () => {
183  const diskState = disk(),
184    recovery = receipt();
185  const store = new DraftStorage(diskState.environment, recovery);
186  const a = (await store.create(Stack(), "A")).drafts[0]!;
187  await store.remove(a);
188  const workspace = await store.create(Stack(), "B");
189  const previous = recovery.read();
190  diskState.fail();
191  await assert.rejects(() => store.remove(workspace.drafts[0]!), /Quota/);
192  assert.deepEqual(store.read(), workspace);
193  assert.equal(recovery.read(), previous);
194});
195
196test("restoration write failure leaves the removed draft available for retry", async () => {
197  const diskState = disk(),
198    recovery = receipt();
199  const store = new DraftStorage(diskState.environment, recovery);
200  const draft = (await store.create(Stack(), "A")).drafts[0]!;
201  await store.remove(draft);
202  diskState.fail();
203  await assert.rejects(() => store.undoRemoval(), /Quota/);
204  assert.deepEqual(store.lastRemoval()!.draft, draft);
205  assert.equal(store.read()!.drafts.length, 0);
206});
207
208test("a failed receipt cleanup cannot undo a successful durable restoration", async () => {
209  const diskState = disk(),
210    recovery = receipt();
211  const store = new DraftStorage(diskState.environment, recovery);
212  const draft = (await store.create(Stack(), "A")).drafts[0]!;
213  await store.remove(draft);
214  recovery.fail();
215  assert.deepEqual((await store.undoRemoval()).drafts[0], draft);
216  assert.equal(store.lastRemoval(), undefined);
217  await assert.rejects(() => store.undoRemoval(), /no removed draft/);
218});
219
220test("a readable removal remains recoverable while durable storage is unreadable", async () => {
221  const diskState = disk(),
222    recovery = receipt();
223  const store = new DraftStorage(diskState.environment, recovery);
224  const draft = (await store.create(Stack(), "A")).drafts[0]!;
225  await store.remove(draft);
226  diskState.replace("{broken");
227  assert.deepEqual(store.lastRemoval()!.draft, draft);
228  await assert.rejects(() => store.undoRemoval());
229  assert.equal(diskState.environment.read(), "{broken");
230  assert.deepEqual(store.lastRemoval()!.draft, draft);
231});
232
233test("a removal from another tab cannot replace this tab's recovery copy", async () => {
234  const diskState = disk(),
235    recovery = receipt();
236  const first = new DraftStorage(diskState.environment, recovery);
237  const second = new DraftStorage(diskState.environment, receipt());
238  const a = (await first.create(Stack(), "A")).drafts[0]!;
239  await first.remove(a);
240  const b = (await first.create(Stack(), "B")).drafts[0]!;
241  await second.remove(b);
242  await assert.rejects(() => first.remove(b), /already removed/);
243  assert.deepEqual(first.lastRemoval()!.draft, a);
244});
245
246test("capacity refusal retains recovery until room is freed in another tab", async () => {
247  const diskState = disk(),
248    recovery = receipt();
249  const first = new DraftStorage(diskState.environment, recovery);
250  const second = new DraftStorage(diskState.environment, receipt());
251  const original = (await first.create(Stack(), "Original")).drafts[0]!;
252  await first.remove(original);
253  for (let i = 0; i < 20; i++) await second.create(Stack(), `Draft ${i}`);
254  const before = first.read();
255  await assert.rejects(() => first.undoRemoval(), /not restored/);
256  assert.deepEqual(first.read(), before);
257  assert.deepEqual(first.lastRemoval()!.draft, original);
258  await second.remove(before!.drafts[0]!);
259  const restored = await first.undoRemoval();
260  assert.equal(restored.drafts.length, 20);
261  assert.deepEqual(restored.drafts[0], original);
262});
263
264test("making room cannot silently replace a removal that no longer fits", async () => {
265  const diskState = disk(),
266    recovery = receipt();
267  const store = new DraftStorage(diskState.environment, recovery);
268  const original = (await store.create(Stack(), "Original")).drafts[0]!;
269  await store.remove(original);
270  for (let i = 0; i < 20; i++) await store.create(Stack(), `Draft ${i}`);
271  const before = store.read()!;
272  const oldReceipt = recovery.read();
273  await assert.rejects(
274    () => store.remove(before.drafts[0]!),
275    /Original.*cannot currently be restored/,
276  );
277  assert.deepEqual(store.read(), before);
278  assert.equal(recovery.read(), oldReceipt);
279  const changed = await store.remove(before.drafts[0]!, true);
280  assert.equal(changed.drafts.length, 19);
281  assert.deepEqual(store.lastRemoval()!.draft, before.drafts[0]);
282});
283
284test("an unreadable old receipt needs an explicit replacement choice", async () => {
285  const diskState = disk(),
286    recovery = receipt();
287  const store = new DraftStorage(diskState.environment, recovery);
288  const workspace = await store.create(Stack(), "Current");
289  recovery.write("{broken");
290  await assert.rejects(
291    () => store.remove(workspace.drafts[0]!),
292    /entry cannot be read/,
293  );
294  assert.deepEqual(store.read(), workspace);
295  assert.equal(recovery.read(), "{broken");
296  await store.remove(workspace.drafts[0]!, true);
297  assert.deepEqual(store.lastRemoval()!.draft, workspace.drafts[0]);
298});