Fix execaSync() returning undefined output when the subprocess fails to spawn

Fixes #1263

Author: sindresorhus

lib/io/output-sync.js

@@ -8,11 +8,8 @@ import {getFileTarget} from '../stdio/duplicate.js';
 import {truncateMaxBufferSync} from './max-buffer.js';
 
 // Apply `stdout`/`stderr` options, after spawning, in sync mode
-export const transformOutputSync = ({fileDescriptors, syncResult: {output}, options, verboseInfo}) => {
-	if (output === null) {
-		return {output: Array.from({length: fileDescriptors.length}), error: undefined};
-	}
-
+export const transformOutputSync = ({fileDescriptors, syncResult, options, verboseInfo}) => {
+	const output = syncResult.output ?? getSpawnFailureOutput(options);
 	const outputFiles = new Set();
 	// Transforms, `verbose` and file writes apply to a single file descriptor each, so their errors must not affect the other ones
 	const errors = [];
@@ -28,6 +25,10 @@ export const transformOutputSync = ({fileDescriptors, syncResult: {output}, opti
 	return {output: transformedOutput, error: errors.find(error => error !== undefined)};
 };
 
+// When the subprocess fails to spawn, `spawnSync()` returns no output. Like with asynchronous methods, each piped output is empty instead.
+// This is the output `spawnSync()` returns when the subprocess succeeds without printing anything: `stdin` and non-piped file descriptors are `null`. Input pipes on other file descriptors cannot be used with synchronous methods.
+const getSpawnFailureOutput = ({stdio}) => stdio.map((stdioOption, fdNumber) => fdNumber !== 0 && stdioOption === 'pipe' ? new Uint8Array() : null);
+
 const transformOutputResultSync = (
 	{result, fileDescriptors, fdNumber, errors, outputFiles, verboseInfo},
 	{buffer, encoding, lines, stripFinalNewline, maxBuffer},
@@ -79,7 +80,8 @@ const transformOutputResultSync = (
 // Applies transform generators to `stdout`/`stderr`
 const runOutputGeneratorsSync = (chunks, stdioItems, encoding) => {
 	try {
-		return {chunks: runGeneratorsSync(chunks, stdioItems, encoding, false)};
+		// `error` is set, so that a polluted `Object.prototype.error` is not read when destructuring
+		return {chunks: runGeneratorsSync(chunks, stdioItems, encoding, false), error: undefined};
 	} catch (error) {
 		return {chunks, error};
 	}

test/return/early-error.js

@@ -15,6 +15,7 @@ import {
 import {setFixtureDirectory} from '../helpers/fixtures-directory.js';
 import {foobarString, foobarUint8Array} from '../helpers/input.js';
 import {fullStdio} from '../helpers/stdio.js';
+import {getOutputGenerator, convertTransformToFinal} from '../helpers/generator.js';
 import {
 	earlyErrorOptions,
 	getEarlyErrorSubprocess,
@@ -43,6 +44,24 @@ test('execaSync() throws error if ENOENT', () => {
 	}, {message: ENOENT_REGEXP});
 });
 
+// The subprocess never started, so its output is empty, but it must have the same shape as with the asynchronous methods
+const testSpawnFailureOutput = async options => {
+	const {stdio, all} = await execa('nonexistent-command-for-execa', {...options, reject: false});
+	const {stdio: stdioSync, all: allSync} = execaSync('nonexistent-command-for-execa', {...options, reject: false});
+	assert.deepEqual(stdioSync, stdio);
+	assert.deepEqual(allSync, all);
+};
+
+test('execaSync() output is empty when the command does not exist', () => testSpawnFailureOutput({}));
+test('execaSync() output is empty when the command does not exist, with encoding: buffer', () => testSpawnFailureOutput({encoding: 'buffer'}));
+test('execaSync() output is empty when the command does not exist, with lines: true', () => testSpawnFailureOutput({lines: true}));
+test('execaSync() output is empty when the command does not exist, with all: true', () => testSpawnFailureOutput({all: true}));
+test('execaSync() output is empty when the command does not exist, with an additional file descriptor', () => testSpawnFailureOutput(fullStdio));
+test('execaSync() output is undefined when the command does not exist, with stdout: ignore', () => testSpawnFailureOutput({stdout: 'ignore'}));
+test('execaSync() output is undefined when the command does not exist, with buffer: false', () => testSpawnFailureOutput({buffer: false}));
+test('execaSync() output is empty when the cwd does not exist', () => testSpawnFailureOutput({cwd: '/nonexistent-directory-for-execa'}));
+test('execaSync() output runs the final of transforms when the command does not exist', () => testSpawnFailureOutput({stdout: convertTransformToFinal(getOutputGenerator(foobarString)(), true)}));
+
 const testEarlyErrorShape = async reject => {
 	const subprocess = getEarlyErrorSubprocess({reject});
 	assert.doesNotThrow(() => {