mirror of
https://github.com/github/awesome-copilot.git
synced 2026-10-13 15:24:25 +00:00
226 lines
9.6 KiB
JavaScript
226 lines
9.6 KiB
JavaScript
// Tests for how drawings are kept on disk: ids, the element limit, loading, and failed writes.
|
|
// Run `node --test` in the extension folder.
|
|
import assert from "node:assert/strict";
|
|
import { promises as fs } from "node:fs";
|
|
import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import { setTimeout as sleep } from "node:timers/promises";
|
|
import { MAX_ELEMENTS } from "./lib/model.mjs";
|
|
import { DrawingStore, StoreError } from "./store.mjs";
|
|
|
|
const rect = (id) => ({ id, type: "rect", x: 0, y: 0, w: 100, h: 60, text: id });
|
|
|
|
// A store on a temp folder. When the test ends, pending writes finish and the folder is removed.
|
|
async function openStore(t) {
|
|
const dir = await mkdtemp(path.join(os.tmpdir(), "draw-store-test-"));
|
|
const store = new DrawingStore(dir);
|
|
await store.ready;
|
|
t.after(async () => {
|
|
await store.flush().catch(() => {});
|
|
await rm(dir, { recursive: true, force: true, maxRetries: 3 });
|
|
});
|
|
return store;
|
|
}
|
|
|
|
// Puts a folder where a drawing's file should be, so writing or deleting the file fails.
|
|
async function blockFile(file) {
|
|
await rm(file, { force: true });
|
|
await mkdir(file);
|
|
await writeFile(path.join(file, "keep"), "");
|
|
}
|
|
|
|
test("a failed save warns once, keeps retrying and clears when a write works", async (t) => {
|
|
const store = await openStore(t);
|
|
const doc = store.create("Plan");
|
|
await store.flush();
|
|
const events = [];
|
|
store.on("save", (id, error) => events.push({ id, error }));
|
|
const file = store.filePath(doc.id);
|
|
await blockFile(file);
|
|
|
|
store.replace(doc.id, [rect("a")], "test");
|
|
// Each flush is one more failed try. The message stays the same, so the user is only warned once.
|
|
await assert.rejects(store.flush(), (err) => err instanceof StoreError && err.code === "save_failed" && err.status === 500);
|
|
await assert.rejects(store.flush(), { code: "save_failed" });
|
|
assert.equal(events.length, 1);
|
|
assert.equal(events[0].id, doc.id);
|
|
assert.equal(store.saveError(doc.id), events[0].error);
|
|
assert.ok(!events[0].error.includes(".tmp"), `the message names the temp file: ${events[0].error}`);
|
|
|
|
await rm(file, { recursive: true });
|
|
await store.flush();
|
|
assert.deepEqual(events[1], { id: doc.id, error: null });
|
|
assert.equal(store.saveError(doc.id), null);
|
|
assert.deepEqual(JSON.parse(await readFile(file, "utf8")).elements.map((e) => e.id), ["a"]);
|
|
});
|
|
|
|
test("a drawing whose file cannot be deleted is kept", async (t) => {
|
|
const store = await openStore(t);
|
|
const doc = store.create("Plan");
|
|
await store.flush();
|
|
const file = store.filePath(doc.id);
|
|
await blockFile(file);
|
|
|
|
await assert.rejects(store.remove(doc.id), { code: "delete_failed", status: 500 });
|
|
assert.equal(store.get(doc.id), doc);
|
|
assert.deepEqual(store.list().map((d) => d.id), [doc.id]);
|
|
await rm(file, { recursive: true });
|
|
});
|
|
|
|
test("ids are short, unique and safe to use as file names", async (t) => {
|
|
const store = await openStore(t);
|
|
const name = "A very long drawing name ".repeat(8);
|
|
const ids = Array.from({ length: 12 }, () => store.create(name).id);
|
|
assert.equal(new Set(ids).size, ids.length);
|
|
for (const id of ids) {
|
|
assert.ok(id.length <= 48, id);
|
|
assert.match(id, /^[a-z0-9]+(?:-[a-z0-9]+)*$/);
|
|
}
|
|
assert.equal(store.create("Ünïcödé / name?").id, "unicode-name");
|
|
assert.equal(store.create("???").id, "drawing");
|
|
});
|
|
|
|
test("changes past the element limit are refused and leave the drawing alone", async (t) => {
|
|
const store = await openStore(t);
|
|
const doc = store.create("Plan");
|
|
store.replace(doc.id, [rect("a")], "test");
|
|
const many = Array.from({ length: MAX_ELEMENTS + 1 }, (_, i) => rect(`r${i}`));
|
|
assert.throws(() => store.replace(doc.id, many, "test"), { code: "too_many_elements", status: 400 });
|
|
assert.equal(doc.rev, 1);
|
|
assert.deepEqual(doc.elements.map((e) => e.id), ["a"]);
|
|
store.replace(doc.id, many.slice(0, MAX_ELEMENTS), "test");
|
|
assert.equal(doc.elements.length, MAX_ELEMENTS);
|
|
});
|
|
|
|
test("edits send the drawing list out again, once for a burst of them", async (t) => {
|
|
const store = await openStore(t);
|
|
const lists = [];
|
|
store.on("list", () => lists.push(store.list()));
|
|
|
|
// A new drawing is listed once its elements are in, so a copy never shows up empty.
|
|
const doc = store.create("Plan");
|
|
store.replace(doc.id, [rect("a"), rect("b")], "test");
|
|
assert.equal(lists.length, 0);
|
|
await sleep(400);
|
|
assert.deepEqual(lists.map((list) => list[0].count), [2]);
|
|
|
|
store.applyOps(doc.id, { upserts: [rect("c")] }, "user");
|
|
store.applyOps(doc.id, { deletes: ["a"] }, "user");
|
|
store.rename(doc.id, "Architecture");
|
|
await sleep(400);
|
|
assert.equal(lists.length, 2);
|
|
assert.deepEqual(lists[1], [{ id: doc.id, name: "Architecture", updatedAt: doc.updatedAt, count: 2 }]);
|
|
});
|
|
|
|
test("drawings load back from disk, and unreadable files are skipped", async (t) => {
|
|
const store = await openStore(t);
|
|
const doc = store.create("Plan");
|
|
store.replace(doc.id, [rect("a"), rect("b")], "test");
|
|
store.bindInstance("panel", doc.id);
|
|
await store.flush();
|
|
await writeFile(path.join(store.dir, "broken.json"), "{ not json");
|
|
await writeFile(path.join(store.dir, "Not A Slug.json"), JSON.stringify({ elements: [] }));
|
|
|
|
const logs = [];
|
|
const again = new DrawingStore(store.dir, { log: (message) => logs.push(message) });
|
|
await again.ready;
|
|
assert.deepEqual(again.list().map((d) => d.id), [doc.id]);
|
|
assert.deepEqual(again.get(doc.id).elements, doc.elements);
|
|
assert.equal(again.drawingForInstance("panel").id, doc.id);
|
|
assert.ok(logs.some((message) => message.includes("broken.json")));
|
|
});
|
|
|
|
test("exports of one drawing written in the same millisecond all finish", async (t) => {
|
|
const store = await openStore(t);
|
|
// Temp file names hold the time, so stop the clock. Then rename only once every temp file is
|
|
// written, one at a time: temp files that shared a name would be renamed out from under each other.
|
|
t.mock.method(Date, "now", () => 1700000000000);
|
|
const rename = fs.rename;
|
|
let waiting = 0;
|
|
let release;
|
|
let queue = new Promise((resolve) => (release = resolve));
|
|
t.mock.method(fs, "rename", (...args) => {
|
|
if (++waiting === 3) release();
|
|
const done = queue.then(() => rename(...args));
|
|
queue = done.catch(() => {});
|
|
return done;
|
|
});
|
|
const payloads = ["<svg id='a'/>", "<svg id='b'/>", "<svg id='c'/>"];
|
|
const files = await Promise.all(payloads.map((data) => store.writeExport("plan", "svg", data)));
|
|
assert.equal(new Set(files).size, 1);
|
|
assert.ok(payloads.includes(await readFile(files[0], "utf8")));
|
|
});
|
|
|
|
test("a save that fails part way through writing leaves no temp file behind", async (t) => {
|
|
const store = await openStore(t);
|
|
const doc = store.create("Plan");
|
|
await store.flush();
|
|
// Like a full disk: the temp file gets part of the drawing, and then the write fails.
|
|
const write = fs.writeFile;
|
|
const failing = t.mock.method(fs, "writeFile", async (file, data, ...rest) => {
|
|
if (!String(file).endsWith(".tmp")) return write(file, data, ...rest);
|
|
await write(file, String(data).slice(0, 10), ...rest);
|
|
throw Object.assign(new Error(`ENOSPC: no space left on device, write '${file}'`), { code: "ENOSPC", syscall: "write" });
|
|
});
|
|
const temps = async () => (await readdir(store.dir)).filter((name) => name.endsWith(".tmp"));
|
|
|
|
store.replace(doc.id, [rect("a")], "test");
|
|
await assert.rejects(store.flush(), { code: "save_failed" });
|
|
await assert.rejects(store.flush(), { code: "save_failed" });
|
|
assert.deepEqual(await temps(), []);
|
|
|
|
failing.mock.restore();
|
|
await store.flush();
|
|
assert.deepEqual(await temps(), []);
|
|
assert.deepEqual(JSON.parse(await readFile(store.filePath(doc.id), "utf8")).elements.map((e) => e.id), ["a"]);
|
|
});
|
|
|
|
test("state writes go one at a time, and flush waits for one that has already started", async (t) => {
|
|
const store = await openStore(t);
|
|
const a = store.create("A");
|
|
const b = store.create("B");
|
|
await store.flush();
|
|
// Holds the next rename of the state file until it is released, like a file an antivirus is reading.
|
|
const rename = fs.rename;
|
|
let hold = null;
|
|
t.mock.method(fs, "rename", async (from, to) => {
|
|
const h = String(to).endsWith(".state.json") ? hold : null;
|
|
if (!h) return rename(from, to);
|
|
hold = null;
|
|
h.started();
|
|
await h.gate;
|
|
try {
|
|
return await rename(from, to);
|
|
} finally {
|
|
h.finished();
|
|
}
|
|
});
|
|
const holdNext = () => {
|
|
const h = {};
|
|
h.gate = new Promise((resolve) => (h.release = resolve));
|
|
h.waiting = new Promise((resolve) => (h.started = resolve));
|
|
h.done = new Promise((resolve) => (h.finished = resolve));
|
|
return (hold = h);
|
|
};
|
|
const shown = async () => JSON.parse(await readFile(path.join(store.dir, ".state.json"), "utf8")).instances.panel;
|
|
|
|
const first = holdNext();
|
|
store.bindInstance("panel", a.id);
|
|
await first.waiting;
|
|
setTimeout(first.release, 50);
|
|
await store.flush();
|
|
assert.equal(await shown(), a.id);
|
|
|
|
// A newer binding made while an older write is held is the one left on disk.
|
|
const second = holdNext();
|
|
store.bindInstance("panel", b.id);
|
|
await second.waiting;
|
|
store.bindInstance("panel", a.id);
|
|
setTimeout(second.release, 50);
|
|
await store.flush();
|
|
await second.done;
|
|
assert.equal(await shown(), a.id);
|
|
});
|