src/tools/rustdoc-gui/tester.js - toolchain/rustc - Git at Google

 // This package needs to be install:
 //
 // ```
 // npm install browser-ui-test
 // ```

 const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const {Options, runTest} = require("browser-ui-test");

 // If a test fails or errors, we will retry it two more times in case it was a flaky failure.
 const NB_RETRY = 3;

 function showHelp() {
     console.log("rustdoc-js options:");
     console.log("  --doc-folder [PATH]        : location of the generated doc folder");
     console.log("  --file [PATH]              : file to run (can be repeated)");
     console.log("  --debug                    : show extra information about script run");
     console.log("  --show-text                : render font in pages");
     console.log("  --no-headless              : disable headless mode");
     console.log("  --help                     : show this message then quit");
     console.log("  --tests-folder [PATH]      : location of the .GOML tests folder");
     console.log("  --jobs [NUMBER]            : number of threads to run tests on");
     console.log("  --executable-path [PATH]   : path of the browser's executable to be used");
 }

 function isNumeric(s) {
     return /^\d+$/.test(s);
 }

 function parseOptions(args) {
     const opts = {
         "doc_folder": "",
         "tests_folder": "",
         "files": [],
         "debug": false,
         "show_text": false,
         "no_headless": false,
         "jobs": -1,
         "executable_path": null,
     };
     const correspondences = {
         "--doc-folder": "doc_folder",
         "--tests-folder": "tests_folder",
         "--debug": "debug",
         "--show-text": "show_text",
         "--no-headless": "no_headless",
         "--executable-path": "executable_path",
     };

     for (let i = 0; i < args.length; ++i) {
         const arg = args[i];
         if (arg === "--doc-folder"
             || arg === "--tests-folder"
             || arg === "--file"
             || arg === "--jobs"
             || arg === "--executable-path") {
             i += 1;
             if (i >= args.length) {
                 console.log("Missing argument after `" + arg + "` option.");
                 return null;
             }
             const arg_value = args[i];
             if (arg === "--jobs") {
                 if (!isNumeric(arg_value)) {
                     console.log(
                         "`--jobs` option expects a positive number, found `" + arg_value + "`");
                     return null;
                 }
                 opts["jobs"] = parseInt(arg_value);
             } else if (arg !== "--file") {
                 opts[correspondences[arg]] = arg_value;
             } else {
                 opts["files"].push(arg_value);
             }
         } else if (arg === "--help") {
             showHelp();
             process.exit(0);
         } else if (correspondences[arg]) {
             opts[correspondences[arg]] = true;
         } else {
             console.log("Unknown option `" + arg + "`.");
             console.log("Use `--help` to see the list of options");
             return null;
         }
     }
     if (opts["tests_folder"].length < 1) {
         console.log("Missing `--tests-folder` option.");
     } else if (opts["doc_folder"].length < 1) {
         console.log("Missing `--doc-folder` option.");
     } else {
         return opts;
     }
     return null;
 }

 /// Print single char status information without \n
 function char_printer(n_tests) {
     const max_per_line = 10;
     let current = 0;
     return {
         successful: function() {
             current += 1;
             if (current % max_per_line === 0) {
                 process.stdout.write(`. (${current}/${n_tests})${os.EOL}`);
             } else {
                 process.stdout.write(".");
             }
         },
         erroneous: function() {
             current += 1;
             if (current % max_per_line === 0) {
                 process.stderr.write(`F (${current}/${n_tests})${os.EOL}`);
             } else {
                 process.stderr.write("F");
             }
         },
         finish: function() {
             if (current % max_per_line === 0) {
                 // Don't output if we are already at a matching line end
                 console.log("");
             } else {
                 const spaces = " ".repeat(max_per_line - (current % max_per_line));
                 process.stdout.write(`${spaces} (${current}/${n_tests})${os.EOL}${os.EOL}`);
             }
         },
     };
 }

 // Sort array by .file_name property
 function by_filename(a, b) {
     return a.file_name - b.file_name;
 }

 async function runTests(opts, framework_options, files, results, status_bar, showTestFailures) {
     const tests_queue = [];

     for (const testPath of files) {
         const callback = runTest(testPath, {"options": framework_options})
             .then(out => {
                 const [output, nb_failures] = out;
                 results[nb_failures === 0 ? "successful" : "failed"].push({
                     file_name: testPath,
                     output: output,
                 });
                 if (nb_failures === 0) {
                     status_bar.successful();
                 } else if (showTestFailures) {
                     status_bar.erroneous();
                 }
             })
             .catch(err => {
                 results.errored.push({
                     file_name: testPath,
                     output: err,
                 });
                 if (showTestFailures) {
                     status_bar.erroneous();
                 }
             })
             .finally(() => {
                 // We now remove the promise from the tests_queue.
                 tests_queue.splice(tests_queue.indexOf(callback), 1);
             });
         tests_queue.push(callback);
         if (opts["jobs"] > 0 && tests_queue.length >= opts["jobs"]) {
             await Promise.race(tests_queue);
         }
     }
     if (tests_queue.length > 0) {
         await Promise.all(tests_queue);
     }
 }

 function createEmptyResults() {
     return {
         successful: [],
         failed: [],
         errored: [],
     };
 }

 async function main(argv) {
     const opts = parseOptions(argv.slice(2));
     if (opts === null) {
         process.exit(1);
     }

     // Print successful tests too
     let debug = false;
     // Run tests in sequentially
     let headless = true;
     const framework_options = new Options();
     try {
         // This is more convenient that setting fields one by one.
         const args = [
             "--variable", "DOC_PATH", opts["doc_folder"].split("\\").join("/"),
             "--enable-fail-on-js-error", "--allow-file-access-from-files",
             "--no-sandbox",
         ];
         if (opts["debug"]) {
             debug = true;
             args.push("--debug");
         }
         if (opts["show_text"]) {
             args.push("--show-text");
         }
         if (opts["no_headless"]) {
             args.push("--no-headless");
             headless = false;
         }
         if (opts["executable_path"] !== null) {
             args.push("--executable-path");
             args.push(opts["executable_path"]);
         }
         framework_options.parseArguments(args);
     } catch (error) {
         console.error(`invalid argument: ${error}`);
         process.exit(1);
     }

     let files;
     if (opts["files"].length === 0) {
         files = fs.readdirSync(opts["tests_folder"]);
     } else {
         files = opts["files"];
     }
     files = files.filter(file => path.extname(file) === ".goml");
     if (files.length === 0) {
         console.error("rustdoc-gui: No test selected");
         process.exit(2);
     }
     files.forEach((file_name, index) => {
         files[index] = path.join(opts["tests_folder"], file_name);
     });
     files.sort();

     if (!headless) {
         opts["jobs"] = 1;
         console.log("`--no-headless` option is active, disabling concurrency for running tests.");
     }

     if (opts["jobs"] < 1) {
         const len = files.length;
         console.log(
             `Running ${len} rustdoc-gui (UNBOUNDED concurrency; use "-j#" for a limit) ...`,
         );
         process.setMaxListeners(files.length + 1);
     } else if (headless) {
         console.log(`Running ${files.length} rustdoc-gui (${opts["jobs"]} concurrently) ...`);
         process.setMaxListeners(opts["jobs"] + 1);
     } else {
         console.log(`Running ${files.length} rustdoc-gui ...`);
     }

     const originalFilesLen = files.length;
     const results = createEmptyResults();
     const status_bar = char_printer(files.length);

     let new_results;
     for (let it = 0; it < NB_RETRY && files.length > 0; ++it) {
         new_results = createEmptyResults();
         await runTests(opts, framework_options, files, new_results, status_bar, it + 1 >= NB_RETRY);
         Array.prototype.push.apply(results.successful, new_results.successful);
         // We generate the new list of files with the previously failing tests.
         files = Array.prototype.concat(new_results.failed, new_results.errored).map(
             f => f["file_name"]);
         if (files.length > originalFilesLen / 2) {
             // If we have too many failing tests, it's very likely not flaky failures anymore so
             // no need to retry.
             break;
         }
     }

     status_bar.finish();

     Array.prototype.push.apply(results.failed, new_results.failed);
     Array.prototype.push.apply(results.errored, new_results.errored);

     if (debug) {
         results.successful.sort(by_filename);
         results.successful.forEach(r => {
             console.log(r.output);
         });
     }

     if (results.failed.length > 0) {
         console.log("");
         results.failed.sort(by_filename);
         results.failed.forEach(r => {
             console.log(r.file_name, r.output);
         });
     }
     if (results.errored.length > 0) {
         console.log(os.EOL);
         // print run errors on the bottom so developers see them better
         results.errored.sort(by_filename);
         results.errored.forEach(r => {
             console.error(r.file_name, r.output);
         });
     }

     if (results.failed.length > 0 || results.errored.length > 0) {
         process.exit(1);
     }
     process.exit(0);
 }

 main(process.argv);
	// This package needs to be install:
	//
	// ```
	// npm install browser-ui-test
	// ```

	const fs = require("fs");
	const path = require("path");
	const os = require("os");
	const {Options, runTest} = require("browser-ui-test");

	// If a test fails or errors, we will retry it two more times in case it was a flaky failure.
	const NB_RETRY = 3;

	function showHelp() {
	console.log("rustdoc-js options:");
	console.log(" --doc-folder [PATH] : location of the generated doc folder");
	console.log(" --file [PATH] : file to run (can be repeated)");
	console.log(" --debug : show extra information about script run");
	console.log(" --show-text : render font in pages");
	console.log(" --no-headless : disable headless mode");
	console.log(" --help : show this message then quit");
	console.log(" --tests-folder [PATH] : location of the .GOML tests folder");
	console.log(" --jobs [NUMBER] : number of threads to run tests on");
	console.log(" --executable-path [PATH] : path of the browser's executable to be used");
	}

	function isNumeric(s) {
	return /^\d+$/.test(s);
	}

	function parseOptions(args) {
	const opts = {
	"doc_folder": "",
	"tests_folder": "",
	"files": [],
	"debug": false,
	"show_text": false,
	"no_headless": false,
	"jobs": -1,
	"executable_path": null,
	};
	const correspondences = {
	"--doc-folder": "doc_folder",
	"--tests-folder": "tests_folder",
	"--debug": "debug",
	"--show-text": "show_text",
	"--no-headless": "no_headless",
	"--executable-path": "executable_path",
	};

	for (let i = 0; i < args.length; ++i) {
	const arg = args[i];
	if (arg === "--doc-folder"
	\|\| arg === "--tests-folder"
	\|\| arg === "--file"
	\|\| arg === "--jobs"
	\|\| arg === "--executable-path") {
	i += 1;
	if (i >= args.length) {
	console.log("Missing argument after `" + arg + "` option.");
	return null;
	}
	const arg_value = args[i];
	if (arg === "--jobs") {
	if (!isNumeric(arg_value)) {
	console.log(
	"`--jobs` option expects a positive number, found `" + arg_value + "`");
	return null;
	}
	opts["jobs"] = parseInt(arg_value);
	} else if (arg !== "--file") {
	opts[correspondences[arg]] = arg_value;
	} else {
	opts["files"].push(arg_value);
	}
	} else if (arg === "--help") {
	showHelp();
	process.exit(0);
	} else if (correspondences[arg]) {
	opts[correspondences[arg]] = true;
	} else {
	console.log("Unknown option `" + arg + "`.");
	console.log("Use `--help` to see the list of options");
	return null;
	}
	}
	if (opts["tests_folder"].length < 1) {
	console.log("Missing `--tests-folder` option.");
	} else if (opts["doc_folder"].length < 1) {
	console.log("Missing `--doc-folder` option.");
	} else {
	return opts;
	}
	return null;
	}

	/// Print single char status information without \n
	function char_printer(n_tests) {
	const max_per_line = 10;
	let current = 0;
	return {
	successful: function() {
	current += 1;
	if (current % max_per_line === 0) {
	process.stdout.write(`. (${current}/${n_tests})${os.EOL}`);
	} else {
	process.stdout.write(".");
	}
	},
	erroneous: function() {
	current += 1;
	if (current % max_per_line === 0) {
	process.stderr.write(`F (${current}/${n_tests})${os.EOL}`);
	} else {
	process.stderr.write("F");
	}
	},
	finish: function() {
	if (current % max_per_line === 0) {
	// Don't output if we are already at a matching line end
	console.log("");
	} else {
	const spaces = " ".repeat(max_per_line - (current % max_per_line));
	process.stdout.write(`${spaces} (${current}/${n_tests})${os.EOL}${os.EOL}`);
	}
	},
	};
	}

	// Sort array by .file_name property
	function by_filename(a, b) {
	return a.file_name - b.file_name;
	}

	async function runTests(opts, framework_options, files, results, status_bar, showTestFailures) {
	const tests_queue = [];

	for (const testPath of files) {
	const callback = runTest(testPath, {"options": framework_options})
	.then(out => {
	const [output, nb_failures] = out;
	results[nb_failures === 0 ? "successful" : "failed"].push({
	file_name: testPath,
	output: output,
	});
	if (nb_failures === 0) {
	status_bar.successful();
	} else if (showTestFailures) {
	status_bar.erroneous();
	}
	})
	.catch(err => {
	results.errored.push({
	file_name: testPath,
	output: err,
	});
	if (showTestFailures) {
	status_bar.erroneous();
	}
	})
	.finally(() => {
	// We now remove the promise from the tests_queue.
	tests_queue.splice(tests_queue.indexOf(callback), 1);
	});
	tests_queue.push(callback);
	if (opts["jobs"] > 0 && tests_queue.length >= opts["jobs"]) {
	await Promise.race(tests_queue);
	}
	}
	if (tests_queue.length > 0) {
	await Promise.all(tests_queue);
	}
	}

	function createEmptyResults() {
	return {
	successful: [],
	failed: [],
	errored: [],
	};
	}

	async function main(argv) {
	const opts = parseOptions(argv.slice(2));
	if (opts === null) {
	process.exit(1);
	}

	// Print successful tests too
	let debug = false;
	// Run tests in sequentially
	let headless = true;
	const framework_options = new Options();
	try {
	// This is more convenient that setting fields one by one.
	const args = [
	"--variable", "DOC_PATH", opts["doc_folder"].split("\\").join("/"),
	"--enable-fail-on-js-error", "--allow-file-access-from-files",
	"--no-sandbox",
	];
	if (opts["debug"]) {
	debug = true;
	args.push("--debug");
	}
	if (opts["show_text"]) {
	args.push("--show-text");
	}
	if (opts["no_headless"]) {
	args.push("--no-headless");
	headless = false;
	}
	if (opts["executable_path"] !== null) {
	args.push("--executable-path");
	args.push(opts["executable_path"]);
	}
	framework_options.parseArguments(args);
	} catch (error) {
	console.error(`invalid argument: ${error}`);
	process.exit(1);
	}

	let files;
	if (opts["files"].length === 0) {
	files = fs.readdirSync(opts["tests_folder"]);
	} else {
	files = opts["files"];
	}
	files = files.filter(file => path.extname(file) === ".goml");
	if (files.length === 0) {
	console.error("rustdoc-gui: No test selected");
	process.exit(2);
	}
	files.forEach((file_name, index) => {
	files[index] = path.join(opts["tests_folder"], file_name);
	});
	files.sort();

	if (!headless) {
	opts["jobs"] = 1;
	console.log("`--no-headless` option is active, disabling concurrency for running tests.");
	}

	if (opts["jobs"] < 1) {
	const len = files.length;
	console.log(
	`Running ${len} rustdoc-gui (UNBOUNDED concurrency; use "-j#" for a limit) ...`,
	);
	process.setMaxListeners(files.length + 1);
	} else if (headless) {
	console.log(`Running ${files.length} rustdoc-gui (${opts["jobs"]} concurrently) ...`);
	process.setMaxListeners(opts["jobs"] + 1);
	} else {
	console.log(`Running ${files.length} rustdoc-gui ...`);
	}

	const originalFilesLen = files.length;
	const results = createEmptyResults();
	const status_bar = char_printer(files.length);

	let new_results;
	for (let it = 0; it < NB_RETRY && files.length > 0; ++it) {
	new_results = createEmptyResults();
	await runTests(opts, framework_options, files, new_results, status_bar, it + 1 >= NB_RETRY);
	Array.prototype.push.apply(results.successful, new_results.successful);
	// We generate the new list of files with the previously failing tests.
	files = Array.prototype.concat(new_results.failed, new_results.errored).map(
	f => f["file_name"]);
	if (files.length > originalFilesLen / 2) {
	// If we have too many failing tests, it's very likely not flaky failures anymore so
	// no need to retry.
	break;
	}
	}

	status_bar.finish();

	Array.prototype.push.apply(results.failed, new_results.failed);
	Array.prototype.push.apply(results.errored, new_results.errored);

	if (debug) {
	results.successful.sort(by_filename);
	results.successful.forEach(r => {
	console.log(r.output);
	});
	}

	if (results.failed.length > 0) {
	console.log("");
	results.failed.sort(by_filename);
	results.failed.forEach(r => {
	console.log(r.file_name, r.output);
	});
	}
	if (results.errored.length > 0) {
	console.log(os.EOL);
	// print run errors on the bottom so developers see them better
	results.errored.sort(by_filename);
	results.errored.forEach(r => {
	console.error(r.file_name, r.output);
	});
	}

	if (results.failed.length > 0 \|\| results.errored.length > 0) {
	process.exit(1);
	}
	process.exit(0);
	}

	main(process.argv);