mirror of
https://github.com/cypress-io/cypress.git
synced 2026-02-25 10:30:39 -06:00
597 lines
18 KiB
JavaScript
597 lines
18 KiB
JavaScript
require('../../spec_helper')
|
|
const _ = require('lodash')
|
|
const os = require('os')
|
|
const path = require('path')
|
|
const chalk = require('chalk')
|
|
const Promise = require('bluebird')
|
|
const mockfs = require('mock-fs')
|
|
const mockedEnv = require('mocked-env')
|
|
const snapshot = require('../../support/snapshot')
|
|
|
|
const stdout = require('../../support/stdout')
|
|
|
|
const fs = require(`${lib}/fs`)
|
|
const download = require(`${lib}/tasks/download`)
|
|
const install = require(`${lib}/tasks/install`)
|
|
const state = require(`${lib}/tasks/state`)
|
|
const unzip = require(`${lib}/tasks/unzip`)
|
|
const logger = require(`${lib}/logger`)
|
|
const util = require(`${lib}/util`)
|
|
|
|
const normalize = require('../../support/normalize')
|
|
|
|
const packageVersion = '1.2.3'
|
|
const downloadDestination = path.join(os.tmpdir(), 'cypress.zip')
|
|
const installDir = '/cache/Cypress/1.2.3'
|
|
|
|
describe('/lib/tasks/install', function () {
|
|
require('mocha-banner').register()
|
|
|
|
beforeEach(function () {
|
|
this.stdout = stdout.capture()
|
|
|
|
// allow simpler log message comparison without
|
|
// chalk's terminal control strings
|
|
chalk.level = 0
|
|
})
|
|
|
|
afterEach(() => {
|
|
stdout.restore()
|
|
|
|
chalk.level = 3
|
|
})
|
|
|
|
context('.start', function () {
|
|
beforeEach(function () {
|
|
logger.reset()
|
|
|
|
// sinon.stub(os, 'tmpdir').returns('/tmp')
|
|
sinon.stub(util, 'isCi').returns(false)
|
|
sinon.stub(util, 'isPostInstall').returns(false)
|
|
sinon.stub(util, 'pkgVersion').returns(packageVersion)
|
|
sinon.stub(download, 'start').resolves(packageVersion)
|
|
sinon.stub(unzip, 'start').resolves()
|
|
sinon.stub(Promise, 'delay').resolves()
|
|
sinon.stub(fs, 'removeAsync').resolves()
|
|
sinon.stub(state, 'getVersionDir').returns('/cache/Cypress/1.2.3')
|
|
sinon.stub(state, 'getBinaryDir').returns('/cache/Cypress/1.2.3/Cypress.app')
|
|
sinon.stub(state, 'getBinaryPkgVersionAsync').resolves()
|
|
sinon.stub(fs, 'ensureDirAsync').resolves(undefined)
|
|
os.platform.returns('darwin')
|
|
})
|
|
|
|
describe('skips install', function () {
|
|
it('when environment variable is set', function () {
|
|
process.env.CYPRESS_INSTALL_BINARY = '0'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).not.to.be.called
|
|
|
|
snapshot(
|
|
'skip installation 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('override version', function () {
|
|
it('warns when specifying cypress version in env', function () {
|
|
const version = '0.12.1'
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = version
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
zipFilePath: downloadDestination,
|
|
})
|
|
|
|
snapshot(
|
|
'specify version in env vars 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
it('trims environment variable before installing', function () {
|
|
// note how the version has extra spaces around it on purpose
|
|
const filename = '/tmp/local/file.zip'
|
|
const version = ` ${filename} `
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = version
|
|
// internally, the variable should be trimmed and just filename checked
|
|
sinon.stub(fs, 'pathExistsAsync').withArgs(filename).resolves(true)
|
|
|
|
const installDir = state.getVersionDir()
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
zipFilePath: filename,
|
|
installDir,
|
|
})
|
|
})
|
|
})
|
|
|
|
it('removes double quotes around the environment variable before installing', function () {
|
|
// note how the version has extra spaces around it on purpose
|
|
// and there are double quotes
|
|
const filename = '/tmp/local/file.zip'
|
|
const version = ` "${filename}" `
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = version
|
|
// internally, the variable should be trimmed, double quotes removed
|
|
// and just filename checked against the file system
|
|
sinon.stub(fs, 'pathExistsAsync').withArgs(filename).resolves(true)
|
|
|
|
const installDir = state.getVersionDir()
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
zipFilePath: filename,
|
|
installDir,
|
|
})
|
|
})
|
|
})
|
|
|
|
it('can install local binary zip file without download from absolute path', function () {
|
|
const version = '/tmp/local/file.zip'
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = version
|
|
sinon.stub(fs, 'pathExistsAsync').withArgs(version).resolves(true)
|
|
|
|
const installDir = state.getVersionDir()
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
zipFilePath: version,
|
|
installDir,
|
|
})
|
|
})
|
|
})
|
|
|
|
it('can install local binary zip file from relative path', function () {
|
|
const version = './cypress-resources/file.zip'
|
|
|
|
mockfs({
|
|
[version]: 'asdf',
|
|
})
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = version
|
|
|
|
const installDir = state.getVersionDir()
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).not.to.be.called
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
zipFilePath: path.resolve(version),
|
|
installDir,
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when version is already installed', function () {
|
|
beforeEach(function () {
|
|
state.getBinaryPkgVersionAsync.resolves(packageVersion)
|
|
})
|
|
|
|
it('doesn\'t attempt to download', function () {
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).not.to.be.called
|
|
expect(state.getBinaryPkgVersionAsync).to.be.calledWith('/cache/Cypress/1.2.3/Cypress.app')
|
|
})
|
|
})
|
|
|
|
it('logs \'skipping install\' when explicit cypress install', function () {
|
|
return install.start()
|
|
.then(() => {
|
|
return snapshot(
|
|
'version already installed - cypress install 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
it('logs when already installed when run from postInstall', function () {
|
|
util.isPostInstall.returns(true)
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
snapshot(
|
|
'version already installed - postInstall 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('when getting installed version fails', function () {
|
|
beforeEach(function () {
|
|
state.getBinaryPkgVersionAsync.resolves(null)
|
|
|
|
return install.start()
|
|
})
|
|
|
|
it('logs message and starts download', function () {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version: packageVersion,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
installDir,
|
|
})
|
|
|
|
snapshot(
|
|
'continues installing on failure 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when there is no install version', function () {
|
|
beforeEach(function () {
|
|
state.getBinaryPkgVersionAsync.resolves(null)
|
|
|
|
return install.start()
|
|
})
|
|
|
|
it('logs message and starts download', function () {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version: packageVersion,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
installDir,
|
|
})
|
|
|
|
// cleans up the zip file
|
|
expect(fs.removeAsync).to.be.calledWith(
|
|
downloadDestination,
|
|
)
|
|
|
|
snapshot(
|
|
'installs without existing installation 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when getting installed version does not match needed version', function () {
|
|
beforeEach(function () {
|
|
state.getBinaryPkgVersionAsync.resolves('x.x.x')
|
|
|
|
return install.start()
|
|
})
|
|
|
|
it('logs message and starts download', function () {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version: packageVersion,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
installDir,
|
|
})
|
|
|
|
snapshot(
|
|
'installed version does not match needed version 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('with force: true', function () {
|
|
beforeEach(function () {
|
|
state.getBinaryPkgVersionAsync.resolves(packageVersion)
|
|
|
|
return install.start({ force: true })
|
|
})
|
|
|
|
it('logs message and starts download', function () {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version: packageVersion,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
installDir,
|
|
})
|
|
|
|
snapshot(
|
|
'forcing true always installs 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('as a global install', function () {
|
|
beforeEach(function () {
|
|
sinon.stub(util, 'isInstalledGlobally').returns(true)
|
|
|
|
state.getBinaryPkgVersionAsync.resolves('x.x.x')
|
|
|
|
return install.start()
|
|
})
|
|
|
|
it('logs global warning and download', function () {
|
|
expect(download.start).to.be.calledWithMatch({
|
|
version: packageVersion,
|
|
})
|
|
|
|
expect(unzip.start).to.be.calledWithMatch({
|
|
installDir,
|
|
})
|
|
|
|
snapshot(
|
|
'warning installing as global 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('when running in CI', function () {
|
|
beforeEach(function () {
|
|
util.isCi.returns(true)
|
|
|
|
state.getBinaryPkgVersionAsync.resolves('x.x.x')
|
|
|
|
return install.start()
|
|
})
|
|
|
|
it('uses verbose renderer', function () {
|
|
snapshot(
|
|
'installing in ci 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
|
|
describe('failed write access to cache directory', function () {
|
|
it('logs error on failure', function () {
|
|
os.platform.returns('darwin')
|
|
sinon.stub(state, 'getCacheDir').returns('/invalid/cache/dir')
|
|
|
|
const err = new Error('EACCES: permission denied, mkdir \'/invalid\'')
|
|
|
|
err.code = 'EACCES'
|
|
fs.ensureDirAsync.rejects(err)
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
throw new Error('should have caught error')
|
|
})
|
|
.catch((err) => {
|
|
logger.error(err)
|
|
|
|
snapshot(
|
|
'invalid cache directory 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('CYPRESS_INSTALL_BINARY is URL or Zip', function () {
|
|
it('uses cache when correct version installed given URL', function () {
|
|
state.getBinaryPkgVersionAsync.resolves('1.2.3')
|
|
util.pkgVersion.returns('1.2.3')
|
|
process.env.CYPRESS_INSTALL_BINARY = 'www.cypress.io/cannot-download/2.4.5'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).to.not.be.called
|
|
})
|
|
})
|
|
|
|
it('uses cache when mismatch version given URL ', function () {
|
|
state.getBinaryPkgVersionAsync.resolves('1.2.3')
|
|
util.pkgVersion.returns('4.0.0')
|
|
process.env.CYPRESS_INSTALL_BINARY = 'www.cypress.io/cannot-download/2.4.5'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(download.start).to.not.be.called
|
|
})
|
|
})
|
|
|
|
it('uses cache when correct version installed given Zip', function () {
|
|
sinon.stub(fs, 'pathExistsAsync').withArgs('/path/to/zip.zip').resolves(true)
|
|
|
|
state.getBinaryPkgVersionAsync.resolves('1.2.3')
|
|
util.pkgVersion.returns('1.2.3')
|
|
|
|
process.env.CYPRESS_INSTALL_BINARY = '/path/to/zip.zip'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(unzip.start).to.not.be.called
|
|
})
|
|
})
|
|
|
|
it('uses cache when mismatch version given Zip ', function () {
|
|
sinon.stub(fs, 'pathExistsAsync').withArgs('/path/to/zip.zip').resolves(true)
|
|
|
|
state.getBinaryPkgVersionAsync.resolves('1.2.3')
|
|
util.pkgVersion.returns('4.0.0')
|
|
process.env.CYPRESS_INSTALL_BINARY = '/path/to/zip.zip'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
expect(unzip.start).to.not.be.called
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('CYPRESS_BINARY_VERSION', function () {
|
|
it('throws when env var CYPRESS_BINARY_VERSION', function () {
|
|
process.env.CYPRESS_BINARY_VERSION = '/asf/asf'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
throw new Error('should have thrown')
|
|
})
|
|
.catch((err) => {
|
|
logger.error(err)
|
|
|
|
snapshot(
|
|
'error for removed CYPRESS_BINARY_VERSION 1',
|
|
normalize(this.stdout.toString()),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
it('is silent when log level is silent', function () {
|
|
process.env.npm_config_loglevel = 'silent'
|
|
|
|
return install.start()
|
|
.then(() => {
|
|
return snapshot(
|
|
'silent install 1',
|
|
normalize(`[no output]${this.stdout.toString()}`),
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
context('._getBinaryUrlFromPrereleaseNpmUrl', function () {
|
|
beforeEach(() => {
|
|
os.platform.returns('linux')
|
|
sinon.stub(os, 'arch').returns('x64')
|
|
})
|
|
|
|
it('returns binary url for prerelease npm url', function () {
|
|
expect(install._getBinaryUrlFromPrereleaseNpmUrl('https://cdn.cypress.io/beta/npm/5.1.1/ciprovider-branchname-sha/cypress.tgz'))
|
|
.to.eq('https://cdn.cypress.io/beta/binary/5.1.1/linux-x64/ciprovider-branchname-sha/cypress.zip')
|
|
|
|
expect(install._getBinaryUrlFromPrereleaseNpmUrl('https://cdn.cypress.io/beta/npm/5.1.1/circle-develop-3fdfc3b453eb38ad3c0b079531e4dde6668e3dd0-436710/cypress.tgz'))
|
|
.to.eq('https://cdn.cypress.io/beta/binary/5.1.1/linux-x64/circle-develop-3fdfc3b453eb38ad3c0b079531e4dde6668e3dd0-436710/cypress.zip')
|
|
})
|
|
|
|
it('returns nothing for an invalid url', function () {
|
|
expect(install._getBinaryUrlFromPrereleaseNpmUrl('1.2.3')).to.be.undefined
|
|
expect(install._getBinaryUrlFromPrereleaseNpmUrl(null)).to.be.undefined
|
|
})
|
|
})
|
|
|
|
context('._getVersionSpecifier', function () {
|
|
let restoreEnv
|
|
|
|
beforeEach(function () {
|
|
sinon.stub(fs, 'readJSON').rejects()
|
|
restoreEnv && restoreEnv()
|
|
})
|
|
|
|
it('resolves undefined if no versionSpecifier found', async function () {
|
|
expect(await install._getVersionSpecifier('/foo/bar/baz')).to.be.undefined
|
|
})
|
|
|
|
it('resolves with cypress.tgz URL if specified in npm argv', async function () {
|
|
restoreEnv = mockedEnv({
|
|
npm_config_argv: JSON.stringify({
|
|
original: ['npm', 'i', 'https://foo.com/cypress.tgz'],
|
|
}),
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('/foo/bar/baz')).to.eq('https://foo.com/cypress.tgz')
|
|
})
|
|
|
|
it('resolves with versionSpecifier from parent pkg.json', async function () {
|
|
fs.readJSON.withArgs('/foo/bar/baz/package.json').resolves({
|
|
dependencies: {
|
|
'cypress': '1.2.3',
|
|
},
|
|
})
|
|
|
|
fs.readJSON.withArgs('/foo/bar/package.json').resolves({
|
|
dependencies: {
|
|
'cypress': 'wrong',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('/foo/bar/baz')).to.eq('1.2.3')
|
|
})
|
|
|
|
it('resolves with devDependencies too', async function () {
|
|
fs.readJSON.withArgs('/foo/bar/baz/package.json').resolves({
|
|
devDependencies: {
|
|
'cypress': '4.5.6',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('/foo/bar/baz')).to.eq('4.5.6')
|
|
})
|
|
|
|
it('resolves with optionalDependencies too', async function () {
|
|
fs.readJSON.withArgs('/foo/bar/baz/package.json').resolves({
|
|
optionalDependencies: {
|
|
'cypress': '6.7.8',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('/foo/bar/baz')).to.eq('6.7.8')
|
|
})
|
|
|
|
context('with win32 path functions and paths', async function () {
|
|
const oldPath = _.clone(path)
|
|
|
|
beforeEach(() => {
|
|
_.assign(path, path.win32)
|
|
})
|
|
|
|
afterEach(() => {
|
|
_.assign(path, oldPath)
|
|
})
|
|
|
|
it('resolves undefined if no versionSpecifier found', async function () {
|
|
expect(await install._getVersionSpecifier('C:\\foo\\bar\\baz')).to.be.undefined
|
|
})
|
|
|
|
it('resolves with versionSpecifier from parent pkg.json', async function () {
|
|
fs.readJSON.withArgs('C:\\foo\\bar\\baz\\package.json').resolves({
|
|
dependencies: {
|
|
'cypress': '1.2.3',
|
|
},
|
|
})
|
|
|
|
fs.readJSON.withArgs('C:\\foo\\bar\\package.json').resolves({
|
|
dependencies: {
|
|
'cypress': 'wrong',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('C:\\foo\\bar\\baz')).to.eq('1.2.3')
|
|
})
|
|
|
|
it('resolves with devDependencies too', async function () {
|
|
fs.readJSON.withArgs('C:\\foo\\bar\\baz\\package.json').resolves({
|
|
devDependencies: {
|
|
'cypress': '4.5.6',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('C:\\foo\\bar\\baz')).to.eq('4.5.6')
|
|
})
|
|
|
|
it('resolves with optionalDependencies too', async function () {
|
|
fs.readJSON.withArgs('C:\\foo\\bar\\baz\\package.json').resolves({
|
|
optionalDependencies: {
|
|
'cypress': '6.7.8',
|
|
},
|
|
})
|
|
|
|
expect(await install._getVersionSpecifier('C:\\foo\\bar\\baz')).to.eq('6.7.8')
|
|
})
|
|
})
|
|
})
|
|
})
|