Do not rely on external zip tool in tests

Author: davidje13

src/extras/filesystem/readZip.mts

@@ -151,6 +151,9 @@ export async function readZip(source: string): Promise<ZipDirectory> {
         continue;
       }
       const localHeader = await getFilePart(localHeaderOffset, 30);
+      if (read32BE(localHeader, 0) !== 0x504b0304) {
+        throw new ZipError(`invalid local header for ${fileName}`);
+      }
       const localNameLength = read16LE(localHeader, 26);
       const localExraLength = read16LE(localHeader, 28);
       const localHeaderSize = 30 + localNameLength + localExraLength;

src/extras/filesystem/zipFileFinder.test.mts

@@ -1,9 +1,7 @@
-import { spawn } from 'node:child_process';
-import { rm } from 'node:fs/promises';
 import { join, sep } from 'node:path';
 import {
-  makeFileStructure,
   makeTestTempDir,
+  writeTestZip,
   type FilesDefinition,
 } from '../../test-helpers/makeFileStructure.mts';
 import { Negotiator } from '../request/Negotiator.mts';
@@ -23,24 +21,9 @@ describe('zipFileFinder', () => {
     options: FileFinderOptions = {},
     relativePath: string[] = [],
   ) => {
-    const dir = ctx.getTyped(TEST_DIR);
-    await makeFileStructure(dir, { content: structure });
-    await new Promise<void>((resolve, reject) => {
-      const p = spawn('zip', ['-X', '-r', '-n', '.gz:.deflate', join('..', 'all.zip'), '.'], {
-        cwd: join(dir, 'content'),
-        stdio: ['ignore', 'ignore', 'inherit'],
-      });
-      p.once('error', reject);
-      p.once('exit', (code, signal) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(code ?? signal);
-        }
-      });
-    });
-    await rm(join(dir, 'content'), { recursive: true });
-    const root = await readZip(join(dir, 'all.zip'));
+    const zipPath = join(ctx.getTyped(TEST_DIR), 'all.zip');
+    await writeTestZip(zipPath, structure);
+    const root = await readZip(zipPath);
     return zipFileFinder(root.find(relativePath) as ZipDirectory, options);
   };
 

src/test-helpers/makeFileStructure.mts

@@ -1,6 +1,8 @@
 import { tmpdir } from 'node:os';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { deflateRawSync } from 'node:zlib';
+import { constants, mkdir, mkdtemp, open, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { Queue } from '../util/Queue.mts';
 import 'lean-test';
 
 export type FilesDefinition = { [k in string]: string | FilesDefinition };
@@ -37,3 +39,92 @@ export async function makeFileStructure(dir: string, structure: FilesDefinition)
     }
   }
 }
+
+export async function writeTestZip(path: string, structure: FilesDefinition) {
+  // this writes enough data for readZip to understand the contents
+  // in particular, it does not write the modification time, permission flags, or crc32
+
+  const cdItems: {
+    filename: Buffer;
+    pos: number;
+    compression: number;
+    compressedSize: number;
+    uncompressedSize: number;
+  }[] = [];
+  const handle = await open(path, constants.O_CREAT | constants.O_WRONLY);
+  try {
+    const stream = handle.createWriteStream();
+    let pos = 0;
+
+    const queue = new Queue({ path: [] as string[], structure });
+    for (const { path, structure } of queue) {
+      for (const [name, content] of Object.entries(structure)) {
+        const itemPath = [...path, name];
+        let compressed = VOID;
+        let uncompressedSize = 0;
+        let compression = 0;
+        let filename: Buffer;
+        if (typeof content === 'string') {
+          filename = Buffer.from(itemPath.join('/'), 'utf-8');
+          const uncompressed = Buffer.from(content, 'utf-8');
+          uncompressedSize = uncompressed.byteLength;
+          if (uncompressedSize < 20) {
+            compressed = uncompressed;
+          } else {
+            compressed = deflateRawSync(uncompressed);
+            compression = 8;
+          }
+        } else {
+          queue.push({ path: itemPath, structure: content });
+          filename = Buffer.from(itemPath.join('/') + '/', 'utf-8');
+        }
+        cdItems.push({
+          filename,
+          pos,
+          compression,
+          compressedSize: compressed.byteLength,
+          uncompressedSize,
+        });
+        const localFileHeader = Buffer.alloc(30);
+        localFileHeader.writeUint32BE(0x504b0304, 0);
+        localFileHeader.writeUint16LE(20, 4);
+        localFileHeader[6] = 0x40;
+        localFileHeader.writeUint16LE(compression, 8);
+        localFileHeader.writeUint32LE(compressed.byteLength, 18);
+        localFileHeader.writeUint32LE(uncompressedSize, 22);
+        localFileHeader.writeUint16LE(filename.byteLength, 26);
+        stream.write(localFileHeader);
+        stream.write(filename);
+        stream.write(compressed);
+        pos += localFileHeader.byteLength + filename.byteLength + compressed.byteLength;
+      }
+    }
+
+    const cdPos = pos;
+    for (const item of cdItems) {
+      const cdFileHeader = Buffer.alloc(46);
+      cdFileHeader.writeUint32BE(0x504b0102, 0);
+      cdFileHeader.writeUint16LE(20, 6);
+      cdFileHeader[8] = 0x40;
+      cdFileHeader.writeUint16LE(item.compression, 10);
+      cdFileHeader.writeUint32LE(item.compressedSize, 20);
+      cdFileHeader.writeUint32LE(item.uncompressedSize, 24);
+      cdFileHeader.writeUint16LE(item.filename.byteLength, 28);
+      cdFileHeader.writeUint32LE(item.pos, 42);
+      stream.write(cdFileHeader);
+      stream.write(item.filename);
+      pos += cdFileHeader.byteLength + item.filename.byteLength;
+    }
+    const eocd = Buffer.alloc(22);
+    eocd.writeUint32BE(0x504b0506, 0);
+    eocd.writeUint16LE(cdItems.length, 8);
+    eocd.writeUint16LE(cdItems.length, 10);
+    eocd.writeUint32LE(pos - cdPos, 12);
+    eocd.writeUint32LE(cdPos, 16);
+    stream.write(eocd);
+  } finally {
+    await handle.close();
+  }
+}
+
+const VOID = Buffer.alloc(0);