Rename internal variables

sindresorhus · Sep 1, 2024 · fa036ed · fa036ed
1 parent 84a79b0
commit fa036ed
Show file tree

Hide file tree

Showing 7 changed files with 172 additions and 171 deletions.
diff --git a/test/helpers/main.js b/test/helpers/main.js
@@ -24,13 +24,13 @@ export const arrayFromAsync = async asyncIterable => {
 	return chunks;
 };
 
-export const destroySubprocessStream = async ({nodeChildProcess}, error, streamName) => {
-	const subprocess = await nodeChildProcess;
-	subprocess[streamName].destroy(error);
+export const destroySubprocessStream = async (subprocess, error, streamName) => {
+	const nodeChildProcess = await subprocess.nodeChildProcess;
+	nodeChildProcess[streamName].destroy(error);
 };
 
-export const writeMultibyte = async promise => {
-	const {stdin} = await promise.nodeChildProcess;
+export const writeMultibyte = async subprocess => {
+	const {stdin} = await subprocess.nodeChildProcess;
 	stdin.write(multibyteFirstHalf);
 	await setTimeout(1e2);
 	stdin.end(multibyteSecondHalf);

diff --git a/test/index.js b/test/index.js
@@ -9,24 +9,24 @@ test('Can pass no arguments', async t => {
 });
 
 test('Can pass no arguments nor options', async t => {
-	const promise = nanoSpawn(...nodeHanging);
-	const nodeChildProcess = await promise.nodeChildProcess;
+	const subprocess = nanoSpawn(...nodeHanging);
+	const nodeChildProcess = await subprocess.nodeChildProcess;
 	nodeChildProcess.kill();
-	const error = await t.throwsAsync(promise);
+	const error = await t.throwsAsync(subprocess);
 	assertSigterm(t, error);
 });
 
 test('Returns a promise', async t => {
-	const promise = nanoSpawn(...nodePrintStdout);
-	t.false(Object.prototype.propertyIsEnumerable.call(promise, 'then'));
-	t.false(Object.hasOwn(promise, 'then'));
-	t.true(promise instanceof Promise);
-	await promise;
+	const subprocess = nanoSpawn(...nodePrintStdout);
+	t.false(Object.prototype.propertyIsEnumerable.call(subprocess, 'then'));
+	t.false(Object.hasOwn(subprocess, 'then'));
+	t.true(subprocess instanceof Promise);
+	await subprocess;
 });
 
-test('promise.nodeChildProcess is set', async t => {
-	const promise = nanoSpawn(...nodePrintStdout);
-	const nodeChildProcess = await promise.nodeChildProcess;
+test('subprocess.nodeChildProcess is set', async t => {
+	const subprocess = nanoSpawn(...nodePrintStdout);
+	const nodeChildProcess = await subprocess.nodeChildProcess;
 	t.true(Number.isInteger(nodeChildProcess.pid));
-	await promise;
+	await subprocess;
 });
diff --git a/test/iterable.js b/test/iterable.js
diff --git a/test/options.js b/test/options.js
@@ -54,52 +54,52 @@ test('Can pass options.cwd string', testCwd, fixturesPath);
 test('Can pass options.cwd URL', testCwd, FIXTURES_URL);
 
 const testStdOption = async (t, optionName) => {
-	const promise = nanoSpawn(...nodePrintStdout, {[optionName]: 'ignore'});
-	const subprocess = await promise.nodeChildProcess;
-	t.is(subprocess[optionName], null);
-	await promise;
+	const subprocess = nanoSpawn(...nodePrintStdout, {[optionName]: 'ignore'});
+	const nodeChildProcess = await subprocess.nodeChildProcess;
+	t.is(nodeChildProcess[optionName], null);
+	await subprocess;
 };
 
 test('Can pass options.stdin', testStdOption, 'stdin');
 test('Can pass options.stdout', testStdOption, 'stdout');
 test('Can pass options.stderr', testStdOption, 'stderr');
 
 const testStdOptionDefault = async (t, optionName) => {
-	const promise = nanoSpawn(...nodePrintStdout);
-	const subprocess = await promise.nodeChildProcess;
-	t.not(subprocess[optionName], null);
-	await promise;
+	const subprocess = nanoSpawn(...nodePrintStdout);
+	const nodeChildProcess = await subprocess.nodeChildProcess;
+	t.not(nodeChildProcess[optionName], null);
+	await subprocess;
 };
 
 test('options.stdin defaults to "pipe"', testStdOptionDefault, 'stdin');
 test('options.stdout defaults to "pipe"', testStdOptionDefault, 'stdout');
 test('options.stderr defaults to "pipe"', testStdOptionDefault, 'stderr');
 
 test('Can pass options.stdio array', async t => {
-	const promise = nanoSpawn(...nodePrintStdout, {stdio: ['ignore', 'pipe', 'pipe', 'pipe']});
-	const {stdin, stdout, stderr, stdio} = await promise.nodeChildProcess;
+	const subprocess = nanoSpawn(...nodePrintStdout, {stdio: ['ignore', 'pipe', 'pipe', 'pipe']});
+	const {stdin, stdout, stderr, stdio} = await subprocess.nodeChildProcess;
 	t.is(stdin, null);
 	t.not(stdout, null);
 	t.not(stderr, null);
 	t.is(stdio.length, 4);
-	await promise;
+	await subprocess;
 });
 
 test('Can pass options.stdio string', async t => {
-	const promise = nanoSpawn(...nodePrintStdout, {stdio: 'ignore'});
-	const {stdin, stdout, stderr, stdio} = await promise.nodeChildProcess;
+	const subprocess = nanoSpawn(...nodePrintStdout, {stdio: 'ignore'});
+	const {stdin, stdout, stderr, stdio} = await subprocess.nodeChildProcess;
 	t.is(stdin, null);
 	t.is(stdout, null);
 	t.is(stderr, null);
 	t.is(stdio.length, 3);
-	await promise;
+	await subprocess;
 });
 
 const testStdioPriority = async (t, stdio) => {
-	const promise = nanoSpawn(...nodePrintStdout, {stdio, stdout: 'ignore'});
-	const {stdout} = await promise.nodeChildProcess;
+	const subprocess = nanoSpawn(...nodePrintStdout, {stdio, stdout: 'ignore'});
+	const {stdout} = await subprocess.nodeChildProcess;
 	t.not(stdout, null);
-	await promise;
+	await subprocess;
 };
 
 test('options.stdio array has priority over options.stdout', testStdioPriority, ['pipe', 'pipe', 'pipe']);

diff --git a/test/pipe.js b/test/pipe.js
@@ -67,8 +67,8 @@ test('.pipe() source fails due to stream error', async t => {
 	const first = nanoSpawn(...nodePrintStdout);
 	const second = first.pipe(...nodeToUpperCase);
 	const cause = new Error(testString);
-	const subprocess = await first.nodeChildProcess;
-	subprocess.stdout.destroy(cause);
+	const nodeChildProcess = await first.nodeChildProcess;
+	nodeChildProcess.stdout.destroy(cause);
 	const error = await t.throwsAsync(second);
 	assertErrorEvent(t, error, cause);
 });
@@ -90,8 +90,8 @@ test('.pipe() destination fails due to stream error', async t => {
 	const first = nanoSpawn(...nodePrintStdout);
 	const second = first.pipe(...nodeToUpperCase);
 	const cause = new Error(testString);
-	const subprocess = await second.nodeChildProcess;
-	subprocess.stdin.destroy(cause);
+	const nodeChildProcess = await second.nodeChildProcess;
+	nodeChildProcess.stdin.destroy(cause);
 	const error = await t.throwsAsync(second);
 	assertErrorEvent(t, error, cause);
 });
@@ -250,63 +250,63 @@ test('.pipe() with stdout stream in source', async t => {
 });
 
 test('.pipe() + stdout/stderr iteration', async t => {
-	const promise = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCase);
-	const lines = await arrayFromAsync(promise);
+	const subprocess = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCase);
+	const lines = await arrayFromAsync(subprocess);
 	t.deepEqual(lines, [testUpperCase]);
-	const {stdout, stderr, output} = await promise;
+	const {stdout, stderr, output} = await subprocess;
 	t.is(stdout, '');
 	t.is(stderr, '');
 	t.is(output, '');
 });
 
 test('.pipe() + stdout iteration', async t => {
-	const promise = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCase);
-	const lines = await arrayFromAsync(promise.stdout);
+	const subprocess = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCase);
+	const lines = await arrayFromAsync(subprocess.stdout);
 	t.deepEqual(lines, [testUpperCase]);
-	const {stdout, output} = await promise;
+	const {stdout, output} = await subprocess;
 	t.is(stdout, '');
 	t.is(output, '');
 });
 
 test('.pipe() + stderr iteration', async t => {
-	const promise = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCaseStderr);
-	const lines = await arrayFromAsync(promise.stderr);
+	const subprocess = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCaseStderr);
+	const lines = await arrayFromAsync(subprocess.stderr);
 	t.deepEqual(lines, [testUpperCase]);
-	const {stderr, output} = await promise;
+	const {stderr, output} = await subprocess;
 	t.is(stderr, '');
 	t.is(output, '');
 });
 
 test('.pipe() + stdout iteration, source fail', async t => {
-	const promise = nanoSpawn(...nodePrintFail).pipe(...nodeToUpperCase);
-	const error = await t.throwsAsync(arrayFromAsync(promise.stdout));
+	const subprocess = nanoSpawn(...nodePrintFail).pipe(...nodeToUpperCase);
+	const error = await t.throwsAsync(arrayFromAsync(subprocess.stdout));
 	assertFail(t, error);
 	t.is(error.stdout, testString);
-	const secondError = await t.throwsAsync(promise);
+	const secondError = await t.throwsAsync(subprocess);
 	t.is(secondError.stdout, testString);
 	t.is(secondError.output, secondError.stdout);
 });
 
 test('.pipe() + stdout iteration, destination fail', async t => {
-	const promise = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCaseFail);
-	const error = await t.throwsAsync(arrayFromAsync(promise.stdout));
+	const subprocess = nanoSpawn(...nodePrintStdout).pipe(...nodeToUpperCaseFail);
+	const error = await t.throwsAsync(arrayFromAsync(subprocess.stdout));
 	assertFail(t, error);
 	t.is(error.stdout, '');
-	const secondError = await t.throwsAsync(promise);
+	const secondError = await t.throwsAsync(subprocess);
 	t.is(secondError.stdout, '');
 	t.is(secondError.output, '');
 });
 
 test('.pipe() with EPIPE', async t => {
-	const promise = nanoSpawn(...nodeEval(`setInterval(() => {
+	const subprocess = nanoSpawn(...nodeEval(`setInterval(() => {
 	console.log("${testString}");
 }, 0);
 process.stdout.on("error", () => {
 	process.exit();
 });`)).pipe('head', ['-n', '2']);
-	const lines = await arrayFromAsync(promise);
+	const lines = await arrayFromAsync(subprocess);
 	t.deepEqual(lines, [testString, testString]);
-	const {stdout, output} = await promise;
+	const {stdout, output} = await subprocess;
 	t.is(stdout, '');
 	t.is(output, '');
 });
diff --git a/test/result.js b/test/result.js
@@ -64,8 +64,8 @@ test('Error on "error" event during spawn', async t => {
 });
 
 test('Error on "error" event during spawn, with iteration', async t => {
-	const promise = nanoSpawn(...nodeHanging, {signal: AbortSignal.abort()});
-	const error = await t.throwsAsync(arrayFromAsync(promise.stdout));
+	const subprocess = nanoSpawn(...nodeHanging, {signal: AbortSignal.abort()});
+	const error = await t.throwsAsync(arrayFromAsync(subprocess.stdout));
 	assertSigterm(t, error);
 });
 
@@ -75,10 +75,10 @@ if (isLinux) {
 	test('Error on "error" event after spawn', async t => {
 		const cause = new Error(testString);
 		const controller = new AbortController();
-		const promise = nanoSpawn(...nodeHanging, {signal: controller.signal});
-		await promise.nodeChildProcess;
+		const subprocess = nanoSpawn(...nodeHanging, {signal: controller.signal});
+		await subprocess.nodeChildProcess;
 		controller.abort(cause);
-		const error = await t.throwsAsync(promise);
+		const error = await t.throwsAsync(subprocess);
 		assertAbortError(t, error, cause);
 	});
 }
@@ -135,10 +135,10 @@ setTimeout(() => {
 });
 
 const testStreamError = async (t, streamName) => {
-	const promise = nanoSpawn(...nodePrintStdout);
+	const subprocess = nanoSpawn(...nodePrintStdout);
 	const cause = new Error(testString);
-	destroySubprocessStream(promise, cause, streamName);
-	const error = await t.throwsAsync(promise);
+	destroySubprocessStream(subprocess, cause, streamName);
+	const error = await t.throwsAsync(subprocess);
 	assertErrorEvent(t, error, cause);
 };
 

diff --git a/test/spawn.js b/test/spawn.js
@@ -84,9 +84,9 @@ test('result.output is an empty string if options.stdout and options.stderr "ign
 });
 
 test.serial('result.stdout works with multibyte sequences', async t => {
-	const promise = nanoSpawn(...nodePassThrough);
-	writeMultibyte(promise);
-	const {stdout, output} = await promise;
+	const subprocess = nanoSpawn(...nodePassThrough);
+	writeMultibyte(subprocess);
+	const {stdout, output} = await subprocess;
 	t.is(stdout, multibyteString);
 	t.is(output, stdout);
 });