test: split test-cli-syntax into multiple tests

Split test-cli-syntax into multiple files to improve reliability and/or
isolate unreliable test cases.

Move test cases back to parallel as appropriate.

PR-URL: #24922
Reviewed-By: Bryan English <bryan@bryanenglish.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>

test/parallel/test-cli-syntax-eval.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { exec } = require('child_process');
+
+const node = process.execPath;
+
+// should throw if -c and -e flags are both passed
+['-c', '--check'].forEach(function(checkFlag) {
+  ['-e', '--eval'].forEach(function(evalFlag) {
+    const args = [checkFlag, evalFlag, 'foo'];
+    const cmd = [node, ...args].join(' ');
+    exec(cmd, common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err instanceof Error, true);
+      assert.strictEqual(err.code, 9);
+      assert(
+        stderr.startsWith(
+          `${node}: either --check or --eval can be used, not both`
+        )
+      );
+    }));
+  });
+});

test/parallel/test-cli-syntax-piped-bad.js

@@ -0,0 +1,35 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const node = process.execPath;
+
+// test both sets of arguments that check syntax
+const syntaxArgs = [
+  ['-c'],
+  ['--check']
+];
+
+// Match on the name of the `Error` but not the message as it is different
+// depending on the JavaScript engine.
+const syntaxErrorRE = /^SyntaxError: \b/m;
+
+// Should throw if code piped from stdin with --check has bad syntax
+// loop each possible option, `-c` or `--check`
+syntaxArgs.forEach(function(args) {
+  const stdin = 'var foo bar;';
+  const c = spawnSync(node, args, { encoding: 'utf8', input: stdin });
+
+  // stderr should include '[stdin]' as the filename
+  assert(c.stderr.startsWith('[stdin]'), `${c.stderr} starts with ${stdin}`);
+
+  // no stdout or stderr should be produced
+  assert.strictEqual(c.stdout, '');
+
+  // stderr should have a syntax error message
+  assert(syntaxErrorRE.test(c.stderr), `${syntaxErrorRE} === ${c.stderr}`);
+
+  assert.strictEqual(c.status, 1);
+});

test/parallel/test-cli-syntax-piped-good.js

@@ -0,0 +1,26 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const node = process.execPath;
+
+// test both sets of arguments that check syntax
+const syntaxArgs = [
+  ['-c'],
+  ['--check']
+];
+
+// should not execute code piped from stdin with --check
+// loop each possible option, `-c` or `--check`
+syntaxArgs.forEach(function(args) {
+  const stdin = 'throw new Error("should not get run");';
+  const c = spawnSync(node, args, { encoding: 'utf8', input: stdin });
+
+  // no stdout or stderr should be produced
+  assert.strictEqual(c.stdout, '');
+  assert.strictEqual(c.stderr, '');
+
+  assert.strictEqual(c.status, 0);
+});

test/sequential/sequential.status

@@ -8,7 +8,10 @@ prefix sequential
 # https://github.com/nodejs/node/issues/22336
 test-gc-http-client: PASS,FLAKY
 # https://github.com/nodejs/node/issues/24403
-test-cli-syntax: PASS,FLAKY
+test-cli-syntax-bad: PASS,FLAKY
+test-cli-syntax-file-not-found: PASS,FLAKY
+test-cli-syntax-good: PASS,FLAKY
+test-cli-syntax-require: PASS,FLAKY
 
 [$system==win32]
 # https://github.com/nodejs/node/issues/22327

test/sequential/test-cli-syntax-bad.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { exec } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const node = process.execPath;
+
+// test both sets of arguments that check syntax
+const syntaxArgs = [
+  ['-c'],
+  ['--check']
+];
+
+// Match on the name of the `Error` but not the message as it is different
+// depending on the JavaScript engine.
+const syntaxErrorRE = /^SyntaxError: \b/m;
+
+// test bad syntax with and without shebang
+[
+  'syntax/bad_syntax.js',
+  'syntax/bad_syntax',
+  'syntax/bad_syntax_shebang.js',
+  'syntax/bad_syntax_shebang'
+].forEach(function(file) {
+  file = fixtures.path(file);
+
+  // loop each possible option, `-c` or `--check`
+  syntaxArgs.forEach(function(args) {
+    const _args = args.concat(file);
+    const cmd = [node, ..._args].join(' ');
+    exec(cmd, common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err instanceof Error, true);
+      assert.strictEqual(err.code, 1);
+
+      // no stdout should be produced
+      assert.strictEqual(stdout, '');
+
+      // stderr should have a syntax error message
+      assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
+
+      // stderr should include the filename
+      assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
+    }));
+  });
+});

test/sequential/test-cli-syntax-file-not-found.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { exec } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const node = process.execPath;
+
+// test both sets of arguments that check syntax
+const syntaxArgs = [
+  ['-c'],
+  ['--check']
+];
+
+const notFoundRE = /^Error: Cannot find module/m;
+
+// test file not found
+[
+  'syntax/file_not_found.js',
+  'syntax/file_not_found'
+].forEach(function(file) {
+  file = fixtures.path(file);
+
+  // loop each possible option, `-c` or `--check`
+  syntaxArgs.forEach(function(args) {
+    const _args = args.concat(file);
+    const cmd = [node, ..._args].join(' ');
+    exec(cmd, common.mustCall((err, stdout, stderr) => {
+      // no stdout should be produced
+      assert.strictEqual(stdout, '');
+
+      // stderr should have a module not found error message
+      assert(notFoundRE.test(stderr), `${notFoundRE} === ${stderr}`);
+
+      assert.strictEqual(err.code, 1);
+    }));
+  });
+});

test/sequential/test-cli-syntax-good.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { exec } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const node = process.execPath;
+
+// test both sets of arguments that check syntax
+const syntaxArgs = [
+  ['-c'],
+  ['--check']
+];
+
+// test good syntax with and without shebang
+[
+  'syntax/good_syntax.js',
+  'syntax/good_syntax',
+  'syntax/good_syntax_shebang.js',
+  'syntax/good_syntax_shebang',
+  'syntax/illegal_if_not_wrapped.js'
+].forEach(function(file) {
+  file = fixtures.path(file);
+
+  // loop each possible option, `-c` or `--check`
+  syntaxArgs.forEach(function(args) {
+    const _args = args.concat(file);
+
+    const cmd = [node, ..._args].join(' ');
+    exec(cmd, common.mustCall((err, stdout, stderr) => {
+      if (err) {
+        console.log('-- stdout --');
+        console.log(stdout);
+        console.log('-- stderr --');
+        console.log(stderr);
+      }
+      assert.ifError(err);
+      assert.strictEqual(stdout, '');
+      assert.strictEqual(stderr, '');
+    }));
+  });
+});

test/sequential/test-cli-syntax-require.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { exec } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+const node = process.execPath;
+
+// Match on the name of the `Error` but not the message as it is different
+// depending on the JavaScript engine.
+const syntaxErrorRE = /^SyntaxError: \b/m;
+
+// should work with -r flags
+['-c', '--check'].forEach(function(checkFlag) {
+  ['-r', '--require'].forEach(function(requireFlag) {
+    const preloadFile = fixtures.path('no-wrapper.js');
+    const file = fixtures.path('syntax', 'illegal_if_not_wrapped.js');
+    const args = [requireFlag, preloadFile, checkFlag, file];
+    const cmd = [node, ...args].join(' ');
+    exec(cmd, common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err instanceof Error, true);
+      assert.strictEqual(err.code, 1);
+
+      // no stdout should be produced
+      assert.strictEqual(stdout, '');
+
+      // stderr should have a syntax error message
+      assert(syntaxErrorRE.test(stderr), `${syntaxErrorRE} === ${stderr}`);
+
+      // stderr should include the filename
+      assert(stderr.startsWith(file), `${stderr} starts with ${file}`);
+    }));
+  });
+});