46fe8fb8b4
This has a couple benefits: - we now use a .bazelversion file rather than package.json to pin the version of bazel we want. This means even if you install bazel on your computer rather than via yarn, you'll still get a warning if your bazel version is wrong. - you no longer end up downloading three copies of bazel due to bugs in both npm and yarn where they download all tarballs before checking the metadata to see which are usable on the local platform. - bazelisk correctly handles the tools/bazel trick for wrapping functionality, which we want to use to instrument developer build latencies PR Close #36078
377 lines
12 KiB
JavaScript
377 lines
12 KiB
JavaScript
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
const spawnSync = require('child_process').spawnSync;
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const tmp = require('tmp');
|
|
const runfiles = require(process.env['BAZEL_NODE_RUNFILES_HELPER']);
|
|
|
|
const VERBOSE_LOGS = !!process.env['VERBOSE_LOGS'];
|
|
|
|
// Set to true if you want the /tmp folder created to persist after running `bazel test`
|
|
const KEEP_TMP = false;
|
|
|
|
// bazelisk requires a $HOME environment variable for its cache
|
|
process.env['HOME'] = tmp.dirSync({keep: KEEP_TMP, unsafeCleanup: !KEEP_TMP}).name;
|
|
|
|
function fail(...m) {
|
|
console.error();
|
|
console.error(`[${path.basename(__filename)}]`);
|
|
console.error('error:', ...m);
|
|
console.error();
|
|
process.exit(1);
|
|
}
|
|
|
|
function log(...m) {
|
|
console.error(`[${path.basename(__filename)}]`, ...m);
|
|
}
|
|
|
|
function log_verbose(...m) {
|
|
if (VERBOSE_LOGS) log(...m);
|
|
}
|
|
|
|
/**
|
|
* Create a new directory and any necessary subdirectories
|
|
* if they do not exist.
|
|
*/
|
|
function mkdirp(p) {
|
|
if (!fs.existsSync(p)) {
|
|
mkdirp(path.dirname(p));
|
|
fs.mkdirSync(p);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if a given path exists and is a file.
|
|
* Note: fs.statSync() is used which resolves symlinks.
|
|
*/
|
|
function isFile(p) {
|
|
return fs.existsSync(p) && fs.statSync(p).isFile();
|
|
}
|
|
|
|
/**
|
|
* Check if a given path is an executable file.
|
|
*/
|
|
function isExecutable(p) {
|
|
try {
|
|
fs.accessSync(p, fs.constants.X_OK);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given two arrays returns the longest common slice.
|
|
*/
|
|
function commonSlice(a, b) {
|
|
const p = a.length < b.length ? [a, b] : [b, a];
|
|
for (let i = 0; i < p[0].length; ++i) {
|
|
if (p[0][i] !== p[1][i]) {
|
|
return p[0].slice(0, i);
|
|
}
|
|
}
|
|
return p[0];
|
|
}
|
|
|
|
/**
|
|
* Given a list of files, the root directory is returned
|
|
*/
|
|
function rootDirectory(files) {
|
|
let root = path.dirname(files[0]).replace(/\\/g, '/').split('/');
|
|
for (f of files) {
|
|
root = commonSlice(root, path.dirname(f).replace(/\\/g, '/').split('/'));
|
|
if (!root.length) break;
|
|
}
|
|
if (!root.length) {
|
|
fail(`not all test files are under the same root!`);
|
|
}
|
|
return root.join('/');
|
|
}
|
|
|
|
/**
|
|
* Utility function to copy a list of files under a common root to a destination folder.
|
|
*/
|
|
function copy(files, root, to) {
|
|
for (src of files) {
|
|
if (!src.startsWith(root)) {
|
|
fail(`file to copy ${src} is not under root ${root}`);
|
|
}
|
|
if (isFile(src)) {
|
|
const rel = src.slice(root.length + 1);
|
|
if (rel.startsWith('node_modules/')) {
|
|
// don't copy nested node_modules
|
|
continue;
|
|
}
|
|
const dest = `${to}/${rel}`;
|
|
mkdirp(path.dirname(dest));
|
|
fs.copyFileSync(src, dest);
|
|
// Set file permissions to set for files copied to tmp folders.
|
|
// These are needed as files copied out of bazel-bin will have
|
|
// restrictive permissions that may break tests.
|
|
fs.chmodSync(dest, isExecutable(src) ? '755' : '644');
|
|
log_verbose(`copied file ${src} -> ${dest}`);
|
|
} else {
|
|
fail('directories in test_files not supported');
|
|
}
|
|
}
|
|
return to;
|
|
}
|
|
|
|
/**
|
|
* Utility function to copy a list of files to a tmp folder based on their common root.
|
|
*/
|
|
function copyToTmp(files) {
|
|
const resolved = files.map(f => runfiles.resolveWorkspaceRelative(f));
|
|
return copy(
|
|
resolved, rootDirectory(resolved),
|
|
tmp.dirSync({keep: KEEP_TMP, unsafeCleanup: !KEEP_TMP}).name);
|
|
}
|
|
|
|
/**
|
|
* Expands environment variables in a string of the form ${FOO_BAR}.
|
|
*/
|
|
function expandEnv(s) {
|
|
if (!s) return s;
|
|
const reg = /\$\{(\w+)\}/g;
|
|
return s.replace(reg, (matched) => {
|
|
const varName = matched.substring(2, matched.length - 1);
|
|
if (process.env.hasOwnProperty(varName)) {
|
|
return process.env[varName];
|
|
} else {
|
|
throw `Failed to expand unbound environment variable '${varName}' in '${s}'`;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* TestRunner handles setting up the integration test and executing
|
|
* the test commands based on the config.
|
|
*/
|
|
class TestRunner {
|
|
constructor(config) {
|
|
this.config = config;
|
|
this.successful = 0;
|
|
this._setupTestFiles();
|
|
this._writeNpmPackageManifest();
|
|
}
|
|
|
|
/**
|
|
* Run all test commands in the integration test.
|
|
* Returns on first failure.
|
|
*/
|
|
run() {
|
|
for (const command of this.config.commands) {
|
|
// TODO: handle a quoted binary path that contains a space such as "/path to/binary"
|
|
// and quoted arguments that contain spaces
|
|
const split = command.split(' ');
|
|
let binary = split[0];
|
|
const args = split.slice(1).map(a => expandEnv(a));
|
|
switch (binary) {
|
|
case 'patch-package-json': {
|
|
let packageJsonFile = 'package.json';
|
|
if (args.length > 0) {
|
|
packageJsonFile = args[0];
|
|
}
|
|
log(`running test command ${this.successful+1} of ${this.config.commands.length}: patching '${packageJsonFile}' in '${this.testRoot}'`);
|
|
this._patchPackageJson(packageJsonFile);
|
|
} break;
|
|
|
|
default: {
|
|
if (binary.startsWith('external/')) {
|
|
binary = `../${binary.substring('external/'.length)}`;
|
|
}
|
|
const runfilesBinary = runfiles.resolveWorkspaceRelative(binary);
|
|
binary = fs.existsSync(runfilesBinary) ? runfilesBinary : binary;
|
|
log(`running test command ${this.successful+1} of ${this.config.commands.length}: '${binary} ${args.join(' ')}' in '${this.testRoot}'`);
|
|
const spawnedProcess = spawnSync(binary, args, {cwd: this.testRoot, stdio: 'inherit'});
|
|
if (spawnedProcess.error) {
|
|
fail(
|
|
`test command ${testRunner.successful+1} '${binary} ${args.join(' ')}' failed with ${spawnedProcess.error.code}`);
|
|
}
|
|
if (spawnedProcess.status) {
|
|
log(`test command ${testRunner.successful+1} '${binary} ${args.join(' ')}' failed with status code ${spawnedProcess.status}`);
|
|
return spawnedProcess.status;
|
|
}
|
|
}
|
|
}
|
|
this.successful++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*
|
|
* Patch the specified package.json file with the npmPackages passed in the config.
|
|
*/
|
|
_patchPackageJson(packageJsonFile) {
|
|
const packageJson = `${this.testRoot}/${packageJsonFile}`;
|
|
if (!isFile(packageJson)) {
|
|
fail(`no ${packageJsonFile} file found at test root ${this.testRoot}`);
|
|
}
|
|
const contents = JSON.parse(fs.readFileSync(packageJson, {encoding: 'utf-8'}));
|
|
let replacements = 0;
|
|
// replace npm packages
|
|
for (const key of Object.keys(this.config.npmPackages)) {
|
|
const path = runfiles.resolveWorkspaceRelative(this.config.npmPackages[key]);
|
|
const replacement = `file:${path}`;
|
|
if (contents.dependencies && contents.dependencies[key]) {
|
|
replacements++;
|
|
contents.dependencies[key] = replacement;
|
|
log(`overriding dependencies['${key}'] npm package with 'file:${path}' in package.json file`);
|
|
}
|
|
if (contents.devDependencies && contents.devDependencies[key]) {
|
|
replacements++;
|
|
contents.devDependencies[key] = replacement;
|
|
log(`overriding devDependencies['${key}'] npm package with 'file:${path}' in package.json file`);
|
|
}
|
|
if (contents.resolutions && contents.resolutions[key]) {
|
|
replacements++;
|
|
contents.resolutions[key] = replacement;
|
|
log(`overriding resolutions['${key}'] npm package with 'file:${path}' in package.json file`);
|
|
}
|
|
// TODO: handle other formats for resolutions such as `some-package/${key}` or
|
|
// `some-package/**/${key}`
|
|
const altKey = `**/${key}`;
|
|
if (contents.resolutions && contents.resolutions[altKey]) {
|
|
replacements++;
|
|
contents.resolutions[altKey] = replacement;
|
|
log(`overriding resolutions['${altKey}'] npm package with 'file:${path}' in package.json file`);
|
|
}
|
|
}
|
|
// check packages that must be replaced
|
|
const failedPackages = [];
|
|
for (const key of this.config.checkNpmPackages) {
|
|
if (contents.dependencies && contents.dependencies[key] &&
|
|
(!contents.dependencies[key].startsWith('file:') ||
|
|
contents.dependencies[key].startsWith('file:.'))) {
|
|
failedPackages.push(key);
|
|
} else if (
|
|
contents.devDependencies && contents.devDependencies[key] &&
|
|
(!contents.devDependencies[key].startsWith('file:') ||
|
|
contents.devDependencies[key].startsWith('file:.'))) {
|
|
failedPackages.push(key);
|
|
}
|
|
}
|
|
const contentsEncoded = JSON.stringify(contents, null, 2);
|
|
log(`package.json file:\n${contentsEncoded}`);
|
|
if (failedPackages.length) {
|
|
fail(
|
|
`expected replacements of npm packages ${JSON.stringify(failedPackages)} not found; add these to the npm_packages attribute`);
|
|
}
|
|
if (replacements) {
|
|
fs.writeFileSync(packageJson, contentsEncoded);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*
|
|
* Copy all the test files to a tmp folder so they are sandboxed for the test
|
|
* and so that changes made to source files such as patching package.json
|
|
* do not persist in the user's workspace.
|
|
*
|
|
* In debug mode, do not copy any file but set the testRoot to the user's workspace.
|
|
*/
|
|
_setupTestFiles() {
|
|
if (!this.config.testFiles.length) {
|
|
fail(`no test files`);
|
|
}
|
|
if (this.config.debug) {
|
|
// Setup the test in the test files root directory
|
|
const root = rootDirectory(this.config.testFiles);
|
|
if (path.isAbsolute(root)) {
|
|
fail(`root directory of Bazel test files should not be an absolute path but got '${root}'`);
|
|
}
|
|
if (root.startsWith(`../`)) {
|
|
fail(`debug mode only available with test files in the root workspace`);
|
|
}
|
|
let workspaceDirectory = process.env['BUILD_WORKSPACE_DIRECTORY'];
|
|
if (!workspaceDirectory) {
|
|
// bazel test
|
|
const runfilesPath = process.env['RUNFILES'];
|
|
if (!runfilesPath) {
|
|
fail(`RUNFILES environment variable is not set`);
|
|
}
|
|
// read the contents of the output_base/DO_NOT_BUILD_HERE file to get
|
|
// the workspace directory
|
|
const index = runfilesPath.search(/[\\/]execroot[\\/]/);
|
|
if (index === -1) {
|
|
fail(`no /execroot/ in runfiles path`);
|
|
}
|
|
const outputBase = runfilesPath.substr(0, index);
|
|
workspaceDirectory =
|
|
fs.readFileSync(`${outputBase}/DO_NOT_BUILD_HERE`, {encoding: 'utf-8'});
|
|
}
|
|
this.testRoot = `${workspaceDirectory}/${root}`;
|
|
log(`configuring test in-place under ${this.testRoot}`);
|
|
} else {
|
|
this.testRoot = copyToTmp(this.config.testFiles);
|
|
log(`test files from '${rootDirectory(this.config.testFiles)}' copied to tmp folder ${this.testRoot}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
*
|
|
* Write an NPM_PACKAGE_MANIFEST.json file to the test root with a mapping of
|
|
* the npm package mappings for this this test. Integration tests can opt
|
|
* to use this mappings file instead of the built-in `patch-package-json`
|
|
* command.
|
|
*/
|
|
_writeNpmPackageManifest() {
|
|
if (!this.testRoot) {
|
|
fail(`test files not yet setup`);
|
|
}
|
|
const manifest = {};
|
|
for (const key of Object.keys(this.config.npmPackages)) {
|
|
manifest[key] = runfiles.resolveWorkspaceRelative(this.config.npmPackages[key]);
|
|
}
|
|
const manifestPath = `${this.testRoot}/NPM_PACKAGE_MANIFEST.json`;
|
|
fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
|
|
log(`npm package manifest written to ${manifestPath}`);
|
|
}
|
|
}
|
|
|
|
const config = require(process.argv[2]);
|
|
|
|
// set env vars passed from --define
|
|
for (const k of Object.keys(config.envVars)) {
|
|
const v = config.envVars[k];
|
|
process.env[k] = v;
|
|
log_verbose(`set environment variable ${k}='${v}'`);
|
|
}
|
|
|
|
log_verbose(`env: ${JSON.stringify(process.env, null, 2)}`);
|
|
log_verbose(`config: ${JSON.stringify(config, null, 2)}`);
|
|
log(`running in ${process.cwd()}`);
|
|
|
|
const testRunner = new TestRunner(config);
|
|
const result = testRunner.run();
|
|
log(`${testRunner.successful} of ${config.commands.length} test commands successful`);
|
|
if (result) {
|
|
if (!config.debug) {
|
|
log(`to run this integration test in debug mode:
|
|
|
|
bazel run ${process.env['TEST_TARGET']}.debug
|
|
|
|
in debug mode the integration test will be run out of the workspace folder`);
|
|
}
|
|
}
|
|
if (config.debug) {
|
|
log(`this integration test may be re-run manually from the '${testRunner.testRoot}' folder
|
|
|
|
for example,
|
|
|
|
cd ${testRunner.testRoot}
|
|
yarn test`);
|
|
}
|
|
process.exit(result);
|