test: add tests for new zipStream fs

Author: Hweinstock

packages/core/src/shared/utilities/zipStream.ts

@@ -110,17 +110,16 @@ export class ZipStream {
         return this._zipWriter.add(path, new TextReader(data))
     }
 
-    // TODO: add tests for this.
     public writeData(data: Uint8Array, path: string) {
         return this._zipWriter.add(path, new Uint8ArrayReader(data))
     }
 
     /**
      * Add the content for file to zip at path.
-     * @param file file to read
-     * @param path path to write data to in zip.
+     * @param sourceFilePath file to read
+     * @param targetFilePath path to write data to in zip.
      */
-    public writeFile(file: string, path: string) {
+    public writeFile(sourceFilePath: string, targetFilePath: string) {
         // We use _numberOfFilesToStream to make sure we don't finalize too soon
         // (before the progress event has been fired for the last file)
         // The problem is that we can't rely on progress.entries.total,
@@ -131,15 +130,15 @@ export class ZipStream {
         // We only start zipping another file if we're under our limit
         // of concurrent file streams
         if (this._filesBeingZipped < this._maxNumberOfFileStreams) {
-            void readFileAsString(file).then((content) => {
-                return this._zipWriter.add(path, new TextReader(content), {
+            void readFileAsString(sourceFilePath).then((content) => {
+                return this._zipWriter.add(targetFilePath, new TextReader(content), {
                     onend: this.boundFileCompletionCallback,
                     onstart: this.boundFileStartCallback,
                 })
             })
         } else {
             // Queue it for later (see "write" event)
-            this._filesToZip.push([file, path])
+            this._filesToZip.push([sourceFilePath, targetFilePath])
         }
     }
 
@@ -166,7 +165,6 @@ export class ZipStream {
         }
     }
 
-    // TODO: add tests for this.
     public async finalizeToFile(targetPath: string) {
         const result = await this.finalize()
         const contents = result.streamBuffer.getContents() || Buffer.from('')

packages/core/src/test/shared/utilities/zipStream.test.ts

@@ -21,7 +21,7 @@ describe('zipStream', function () {
         await fs.delete(tmpDir, { recursive: true })
     })
 
-    it('Should create a zip stream from text content', async function () {
+    it('should create a zip stream from text content', async function () {
         const zipStream = new ZipStream({ hashAlgorithm: 'md5' })
         await zipStream.writeString('foo bar', 'file.txt')
         const result = await zipStream.finalize()
@@ -39,7 +39,29 @@ describe('zipStream', function () {
         assert.strictEqual(result.sizeInBytes, (await fs.stat(zipPath)).size)
     })
 
-    it('Should create a zip stream from file', async function () {
+    it('should create a zip stream from binary content', async function () {
+        const zipStream = new ZipStream({ hashAlgorithm: 'md5' })
+        await zipStream.writeData(Buffer.from('foo bar'), 'file.txt')
+        const result = await zipStream.finalize()
+
+        const zipBuffer = result.streamBuffer.getContents()
+        assert.ok(zipBuffer)
+
+        const zipPath = path.join(tmpDir, 'test.zip')
+        await fs.writeFile(zipPath, zipBuffer)
+        const expectedMd5 = crypto
+            .createHash('md5')
+            .update(await fs.readFileBytes(zipPath))
+            .digest('base64')
+        assert.strictEqual(result.hash, expectedMd5)
+        assert.strictEqual(result.sizeInBytes, (await fs.stat(zipPath)).size)
+
+        const zipContents = await ZipStream.unzip(zipBuffer)
+        assert.strictEqual(zipContents.length, 1)
+        assert.strictEqual(zipContents[0].filename, 'file.txt')
+    })
+
+    it('should create a zip stream from file', async function () {
         const testFilePath = path.join(tmpDir, 'test.txt')
         await fs.writeFile(testFilePath, 'foo bar')
 
@@ -71,4 +93,14 @@ describe('zipStream', function () {
         const zipEntries = await ZipStream.unzip(zipBuffer)
         assert.strictEqual(zipEntries[0].filename, 'file.txt')
     })
+
+    it('should write contents to file', async function () {
+        const zipStream = new ZipStream()
+        await zipStream.writeString('foo bar', 'file.txt')
+        await zipStream.writeData(Buffer.from('foo bar'), 'file2.txt')
+        const zipPath = path.join(tmpDir, 'test.zip')
+        const result = await zipStream.finalizeToFile(path.join(tmpDir, 'test.zip'))
+
+        assert.strictEqual(result.sizeInBytes, (await fs.stat(zipPath)).size)
+    })
 })