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});