test(ooxml.js): work toward a 100% mutation score

packages/ooxml.js/src/compact.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import {
+  CompactXmlNodeSchema,
   decodeCompactPackage,
   decodePackage,
   encodeCompactPackage,
@@ -8,7 +9,7 @@ import {
   toCompact,
   zipPackage,
 } from "./index";
-import type { Package, XmlElement } from "./index";
+import type { CompactPackage, Package, XmlElement } from "./index";
 
 function enc(s: string): Uint8Array<ArrayBuffer> {
   return new TextEncoder().encode(s);
@@ -179,6 +180,109 @@ describe("compact size", () => {
   });
 });
 
+describe("isCompactXmlNode (via CompactXmlNodeSchema)", () => {
+  it("rejects a non-array value", () => {
+    expect(CompactXmlNodeSchema.safeParse("nope").success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse({ 0: 1, 1: 0 }).success).toBe(false);
+  });
+
+  it("accepts a text/cdata/comment node ([1|2|3, number])", () => {
+    expect(CompactXmlNodeSchema.safeParse([1, 0]).success).toBe(true);
+    expect(CompactXmlNodeSchema.safeParse([2, 0]).success).toBe(true);
+    expect(CompactXmlNodeSchema.safeParse([3, 0]).success).toBe(true);
+  });
+
+  it("rejects a text/cdata/comment node with the wrong tuple length", () => {
+    expect(CompactXmlNodeSchema.safeParse([1, 0, 0]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([2, 0, 0]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([3, 0, 0]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([1]).success).toBe(false);
+  });
+
+  it("rejects a text/cdata/comment node whose value slot is not a number", () => {
+    expect(CompactXmlNodeSchema.safeParse([1, "x"]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([2, "x"]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([3, "x"]).success).toBe(false);
+  });
+
+  it("accepts a declaration node ([4, attrPairs])", () => {
+    expect(CompactXmlNodeSchema.safeParse([4, [0, 1]]).success).toBe(true);
+    expect(CompactXmlNodeSchema.safeParse([4, []]).success).toBe(true);
+  });
+
+  it("rejects a declaration node with the wrong tuple length", () => {
+    expect(CompactXmlNodeSchema.safeParse([4, [0, 1], 9]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([4]).success).toBe(false);
+  });
+
+  it("rejects a declaration node whose attr pairs are not a valid CompactAttrPairs", () => {
+    expect(CompactXmlNodeSchema.safeParse([4, "not-an-array"]).success).toBe(
+      false,
+    );
+    expect(CompactXmlNodeSchema.safeParse([4, [0, "x"]]).success).toBe(false);
+  });
+
+  it("accepts a pi node ([5, number, number])", () => {
+    expect(CompactXmlNodeSchema.safeParse([5, 0, 1]).success).toBe(true);
+  });
+
+  it("rejects a pi node with the wrong tuple length", () => {
+    expect(CompactXmlNodeSchema.safeParse([5, 0]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([5, 0, 1, 2]).success).toBe(false);
+  });
+
+  it("rejects a pi node whose target or content slot is not a number", () => {
+    expect(CompactXmlNodeSchema.safeParse([5, "x", 1]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([5, 0, "x"]).success).toBe(false);
+  });
+
+  it("accepts an element node ([0, tag, attrPairs, children])", () => {
+    expect(CompactXmlNodeSchema.safeParse([0, 0, [], []]).success).toBe(true);
+    expect(
+      CompactXmlNodeSchema.safeParse([0, 0, [1, 2], [[1, 0]]]).success,
+    ).toBe(true);
+  });
+
+  it("rejects an element node with the wrong tuple length", () => {
+    expect(CompactXmlNodeSchema.safeParse([0, 0, [], [], 9]).success).toBe(
+      false,
+    );
+    expect(CompactXmlNodeSchema.safeParse([0, 0, []]).success).toBe(false);
+  });
+
+  it("rejects an element node whose tag slot is not a number", () => {
+    expect(CompactXmlNodeSchema.safeParse([0, "x", [], []]).success).toBe(
+      false,
+    );
+  });
+
+  it("rejects an element node whose attr pairs are not a valid CompactAttrPairs", () => {
+    expect(
+      CompactXmlNodeSchema.safeParse([0, 0, "not-an-array", []]).success,
+    ).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([0, 0, [0, "x"], []]).success).toBe(
+      false,
+    );
+  });
+
+  it("rejects an element node whose children slot is not an array", () => {
+    expect(
+      CompactXmlNodeSchema.safeParse([0, 0, [], "not-an-array"]).success,
+    ).toBe(false);
+  });
+
+  it("rejects an element node whose children are not all valid compact nodes", () => {
+    expect(
+      CompactXmlNodeSchema.safeParse([0, 0, [], [["not-a-node"]]]).success,
+    ).toBe(false);
+  });
+
+  it("rejects an unrecognised leading type code, even one that happens to satisfy the element-shape checks", () => {
+    expect(CompactXmlNodeSchema.safeParse([9]).success).toBe(false);
+    expect(CompactXmlNodeSchema.safeParse([9, 0, [], []]).success).toBe(false);
+  });
+});
+
 describe("compact adversarial cases", () => {
   it("round-trips an empty Package", () => {
     const pkg: Package = { parts: {} };
@@ -217,6 +321,56 @@ describe("compact adversarial cases", () => {
     expect(fromCompact(toCompact(pkg))).toEqual(pkg);
   });
 
+  it("round-trips a cdata node", () => {
+    const pkg: Package = {
+      parts: {
+        "word/document.xml": {
+          kind: "xml",
+          nodes: [{ type: "cdata", value: "<raw> & unescaped" }],
+        },
+      },
+    };
+    expect(fromCompact(toCompact(pkg))).toEqual(pkg);
+  });
+
+  it("round-trips a processing-instruction node", () => {
+    const pkg: Package = {
+      parts: {
+        "word/document.xml": {
+          kind: "xml",
+          nodes: [
+            {
+              type: "pi",
+              target: "mso-application",
+              content: 'progid="Word.Document"',
+            },
+          ],
+        },
+      },
+    };
+    expect(fromCompact(toCompact(pkg))).toEqual(pkg);
+  });
+
+  it("throws with the out-of-range string index when a string-table lookup fails", () => {
+    const cpkg: CompactPackage = {
+      s: [],
+      p: { "word/document.xml": [[1, 5]] },
+    };
+    expect(() => fromCompact(cpkg)).toThrow(
+      "fromCompact: string table index 5 is out of range",
+    );
+  });
+
+  it("throws when an attribute index-pairs array has odd length", () => {
+    const cpkg: CompactPackage = {
+      s: ["name-only"],
+      p: { "word/document.xml": [[4, [0]]] },
+    };
+    expect(() => fromCompact(cpkg)).toThrow(
+      "fromCompact: attribute index pairs array has odd length",
+    );
+  });
+
   it("round-trips a large base64 binary part as a single interned string", () => {
     const largeBase64 = Buffer.from(new Uint8Array(64 * 1024).fill(7)).toString(
       "base64",

packages/ooxml.js/src/image/sniff.test.ts

@@ -1,27 +1,102 @@
 import { describe, expect, it } from "vitest";
 import { sniffImageFormat } from "./sniff";
 
-// Ported verbatim from documents.js's src/image/sniff.test.ts.
-describe("sniffImageFormat", () => {
-  it("recognises a PNG signature", () => {
-    expect(
-      sniffImageFormat(
-        new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0, 0]),
-      ),
-    ).toBe("png");
+function enc(s: string): number[] {
+  return Array.from(new TextEncoder().encode(s));
+}
+
+describe("sniffImageFormat: PNG", () => {
+  it("detects a genuine PNG signature", () => {
+    const bytes = new Uint8Array([
+      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3,
+    ]);
+    expect(sniffImageFormat(bytes)).toBe("png");
+  });
+
+  it("does not match a truncated PNG signature (shorter than the real one)", () => {
+    const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    expect(sniffImageFormat(bytes)).toBeUndefined();
+  });
+
+  it("does not match bytes that agree with the PNG signature's prefix but diverge partway through", () => {
+    const bytes = new Uint8Array([
+      0x89, 0x50, 0x4e, 0x47, 0x00, 0x0a, 0x1a, 0x0a,
+    ]);
+    expect(sniffImageFormat(bytes)).toBeUndefined();
+  });
+});
+
+describe("sniffImageFormat: JPEG", () => {
+  it("detects a genuine JPEG signature", () => {
+    expect(sniffImageFormat(new Uint8Array([0xff, 0xd8, 0xff, 0xe0]))).toBe(
+      "jpeg",
+    );
   });
 
-  it("recognises a JPEG signature", () => {
+  it("does not match a signature that diverges on the final byte", () => {
     expect(
-      sniffImageFormat(new Uint8Array([0xff, 0xd8, 0xff, 0xe0, 0, 0])),
-    ).toBe("jpeg");
+      sniffImageFormat(new Uint8Array([0xff, 0xd8, 0x00])),
+    ).toBeUndefined();
+  });
+});
+
+describe("sniffImageFormat: GIF", () => {
+  it("detects the GIF87a signature", () => {
+    const bytes = new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 1, 2]);
+    expect(sniffImageFormat(bytes)).toBe("gif");
+  });
+
+  it("detects the GIF89a signature", () => {
+    const bytes = new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 1, 2]);
+    expect(sniffImageFormat(bytes)).toBe("gif");
   });
 
-  it("returns undefined for unrecognised bytes", () => {
-    expect(sniffImageFormat(new Uint8Array([1, 2, 3, 4]))).toBeUndefined();
+  it("does not match a GIF-like prefix that diverges on the version byte", () => {
+    const bytes = new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x30, 0x61]);
+    expect(sniffImageFormat(bytes)).toBeUndefined();
   });
+});
+
+describe("sniffImageFormat: SVG", () => {
+  it("detects an SVG that opens directly with the root <svg> tag", () => {
+    const bytes = new Uint8Array(enc('<svg xmlns="x"><path/></svg>'));
+    expect(sniffImageFormat(bytes)).toBe("svg");
+  });
+
+  it("detects an SVG whose root tag is preceded by an XML prolog", () => {
+    const bytes = new Uint8Array(
+      enc('<?xml version="1.0"?><svg xmlns="x"></svg>'),
+    );
+    expect(sniffImageFormat(bytes)).toBe("svg");
+  });
+
+  it("detects an SVG whose root/prolog is preceded by leading whitespace", () => {
+    const bytes = new Uint8Array(enc('   \n\t<svg xmlns="x"></svg>'));
+    expect(sniffImageFormat(bytes)).toBe("svg");
+  });
+
+  it("does not detect an SVG signature in plain, unrelated text", () => {
+    const bytes = new Uint8Array(enc("just some text, not a document"));
+    expect(sniffImageFormat(bytes)).toBeUndefined();
+  });
+
+  it("does not detect an SVG signature in an empty byte array", () => {
+    expect(sniffImageFormat(new Uint8Array([]))).toBeUndefined();
+  });
+
+  it("only sniffs the leading 1024-byte window, never a '<svg' tag that appears only later in a longer document", () => {
+    // 2000 bytes of non-SVG filler, with a real '<svg' root tag starting well past the 1024-byte sniff window: the real function must never find it there.
+    const filler = new Uint8Array(2000).fill(0x2e); // '.'
+    const svgTail = enc("<svg xmlns='x'></svg>");
+    const bytes = new Uint8Array(2000 + svgTail.length);
+    bytes.set(filler, 0);
+    bytes.set(svgTail, 1500);
+    expect(sniffImageFormat(bytes)).toBeUndefined();
+  });
+});
 
-  it("returns undefined for bytes shorter than the shortest signature", () => {
-    expect(sniffImageFormat(new Uint8Array([0xff, 0xd8]))).toBeUndefined();
+describe("sniffImageFormat: no format recognised", () => {
+  it("returns undefined for bytes matching none of the known signatures", () => {
+    expect(sniffImageFormat(new Uint8Array([1, 2, 3, 4, 5]))).toBeUndefined();
   });
 });

packages/ooxml.js/src/image/sniff.ts

@@ -12,13 +12,11 @@ const GIF89A_SIGNATURE: readonly number[] = [
   0x47, 0x49, 0x46, 0x38, 0x39, 0x61,
 ];
 
+// No separate length guard needed: bytes[i] is `undefined` for any index at or past bytes.length (an out-of-range read never throws), and undefined can never equal a real signature byte value -- so bytes shorter than the signature already fail this loop's own comparison at the first index past their own end.
 function startsWith(
   bytes: Uint8Array<ArrayBuffer>,
   signature: readonly number[],
 ): boolean {
-  if (bytes.length < signature.length) {
-    return false;
-  }
   for (let i = 0; i < signature.length; i++) {
     if (bytes[i] !== signature[i]) {
       return false;
@@ -31,7 +29,8 @@ function startsWith(
 const SVG_SNIFF_WINDOW = 1024;
 
 function looksLikeSvg(bytes: Uint8Array<ArrayBuffer>): boolean {
-  const window = bytes.subarray(0, Math.min(bytes.length, SVG_SNIFF_WINDOW));
+  // No Math.min against bytes.length needed: subarray's own end argument is clamped to the array's length regardless of what is asked for, so requesting SVG_SNIFF_WINDOW bytes from a shorter buffer already yields only the bytes that exist.
+  const window = bytes.subarray(0, SVG_SNIFF_WINDOW);
   let text = "";
   for (const byte of window) {
     text += String.fromCharCode(byte);