js-zip-pipeline-integration-test-gitignored-fixture

Answer

The gap: parseCSV was unit-tested, but the JSZip→parseCSV pipeline had zero coverage — a ZIP-layer regression (wrong entry name, bad compression, corrupt archive) would pass silently. The real export data/sample-data.zip is gitignored (documented personal spend data), so it can't be a committed fixture. The fix pairs two complementary layers:

1. Always-on synthetic fixture — an in-memory ZIP built with JSZip.generateAsync (same API the browser exporter uses, same pinned version 3.10.1), exercising the full loadAsync → entry lookup → async("string") → parseCSV chain on every run.
2. Real-data assertions gated with it.runIf(existsSync) — runs only where the gitignored data/sample-data.zip exists (local), asserts the known 568 amount / 44 cost rows end-to-end, and is reported as skipped on a fresh checkout so CI stays green.

jszip@3.10.1 is a test-only devDependency (the browser uses the CDN copy), pinned to match it exactly — no production surface change, audit remains 0 vulns.

src/ingestZip.ts (the previously untested pipeline):

import JSZip from "jszip";
import { parseCSV, type Row } from "./parseCSV.js";

export interface IngestionResult { rows: Row[]; amounts: number; costs: number; }

export async function ingestZip(
  data: ArrayBuffer | Uint8Array,      // File.arrayBuffer() in browser; Buffer in tests
  entryName = "data.csv",
): Promise<IngestionResult> {
  const zip = await JSZip.loadAsync(data);
  const file = zip.file(entryName);
  if (!file) throw new Error(`ZIP missing expected entry "${entryName}"`);
  const rows = parseCSV(await file.async("string"));
  return {
    rows,
    amounts: rows.filter((r) => r.kind === "amount").length,
    costs:   rows.filter((r) => r.kind === "cost").length,
  };
}

test/ingestZip.integration.test.ts (the fix):

import { existsSync, readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import JSZip from "jszip";
import { ingestZip } from "../src/ingestZip.js";

const here = dirname(fileURLToPath(import.meta.url));
const REAL_FIXTURE = join(here, "..", "data", "sample-data.zip"); // gitignored
const REAL_EXPECTED = { amounts: 568, costs: 44 };

/** Always-on synthetic fixture — no gitignored file required. */
async function syntheticZip(): Promise<Buffer> {
  const zip = new JSZip();
  zip.file("data.csv", [
    "kind,date,amount,note",
    'amount,2025-01-02,12.50,"batch, cache"',   // quoted comma
    'cost,2025-01-03,0.90,"say ""hi"""',        // escaped quote
  ].join("\n"));
  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
}

describe("JSZip -> parseCSV pipeline (synthetic fixture, always on)", () => {
  it("round-trips: generateAsync -> loadAsync -> parseCSV", async () => {
    const result = await ingestZip(await syntheticZip());
    expect(result.amounts).toBe(1);
    expect(result.rows[0].note).toBe("batch, cache"); // quoting survived the ZIP
  });
  it("throws when the ZIP is missing the CSV entry", async () => {
    const zip = new JSZip(); zip.file("other.csv", "kind\n");
    await expect(ingestZip(await zip.generateAsync({ type: "nodebuffer" })))
      .rejects.toThrow(/missing expected entry "data.csv"/);
  });
  it("rejects corrupt archives instead of failing silently", async () => {
    await expect(ingestZip(Buffer.from("not a zip"))).rejects.toThrow();
  });
  it("accepts Uint8Array like the browser File path", async () => {
    const result = await ingestZip(new Uint8Array(await syntheticZip()));
    expect(result.amounts).toBe(1);
  });
});

describe("Real export data (gitignored fixture, local only)", () => {
  // CI (fresh checkout, no fixture): this test is *skipped*, not failed.
  it.runIf(existsSync(REAL_FIXTURE))(
    "end-to-end: 568 amount rows / 44 cost rows",
    async () => {
      const result = await ingestZip(readFileSync(REAL_FIXTURE));
      expect(result.amounts).toBe(REAL_EXPECTED.amounts);
      expect(result.costs).toBe(REAL_EXPECTED.costs);
      expect(new Set(result.rows.map((r) => r.kind)))
        .toEqual(new Set(["amount", "cost"]));
    },
  );
});

.gitignore documents the constraint so nobody "fixes" it into CI:

# Personal usage exports — local-only (private spend data).
# Tests needing it are gated behind it.runIf(existsSync).
data/sample-data.zip