Skip to content

Spot it. Save it. Free, local-first Chrome extension for images, videos and prompts. Explore 2,000+ curated cases and connect your library to AI Agents via MCP. 提示词导演

7.1 KB
Raw Blame
import test from "node:test";
import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";

import {
  commitMetadataThenDeleteImages,
  replaceImagesWithRollback
} from "../extension/image-transaction.js";

test("metadata failure never deletes referenced images", async () => {
  const deleted = [];
  await assert.rejects(() => commitMetadataThenDeleteImages({
    imageIds: ["visual-one"],
    commitMetadata: async () => { throw new Error("storage unavailable"); },
    deleteImage: async (id) => deleted.push(id)
  }), /storage unavailable/);
  assert.deepEqual(deleted, []);
});

test("successful metadata commit is visible before image cleanup", async () => {
  const calls = [];
  const result = await commitMetadataThenDeleteImages({
    imageIds: ["visual-one", "visual-one", "visual-two"],
    commitMetadata: async () => calls.push("metadata"),
    deleteImage: async (id) => calls.push(`delete:${id}`)
  });
  assert.equal(calls[0], "metadata");
  assert.deepEqual(new Set(result.deletedIds), new Set(["visual-one", "visual-two"]));
  assert.deepEqual(result.failedIds, []);
});

test("large cleanup can delete all unreferenced images in one storage transaction", async () => {
  const calls = [];
  const result = await commitMetadataThenDeleteImages({
    imageIds: ["one", "two", "one"],
    commitMetadata: async () => calls.push("metadata"),
    deleteImages: async (ids) => calls.push(`bulk:${ids.join(",")}`)
  });
  assert.deepEqual(calls, ["metadata", "bulk:one,two"]);
  assert.deepEqual(result, { deletedIds: ["one", "two"], failedIds: [] });
});

test("image replacements roll back when metadata commit fails", async () => {
  const images = new Map([
    ["existing", new Blob(["old"], { type: "image/webp" })]
  ]);
  await assert.rejects(() => replaceImagesWithRollback({
    replacements: replacements([
      ["existing", new Blob(["new"], { type: "image/webp" })],
      ["new-id", new Blob(["new-id"], { type: "image/webp" })]
    ]),
    readImage: async (id) => images.get(id) ?? null,
    writeImage: async (id, blob) => images.set(id, blob),
    deleteImage: async (id) => images.delete(id),
    commitMetadata: async () => { throw new Error("metadata failed"); }
  }), /metadata failed/);
  assert.equal(await images.get("existing").text(), "old");
  assert.equal(images.has("new-id"), false);
});

test("a replacement stream failure rolls back images already staged", async () => {
  const original = new Blob(["old"], { type: "image/webp" });
  const images = new Map([["existing", original]]);
  async function* failingReplacements() {
    yield { id: "existing", blob: new Blob(["new"], { type: "image/webp" }) };
    throw new Error("remote object damaged");
  }
  await assert.rejects(() => replaceImagesWithRollback({
    replacements: failingReplacements(),
    readImage: async (id) => images.get(id) ?? null,
    writeImage: async (id, blob) => images.set(id, blob),
    deleteImage: async (id) => images.delete(id),
    commitMetadata: async () => undefined
  }), /remote object damaged/);
  assert.equal(await images.get("existing").text(), "old");
});

test("a failed image write also restores the image it may have partially replaced", async () => {
  const oldBlob = new Blob(["old"], { type: "image/webp" });
  const images = new Map([["existing", oldBlob]]);
  let firstWrite = true;
  await assert.rejects(() => replaceImagesWithRollback({
    replacements: replacements([["existing", new Blob(["new"], { type: "image/webp" })]]),
    readImage: async (id) => images.get(id) ?? null,
    writeImage: async (id, blob) => {
      images.set(id, blob);
      if (firstWrite) {
        firstWrite = false;
        throw new Error("disk write interrupted");
      }
    },
    deleteImage: async (id) => images.delete(id),
    commitMetadata: async () => undefined
  }), /disk write interrupted/);
  assert.equal(await images.get("existing").text(), "old");
});

async function* replacements(values) {
  for (const [id, blob] of values) yield { id, blob };
}

test("case deletion retains blobs in trash while creative-output deletion still uses metadata-first cleanup", async () => {
  const source = await readFile(new URL("../extension/background.js", import.meta.url), "utf8");
  const caseStart = source.indexOf("async function deleteEntry(entryId)");
  const caseBlock = source.slice(caseStart, source.indexOf("async function deleteCollectionWithEntries", caseStart));
  assert.match(caseBlock, /moveEntryBatchToTrash/);
  assert.doesNotMatch(caseBlock, /deleteMediaBlob|deleteScreenshotBlob|commitMetadataThenDeleteImages/);

  const outputStart = source.indexOf("async function deleteCreativeOutput(message)");
  const outputBlock = source.slice(outputStart, source.indexOf("async function analyzeCreativeOutput", outputStart));
  assert.match(outputBlock, /commitMetadataThenDeleteImages/);
  assert.doesNotMatch(outputBlock, /await deleteScreenshotBlob/);
});

test("external Skill deletion commits metadata before cleaning package files", async () => {
  const source = await readFile(new URL("../extension/background.js", import.meta.url), "utf8");
  const start = source.indexOf("async function deleteCreativeSkillAction(skillId)");
  const block = source.slice(start, source.indexOf("async function getComposerSession", start));
  assert.ok(block.indexOf("await commitLocalChanges") < block.indexOf("await deleteUnreferencedMedia"));
  assert.match(block, /await deleteUnreferencedMedia\(skillPackageAssetIds\(result\.skill\)\)\.catch/);
});

test("page capture never deletes committed media when a post-commit action fails", async () => {
  const source = await readFile(new URL("../extension/background.js", import.meta.url), "utf8");
  const start = source.indexOf("async function commitPageCapture(");
  const block = source.slice(start, source.indexOf("async function startCaptureForCase", start));
  assert.match(block, /metadataCommitted = true/);
  assert.match(block, /if \(!metadataCommitted\) \{[\s\S]*?await progress\.release\?\.\(savedAssetIds\);[\s\S]*?await deleteUnreferencedMedia\(savedAssetIds\)/);
  assert.ok(block.indexOf("metadataCommitted = true") < block.indexOf("await notifySaved"));
});

test("temporary composer assets are tracked before derived data can fail", async () => {
  const source = await readFile(new URL("../extension/composer-page.js", import.meta.url), "utf8");
  const start = source.indexOf("async function addTempReferences");
  const block = source.slice(start, source.indexOf("async function removeTempReference", start));
  assert.ok(block.indexOf("await stage.register([assetId])") >= 0);
  assert.ok(block.indexOf("await stage.register([assetId])") < block.indexOf("await saveMediaBlob"));
  assert.doesNotMatch(block, /deleteMediaBlobs/);
});

test("creative video posters roll back only before their metadata commit", async () => {
  const source = await readFile(new URL("../extension/background.js", import.meta.url), "utf8");
  const start = source.indexOf("async function saveCreativeOutputToLibrary");
  const block = source.slice(start, source.indexOf("async function updateCreativeSignal", start));
  assert.match(block, /posterAssetId = posterId/);
  assert.match(block, /if \(posterAssetId && !metadataCommitted\)/);
});