Merge pull request #296 from keycloakify/introduce-yazl

Introduce-yazl

test/bin/jar.spec.ts

@@ -1,26 +1,86 @@
-import jar from "keycloakify/bin/tools/jar";
-import { it, describe, vi } from "vitest";
+import { jarStream, type ZipEntryGenerator } from "keycloakify/bin/tools/jar";
+import { fromBuffer, Entry, ZipFile } from "yauzl";
+import { it, describe, assert } from "vitest";
+import { Readable } from "stream";
 
-vi.mock("fs", () => ({ promises: { mkdir: () => {} }, createWriteStream: () => {} }));
-vi.mock("stream", async () => {
-    const readableMock = () => {
-        const mockDecorators = {
-            on: () => mockDecorators,
-            pipe: () => mockDecorators
-        };
-        return {
-            from: () => mockDecorators
-        };
-    };
+type AsyncIterable<T> = {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+};
+
+async function arrayFromAsync<T>(asyncIterable: AsyncIterable<T>) {
+    const chunks: T[] = [];
+    for await (const chunk of asyncIterable) chunks.push(chunk);
+    return chunks;
+}
+
+async function readToBuffer(stream: NodeJS.ReadableStream) {
+    return Buffer.concat(await arrayFromAsync(stream as AsyncIterable<Buffer>));
+}
+
+function unzip(buffer: Buffer) {
+    return new Promise<ZipFile>((resolve, reject) =>
+        fromBuffer(buffer, { lazyEntries: true }, (err, zipFile) => {
+            if (err !== null) {
+                reject(err);
+            } else {
+                resolve(zipFile);
+            }
+        })
+    );
+}
+
+function readEntry(zipFile: ZipFile, entry: Entry): Promise<Readable> {
+    return new Promise<Readable>((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, stream) => {
+            if (err !== null) {
+                reject(err);
+            } else {
+                resolve(stream);
+            }
+        });
+    });
+}
+
+function readAll(zipFile: ZipFile): Promise<Map<string, Buffer>> {
+    return new Promise<Map<string, Buffer>>((resolve, reject) => {
+        const entries1: Map<string, Buffer> = new Map();
+        zipFile.on("entry", async (entry: Entry) => {
+            const stream = await readEntry(zipFile, entry);
+            const buffer = await readToBuffer(stream);
+            entries1.set(entry.fileName, buffer);
+            zipFile.readEntry();
+        });
+        zipFile.on("end", () => resolve(entries1));
+        zipFile.on("error", e => reject(e));
+        zipFile.readEntry();
+    });
+}
 
-    return {
-        // @ts-ignore
-        ...(await vi.importActual("stream")),
-        Readable: readableMock()
-    };
-});
 describe("jar", () => {
-    it("creates jar artifacts without error", () => {
-        jar({ artifactId: "artifactId", groupId: "groupId", rootPath: "rootPath", targetPath: "targetPath", version: "1.0.0" });
+    it("creates jar artifacts without error", async () => {
+        async function* mockFiles(): ZipEntryGenerator {
+            yield { zipPath: "foo", buffer: Buffer.from("foo") };
+        }
+
+        const opts = { artifactId: "someArtifactId", groupId: "someGroupId", version: "1.2.3", asyncPathGeneratorFn: mockFiles };
+        const zipped = await jarStream(opts);
+        const buffered = await readToBuffer(zipped.outputStream);
+        const unzipped = await unzip(buffered);
+        const entries = await readAll(unzipped);
+
+        assert.equal(entries.size, 3);
+        assert.isOk(entries.has("foo"));
+        assert.isOk(entries.has("META-INF/MANIFEST.MF"));
+        assert.isOk(entries.has("META-INF/maven/someGroupId/someArtifactId/pom.properties"));
+
+        assert.equal("foo", entries.get("foo")?.toString("utf-8"));
+
+        const manifest = entries.get("META-INF/MANIFEST.MF")?.toString("utf-8");
+        const pomProperties = entries.get("META-INF/maven/someGroupId/someArtifactId/pom.properties")?.toString("utf-8");
+
+        assert.isOk(manifest?.includes("Created-By: Keycloakify"));
+        assert.isOk(pomProperties?.includes("1.2.3"));
+        assert.isOk(pomProperties?.includes("someGroupId"));
+        assert.isOk(pomProperties?.includes("someArtifactId"));
     });
 });