Checkpoint web parity through Chromium input tasks

web/tests/unit/library-archive-cancellation.test.mjs

@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import test from "node:test";
+import ts from "typescript";
+
+const root = path.resolve(import.meta.dirname, "../../..");
+const temporary = fs.mkdtempSync(path.join(os.tmpdir(), "library-archive-cancellation-unit-"));
+const sourcePath = path.join(root, "web/protocol/archive-extraction-transaction.ts");
+const transpiled = ts.transpileModule(fs.readFileSync(sourcePath, "utf8"), {
+  compilerOptions: { module: ts.ModuleKind.ES2022, target: ts.ScriptTarget.ES2022 },
+  fileName: sourcePath,
+  reportDiagnostics: true,
+});
+assert.deepEqual(transpiled.diagnostics, []);
+fs.writeFileSync(path.join(temporary, "archive-extraction-transaction.mjs"), transpiled.outputText);
+const extraction = await import(pathToFileURL(path.join(temporary, "archive-extraction-transaction.mjs")));
+const manifest = JSON.parse(fs.readFileSync(path.join(root, "tests/golden/M12-04H/manifest.json"), "utf8"));
+const fileSha256 = (file) => crypto.createHash("sha256").update(fs.readFileSync(path.join(root, file))).digest("hex");
+const bytesSha256 = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
+
+class DirectoryExtractionStorage {
+  constructor(directory, committed) {
+    this.directory = directory;
+    this.committed = committed;
+    fs.mkdirSync(path.join(directory, "committed"), { recursive: true });
+    fs.writeFileSync(path.join(directory, "committed", "project.blend"), Buffer.from("old-project"));
+  }
+
+  async readCommitted() { return { ...this.committed }; }
+
+  async createStaging(transactionId) {
+    fs.mkdirSync(path.join(this.directory, "staging", transactionId), { recursive: true });
+  }
+
+  async writeStaging(transactionId, entryPath, bytes) {
+    const target = path.join(this.directory, "staging", transactionId, entryPath);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, bytes);
+  }
+
+  async countStagingEntries(transactionId) {
+    const staging = path.join(this.directory, "staging", transactionId);
+    if (!fs.existsSync(staging)) return 0;
+    const visit = (directory) => fs.readdirSync(directory, { withFileTypes: true }).reduce(
+      (count, entry) => count + (entry.isDirectory() ? visit(path.join(directory, entry.name)) : 1), 0,
+    );
+    return visit(staging);
+  }
+
+  async discardStaging(transactionId) {
+    const count = await this.countStagingEntries(transactionId);
+    fs.rmSync(path.join(this.directory, "staging", transactionId), { recursive: true, force: true });
+    return count;
+  }
+
+  async commitStaging(transactionId, expected, candidate) {
+    assert.deepEqual(this.committed, expected);
+    const source = path.join(this.directory, "staging", transactionId, "project.blend");
+    const target = path.join(this.directory, "committed", "project.blend");
+    fs.renameSync(source, target);
+    await this.discardStaging(transactionId);
+    this.committed = { ...candidate };
+    return { ...this.committed };
+  }
+}
+
+const oldBytes = Buffer.from("old-project");
+const newBytes = Buffer.from("new-project");
+const metadataBytes = Buffer.from("metadata");
+const committed = { projectId: "project:m12-04h", revision: 8, sha256: bytesSha256(oldBytes) };
+const candidate = { projectId: committed.projectId, revision: 9, sha256: bytesSha256(newBytes) };
+const request = {
+  schemaVersion: 1,
+  transactionId: "transaction:m12-04h",
+  archiveId: "archive:m12-04h",
+  committed,
+  candidate,
+  entries: [
+    { path: "metadata/index.json", uncompressedBytes: metadataBytes.byteLength, sha256: bytesSha256(metadataBytes) },
+    { path: "project.blend", uncompressedBytes: newBytes.byteLength, sha256: bytesSha256(newBytes) },
+  ],
+};
+
+function createStorage(name) {
+  const directory = path.join(temporary, name);
+  fs.mkdirSync(directory, { recursive: true });
+  return new DirectoryExtractionStorage(directory, committed);
+}
+
+test("M12-04H binds cancellation rollback and evidence artifacts", () => {
+  assert.equal(manifest.task, "M12-04H");
+  assert.equal(manifest.parentTask, "M12-04G");
+  assert.equal(manifest.nextTask, "M12-04I");
+  for (const artifact of Object.values(manifest.artifacts)) assert.equal(fileSha256(artifact.path), artifact.sha256, artifact.path);
+});
+
+test("M12-04H removes partially written staging and preserves the committed project on cancellation", async () => {
+  const storage = createStorage("cancel-after-write");
+  const controller = new AbortController();
+  let reads = 0;
+  const receipt = await extraction.runArchiveExtractionTransaction(request, storage, async (entry) => {
+    reads++;
+    if (reads === 2) controller.abort();
+    return entry.path === "project.blend" ? newBytes : metadataBytes;
+  }, controller.signal);
+  assert.deepEqual(receipt, {
+    status: "CANCELLED",
+    code: "IO_ARCHIVE_CANCELLED",
+    transactionId: request.transactionId,
+    committedBefore: committed,
+    committedAfter: committed,
+    removedStagingEntries: 1,
+    stagingEntriesAfter: 0,
+    publishedProjects: 0,
+  });
+  assert.equal(fs.readFileSync(path.join(storage.directory, "committed", "project.blend"), "utf8"), "old-project");
+  assert.equal(await storage.countStagingEntries(request.transactionId), 0);
+});
+
+test("M12-04H cancels before staging and after the last staged write without publishing", async () => {
+  const beforeStorage = createStorage("cancel-before-stage");
+  const beforeController = new AbortController();
+  beforeController.abort();
+  const before = await extraction.runArchiveExtractionTransaction(request, beforeStorage, async () => newBytes, beforeController.signal);
+  assert.equal(before.status, "CANCELLED");
+  assert.equal(before.removedStagingEntries, 0);
+
+  const finalStorage = createStorage("cancel-after-last-write");
+  const finalController = new AbortController();
+  const originalWrite = finalStorage.writeStaging.bind(finalStorage);
+  finalStorage.writeStaging = async (transactionId, entryPath, bytes) => {
+    await originalWrite(transactionId, entryPath, bytes);
+    if (entryPath === "project.blend") finalController.abort();
+  };
+  const after = await extraction.runArchiveExtractionTransaction(request, finalStorage, async (entry) =>
+    entry.path === "project.blend" ? newBytes : metadataBytes, finalController.signal);
+  assert.equal(after.status, "CANCELLED");
+  assert.equal(after.removedStagingEntries, 2);
+  assert.deepEqual(await finalStorage.readCommitted(), committed);
+  assert.equal(fs.readFileSync(path.join(finalStorage.directory, "committed", "project.blend"), "utf8"), "old-project");
+});
+
+test("M12-04H commits only after all staged payloads pass identity checks", async () => {
+  const storage = createStorage("commit");
+  const receipt = await extraction.runArchiveExtractionTransaction(request, storage, async (entry) =>
+    entry.path === "project.blend" ? newBytes : metadataBytes, new AbortController().signal);
+  assert.deepEqual(receipt, {
+    status: "COMMITTED",
+    transactionId: request.transactionId,
+    committed: candidate,
+    stagingEntriesAfter: 0,
+  });
+  assert.equal(fs.readFileSync(path.join(storage.directory, "committed", "project.blend"), "utf8"), "new-project");
+});
+
+test("M12-04H cleans staging on payload failure and detects rollback identity drift", async () => {
+  const failedStorage = createStorage("payload-failure");
+  await assert.rejects(
+    extraction.runArchiveExtractionTransaction(request, failedStorage, async () => Buffer.from("wrong"), new AbortController().signal),
+    { code: "ASSET_SOURCE_HASH_MISMATCH" },
+  );
+  assert.equal(await failedStorage.countStagingEntries(request.transactionId), 0);
+  assert.deepEqual(await failedStorage.readCommitted(), committed);
+
+  const driftStorage = createStorage("rollback-drift");
+  const originalDiscard = driftStorage.discardStaging.bind(driftStorage);
+  driftStorage.discardStaging = async (transactionId) => {
+    const removed = await originalDiscard(transactionId);
+    driftStorage.committed = { ...committed, revision: committed.revision + 1 };
+    return removed;
+  };
+  const controller = new AbortController();
+  await assert.rejects(
+    extraction.runArchiveExtractionTransaction(request, driftStorage, async (entry) => {
+      const bytes = entry.path === "project.blend" ? newBytes : metadataBytes;
+      queueMicrotask(() => controller.abort());
+      return bytes;
+    }, controller.signal),
+    { code: "STORAGE_TRANSACTION" },
+  );
+});
+
+test("M12-04H rejects stale commits, non-canonical paths, prefix conflicts, and undeclared fields", async () => {
+  const storage = createStorage("invalid-requests");
+  await assert.rejects(
+    extraction.runArchiveExtractionTransaction({ ...request, committed: { ...committed, revision: 7 } }, storage, async () => newBytes, new AbortController().signal),
+    { code: "REVISION_CONFLICT" },
+  );
+  for (const unsafePath of ["../project.blend", "C:/project.blend", "https:project.blend", "dir\\project.blend"]) {
+    await assert.rejects(
+      extraction.runArchiveExtractionTransaction({ ...request, entries: [{ ...request.entries[0], path: unsafePath }] }, storage, async () => metadataBytes, new AbortController().signal),
+      { code: "IO_ARCHIVE_UNSAFE" },
+    );
+  }
+  await assert.rejects(
+    extraction.runArchiveExtractionTransaction({ ...request, entries: [request.entries[0], { ...request.entries[1], path: "metadata" }] }, storage, async () => metadataBytes, new AbortController().signal),
+    { code: "IO_ARCHIVE_UNSAFE" },
+  );
+  await assert.rejects(
+    extraction.runArchiveExtractionTransaction({ ...request, future: true }, storage, async () => newBytes, new AbortController().signal),
+    { code: "IO_ARCHIVE_UNSAFE" },
+  );
+});
+
+test.after(() => fs.rmSync(temporary, { recursive: true, force: true }));