thunderbird-patch-review

Easy-to-use patch review interface for Thunderbird

Contribute: ~marcc/thunderbird-review-plugin@lists.sr.ht

git clone git://mccd.space/thunderbird-patch-review

run.mjs (15025B)

 // Test runner for the pure extension modules (no Thunderbird required):
 //   node tests/run.mjs
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
   parseSubject,
   bodyLooksLikeDiff,
   isPatchMessage,
   sameSeries,
   isReplySubject,
 } from "../extension/modules/patch-detect.js";
 import { parsePatchEmail } from "../extension/modules/diff-parse.js";
 import { pairRanges, computeIntraline } from "../extension/modules/intraline.js";
 import { formatReview } from "../extension/modules/reply-format.js";
 import { locator, GENERAL } from "../extension/modules/review-store.js";
 import { dedupByIndex } from "../extension/modules/series.js";
 import {
   isSourcehutList,
   SOURCEHUT_STATUSES,
   STATUS_HEADER,
 } from "../extension/modules/sourcehut.js";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const fixture = (name) => readFileSync(join(here, "fixtures", name), "utf8");
 
 let failures = 0;
 function check(name, cond, extra = "") {
   if (cond) {
     console.log(`ok   ${name}`);
   } else {
     failures++;
     console.error(`FAIL ${name} ${extra}`);
   }
 }
 
 // --- parseSubject -----------------------------------------------------------
 
 {
   const s = parseSubject("[PATCH v2 3/7] net: fix socket leak");
   check("subject: n/m and version", s && s.n === 3 && s.m === 7 && s.version === 2);
   check("subject: title", s.title === "net: fix socket leak");
   check("subject: prefix", s.prefix === "PATCH");
 
   const rfc = parseSubject("Re: [RFC PATCH net-next 0/5] some series");
   check("subject: reply + RFC + cover", rfc && rfc.n === 0 && rfc.prefix === "RFC PATCH NET-NEXT");
 
   check("subject: bare [PATCH]", parseSubject("[PATCH] one-off fix").m === null);
   check("subject: non-patch", parseSubject("Meeting notes") === null);
   check("subject: PATCH word outside tag", parseSubject("please PATCH this") === null);
 }
 
 // --- sameSeries -------------------------------------------------------------
 
 {
   const a = parseSubject("[PATCH v2 1/3] socket: validate file descriptors");
   const b = parseSubject("[PATCH v2 3/3] assets: add icon");
   const c = parseSubject("[PATCH v3 1/3] socket: validate file descriptors");
   const d = parseSubject("[PATCH v2 1/4] other series");
   check("sameSeries: same v and m", sameSeries(a, b));
   check("sameSeries: different version", !sameSeries(a, c));
   check("sameSeries: different size", !sameSeries(a, d));
 }
 
 // --- detection --------------------------------------------------------------
 
 {
   check("diff detection: fixture", bodyLooksLikeDiff(fixture("patch1.body")));
   check("diff detection: prose", !bodyLooksLikeDiff("just words\nabout --- things\n"));
   check("isPatchMessage: tagged", isPatchMessage("[PATCH 1/2] x", fixture("patch1.body")));
   check("isPatchMessage: untagged diff", isPatchMessage("a fix", fixture("patch1.body")));
   check("isPatchMessage: cover letter", isPatchMessage("[PATCH 0/2] x", fixture("cover.body")));
   check("isPatchMessage: plain mail", !isPatchMessage("hello", "how are you?\n"));
 }
 
 // --- series dedup ----------------------------------------------------------
 
 {
   const mk = (n, date, hasDiff, id = `m${date}`) => ({
     header: { headerMessageId: id, date },
     info: n === null ? null : { n },
     body: "",
     hasDiff,
   });
 
   // A reply that shares the index but carries no diff must lose to the real
   // patch, even when the reply is newer (simulates a list that stripped Re:).
   const d = dedupByIndex([
     mk(1, 1000, true, "patch1"),
     mk(1, 2000, false, "reply1"), // newer, no diff
   ]);
   check("dedup: diff beats newer no-diff for n>0", d.get(1).header.headerMessageId === "patch1");
 
   // Two real patches (resend) with diffs: keep the newer one.
   const d2 = dedupByIndex([
     mk(2, 1000, true, "patch2v1"),
     mk(2, 2000, true, "patch2v2"),
   ]);
   check("dedup: newer diff wins among diffs", d2.get(2).header.headerMessageId === "patch2v2");
 
   // Cover letter (n=0): no diff on either, prefer the newer cover.
   const d3 = dedupByIndex([
     mk(0, 1000, false, "cover1"),
     mk(0, 2000, false, "cover2"),
   ]);
   check("dedup: cover keeps newer when no diff on either", d3.get(0).header.headerMessageId === "cover2");
 
   // Lone n (null index) keyed by message id does not collide.
   const d4 = dedupByIndex([mk(null, 1000, true, "solo")]);
   check("dedup: null-index keyed by id", d4.get("id:solo").header.headerMessageId === "solo");
 }
 
 // --- reply detection -------------------------------------------------------
 
 {
   check("reply: Re: prefix", isReplySubject("Re: [PATCH v2 3/7] net: fix socket leak"));
   check("reply: stacked Re:", isReplySubject("Re: Re: [PATCH] fix a bug"));
   check("reply: Aw/Fwd", isReplySubject("Fwd: [PATCH 0/2] cover") && isReplySubject("aw:[PATCH] x"));
   check("reply: case-insensitive and spaced", isReplySubject("re : [PATCH] x"));
   check("reply: bare patch is not a reply", !isReplySubject("[PATCH v2 3/7] net: fix socket leak"));
   check("reply: cover letter is not a reply", !isReplySubject("[PATCH 0/3] series intro"));
   // Patches whose title happens to start with the letters "Re" but no colon.
   check("reply: word 'Request' is not a reply", !isReplySubject("[PATCH] Request handling"));
 }
 
 // --- diff parsing -----------------------------------------------------------
 
 {
   const p = parsePatchEmail(fixture("patch1.body"));
   check("parse: one file", p.files.length === 1, `got ${p.files.length}`);
   check("parse: path", p.files[0].displayPath === "src/socket.c");
   check("parse: commit message", p.commitMessage.startsWith("Reject negative descriptors"));
   check("parse: diffstat", p.diffstat.includes("1 file changed"));
 
   const hunk = p.files[0].hunks[0];
   check("parse: single hunk", p.files[0].hunks.length === 1);
   check("parse: hunk counts", hunk.oldCount === 15 && hunk.newCount === 20);
 
   const firstAdd = hunk.lines.find((l) => l.origin === "add");
   check("parse: first addition", firstAdd.text === "#include <errno.h>");
   check("parse: new-line numbering", firstAdd.newLine === 2 && firstAdd.oldLine === null);
 
   const firstDel = hunk.lines.find((l) => l.origin === "del");
   check("parse: deletion numbering", firstDel.oldLine === 5 && firstDel.newLine === null);
 
   // Raw lines must round-trip exactly for quoting in replies.
   const start = hunk.lines[0].bodyLine;
   const rawSlice = p.bodyLines.slice(start, start + hunk.lines.length).join("\n");
   check("parse: raw round-trip", rawSlice === hunk.lines.map((l) => l.raw).join("\n"));
 }
 
 {
   const p = parsePatchEmail(fixture("patch2.body"));
   check("parse: new file flag", p.files[0].isNew);
   check("parse: new file path", p.files[0].displayPath === "src/log.c");
   check("parse: all lines added", p.files[0].hunks[0].lines.every((l) => l.origin === "add"));
 }
 
 {
   const p = parsePatchEmail(fixture("patch3.body"));
   check("parse: binary flag", p.files[0].isBinary, JSON.stringify(p.files[0]));
   check("parse: binary has no hunks", p.files[0].hunks.length === 0);
 }
 
 {
   const p = parsePatchEmail(fixture("cover.body"));
   check("parse: cover has no files", p.files.length === 0);
   check("parse: cover keeps text", p.commitMessage.length > 0);
 }
 
 {
   // Single-line commit message: the body starts directly at the scissors.
   // The commit message must be empty — never the diff (the review tab would
   // otherwise render the whole raw patch above the interactive diff).
   const body = [
     "---",
     " file.txt | 1 +",
     " 1 file changed, 1 insertion(+)",
     "",
     "diff --git a/file.txt b/file.txt",
     "index e69de29..8baef1b 100644",
     "--- a/file.txt",
     "+++ b/file.txt",
     "@@ -0,0 +1 @@",
     "+hello",
     "-- ",
     "2.45.0",
     "",
   ].join("\n");
   const p = parsePatchEmail(body);
   check("parse: scissors-first body has empty message", p.commitMessage === "");
   check("parse: scissors-first body still parses diff", p.files.length === 1);
   check("parse: scissors-first diffstat", p.diffstat.includes("1 file changed"));
 }
 
 {
   // git format-patch prepends an mbox-style header block to the body; the
   // UI renders author/subject separately, so the parser must drop that
   // block and keep only the real commit message.
   const body = [
     "From 0123456789abcdef0123456789abcdef01234567 Mon Sep 17 00:00:00 2001",
     "From: Author Name <author@example.com>",
     "Date: Thu, 1 Jan 2026 00:00:00 +0000",
     "Subject: [PATCH] fix a bug",
     "",
     "This is the actual commit message.",
     "",
     "---",
     " file.txt | 1 +",
     " 1 file changed, 1 insertion(+)",
     "",
     "diff --git a/file.txt b/file.txt",
     "index e69de29..8baef1b 100644",
     "--- a/file.txt",
     "+++ b/file.txt",
     "@@ -0,0 +1 @@",
     "+hello",
     "-- ",
     "2.45.0",
     "",
   ].join("\n");
   const p = parsePatchEmail(body);
   check("parse: format-patch header stripped", p.commitMessage === "This is the actual commit message.", JSON.stringify(p.commitMessage));
   check("parse: format-patch diff still parsed", p.files.length === 1);
 }
 
 // --- sourcehut detection ----------------------------------------------------
 
 {
   check(
     "sourcehut: recipient address form",
     isSourcehutList(["Marc <marc@coquand.email>", "~marc/patches@lists.sr.ht"])
   );
   check(
     "sourcehut: List-Id form",
     isSourcehutList(["~marc/patches <~marc/patches.lists.sr.ht>"])
   );
   check("sourcehut: case insensitive", isSourcehutList(["dev@LISTS.SR.HT"]));
   check(
     "sourcehut: other lists rejected",
     !isSourcehutList(["netdev.vger.kernel.org", "dev@lists.example.org"])
   );
   check("sourcehut: lookalike domain rejected", !isSourcehutList(["x@lists.sr.hteam.com"]));
   check("sourcehut: empty/missing values", !isSourcehutList([]) && !isSourcehutList([null, ""]));
   check(
     "sourcehut: all statuses present",
     ["PROPOSED", "NEEDS_REVISION", "SUPERSEDED", "APPROVED", "REJECTED", "APPLIED"].every((s) =>
       SOURCEHUT_STATUSES.includes(s)
     ) && SOURCEHUT_STATUSES.length === 6
   );
   check("sourcehut: header name", STATUS_HEADER === "X-Sourcehut-Patchset-Update");
 }
 
 // --- intra-line highlighting ------------------------------------------------
 
 {
   const mid = pairRanges("return value;", "return newvalue;");
   check("intraline: middle change", mid && mid.del[0] === 7 && mid.add[0] === 7);
   check(
     "intraline: add span text",
     "return newvalue;".slice(mid.add[0], mid.add[1]) === "new"
   );
   check("intraline: del span empty for insertion", mid.del[0] === mid.del[1]);
 
   const unrelated = pairRanges("int foo(void)", "#include <x.h>");
   check("intraline: unrelated lines skipped", unrelated === null);
 
   const lines = [
     { origin: "ctx", text: "a", raw: " a" },
     { origin: "del", text: "\tif (fd < 0)", raw: "-\tif (fd < 0)" },
     { origin: "del", text: "old line", raw: "-old line" },
     { origin: "add", text: "\tif (fd < 0) {", raw: "+\tif (fd < 0) {" },
     { origin: "add", text: "new line", raw: "+new line" },
     { origin: "ctx", text: "b", raw: " b" },
   ];
   const ranges = computeIntraline(lines);
   check("intraline: context untouched", ranges[0] === null && ranges[5] === null);
   check("intraline: pure suffix insertion skips del side", ranges[1] === null);
   check(
     "intraline: add side highlights suffix",
     ranges[3] && "\tif (fd < 0) {".slice(ranges[3].start, ranges[3].end) === " {"
   );
   check(
     "intraline: second pair highlights changed word",
     ranges[2] &&
       "old line".slice(ranges[2].start, ranges[2].end) === "old" &&
       ranges[4] &&
       "new line".slice(ranges[4].start, ranges[4].end) === "new"
   );
 }
 
 {
   // Real patch: "-\tif (fd < 0)" replaced by "+\tif (fd < 0) {" + more adds.
   const p = parsePatchEmail(fixture("patch1.body"));
   const hunk = p.files[0].hunks[0];
   const ranges = computeIntraline(hunk.lines);
   const del = hunk.lines.findIndex((l) => l.origin === "del");
   check("intraline: fixture del pairs with first add", ranges[del] === null);
   const add = hunk.lines.findIndex((l) => l.origin === "add" && l.text.endsWith("{"));
   check(
     "intraline: fixture add span",
     ranges[add] && hunk.lines[add].text.slice(ranges[add].start, ranges[add].end) === " {"
   );
 }
 
 // --- reply formatting -------------------------------------------------------
 
 {
   const p = parsePatchEmail(fixture("patch1.body"));
   const hunk = p.files[0].hunks[0];
   const target = hunk.lines.findIndex((l) => l.text === "#include <errno.h>");
   const later = hunk.lines.findIndex((l) => l.text.includes("errno = EBADF"));
 
   const comments = {
     [GENERAL]: { text: "Looks good overall, two nits." },
     [locator(0, 0, target)]: { text: "Is errno.h needed on all platforms?" },
     [locator(0, 0, later)]: { text: "EBADF or EINVAL here?" },
   };
   const reply = formatReview(p, comments);
 
   check("reply: general comment first", reply.startsWith("Looks good overall"));
   check("reply: quotes file header", reply.includes("> diff --git a/src/socket.c b/src/socket.c"));
   check("reply: quotes hunk header", reply.includes(`> ${hunk.header}`));
   check("reply: quotes target line", reply.includes("> +#include <errno.h>"));
   const quoted = reply.indexOf("> +#include <errno.h>");
   const comment = reply.indexOf("Is errno.h needed");
   check("reply: comment follows its line", quoted !== -1 && comment > quoted);
   const second = reply.indexOf("EBADF or EINVAL");
   check("reply: comment order", second > comment);
   check(
     "reply: unquoted comments",
     !reply.includes("> Is errno.h") && !reply.includes("> EBADF or EINVAL")
   );
 
   check("reply: empty without comments", formatReview(p, {}) === "");
 }
 
 // --- patchHost experiment wiring --------------------------------------------
 // The privileged code only runs inside Thunderbird, but the manifest glue
 // and the script's syntax can be checked here.
 
 {
   const root = join(here, "..", "extension");
   const manifest = JSON.parse(readFileSync(join(root, "manifest.json"), "utf8"));
   const experiment = (manifest.experiment_apis || {}).patchHost;
   check("experiment: declared in the manifest", Boolean(experiment));
   check(
     "experiment: nativeMessaging permission gone",
     !(manifest.permissions || []).includes("nativeMessaging")
   );
 
   const schema = JSON.parse(readFileSync(join(root, experiment.schema), "utf8"));
   const names = schema[0].functions.map((f) => f.name).sort().join(",");
   check("experiment: schema functions", names === "apply,describe,openEditor,pickDir,ping");
   check("experiment: schema functions async", schema[0].functions.every((f) => f.async));
 
   const source = readFileSync(join(root, experiment.parent.script), "utf8");
   let parses = true;
   try {
     new Function(source);
   } catch (e) {
     parses = false;
   }
   check("experiment: implementation parses", parses);
   check("experiment: defines the patchHost class", /\bvar patchHost\s*=/.test(source));
 }
 
 // --- summary ----------------------------------------------------------------
 
 if (failures) {
   console.error(`\n${failures} failure(s)`);
   process.exit(1);
 }
 console.log("\nall tests passed");