@appium/support 2.54.2 → 2.55.3

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');

package/lib/image-util.js

@@ -8,6 +8,10 @@ import log from './logger';
 import { requirePackage } from './node';
 
 
+const OCV_OLD = 'opencv4nodejs';
+const OCV_NEW = '@u4/opencv4nodejs';
+
+
 const { MIME_JPEG, MIME_PNG, MIME_BMP } = Jimp;
 let cv = null;
 
@@ -127,16 +131,20 @@ async function initOpenCV () {
   }
 
   log.debug(`Initializing opencv`);
-  try {
-    cv = await requirePackage('opencv4nodejs');
-  } catch (err) {
-    log.warn(`Unable to load 'opencv4nodejs': ${err.message}`);
+  for (const ocvPackage of [OCV_OLD, OCV_NEW]) {
+    try {
+      log.debug(`Attempting to load '${ocvPackage}'`);
+      cv = await requirePackage(ocvPackage);
+      break;
+    } catch (err) {
+      log.warn(`Unable to load '${ocvPackage}': ${err.message}`);
+    }
   }
 
   if (!cv) {
-    throw new Error(`'opencv4nodejs' module is required to use OpenCV features. ` +
-                    `Please install it first ('npm i -g opencv4nodejs') and restart Appium. ` +
-                    'Read https://github.com/justadudewhohacks/opencv4nodejs#how-to-install for more details on this topic.');
+    throw new Error(`An opencv node module is required to use OpenCV features. ` +
+                    `Please install one first (e.g., 'npm i -g ${OCV_NEW}') and restart Appium. ` +
+                    'Read https://github.com/UrielCh/opencv4nodejs#how-to-install for more details on this topic.');
   }
 }
 

package/lib/index.js

@@ -0,0 +1,28 @@
+import * as tempDir from './tempdir';
+import * as system from './system';
+import * as util from './util';
+import * as fsIndex from './fs';
+import * as net from './net';
+import * as plist from './plist';
+import * as mkdirpIndex from './mkdirp';
+import * as logger from './logging';
+import * as process from './process';
+import * as zip from './zip';
+import * as imageUtil from './image-util';
+import * as mjpeg from './mjpeg';
+import * as node from './node';
+import * as timing from './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,
+};

package/lib/log-internal.js

@@ -103,7 +103,7 @@ class SecureValuesPreprocessor {
   /**
    * Loads rules from the given JSON file
    *
-   * @param {string|Array<string|Rule>} source The full path to the JSON file containing secure
+   * @param {string|string[]|Rule[]>} source The full path to the JSON file containing secure
    * values replacement rules or the rules themselves represented as an array
    * @throws {Error} If the format of the source file is invalid or
    * it does not exist

package/lib/logging.js

@@ -117,7 +117,7 @@ function getLogger (prefix = null) {
  * appear in Appium logs.
  * Each call to this method replaces the previously loaded rules if any existed.
  *
- * @param {string} rulesJsonPath The full path to the JSON file containing
+ * @param {string|string[]|Rule[]} rulesJsonPath The full path to the JSON file containing
  * the replacement rules. Each rule could either be a string to be replaced
  * or an object with predefined properties. See the `Rule` type definition in
  * `log-internals.js` to get more details on its format.

package/lib/net.js

@@ -9,6 +9,7 @@ import Timer from './timing';
 import axios from 'axios';
 import FormData from 'form-data';
 
+const DEFAULT_TIMEOUT_MS = 4 * 60 * 1000;
 
 function toAxiosAuth (auth) {
   if (!_.isPlainObject(auth)) {
@@ -25,7 +26,7 @@ function toAxiosAuth (auth) {
 async function uploadFileToHttp (localFileStream, parsedUri, uploadOptions = {}) {
   const {
     method = 'POST',
-    timeout = 5000,
+    timeout = DEFAULT_TIMEOUT_MS,
     headers,
     auth,
     fileFieldName = 'file',
@@ -128,7 +129,7 @@ async function uploadFileToFtp (localFileStream, parsedUri, uploadOptions = {})
  * (e.g. timings and speed)
  * @property {string} method [POST] - The HTTP method used for file upload
  * @property {AuthCredentials} auth
- * @property {number} timeout [5000] - The actual request timeout in milliseconds
+ * @property {number} timeout [240000] - The actual request timeout in milliseconds
  * @property {Object} headers - Additional request headers mapping
  * @property {?string} fileFieldName [file] - The name of the form field containing the file
  * content to be uploaded. Any falsy value make the request to use non-multipart upload
@@ -186,7 +187,7 @@ async function uploadFile (localPath, remoteUri, uploadOptions = {}) {
  * @property {boolean} isMetered [true] - Whether to log the actual download performance
  * (e.g. timings and speed)
  * @property {AuthCredentials} auth
- * @property {number} timeout [5000] - The actual request timeout in milliseconds
+ * @property {number} timeout [240000] - The actual request timeout in milliseconds
  * @property {Object} headers - Request headers mapping
  */
 
@@ -202,7 +203,7 @@ async function downloadFile (remoteUrl, dstPath, downloadOptions = {}) {
   const {
     isMetered = true,
     auth,
-    timeout = 5000,
+    timeout = DEFAULT_TIMEOUT_MS,
     headers,
   } = downloadOptions;
 

package/lib/zip.js

@@ -7,6 +7,7 @@ import path from 'path';
 import { mkdirp } from '../lib/mkdirp';
 import stream from 'stream';
 import fs from './fs';
+import { isWindows } from './system';
 import { Base64Encode } from 'base64-stream';
 import { toReadableSizeString, GiB } from './util';
 import Timer from './timing';
@@ -173,13 +174,7 @@ class ZipExtractor {
  * For ZIP archives created on MacOS it is usually expected to be `utf8`.
  * By default it is autodetected based on the entry metadata and is only needed to be set explicitly
  * if the particular archive does not comply to the standards, which leads to corrupted file names
- * after extraction.
- * @property {?number} defaultDirMode [0o755] The default permissions for extracted folders. It is only
- * applied when the extractor is unable to retrieve this value for a directory from the archive
- * metadata.
- * @property {?number} defaultFileMode [0o644] The default permissions for extracted files. It is only
- * applied when the extractor is unable to retrieve this value for a file from the archive
- * metadata.
+ * after extraction. Only applicable if system unzip binary is NOT being used.
  * @property {?boolean} useSystemUnzip [false] If true, attempt to use system unzip; if this fails,
  * fallback to the JS unzip implementation.
  */
@@ -214,22 +209,43 @@ async function extractAllTo (zipFilePath, destDir, opts = {}) {
 }
 
 /**
- * Executes system unzip (e.g., `/usr/bin/unzip`).  If available, it is
+ * Executes system unzip (e.g., `/usr/bin/unzip`). If available, it is
  * significantly faster than the JS implementation.
- * This function will reject on win32.
+ * By default all files in the destDir get overridden if already exist.
+ *
  * @param {string} zipFilePath The full path to the source ZIP file
- * @param {string} destDir The full path to the destination folder
+ * @param {string} destDir The full path to the destination folder.
+ * This folder is expected to already exist before extracting the archive.
  */
 async function extractWithSystemUnzip (zipFilePath, destDir) {
-  const unzipExecutablePath = await assertSystemUnzip();
-  // -q means quiet (no stdout)
-  // -o means overwrite
-  // -d is the dest dir
-  await exec(unzipExecutablePath, [
-    '-q',
-    '-o', zipFilePath,
-    '-d', destDir
-  ]);
+  const isWindowsHost = isWindows();
+  let executablePath;
+  try {
+    executablePath = await getExecutablePath(
+      isWindowsHost ? 'powershell.exe' : 'unzip'
+    );
+  } catch (e) {
+    throw new Error('Could not find system unzip');
+  }
+
+  if (isWindowsHost) {
+    // on Windows we use PowerShell to unzip files
+    await exec(executablePath, [
+      '-command', 'Expand-Archive',
+      '-LiteralPath', zipFilePath,
+      '-DestinationPath', destDir,
+      '-Force'
+    ]);
+  } else {
+    // -q means quiet (no stdout)
+    // -o means overwrite
+    // -d is the dest dir
+    await exec(executablePath, [
+      '-q',
+      '-o', zipFilePath,
+      '-d', destDir
+    ]);
+  }
 }
 
 /**
@@ -512,21 +528,19 @@ async function toArchive (dstPath, src = {}, opts = {}) {
 }
 
 /**
- * Finds a system `unzip` executable. Rejects if it is not found.
+ * Finds and memoizes the full path to the given executable.
+ * Rejects if it is not found.
  */
-const assertSystemUnzip = _.memoize(
+const getExecutablePath = _.memoize(
   /**
-   * @returns {B<string>} Path to unzip executable
+   * @returns {B<string>} Full Path to the executable
    */
-  async () => {
-    try {
-      const unzipPath = await fs.which('unzip');
-      log.debug('found system unzip at %s', unzipPath);
-      return unzipPath;
-    } catch {
-      throw new Error('Could not find system unzip');
-    }
-  });
+  async function getExecutablePath (binaryName) {
+    const fullPath = await fs.which(binaryName);
+    log.debug(`Found '%s' at '%s'`, binaryName, fullPath);
+    return fullPath;
+  }
+);
 
 export { extractAllTo, readEntries, toInMemoryZip, _extractEntryTo,
   assertValidZip, toArchive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appium/support",
-  "version": "2.54.2",
+  "version": "2.55.3",
   "description": "Support libs used across appium packages",
   "keywords": [
     "automation",
@@ -21,29 +21,26 @@
   },
   "license": "Apache-2.0",
   "author": "https://github.com/appium",
-  "main": "./build/index.js",
-  "bin": {},
   "directories": {
     "lib": "lib"
   },
   "files": [
     "index.js",
     "lib",
-    "build/index.js",
-    "build/lib"
+    "build"
   ],
   "dependencies": {
-    "@babel/runtime": "7.15.4",
+    "@babel/runtime": "7.16.3",
     "archiver": "5.3.0",
-    "axios": "0.21.4",
+    "axios": "0.24.0",
     "base64-stream": "1.0.0",
     "bluebird": "3.7.2",
     "bplist-creator": "0.1.0",
-    "bplist-parser": "0.3.0",
+    "bplist-parser": "0.3.1",
     "find-root": "1.1.0",
     "form-data": "4.0.0",
     "get-stream": "6.0.1",
-    "glob": "7.1.7",
+    "glob": "7.2.0",
     "jimp": "0.16.1",
     "jsftp": "2.1.3",
     "klaw": "3.0.0",
@@ -60,16 +57,13 @@
     "rimraf": "3.0.2",
     "sanitize-filename": "1.6.3",
     "semver": "7.3.5",
-    "shell-quote": "1.7.2",
-    "source-map-support": "0.5.20",
+    "shell-quote": "1.7.3",
+    "source-map-support": "0.5.21",
     "teen_process": "1.16.0",
     "uuid": "8.3.2",
     "which": "2.0.2",
     "yauzl": "2.10.0"
   },
-  "devDependencies": {
-    "@appium/gulp-plugins": "^5.5.3"
-  },
   "engines": {
     "node": ">=12",
     "npm": ">=6"
@@ -78,5 +72,5 @@
     "access": "public"
   },
   "homepage": "https://appium.io",
-  "gitHead": "4ec2d1edd7f93685d99fb3186b2ab7b42c591eba"
+  "gitHead": "ca90a11813546ab4851e5b1f0406f420a53227e6"
 }