@appium/support 2.55.0 → 2.55.4

package/build/test/zip-e2e-specs.js

@@ -0,0 +1,233 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var zip = _interopRequireWildcard(require("../lib/zip"));
+
+var _index = require("../lib/index");
+
+var _helpers = require("./helpers");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+describe('#zip', function () {
+  const optionMap = new Map([['native JS unzip', {}], ['system unzip', {
+    useSystemUnzip: true
+  }]]);
+  optionMap.forEach((options, desc) => {
+    describe(desc, function () {
+      let assetsPath;
+      let zippedFilePath;
+      let tmpRoot;
+      beforeEach(async function () {
+        assetsPath = await _index.tempDir.openDir();
+        tmpRoot = await _index.tempDir.openDir();
+        const zippedBase64 = 'UEsDBAoAAAAAALlzk0oAAAAAAAAAAAAAAAAJABAAdW56aXBwZWQvVVgMANBO+VjO1vdY9QEUAFBLAwQKAAAAAADAc5NKAAAAAAAAAAAAAAAAEgAQAHVuemlwcGVkL3Rlc3QtZGlyL1VYDADQTvlY19b3WPUBFABQSwMEFAAIAAgAwnOTSgAAAAAAAAAAAAAAABcAEAB1bnppcHBlZC90ZXN0LWRpci9hLnR4dFVYDACDTvlY3Nb3WPUBFADzSM3JyVcIzy/KSQEAUEsHCFaxF0oNAAAACwAAAFBLAwQUAAgACADEc5NKAAAAAAAAAAAAAAAAFwAQAHVuemlwcGVkL3Rlc3QtZGlyL2IudHh0VVgMAINO+Vjf1vdY9QEUAHPLz1dwSiwCAFBLBwhIfrZJCQAAAAcAAABQSwECFQMKAAAAAAC5c5NKAAAAAAAAAAAAAAAACQAMAAAAAAAAAABA7UEAAAAAdW56aXBwZWQvVVgIANBO+VjO1vdYUEsBAhUDCgAAAAAAwHOTSgAAAAAAAAAAAAAAABIADAAAAAAAAAAAQO1BNwAAAHVuemlwcGVkL3Rlc3QtZGlyL1VYCADQTvlY19b3WFBLAQIVAxQACAAIAMJzk0pWsRdKDQAAAAsAAAAXAAwAAAAAAAAAAECkgXcAAAB1bnppcHBlZC90ZXN0LWRpci9hLnR4dFVYCACDTvlY3Nb3WFBLAQIVAxQACAAIAMRzk0pIfrZJCQAAAAcAAAAXAAwAAAAAAAAAAECkgdkAAAB1bnppcHBlZC90ZXN0LWRpci9iLnR4dFVYCACDTvlY39b3WFBLBQYAAAAABAAEADEBAAA3AQAAAAA=';
+        zippedFilePath = _path.default.resolve(tmpRoot, 'zipped.zip');
+        await _index.fs.writeFile(zippedFilePath, zippedBase64, 'base64');
+        await zip.extractAllTo(zippedFilePath, assetsPath, options);
+      });
+      afterEach(async function () {
+        for (const tmpPath of [assetsPath, tmpRoot]) {
+          if (!(await _index.fs.exists(tmpPath))) {
+            continue;
+          }
+
+          await _index.fs.rimraf(tmpPath);
+        }
+      });
+      describe('extractAllTo()', function () {
+        it('should extract contents of a .zip file to a directory', async function () {
+          await _index.fs.readFile(_path.default.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Hello World');
+          await _index.fs.readFile(_path.default.resolve(assetsPath, 'unzipped', 'test-dir', 'b.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Foo Bar');
+        });
+      });
+      describe('assertValidZip', function () {
+        it('should not throw an error if a valid ZIP file is passed', async function () {
+          await zip.assertValidZip(zippedFilePath).should.eventually.be.fulfilled;
+        });
+        it('should throw an error if the file does not exist', async function () {
+          await zip.assertValidZip('blabla').should.eventually.be.rejected;
+        });
+        it('should throw an error if the file is invalid', async function () {
+          await zip.assertValidZip(_path.default.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt')).should.eventually.be.rejected;
+        });
+      });
+      describe('readEntries()', function () {
+        const expectedEntries = [{
+          name: 'unzipped/'
+        }, {
+          name: 'unzipped/test-dir/'
+        }, {
+          name: 'unzipped/test-dir/a.txt',
+          contents: 'Hello World'
+        }, {
+          name: 'unzipped/test-dir/b.txt',
+          contents: 'Foo Bar'
+        }];
+        it('should iterate entries (directories and files) of zip file', async function () {
+          let i = 0;
+          await zip.readEntries(zippedFilePath, async ({
+            entry,
+            extractEntryTo
+          }) => {
+            entry.fileName.should.equal(expectedEntries[i].name);
+
+            if (expectedEntries[i].contents) {
+              await extractEntryTo(tmpRoot);
+              await _index.fs.readFile(_path.default.resolve(tmpRoot, entry.fileName), {
+                flags: 'r',
+                encoding: 'utf8'
+              }).should.eventually.equal(expectedEntries[i].contents);
+            }
+
+            i++;
+          });
+        });
+        it('should stop iterating zipFile if onEntry callback returns false', async function () {
+          let i = 0;
+          await zip.readEntries(zippedFilePath, async () => {
+            i++;
+            return false;
+          });
+          i.should.equal(1);
+        });
+        it('should be rejected if it uses a non-zip file', async function () {
+          let promise = zip.readEntries(_path.default.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt'), async () => {});
+          await promise.should.eventually.be.rejected;
+        });
+      });
+      describe('toInMemoryZip()', function () {
+        it('should convert a local file to an in-memory zip buffer', async function () {
+          const testFolder = _path.default.resolve(assetsPath, 'unzipped');
+
+          const buffer = await zip.toInMemoryZip(testFolder);
+          Buffer.isBuffer(buffer).should.be.true;
+          await _index.fs.writeFile(_path.default.resolve(tmpRoot, 'test.zip'), buffer);
+          await zip.extractAllTo(_path.default.resolve(tmpRoot, 'test.zip'), _path.default.resolve(tmpRoot, 'output'), {
+            fileNamesEncoding: 'utf8'
+          });
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Hello World');
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Foo Bar');
+        });
+        it('should convert a local folder to an in-memory base64-encoded zip buffer', async function () {
+          const testFolder = _path.default.resolve(assetsPath, 'unzipped');
+
+          const buffer = await zip.toInMemoryZip(testFolder, {
+            encodeToBase64: true
+          });
+          await _index.fs.writeFile(_path.default.resolve(tmpRoot, 'test.zip'), Buffer.from(buffer.toString(), 'base64'));
+          await zip.extractAllTo(_path.default.resolve(tmpRoot, 'test.zip'), _path.default.resolve(tmpRoot, 'output'));
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Hello World');
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Foo Bar');
+        });
+        it('should be rejected if use a bad path', async function () {
+          await zip.toInMemoryZip(_path.default.resolve(assetsPath, 'bad_path')).should.be.rejectedWith(/no such/i);
+        });
+        it('should be rejected if max size is exceeded', async function () {
+          const testFolder = _path.default.resolve(assetsPath, 'unzipped');
+
+          await zip.toInMemoryZip(testFolder, {
+            maxSize: 1
+          }).should.be.rejectedWith(/must not be greater/);
+        });
+      });
+      describe('_extractEntryTo()', function () {
+        let entry, mockZipFile, mockZipStream;
+        beforeEach(async function () {
+          entry = {
+            fileName: _path.default.resolve(await _index.tempDir.openDir(), 'temp', 'file')
+          };
+          mockZipStream = new _helpers.MockReadWriteStream();
+          mockZipFile = {
+            openReadStream: (entry, cb) => cb(null, mockZipStream)
+          };
+        });
+        it('should be rejected if zip stream emits an error', async function () {
+          mockZipStream.pipe = () => {
+            mockZipStream.emit('error', new Error('zip stream error'));
+          };
+
+          await zip._extractEntryTo(mockZipFile, entry).should.be.rejectedWith('zip stream error');
+        });
+        it('should be rejected if write stream emits an error', async function () {
+          mockZipStream.pipe = writeStream => {
+            writeStream.emit('error', new Error('write stream error'));
+            mockZipStream.end();
+            writeStream.end();
+          };
+
+          await zip._extractEntryTo(mockZipFile, entry).should.be.rejectedWith('write stream error');
+        });
+      });
+      describe('toArchive', function () {
+        it('should zip all files into an archive', async function () {
+          const testFolder = _path.default.resolve(assetsPath, 'unzipped');
+
+          const dstPath = _path.default.resolve(tmpRoot, 'test.zip');
+
+          await zip.toArchive(dstPath, {
+            cwd: testFolder
+          });
+          await zip.extractAllTo(dstPath, _path.default.resolve(tmpRoot, 'output'));
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Hello World');
+          await _index.fs.readFile(_path.default.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {
+            encoding: 'utf8'
+          }).should.eventually.equal('Foo Bar');
+        });
+      });
+    });
+  });
+  describe('unicode filename handling', function () {
+    let zippedFilePath, assetsPath, tmpRoot;
+    beforeEach(async function () {
+      assetsPath = await _index.tempDir.openDir();
+      tmpRoot = await _index.tempDir.openDir();
+      const zippedBase64 = 'UEsDBBQACAAIABF8/EYAAAAAAAAAABoAAAATACAAa2Fuamkt5q2j5LiW5LiVLmFwcFVUDQAHAgO4VVpX+GBZV/hgdXgLAAEE9QEAAAQUAAAAK8nILFYAorz8EoWi1MScnEqFxDyFxIICLgBQSwcIR93jPhoAAAAaAAAAUEsBAhQDFAAIAAgAEXz8Rkfd4z4aAAAAGgAAABMAIAAAAAAAAAAAAKSBAAAAAGthbmppLeato+S4luS4lS5hcHBVVA0ABwIDuFVaV/hgWVf4YHV4CwABBPUBAAAEFAAAAFBLBQYAAAAAAQABAGEAAAB7AAAAAAA=';
+      zippedFilePath = _path.default.resolve(tmpRoot, 'zipped.zip');
+      await _index.fs.writeFile(zippedFilePath, zippedBase64, 'base64');
+      await zip.extractAllTo(zippedFilePath, assetsPath, {
+        useSystemUnzip: true
+      });
+    });
+    afterEach(async function () {
+      for (const tmpPath of [assetsPath, tmpRoot]) {
+        if (!(await _index.fs.exists(tmpPath))) {
+          continue;
+        }
+
+        await _index.fs.rimraf(tmpPath);
+      }
+    });
+    it('should retain the proper filenames', async function () {
+      const expectedPath = _path.default.join(assetsPath, 'kanji-正世丕.app');
+
+      if (!(await _index.fs.exists(expectedPath))) {
+        throw new chai.AssertionError(`Expected ${expectedPath} to exist, but it does not`);
+      }
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/zip-e2e-specs.js"],"names":["describe","optionMap","Map","useSystemUnzip","forEach","options","desc","assetsPath","zippedFilePath","tmpRoot","beforeEach","tempDir","openDir","zippedBase64","path","resolve","fs","writeFile","zip","extractAllTo","afterEach","tmpPath","exists","rimraf","it","readFile","encoding","should","eventually","equal","assertValidZip","be","fulfilled","rejected","expectedEntries","name","contents","i","readEntries","entry","extractEntryTo","fileName","flags","promise","testFolder","buffer","toInMemoryZip","Buffer","isBuffer","true","fileNamesEncoding","encodeToBase64","from","toString","rejectedWith","maxSize","mockZipFile","mockZipStream","MockReadWriteStream","openReadStream","cb","pipe","emit","Error","_extractEntryTo","writeStream","end","dstPath","toArchive","cwd","expectedPath","join","chai","AssertionError"],"mappings":"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","sourcesContent":["import path from 'path';\nimport * as zip from '../lib/zip';\nimport { tempDir, fs } from '../lib/index';\nimport { MockReadWriteStream } from './helpers';\n\n\ndescribe('#zip', function () {\n\n  const optionMap = new Map([['native JS unzip', {}], ['system unzip', {useSystemUnzip: true}]]);\n\n  optionMap.forEach((options, desc) => {\n    describe(desc, function () {\n      let assetsPath;\n      let zippedFilePath;\n      let tmpRoot;\n\n      beforeEach(async function () {\n        assetsPath = await tempDir.openDir();\n        tmpRoot = await tempDir.openDir();\n        const zippedBase64 = 'UEsDBAoAAAAAALlzk0oAAAAAAAAAAAAAAAAJABAAdW56aXBwZWQvVVgMANBO+VjO1vdY9QEUAFBLAwQKAAAAAADAc5NKAAAAAAAAAAAAAAAAEgAQAHVuemlwcGVkL3Rlc3QtZGlyL1VYDADQTvlY19b3WPUBFABQSwMEFAAIAAgAwnOTSgAAAAAAAAAAAAAAABcAEAB1bnppcHBlZC90ZXN0LWRpci9hLnR4dFVYDACDTvlY3Nb3WPUBFADzSM3JyVcIzy/KSQEAUEsHCFaxF0oNAAAACwAAAFBLAwQUAAgACADEc5NKAAAAAAAAAAAAAAAAFwAQAHVuemlwcGVkL3Rlc3QtZGlyL2IudHh0VVgMAINO+Vjf1vdY9QEUAHPLz1dwSiwCAFBLBwhIfrZJCQAAAAcAAABQSwECFQMKAAAAAAC5c5NKAAAAAAAAAAAAAAAACQAMAAAAAAAAAABA7UEAAAAAdW56aXBwZWQvVVgIANBO+VjO1vdYUEsBAhUDCgAAAAAAwHOTSgAAAAAAAAAAAAAAABIADAAAAAAAAAAAQO1BNwAAAHVuemlwcGVkL3Rlc3QtZGlyL1VYCADQTvlY19b3WFBLAQIVAxQACAAIAMJzk0pWsRdKDQAAAAsAAAAXAAwAAAAAAAAAAECkgXcAAAB1bnppcHBlZC90ZXN0LWRpci9hLnR4dFVYCACDTvlY3Nb3WFBLAQIVAxQACAAIAMRzk0pIfrZJCQAAAAcAAAAXAAwAAAAAAAAAAECkgdkAAAB1bnppcHBlZC90ZXN0LWRpci9iLnR4dFVYCACDTvlY39b3WFBLBQYAAAAABAAEADEBAAA3AQAAAAA=';\n        zippedFilePath = path.resolve(tmpRoot, 'zipped.zip');\n        await fs.writeFile(zippedFilePath, zippedBase64, 'base64');\n        await zip.extractAllTo(zippedFilePath, assetsPath, options);\n      });\n\n      afterEach(async function () {\n        for (const tmpPath of [assetsPath, tmpRoot]) {\n          if (!await fs.exists(tmpPath)) {\n            continue;\n          }\n          await fs.rimraf(tmpPath);\n        }\n      });\n\n      describe('extractAllTo()', function () {\n        it('should extract contents of a .zip file to a directory', async function () {\n          await fs.readFile(path.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt'), {encoding: 'utf8'}).should.eventually.equal('Hello World');\n          await fs.readFile(path.resolve(assetsPath, 'unzipped', 'test-dir', 'b.txt'), {encoding: 'utf8'}).should.eventually.equal('Foo Bar');\n        });\n      });\n\n      describe('assertValidZip', function () {\n        it('should not throw an error if a valid ZIP file is passed', async function () {\n          await zip.assertValidZip(zippedFilePath).should.eventually.be.fulfilled;\n        });\n        it('should throw an error if the file does not exist', async function () {\n          await zip.assertValidZip('blabla').should.eventually.be.rejected;\n        });\n        it('should throw an error if the file is invalid', async function () {\n          await zip.assertValidZip(path.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt')).should.eventually.be.rejected;\n        });\n      });\n\n      describe('readEntries()', function () {\n        const expectedEntries = [\n          {name: 'unzipped/'},\n          {name: 'unzipped/test-dir/'},\n          {name: 'unzipped/test-dir/a.txt', contents: 'Hello World'},\n          {name: 'unzipped/test-dir/b.txt', contents: 'Foo Bar'},\n        ];\n\n        it('should iterate entries (directories and files) of zip file', async function () {\n          let i = 0;\n          await zip.readEntries(zippedFilePath, async ({entry, extractEntryTo}) => {\n            entry.fileName.should.equal(expectedEntries[i].name);\n\n            // If it's a file, test that we can extract it to a temporary directory and that the contents are correct\n            if (expectedEntries[i].contents) {\n              await extractEntryTo(tmpRoot);\n              await fs.readFile(path.resolve(tmpRoot, entry.fileName), {\n                flags: 'r',\n                encoding: 'utf8'\n              }).should.eventually.equal(expectedEntries[i].contents);\n            }\n            i++;\n          });\n        });\n\n        it('should stop iterating zipFile if onEntry callback returns false', async function () {\n          let i = 0;\n          await zip.readEntries(zippedFilePath, async () => { // eslint-disable-line require-await\n            i++;\n            return false;\n          });\n          i.should.equal(1);\n        });\n\n        it('should be rejected if it uses a non-zip file', async function () {\n          let promise = zip.readEntries(path.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt'), async () => {});\n          await promise.should.eventually.be.rejected;\n        });\n      });\n\n      describe('toInMemoryZip()', function () {\n        it('should convert a local file to an in-memory zip buffer', async function () {\n          // Convert directory to in-memory buffer\n          const testFolder = path.resolve(assetsPath, 'unzipped');\n          const buffer = await zip.toInMemoryZip(testFolder);\n          Buffer.isBuffer(buffer).should.be.true;\n\n          // Write the buffer to a zip file\n          await fs.writeFile(path.resolve(tmpRoot, 'test.zip'), buffer);\n\n          // Unzip the file and test that it has the same contents as the directory that was zipped\n          await zip.extractAllTo(path.resolve(tmpRoot, 'test.zip'), path.resolve(tmpRoot, 'output'), {\n            fileNamesEncoding: 'utf8'\n          });\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Hello World');\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Foo Bar');\n        });\n\n        it('should convert a local folder to an in-memory base64-encoded zip buffer', async function () {\n          const testFolder = path.resolve(assetsPath, 'unzipped');\n          const buffer = await zip.toInMemoryZip(testFolder, {\n            encodeToBase64: true,\n          });\n\n          await fs.writeFile(path.resolve(tmpRoot, 'test.zip'), Buffer.from(buffer.toString(), 'base64'));\n\n          // Unzip the file and test that it has the same contents as the directory that was zipped\n          await zip.extractAllTo(path.resolve(tmpRoot, 'test.zip'), path.resolve(tmpRoot, 'output'));\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Hello World');\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Foo Bar');\n        });\n\n        it('should be rejected if use a bad path', async function () {\n          await zip.toInMemoryZip(path.resolve(assetsPath, 'bad_path'))\n            .should.be.rejectedWith(/no such/i);\n        });\n\n        it('should be rejected if max size is exceeded', async function () {\n          const testFolder = path.resolve(assetsPath, 'unzipped');\n          await zip.toInMemoryZip(testFolder, {\n            maxSize: 1,\n          }).should.be.rejectedWith(/must not be greater/);\n        });\n      });\n\n      describe('_extractEntryTo()', function () {\n        let entry, mockZipFile, mockZipStream;\n        beforeEach(async function () {\n          entry = {fileName: path.resolve(await tempDir.openDir(), 'temp', 'file')};\n          mockZipStream = new MockReadWriteStream();\n          mockZipFile = {\n            openReadStream: (entry, cb) => cb(null, mockZipStream), // eslint-disable-line promise/prefer-await-to-callbacks\n          };\n        });\n\n        it('should be rejected if zip stream emits an error', async function () {\n          mockZipStream.pipe = () => {\n            mockZipStream.emit('error', new Error('zip stream error'));\n          };\n          await zip._extractEntryTo(mockZipFile, entry).should.be.rejectedWith('zip stream error');\n        });\n\n        it('should be rejected if write stream emits an error', async function () {\n          mockZipStream.pipe = (writeStream) => {\n            writeStream.emit('error', new Error('write stream error'));\n            mockZipStream.end();\n            writeStream.end();\n          };\n          await zip._extractEntryTo(mockZipFile, entry).should.be.rejectedWith('write stream error');\n        });\n      });\n\n      describe('toArchive', function () {\n        it('should zip all files into an archive', async function () {\n          const testFolder = path.resolve(assetsPath, 'unzipped');\n          const dstPath = path.resolve(tmpRoot, 'test.zip');\n          await zip.toArchive(dstPath, {\n            cwd: testFolder,\n          });\n\n          // Unzip the file and test that it has the same contents as the directory that was zipped\n          await zip.extractAllTo(dstPath, path.resolve(tmpRoot, 'output'));\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'a.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Hello World');\n          await fs.readFile(path.resolve(tmpRoot, 'output', 'test-dir', 'b.txt'), {\n            encoding: 'utf8'\n          }).should.eventually.equal('Foo Bar');\n        });\n      });\n\n\n    });\n  });\n\n  describe('unicode filename handling', function () {\n    let zippedFilePath, assetsPath, tmpRoot;\n\n    beforeEach(async function () {\n      assetsPath = await tempDir.openDir();\n      tmpRoot = await tempDir.openDir();\n\n      const zippedBase64 = 'UEsDBBQACAAIABF8/EYAAAAAAAAAABoAAAATACAAa2Fuamkt5q2j5LiW5LiVLmFwcFVUDQAHAgO4VVpX+GBZV/hgdXgLAAEE9QEAAAQUAAAAK8nILFYAorz8EoWi1MScnEqFxDyFxIICLgBQSwcIR93jPhoAAAAaAAAAUEsBAhQDFAAIAAgAEXz8Rkfd4z4aAAAAGgAAABMAIAAAAAAAAAAAAKSBAAAAAGthbmppLeato+S4luS4lS5hcHBVVA0ABwIDuFVaV/hgWVf4YHV4CwABBPUBAAAEFAAAAFBLBQYAAAAAAQABAGEAAAB7AAAAAAA=';\n      zippedFilePath = path.resolve(tmpRoot, 'zipped.zip');\n      await fs.writeFile(zippedFilePath, zippedBase64, 'base64');\n      await zip.extractAllTo(zippedFilePath, assetsPath, {useSystemUnzip: true});\n    });\n\n    afterEach(async function () {\n      for (const tmpPath of [assetsPath, tmpRoot]) {\n        if (!await fs.exists(tmpPath)) {\n          continue;\n        }\n        await fs.rimraf(tmpPath);\n      }\n    });\n\n    it('should retain the proper filenames', async function () {\n      const expectedPath = path.join(assetsPath, 'kanji-正世丕.app');\n      // we cannot use the `should` syntax because `fs.exists` resolves to a primitive (boolean)\n      if (!await fs.exists(expectedPath)) {\n        throw new chai.AssertionError(`Expected ${expectedPath} to exist, but it does not`);\n      }\n    });\n  });\n});\n"],"file":"test/zip-e2e-specs.js","sourceRoot":"../.."}

package/index.js

@@ -1,28 +1 @@
-import * as tempDir from './lib/tempdir';
-import * as system from './lib/system';
-import * as util from './lib/util';
-import * as fsIndex from './lib/fs';
-import * as net from './lib/net';
-import * as plist from './lib/plist';
-import * as mkdirpIndex from './lib/mkdirp';
-import * as logger from './lib/logging';
-import * as process from './lib/process';
-import * as zip from './lib/zip';
-import * as imageUtil from './lib/image-util';
-import * as mjpeg from './lib/mjpeg';
-import * as node from './lib/node';
-import * as timing from './lib/timing';
-
-
-const { fs } = fsIndex;
-const { cancellableDelay } = util;
-const { mkdirp } = mkdirpIndex;
-
-export {
-  tempDir, system, util, fs, cancellableDelay, plist, mkdirp, logger, process,
-  zip, imageUtil, net, mjpeg, node, timing,
-};
-export default {
-  tempDir, system, util, fs, cancellableDelay, plist, mkdirp, logger, process,
-  zip, imageUtil, net, mjpeg, node, timing,
-};
+module.exports = require('./build/lib');