paperlint 3.0.0 → 3.1.1

package/skills/verify-citations/scripts/verify-cites.net.test.mjs

@@ -0,0 +1,287 @@
+/**
+ * verify-cites.mjs's network layer — the four registries, the DOI authority and NVD — driven
+ * in-process with a fake `fetch`, so every transport outcome is produced on purpose and nothing
+ * touches the network. Each case compares the whole verdict AND the exact requests made: a
+ * resolver that asks the wrong URL is as broken as one that misreads the answer.
+ */
+import assert from "node:assert/strict";
+import { afterEach, expect, test, vi } from "vitest";
+import { verifyCitationLive } from "./verify-cites.mjs";
+
+const json = (status, body) =>
+  new Response(body === undefined ? null : JSON.stringify(body), { status });
+const text = (status, body) => new Response(body, { status });
+
+/**
+ * A fake `fetch`: `routes` maps a URL prefix to a response factory (or an Error to throw). The
+ * longest matching prefix wins; an unrouted URL fails the test. Returns the URLs asked, in order.
+ */
+function fakeFetch(routes) {
+  const calls = [];
+  vi.stubGlobal("fetch", async (url) => {
+    calls.push(url);
+    const hit = Object.keys(routes)
+      .filter((p) => url.startsWith(p))
+      .sort((a, b) => b.length - a.length)[0];
+    if (hit === undefined) throw new Error(`unrouted request: ${url}`);
+    const r = routes[hit];
+    if (r instanceof Error) throw r;
+    return r();
+  });
+  return calls;
+}
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.useRealTimers();
+});
+
+const CR = "https://api.crossref.org/works";
+const OA = "https://api.openalex.org/works";
+const S2 = "https://api.semanticscholar.org/graph/v1/paper";
+const AX = "https://export.arxiv.org/api/query";
+const DOI = "https://doi.org/api/handles/";
+const NVD = "https://services.nvd.nist.gov/rest/json/cves/2.0";
+const TITLE = "Attention Is All You Need";
+const feed = (title, year) =>
+  `<feed><entry><id>http://arxiv.org/abs/1706.03762v1</id><published>${year}-06-12</published><title>${title}</title></entry></feed>`;
+
+test("a DOI every registry resolves to the claimed paper, and the authority knows: true", async () => {
+  const calls = fakeFetch({
+    [CR]: () =>
+      json(200, {
+        message: { title: [TITLE], issued: { "date-parts": [[2017]] } },
+      }),
+    [OA]: () =>
+      json(200, { id: "W1", display_name: TITLE, publication_year: 2017 }),
+    [S2]: () => json(200, { title: TITLE, year: 2017 }),
+    [DOI]: () => json(200, { responseCode: 1 }),
+  });
+  const cite = { id: "v", doi: "10.1/x", title: TITLE, year: 2017 };
+  expect({ result: await verifyCitationLive(cite), calls }).toMatchSnapshot();
+});
+
+test("a DOI nobody knows, and the authority says it does not exist: false", async () => {
+  const calls = fakeFetch({
+    [CR]: () => json(404),
+    [OA]: () => json(404),
+    [S2]: () => json(404),
+    [DOI]: () => json(404),
+  });
+  const result = await verifyCitationLive({ id: "f", doi: "10.1/nope" });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("every registry down (429, 503, 403, a thrown error): unresolvable, never false", async () => {
+  const calls = fakeFetch({
+    [CR]: () => json(429),
+    [OA]: () => json(503),
+    [S2]: () => json(403),
+    [DOI]: new TypeError("fetch failed"),
+  });
+  const result = await verifyCitationLive({
+    id: "u",
+    doi: "10.1/x",
+    title: TITLE,
+  });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("records with fields missing: no title, a subtitle, a year only in `published`, no id", async () => {
+  const calls = fakeFetch({
+    [CR]: () =>
+      json(200, {
+        message: {
+          subtitle: ["All You Need"],
+          published: { "date-parts": [[2017]] },
+        },
+      }),
+    [OA]: () => json(200, { display_name: TITLE }), // no `id` → no record
+    [S2]: () => json(200, { title: null }), // a null title → no record
+    [DOI]: () => json(200, { responseCode: "1" }), // not a number → unknown
+  });
+  const result = await verifyCitationLive({
+    id: "m",
+    doi: "10.1/x",
+    title: TITLE,
+  });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("an arXiv id: Semantic Scholar by arXiv id, the arXiv API by id_list", async () => {
+  const calls = fakeFetch({
+    [S2]: () => json(200, { title: TITLE, year: 2017 }),
+    [AX]: () => text(200, feed(TITLE, 2017)),
+  });
+  const result = await verifyCitationLive({
+    id: "a",
+    arxiv: "1706.03762",
+    title: TITLE,
+  });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("an arXiv id nobody has: the arXiv API's empty feed and S2's 404", async () => {
+  const calls = fakeFetch({
+    [S2]: () => json(404),
+    [AX]: () => text(200, "<feed></feed>"),
+  });
+  const result = await verifyCitationLive({ id: "n", arxiv: "9999.99999" });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("a title only: every registry's search endpoint, hits and all", async () => {
+  const calls = fakeFetch({
+    [`${CR}?`]: () =>
+      json(200, {
+        message: {
+          items: [{ title: [TITLE], issued: { "date-parts": [[2017]] } }, {}],
+        },
+      }),
+    [`${OA}?`]: () =>
+      json(200, {
+        results: [{ display_name: TITLE, publication_year: 2017 }, {}],
+      }),
+    [`${S2}/search`]: () =>
+      json(200, { data: [{ title: TITLE, year: 2017 }, {}] }),
+    [AX]: () => text(200, feed(TITLE, 2017)),
+  });
+  const result = await verifyCitationLive({
+    id: "t",
+    title: TITLE,
+    year: 2017,
+  });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("a title search whose answers are empty or shapeless is a miss, not a match", async () => {
+  const calls = fakeFetch({
+    [`${CR}?`]: () => json(200, {}),
+    [`${OA}?`]: () => json(200, {}),
+    [`${S2}/search`]: () => json(200, {}),
+    [AX]: () => text(200, ""),
+  });
+  const result = await verifyCitationLive({ id: "e", title: TITLE });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("a title search that cannot reach any registry is unresolvable", async () => {
+  const abort = Object.assign(new Error("aborted"), { name: "AbortError" });
+  const calls = fakeFetch({
+    [`${CR}?`]: () => json(500),
+    [`${OA}?`]: () => json(502),
+    [`${S2}/search`]: abort,
+    [AX]: () => text(503, ""),
+  });
+  const result = await verifyCitationLive({ id: "d", title: TITLE });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("S2 and arXiv unreachable for an arXiv id", async () => {
+  const calls = fakeFetch({ [S2]: () => json(500), [AX]: () => text(500, "") });
+  const result = await verifyCitationLive({ id: "x", arxiv: "1706.03762" });
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("CVEs: found by count, found by list, not found, NVD down, and a malformed id", async () => {
+  const calls = fakeFetch({
+    [`${NVD}?cveId=CVE-2024-0001`]: () => json(200, { totalResults: 1 }),
+    [`${NVD}?cveId=CVE-2024-0002`]: () => json(200, { vulnerabilities: [{}] }),
+    [`${NVD}?cveId=CVE-2024-0003`]: () => json(404),
+    [`${NVD}?cveId=CVE-2024-0004`]: () => json(500),
+    [`${NVD}?cveId=CVE-2024-0005`]: () => json(200, {}),
+  });
+  const results = [];
+  for (const cve of [
+    "cve-2024-0001",
+    "CVE-2024-0002",
+    "CVE-2024-0003",
+    "CVE-2024-0004",
+    "CVE-2024-0005",
+    "CVE-24-1",
+  ])
+    results.push(await verifyCitationLive({ id: cve, cve }));
+  expect({ results, calls }).toMatchSnapshot();
+});
+
+test("a second lookup is served from the cache; failures and a nonexistent DOI are not cached", async () => {
+  const cache = {};
+  fakeFetch({
+    [CR]: () => json(200, { message: { title: [TITLE] } }),
+    [OA]: () => json(503),
+    [S2]: () => json(404),
+    [DOI]: () => json(200, { responseCode: 1 }),
+    [NVD]: () => json(200, { totalResults: 1 }),
+  });
+  const cite = { id: "c", doi: "10.1/x", title: TITLE, cve: "CVE-2024-0001" };
+  const first = await verifyCitationLive(cite, { cache });
+  const again = fakeFetch({ [OA]: () => json(503) });
+  const second = await verifyCitationLive(cite, { cache });
+  assert.deepEqual(
+    { same: second, keys: Object.keys(cache).sort(), again },
+    {
+      same: first,
+      // arXiv is not asked about a DOI at all, so it has nothing to cache.
+      keys: [
+        "crossref:doi:10.1/x",
+        "doi_authority:10.1/x",
+        "nvd:CVE-2024-0001",
+        "semantic_scholar:doi:10.1/x",
+      ],
+      // Only the resolver that failed the first time is asked again.
+      again: ["https://api.openalex.org/works/doi:10.1%2Fx"],
+    },
+  );
+});
+
+test("offline: no request at all, the verdict from the citation alone", async () => {
+  const calls = fakeFetch({});
+  const result = await verifyCitationLive(
+    { id: "o", doi: "10.1/x", title: TITLE },
+    { offline: true },
+  );
+  expect({ result, calls }).toMatchSnapshot();
+});
+
+test("a registry that never answers is abandoned after the timeout, as unreachable", async () => {
+  vi.useFakeTimers();
+  const calls = [];
+  vi.stubGlobal("fetch", (url, { signal }) => {
+    calls.push(url);
+    return new Promise((_, reject) =>
+      signal.addEventListener("abort", () =>
+        reject(Object.assign(new Error("aborted"), { name: "AbortError" })),
+      ),
+    );
+  });
+  const pending = verifyCitationLive({ id: "s", title: TITLE });
+  for (let i = 0; i < 4; i++) await vi.advanceTimersByTimeAsync(15000);
+  const result = await pending;
+  assert.deepEqual(
+    { verdict: result.verdict, calls: calls.length },
+    { verdict: "unresolvable", calls: 4 },
+  );
+});
+
+test("a registry that answers 200 with no body, or a record without its title, still classifies", async () => {
+  const calls = fakeFetch({
+    [CR]: () => json(200, {}),
+    [OA]: () => json(200, { id: "W1", publication_year: 2017 }),
+    [S2]: () => json(200, { title: "", year: 2017 }),
+    [DOI]: () => json(200, { responseCode: 1 }),
+  });
+  const result = await verifyCitationLive({
+    id: "b",
+    doi: "10.1/x",
+    title: TITLE,
+  });
+  // OpenAlex resolves the DOI to a record with no title: an incomparable title is not a
+  // mismatch, so the DOI stands confirmed.
+  assert.deepEqual(
+    {
+      verdict: result.verdict,
+      matched_db: result.matched_db,
+      calls: calls.length,
+    },
+    { verdict: "true", matched_db: "openalex", calls: 4 },
+  );
+});

package/skills/verify-citations/scripts/verify-cites.test.mjs

@@ -15,7 +15,6 @@ import { test } from "vitest";
 import {
   levenshtein,
   titleSimilarity,
-  titlesMatch,
   yearMatch,
   titleRelation,
   bestTitleRelation,
@@ -30,6 +29,8 @@ import {
   normalizeDoi,
   normalizeArxiv,
   normalizeIdentifiers,
+  normalizeTitle,
+  isValidCveId,
 } from "./verify-cites.mjs";
 
 /** One vitest case per check, named by it. */
@@ -52,17 +53,17 @@ ok(
   "case/normalize identical titles",
 );
 ok(
-  titlesMatch(
+  titleSimilarity(
     "Deep Residual Learning for Image Recognition",
     "Deep Residual Learning for Image Recognitionn",
-  ),
+  ) >= 0.7,
   "one typo still ≥0.70",
 );
 ok(
-  !titlesMatch(
+  titleSimilarity(
     "Attention Is All You Need",
     "A Survey of Reinforcement Learning",
-  ),
+  ) < 0.7,
   "unrelated titles < 0.70",
 );
 ok(yearMatch(2020, 2021), "year ±1 ok");
@@ -733,3 +734,146 @@ console.log("\n[S4] .bib parser edge cases:");
     "bibitem DOI trailing period not swallowed",
   );
 }
+
+// ── Edges of the pure layer: the defensive arms, each with the input that reaches it ──────────
+
+test("levenshtein and normalizeTitle take a missing string as empty", () => {
+  assert.deepEqual(
+    [
+      levenshtein(null, "ab"),
+      levenshtein("abc", undefined),
+      levenshtein("", ""),
+      normalizeTitle(undefined),
+    ],
+    [2, 3, 0, ""],
+  );
+});
+
+test("normalizeDoi / normalizeArxiv pass a missing value through untouched", () => {
+  assert.deepEqual(
+    [
+      normalizeDoi(undefined),
+      normalizeDoi(""),
+      normalizeArxiv(null),
+      normalizeArxiv(""),
+    ],
+    [undefined, "", null, ""],
+  );
+});
+
+test("titleRelation: an acronym of one letter is not an acronym; scripts are told apart", () => {
+  assert.deepEqual(
+    [
+      // "x" is one letter: it cannot spell the initials of anything.
+      titleRelation("x", "extensible markup language"),
+      titleRelation("Нейронные сети", "Neural networks"),
+      titleRelation("ニューラルネットワーク", "Neural networks"),
+      titleRelation("Νευρωνικά δίκτυα", "Neural networks"),
+      titleRelation("الشبكات العصبية", "Neural networks"),
+      titleRelation("!!!", "Neural networks"),
+    ],
+    [
+      "different",
+      "incomparable",
+      "incomparable",
+      "incomparable",
+      "incomparable",
+      "incomparable",
+    ],
+  );
+});
+
+test("yearMatch reads a year out of a string and ignores one that is not a year", () => {
+  assert.deepEqual(
+    [
+      yearMatch("2017-06", 2018),
+      yearMatch("2017", 2020),
+      yearMatch("n.d.", 2020),
+    ],
+    [true, false, true],
+  );
+});
+
+test("classifyResolver: a title search with no `records` field is a miss", () => {
+  assert.deepEqual(
+    classifyResolver(
+      { title: "A Paper" },
+      { db: "crossref", transport: "ok", query: "title" },
+    ),
+    { db: "crossref", status: "title_miss" },
+  );
+});
+
+test("checkNvd with no CVE on the citation says nothing; isValidCveId of nothing is false", () => {
+  assert.deepEqual(
+    [checkNvd({}, null), isValidCveId(undefined)],
+    [null, false],
+  );
+});
+
+test("reduceVerdict: an arXiv id missed only by a non-authoritative source is unresolvable", () => {
+  const r = reduceVerdict({ id: "a", arxiv: "1706.03762" }, [
+    {
+      db: "semantic_scholar",
+      status: "id_unmatched",
+      query: "arxiv",
+      authoritative: false,
+    },
+  ]);
+  assert.deepEqual(r, {
+    id: "a",
+    verdict: "unresolvable",
+    reason:
+      "arXiv id 1706.03762 missed only by non-authoritative sources (the reachable arXiv API did not definitively reject it) — cannot assert fabrication → unresolvable",
+    matched_db: null,
+  });
+});
+
+test("parseBib: @comment/@string/@preamble are skipped, a bare value is read, an empty one is absent", () => {
+  const bib = [
+    "@comment{c, not an entry}",
+    "@string{s, x = {y}}",
+    '@article{k1, title = "Quoted Title", year = 2017, eprint = {1706.03762}, archiveprefix = {arXiv}}',
+    "@misc{k2, title = {T}, year = ,}",
+  ].join("\n");
+  assert.deepEqual(parseBib(bib), [
+    { id: "k1", title: "Quoted Title", year: "2017", arxiv: "1706.03762" },
+    { id: "k2", title: "T" },
+  ]);
+});
+
+test("parseBib's \\bibitem fallback reads an arXiv id and an \\emph title", () => {
+  const text = [
+    "\\begin{thebibliography}{9}",
+    "\\bibitem{a} A. Author. \\emph{A Long Enough Title}. arXiv:1706.03762, 2017.",
+    "\\end{thebibliography}",
+  ].join("\n");
+  assert.deepEqual(parseBib(text), [
+    {
+      id: "a",
+      arxiv: "1706.03762",
+      year: "2017",
+      title: "A Long Enough Title",
+    },
+  ]);
+});
+
+test("parseArxivFeed: an entry without a title is skipped, one without a date has no year", () => {
+  assert.deepEqual(
+    parseArxivFeed("<entry><id>x</id></entry><entry><title>T</title></entry>"),
+    [{ title: "T", year: null }],
+  );
+});
+
+test("a two-letter token ending in s is depluralised to one letter, which spells no acronym", () => {
+  assert.equal(
+    titleRelation("TS models", "totally separate models"),
+    "different",
+  );
+});
+
+test("parseArxivFeed keeps an entry titled Error when it has no <id> to prove it is the sentinel", () => {
+  assert.deepEqual(parseArxivFeed("<entry><title>Error</title></entry>"), [
+    { title: "Error", year: null },
+  ]);
+});

package/src/adapters/banal/failure.test.ts

@@ -4,7 +4,12 @@
  */
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { describe, describeLine, PERL_MISSING } from "./failure.ts";
+import {
+  type BanalFailure,
+  describe,
+  describeLine,
+  PERL_MISSING,
+} from "./failure.ts";
 import { acceptProbe } from "./probe.ts";
 
 test("describe: perl missing carries the fix", () => {
@@ -61,3 +66,67 @@ test("acceptProbe: one page and a body size is accepted; anything else is `probe
   assert.equal(!r.ok && r.error.kind, "probe-rejected");
   assert.equal(acceptProbe({ pages: [], bodyfontsize: 10 }).ok, false);
 });
+
+test("describe: every other kind is one exact sentence", () => {
+  const cases: readonly [BanalFailure, string][] = [
+    [
+      { kind: "process-failed", status: 2, stderrHead: "boom" },
+      "banal failed (exit 2): boom",
+    ],
+    [
+      { kind: "signalled", signal: "SIGKILL", stderrHead: "" },
+      "banal failed (SIGKILL): no output",
+    ],
+    [
+      { kind: "signalled", signal: "SIGTERM", stderrHead: "late" },
+      "banal failed (SIGTERM): late",
+    ],
+    [{ kind: "spawn-failed", message: "EACCES" }, "banal failed: EACCES"],
+    [
+      { kind: "timed-out", afterMs: 500 },
+      "banal failed: no answer after 500 ms",
+    ],
+    [{ kind: "no-json", head: "" }, "banal printed no JSON: nothing"],
+    [{ kind: "no-json", head: "Usage:" }, "banal printed no JSON: Usage:"],
+    [
+      { kind: "banal-error", stderrHead: "bad xml" },
+      "banal could not read the banal input XML: bad xml",
+    ],
+    [
+      {
+        kind: "unexpected-shape",
+        issues: ["pages missing", "bodyfontsize not a number"],
+      },
+      "banal printed JSON that is not a measurement: pages missing; bodyfontsize not a number",
+    ],
+    [
+      { kind: "probe-rejected", got: { pages: [] } },
+      'banal ran on a one-page probe but measured nothing: {"pages":[]}',
+    ],
+    [
+      { kind: "download-failed", url: "https://x/banal", detail: "HTTP 404" },
+      "could not download banal from https://x/banal: HTTP 404",
+    ],
+    [
+      { kind: "not-pinned", path: "/c/banal" },
+      "banal in /c/banal is not the pinned one (sha256 differs)",
+    ],
+    [
+      {
+        kind: "does-not-run",
+        path: "/c/banal",
+        why: { kind: "timed-out", afterMs: 9 },
+      },
+      "banal in /c/banal does not run: banal failed: no answer after 9 ms",
+    ],
+  ];
+  for (const [failure, sentence] of cases)
+    assert.deepEqual(describe(failure), [sentence]);
+});
+
+test("describeLine: a sha256 mismatch joins its three lines", () => {
+  assert.equal(
+    describeLine({ kind: "sha-mismatch", url: "u", expected: "e", got: "g" }),
+    "banal from u does not have the pinned sha256 — refusing to install it; expected e; got      g",
+  );
+});

package/src/adapters/banal/index.test.ts

@@ -103,6 +103,22 @@ test("installer: ensure reports the download, and Ready says where and what was
   assert.equal(i.check().ok, true);
 });
 
+test("installer with no source: the pin is downloaded, and bytes that are not the pin are refused", () => {
+  const download = fixedDownload(BODY);
+  const io = memoryPorts({
+    run: scriptedProcess(() => exitedWith("")),
+    download,
+  });
+  const r = banalInstaller(io, parseBanalSettings({}, dirs)).ensure(() => {});
+  assert.ok(!r.ok);
+  assert.match(
+    r.error[0],
+    /does not have the pinned sha256 — refusing to install it/,
+  );
+  assert.equal(download.urls.length, 1);
+  assert.notEqual(download.urls[0], source.url);
+});
+
 test("installer: a failure is lines of text, the first saying what happened", () => {
   const io = memoryPorts({
     run: scriptedProcess(() => ({ kind: "not-found", file: "perl" })),

package/src/adapters/banal/output.test.ts

@@ -60,6 +60,11 @@ const ROWS: readonly (readonly [
     exited({ stdout: "Usage: banal" }),
     { kind: "no-json", head: "Usage: banal" },
   ],
+  [
+    "nothing on stdout: the head is stderr's first line",
+    exited({ stdout: "", stderr: "\nCan't locate XML/Parser.pm\n" }),
+    { kind: "no-json", head: "Can't locate XML/Parser.pm" },
+  ],
   [
     // Guards: banal's own failure object exits 0 — it must not read as zero pages.
     'banal\'s `"error": true` with exit 0',

package/src/adapters/curl/download.test.ts

@@ -16,7 +16,8 @@ import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { afterAll as after, test } from "vitest";
 import type { AbsolutePath } from "../../domain/paths.ts";
-import { curlDownload } from "./download.io.ts";
+import { curlDownload, curlFailure } from "./download.io.ts";
+import type { ProcessExit } from "../../ports/process.ts";
 import { spawnProcess } from "../node/index.ts";
 
 const root = realpathSync(
@@ -55,3 +56,44 @@ test("🔴 Download: no curl on PATH is named as that, not as a failed URL", ()
   // Guards: a missing curl is its own diagnosis — once, it read "spawnSync curl ENOENT".
   assert.deepEqual(!r.ok && r.error, { detail: "curl is not installed" });
 });
+
+test("curlFailure: every way curl can end, in its own words", () => {
+  const cases: readonly [ProcessExit, string | null][] = [
+    [{ kind: "exited", status: 0, stdout: "", stderr: "" }, null],
+    [{ kind: "spawn-failed", message: "EACCES" }, "EACCES"],
+    [
+      { kind: "timed-out", afterMs: 40_000, stdout: "", stderr: "" },
+      "no answer after 40000 ms",
+    ],
+    [{ kind: "exited", status: 22, stdout: "", stderr: "" }, "curl exited 22"],
+    [
+      {
+        kind: "exited",
+        status: 22,
+        stdout: "",
+        stderr: "curl: (22) 404\nmore",
+      },
+      "curl: (22) 404",
+    ],
+    [
+      { kind: "signalled", signal: "SIGTERM", stdout: "", stderr: "" },
+      "SIGTERM",
+    ],
+  ];
+  for (const [exit, words] of cases) assert.equal(curlFailure(exit), words);
+});
+
+test("Download: curl exits 0 and writes nothing — a failure that says so, not empty bytes", () => {
+  const tmp = at("dl-silent");
+  mkdirSync(tmp, { recursive: true });
+  const d = curlDownload({
+    run: { run: () => ({ kind: "exited", status: 0, stdout: "", stderr: "" }) },
+    env: {},
+    tmpDir: tmp,
+  });
+  assert.deepEqual(d.fetch("https://example.test/banal", 1_000), {
+    ok: false,
+    error: { detail: "curl wrote no file" },
+  });
+  assert.deepEqual(readdirSync(tmp), []);
+});

package/src/adapters/memory/index.test.ts

@@ -0,0 +1,25 @@
+/** The in-memory test doubles keep the contracts of the ports they stand in for. */
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { fixedDownload, memoryWorkspace } from "./index.ts";
+
+test("memoryWorkspace: a `within` that throws is recorded as `threw`, and the error goes on", () => {
+  const ws = memoryWorkspace();
+  assert.throws(
+    () =>
+      ws.within("x-", (s) => {
+        s.write("f", "body", "read");
+        throw new Error("inside");
+      }),
+    /inside/,
+  );
+  assert.deepEqual(ws.ended, ["threw"]);
+  assert.deepEqual(ws.written, [{ name: "f", content: "body", mode: "read" }]);
+});
+
+test("fixedDownload: bytes are handed back as they are, and every URL is recorded", () => {
+  const bytes = new Uint8Array([1, 2, 3]);
+  const d = fixedDownload(bytes);
+  assert.deepEqual(d.fetch("https://a", 1), { ok: true, value: bytes });
+  assert.deepEqual(d.urls, ["https://a"]);
+});

package/src/adapters/node/files.io.ts

@@ -11,7 +11,8 @@ import { dirname } from "node:path";
 import type { AbsolutePath } from "../../domain/paths.ts";
 import type { Files } from "../../ports/files.ts";
 
-const code = (e: unknown): unknown =>
+/** An error's errno code; anything thrown that is not an Error has none. */
+export const errorCode = (e: unknown): unknown =>
   e instanceof Error ? (e as NodeJS.ErrnoException).code : undefined;
 
 export const nodeFiles: Files = {
@@ -22,7 +23,7 @@ export const nodeFiles: Files = {
     try {
       return readFileSync(p);
     } catch (e) {
-      if (code(e) === "ENOENT") return null;
+      if (errorCode(e) === "ENOENT") return null;
       throw e;
     }
   },