ava 0.16.0 → 0.18.2

package/lib/test-worker.js

@@ -1,114 +1,64 @@
 'use strict';
 /* eslint-disable import/order */
-var opts = JSON.parse(process.argv[2]);
-var testPath = opts.file;
+const process = require('./process-adapter');
 
-// Fake TTY support
-if (opts.tty) {
-	process.stdout.isTTY = true;
-	process.stdout.columns = opts.tty.columns || 80;
-	process.stdout.rows = opts.tty.rows;
+const opts = process.opts;
+const testPath = opts.file;
 
-	var tty = require('tty');
-	var isatty = tty.isatty;
-
-	tty.isatty = function (fd) {
-		if (fd === 1 || fd === process.stdout) {
-			return true;
-		}
-
-		return isatty(fd);
-	};
-}
-
-var path = require('path');
-var fs = require('fs');
-var debug = require('debug')('ava');
-var sourceMapSupport = require('source-map-support');
-
-if (debug.enabled) {
-	// Forward the `time-require` `--sorted` flag.
-	// Intended for internal optimization tests only.
-	if (opts._sorted) {
-		process.argv.push('--sorted');
-	}
-
-	require('time-require');
-}
-
-// bind globals first before anything has a chance to interfere
-var globals = require('./globals');
+// Bind globals first before anything has a chance to interfere
+const globals = require('./globals');
 globals.options = opts;
-var Promise = require('bluebird');
+const Promise = require('bluebird');
 
 // Bluebird specific
 Promise.longStackTraces();
 
 (opts.require || []).forEach(require);
 
-var sourceMapCache = Object.create(null);
-
-sourceMapSupport.install({
-	environment: 'node',
-	handleUncaughtExceptions: false,
-	retrieveSourceMap: function (source) {
-		if (sourceMapCache[source]) {
-			return {
-				url: source,
-				map: fs.readFileSync(sourceMapCache[source], 'utf8')
-			};
-		}
-	}
-});
+process.installSourceMapSupport();
 
-var currentlyUnhandled = require('currently-unhandled')();
-var serializeError = require('./serialize-error');
-var send = require('./send');
-var throwsHelper = require('./throws-helper');
-var installPrecompiler = require('require-precompiled');
-var cacheDir = opts.cacheDir;
+const currentlyUnhandled = require('currently-unhandled')();
+const serializeError = require('./serialize-error');
+const send = process.send;
+const throwsHelper = require('./throws-helper');
 
-// check if test files required ava and show error, when they didn't
+// Check if test files required ava and show error, when they didn't
 exports.avaRequired = false;
 
-installPrecompiler(function (filename) {
-	var precompiled = opts.precompiled[filename];
+process.installPrecompilerHook();
 
-	if (precompiled) {
-		sourceMapCache[filename] = path.join(cacheDir, precompiled + '.js.map');
-		return fs.readFileSync(path.join(cacheDir, precompiled + '.js'), 'utf8');
-	}
+const dependencies = [];
+process.installDependencyTracking(dependencies, testPath);
 
-	return null;
-});
-
-var dependencies = [];
-Object.keys(require.extensions).forEach(function (ext) {
-	var wrappedHandler = require.extensions[ext];
-	require.extensions[ext] = function (module, filename) {
-		if (filename !== testPath) {
-			dependencies.push(filename);
-		}
-		wrappedHandler(module, filename);
-	};
-});
-
-require(testPath);
+require(testPath); // eslint-disable-line import/no-dynamic-require
 
 process.on('unhandledRejection', throwsHelper);
 
-process.on('uncaughtException', function (exception) {
+process.on('uncaughtException', exception => {
 	throwsHelper(exception);
-	send('uncaughtException', {exception: serializeError(exception)});
+
+	let serialized;
+	try {
+		serialized = serializeError(exception);
+	} catch (ignore) { // eslint-disable-line unicorn/catch-error-name
+		// Avoid using serializeError
+		const err = new Error('Failed to serialize uncaught exception');
+		serialized = {
+			name: err.name,
+			message: err.message,
+			stack: err.stack
+		};
+	}
+	send('uncaughtException', {exception: serialized});
 });
 
-// if ava was not required, show an error
+// If AVA was not required, show an error
 if (!exports.avaRequired) {
 	send('no-tests', {avaRequired: false});
 }
 
-// parse and re-emit ava messages
-process.on('message', function (message) {
+// Parse and re-emit AVA messages
+process.on('message', message => {
 	if (!message.ava) {
 		return;
 	}
@@ -116,35 +66,35 @@ process.on('message', function (message) {
 	process.emit(message.name, message.data);
 });
 
-process.on('ava-exit', function () {
-	// use a little delay when running on AppVeyor (because it's shit)
-	var delay = process.env.AVA_APPVEYOR ? 100 : 0;
+process.on('ava-exit', () => {
+	// Use a little delay when running on AppVeyor (because it's shit)
+	const delay = process.env.AVA_APPVEYOR ? 100 : 0;
 
-	globals.setTimeout(function () {
+	globals.setTimeout(() => {
 		process.exit(0); // eslint-disable-line xo/no-process-exit
 	}, delay);
 });
 
-var tearingDown = false;
-process.on('ava-teardown', function () {
-	// ava-teardown can be sent more than once.
+let tearingDown = false;
+process.on('ava-teardown', () => {
+	// AVA-teardown can be sent more than once
 	if (tearingDown) {
 		return;
 	}
 	tearingDown = true;
 
-	var rejections = currentlyUnhandled();
+	let rejections = currentlyUnhandled();
 
 	if (rejections.length === 0) {
 		exit();
 		return;
 	}
 
-	rejections = rejections.map(function (rejection) {
+	rejections = rejections.map(rejection => {
 		return serializeError(rejection.reason);
 	});
 
-	send('unhandledRejections', {rejections: rejections});
+	send('unhandledRejections', {rejections});
 	globals.setTimeout(exit, 100);
 });
 
@@ -152,5 +102,5 @@ function exit() {
 	// Include dependencies in the final teardown message. This ensures the full
 	// set of dependencies is included no matter how the process exits, unless
 	// it flat out crashes.
-	send('teardown', {dependencies: dependencies});
+	send('teardown', {dependencies});
 }