cypress 15.2.0 → 15.3.0

package/{lib → dist}/tasks/state.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,7 +17,8 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const untildify_1 = __importDefault(require("untildify"));
 const debug_1 = __importDefault(require("debug"));
-const fs_1 = __importDefault(require("../fs"));
+const process_1 = require("process");
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const util_1 = __importDefault(require("../util"));
 const debug = (0, debug_1.default)('cypress:cli');
 const getPlatformExecutable = () => {
@@ -59,7 +69,7 @@ const getVersionDir = (version = util_1.default.pkgVersion(), buildInfo = util_1
  */
 const isInstallingFromPostinstallHook = () => {
     // individual folders
-    const cwdFolders = process.cwd().split(path_1.default.sep);
+    const cwdFolders = (0, process_1.cwd)().split(path_1.default.sep);
     const length = cwdFolders.length;
     return cwdFolders[length - 2] === 'node_modules' && cwdFolders[length - 1] === 'cypress';
 };
@@ -80,19 +90,17 @@ const getCacheDir = () => {
     }
     return cache_directory;
 };
-const parseRealPlatformBinaryFolderAsync = (binaryPath) => {
-    return fs_1.default.realpathAsync(binaryPath)
-        .then((realPath) => {
-        debug('CYPRESS_RUN_BINARY has realpath:', realPath);
-        if (!realPath.toString().endsWith(getPlatformExecutable())) {
-            return false;
-        }
-        if (os_1.default.platform() === 'darwin') {
-            return path_1.default.resolve(realPath, '..', '..', '..');
-        }
-        return path_1.default.resolve(realPath, '..');
-    });
-};
+const parseRealPlatformBinaryFolderAsync = (binaryPath) => __awaiter(void 0, void 0, void 0, function* () {
+    const realPath = yield fs_extra_1.default.realpath(binaryPath);
+    debug('CYPRESS_RUN_BINARY has realpath:', realPath);
+    if (!realPath.toString().endsWith(getPlatformExecutable())) {
+        return false;
+    }
+    if (os_1.default.platform() === 'darwin') {
+        return path_1.default.resolve(realPath, '..', '..', '..');
+    }
+    return path_1.default.resolve(realPath, '..');
+});
 const getDistDir = () => {
     return path_1.default.join(__dirname, '..', '..', 'dist');
 };
@@ -104,34 +112,38 @@ const getDistDir = () => {
 const getBinaryStatePath = (binaryDir) => {
     return path_1.default.join(binaryDir, '..', 'binary_state.json');
 };
-const getBinaryStateContentsAsync = (binaryDir) => {
+const getBinaryStateContentsAsync = (binaryDir) => __awaiter(void 0, void 0, void 0, function* () {
     const fullPath = getBinaryStatePath(binaryDir);
-    return fs_1.default.readJsonAsync(fullPath)
-        .catch({ code: 'ENOENT' }, SyntaxError, () => {
-        debug('could not read binary_state.json file at "%s"', fullPath);
-        return {};
-    });
-};
-const getBinaryVerifiedAsync = (binaryDir) => {
-    return getBinaryStateContentsAsync(binaryDir)
-        .tap(debug)
-        .get('verified');
-};
-const clearBinaryStateAsync = (binaryDir) => {
-    return fs_1.default.removeAsync(getBinaryStatePath(binaryDir));
-};
+    try {
+        const contents = yield fs_extra_1.default.readJson(fullPath);
+        debug('binary_state.json contents:', contents);
+        return contents;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT' || error instanceof SyntaxError) {
+            debug('could not read binary_state.json file at "%s"', fullPath);
+            return {};
+        }
+        throw error;
+    }
+});
+const getBinaryVerifiedAsync = (binaryDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const contents = yield getBinaryStateContentsAsync(binaryDir);
+    return contents.verified;
+});
+const clearBinaryStateAsync = (binaryDir) => __awaiter(void 0, void 0, void 0, function* () {
+    yield fs_extra_1.default.remove(getBinaryStatePath(binaryDir));
+});
 /**
  * Writes the new binary status.
  * @param {boolean} verified The new test runner state after smoke test
  * @param {string} binaryDir Folder holding the binary
  * @returns {Promise<void>} returns a promise
  */
-const writeBinaryVerifiedAsync = (verified, binaryDir) => {
-    return getBinaryStateContentsAsync(binaryDir)
-        .then((contents) => {
-        return fs_1.default.outputJsonAsync(getBinaryStatePath(binaryDir), lodash_1.default.extend(contents, { verified }), { spaces: 2 });
-    });
-};
+const writeBinaryVerifiedAsync = (verified, binaryDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const contents = yield getBinaryStateContentsAsync(binaryDir);
+    yield fs_extra_1.default.outputJson(getBinaryStatePath(binaryDir), lodash_1.default.extend(contents, { verified }), { spaces: 2 });
+});
 const getPathToExecutable = (binaryDir) => {
     return path_1.default.join(binaryDir, getPlatformExecutable());
 };
@@ -139,17 +151,15 @@ const getPathToExecutable = (binaryDir) => {
  * Resolves with an object read from the binary app package.json file.
  * If the file does not exist resolves with null
  */
-const getBinaryPkgAsync = (binaryDir) => {
+const getBinaryPkgAsync = (binaryDir) => __awaiter(void 0, void 0, void 0, function* () {
     const pathToPackageJson = getBinaryPkgPath(binaryDir);
     debug('Reading binary package.json from:', pathToPackageJson);
-    return fs_1.default.pathExistsAsync(pathToPackageJson)
-        .then((exists) => {
-        if (!exists) {
-            return null;
-        }
-        return fs_1.default.readJsonAsync(pathToPackageJson);
-    });
-};
+    const exists = yield fs_extra_1.default.pathExists(pathToPackageJson);
+    if (!exists) {
+        return null;
+    }
+    return fs_extra_1.default.readJson(pathToPackageJson);
+});
 const getBinaryPkgVersion = (o) => lodash_1.default.get(o, 'version', null);
 const getBinaryElectronVersion = (o) => lodash_1.default.get(o, 'electronVersion', null);
 const getBinaryElectronNodeVersion = (o) => lodash_1.default.get(o, 'electronNodeVersion', null);

package/dist/tasks/unzip.js

@@ -0,0 +1,192 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const child_process_1 = __importDefault(require("child_process"));
+const os_1 = __importDefault(require("os"));
+const yauzl_1 = __importDefault(require("yauzl"));
+const debug_1 = __importDefault(require("debug"));
+const extract_zip_1 = __importDefault(require("extract-zip"));
+const readline_1 = __importDefault(require("readline"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const errors_1 = require("../errors");
+const util_1 = __importDefault(require("../util"));
+const assert_1 = __importDefault(require("assert"));
+const debug = (0, debug_1.default)('cypress:cli:unzip');
+const unzipTools = {
+    extract: extract_zip_1.default,
+};
+// expose this function for simple testing
+const unzip = (_a) => __awaiter(void 0, [_a], void 0, function* ({ zipFilePath, installDir, progress }) {
+    debug('unzipping from %s', zipFilePath);
+    debug('into', installDir);
+    if (!zipFilePath) {
+        throw new Error('Missing zip filename');
+    }
+    const startTime = Date.now();
+    let yauzlDoneTime = 0;
+    yield fs_extra_1.default.ensureDir(installDir);
+    yield new Promise((resolve, reject) => {
+        return yauzl_1.default.open(zipFilePath, (err, zipFile) => {
+            yauzlDoneTime = Date.now();
+            if (err) {
+                debug('error using yauzl %s', err.message);
+                return reject(err);
+            }
+            const total = zipFile.entryCount;
+            debug('zipFile entries count', total);
+            const started = new Date();
+            let percent = 0;
+            let count = 0;
+            const notify = (percent) => {
+                const elapsed = +new Date() - +started;
+                const eta = util_1.default.calculateEta(percent, elapsed);
+                progress.onProgress(percent, util_1.default.secsRemaining(eta));
+            };
+            const tick = () => {
+                count += 1;
+                percent = ((count / total) * 100);
+                const displayPercent = percent.toFixed(0);
+                return notify(Number(displayPercent));
+            };
+            const unzipWithNode = () => __awaiter(void 0, void 0, void 0, function* () {
+                debug('unzipping with node.js (slow)');
+                const opts = {
+                    dir: installDir,
+                    onEntry: tick,
+                };
+                debug('calling Node extract tool %s %o', zipFilePath, opts);
+                try {
+                    yield unzipTools.extract(zipFilePath, opts);
+                    debug('node unzip finished');
+                    return resolve();
+                }
+                catch (err) {
+                    const error = err || new Error('Unknown error with Node extract tool');
+                    debug('error %s', error.message);
+                    return reject(error);
+                }
+            });
+            const unzipFallback = lodash_1.default.once(unzipWithNode);
+            const unzipWithUnzipTool = () => {
+                debug('unzipping via `unzip`');
+                const inflatingRe = /inflating:/;
+                const sp = child_process_1.default.spawn('unzip', ['-o', zipFilePath, '-d', installDir]);
+                sp.on('error', (err) => {
+                    debug('unzip tool error: %s', err.message);
+                    unzipFallback();
+                });
+                sp.on('close', (code) => {
+                    debug('unzip tool close with code %d', code);
+                    if (code === 0) {
+                        percent = 100;
+                        notify(percent);
+                        return resolve();
+                    }
+                    debug('`unzip` failed %o', { code });
+                    return unzipFallback();
+                });
+                sp.stdout.on('data', (data) => {
+                    if (inflatingRe.test(data)) {
+                        return tick();
+                    }
+                });
+                sp.stderr.on('data', (data) => {
+                    debug('`unzip` stderr %s', data);
+                });
+            };
+            // we attempt to first unzip with the native osx
+            // ditto because its less likely to have problems
+            // with corruption, symlinks, or icons causing failures
+            // and can handle resource forks
+            // http://automatica.com.au/2011/02/unzip-mac-os-x-zip-in-terminal/
+            const unzipWithOsx = () => {
+                debug('unzipping via `ditto`');
+                const copyingFileRe = /^copying file/;
+                const sp = child_process_1.default.spawn('ditto', ['-xkV', zipFilePath, installDir]);
+                // f-it just unzip with node
+                sp.on('error', (err) => {
+                    debug(err.message);
+                    unzipFallback();
+                });
+                sp.on('close', (code) => {
+                    if (code === 0) {
+                        // make sure we get to 100% on the progress bar
+                        // because reading in lines is not really accurate
+                        percent = 100;
+                        notify(percent);
+                        return resolve();
+                    }
+                    debug('`ditto` failed %o', { code });
+                    return unzipFallback();
+                });
+                return readline_1.default.createInterface({
+                    input: sp.stderr,
+                })
+                    .on('line', (line) => {
+                    if (copyingFileRe.test(line)) {
+                        return tick();
+                    }
+                });
+            };
+            switch (os_1.default.platform()) {
+                case 'darwin':
+                    return unzipWithOsx();
+                case 'linux':
+                    return unzipWithUnzipTool();
+                case 'win32':
+                    return unzipWithNode();
+                default:
+                    return;
+            }
+        });
+    });
+    debug('unzip completed %o', {
+        yauzlMs: yauzlDoneTime - startTime,
+        unzipMs: Date.now() - yauzlDoneTime,
+    });
+});
+function isMaybeWindowsMaxPathLengthError(err) {
+    return os_1.default.platform() === 'win32' && err.code === 'ENOENT' && err.syscall === 'realpath';
+}
+const start = (_a) => __awaiter(void 0, [_a], void 0, function* ({ zipFilePath, installDir, progress }) {
+    assert_1.default.ok(lodash_1.default.isString(installDir) && !lodash_1.default.isEmpty(installDir), 'missing installDir');
+    if (!progress) {
+        progress = { onProgress: () => {
+                return {};
+            } };
+    }
+    try {
+        const installDirExists = yield fs_extra_1.default.pathExists(installDir);
+        if (installDirExists) {
+            debug('removing existing unzipped binary', installDir);
+            yield fs_extra_1.default.remove(installDir);
+        }
+        yield unzip({ zipFilePath, installDir, progress });
+    }
+    catch (err) {
+        const errorTemplate = isMaybeWindowsMaxPathLengthError(err) ?
+            errors_1.errors.failedUnzipWindowsMaxPathLength
+            : errors_1.errors.failedUnzip;
+        yield (0, errors_1.throwFormErrorText)(errorTemplate)(err);
+    }
+});
+const unzipModule = {
+    start,
+    utils: {
+        unzip,
+        unzipTools,
+    },
+};
+exports.default = unzipModule;