src: support namespace options in configuration file

PR-URL: #58073 Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com> Reviewed-By: Giovanni Bucci <github@puskin.it> Reviewed-By: Daniel Lemire <daniel@lemire.me>

Author: pmarchini

doc/api/cli.md

@@ -931,11 +931,19 @@ in the `$schema` must be replaced with the version of Node.js you are using.
  ],
  "watch-path": "src",
  "watch-preserve-output": true
+ },
+ "testRunner": {
+ "test-isolation": "process"
  }
 }
 ```
 
-In the `nodeOptions` field, only flags that are allowed in [`NODE_OPTIONS`][] are supported.
+The configuration file supports namespace-specific options:
+
+* The `nodeOptions` field contains CLI flags that are allowed in [`NODE_OPTIONS`][].
+
+* Namespace fields like `testRunner` contain configuration specific to that subsystem.
+
 No-op flags are not supported.
 Not all V8 flags are currently supported.
 
@@ -949,7 +957,7 @@ For example, the configuration file above is equivalent to
 the following command-line arguments:
 
 ```bash
-node --import amaro/strip --watch-path=src --watch-preserve-output
+node --import amaro/strip --watch-path=src --watch-preserve-output --test-isolation=process
 ```
 
 The priority in configuration is as follows:
@@ -962,11 +970,10 @@ Values in the configuration file will not override the values in the environment
 variables and command-line options, but will override the values in the `NODE_OPTIONS`
 env file parsed by the `--env-file` flag.
 
-If duplicate keys are present in the configuration file, only
-the first key will be used.
+Keys cannot be duplicated within the same or different namespaces.
 
 The configuration parser will throw an error if the configuration file contains
-unknown keys or keys that cannot used in `NODE_OPTIONS`.
+unknown keys or keys that cannot be used in a namespace.
 
 Node.js will not sanitize or perform validation on the user-provided configuration,
 so **NEVER** use untrusted configuration files.

doc/node-config-schema.json

@@ -584,6 +584,135 @@
  }
  },
  "type": "object"
+ },
+ "testRunner": {
+ "type": "object",
+ "additionalProperties": false,
+ "properties": {
+ "experimental-test-coverage": {
+ "type": "boolean"
+ },
+ "experimental-test-module-mocks": {
+ "type": "boolean"
+ },
+ "test-concurrency": {
+ "type": "number"
+ },
+ "test-coverage-branches": {
+ "type": "number"
+ },
+ "test-coverage-exclude": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-coverage-functions": {
+ "type": "number"
+ },
+ "test-coverage-include": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-coverage-lines": {
+ "type": "number"
+ },
+ "test-force-exit": {
+ "type": "boolean"
+ },
+ "test-global-setup": {
+ "type": "string"
+ },
+ "test-isolation": {
+ "type": "string"
+ },
+ "test-name-pattern": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-only": {
+ "type": "boolean"
+ },
+ "test-reporter": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-reporter-destination": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-shard": {
+ "type": "string"
+ },
+ "test-skip-pattern": {
+ "oneOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string",
+ "minItems": 1
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "test-timeout": {
+ "type": "number"
+ },
+ "test-update-snapshots": {
+ "type": "boolean"
+ }
+ }
  }
  },
  "type": "object"

lib/internal/options.js

@@ -13,6 +13,7 @@ const {
  getCLIOptionsInfo,
  getEmbedderOptions: getEmbedderOptionsFromBinding,
  getEnvOptionsInputType,
+ getNamespaceOptionsInputType,
 } = internalBinding('options');
 
 let warnOnAllowUnauthorized = true;
@@ -38,7 +39,22 @@ function getEmbedderOptions() {
 }
 
 function generateConfigJsonSchema() {
- const map = getEnvOptionsInputType();
+ const envOptionsMap = getEnvOptionsInputType();
+ const namespaceOptionsMap = getNamespaceOptionsInputType();
+
+ function createPropertyForType(type) {
+ if (type === 'array') {
+ return {
+ __proto__: null,
+ oneOf: [
+ { __proto__: null, type: 'string' },
+ { __proto__: null, items: { __proto__: null, type: 'string', minItems: 1 }, type: 'array' },
+ ],
+ };
+ }
+
+ return { __proto__: null, type };
+ }
 
  const schema = {
  __proto__: null,
@@ -60,31 +76,58 @@ function generateConfigJsonSchema() {
  type: 'object',
  };
 
- const nodeOptions = schema.properties.nodeOptions.properties;
+ // Get the root properties object for adding namespaces
+ const rootProperties = schema.properties;
+ const nodeOptions = rootProperties.nodeOptions.properties;
 
- for (const { 0: key, 1: type } of map) {
+ // Add env options to nodeOptions (backward compatibility)
+ for (const { 0: key, 1: type } of envOptionsMap) {
  const keyWithoutPrefix = StringPrototypeReplace(key, '--', '');
- if (type === 'array') {
- nodeOptions[keyWithoutPrefix] = {
- __proto__: null,
- oneOf: [
- { __proto__: null, type: 'string' },
- { __proto__: null, items: { __proto__: null, type: 'string', minItems: 1 }, type: 'array' },
- ],
- };
- } else {
- nodeOptions[keyWithoutPrefix] = { __proto__: null, type };
+ nodeOptions[keyWithoutPrefix] = createPropertyForType(type);
+ }
+
+ // Add namespace properties at the root level
+ for (const { 0: namespace, 1: optionsMap } of namespaceOptionsMap) {
+ // Create namespace object at the root level
+ rootProperties[namespace] = {
+ __proto__: null,
+ type: 'object',
+ additionalProperties: false,
+ properties: { __proto__: null },
+ };
+
+ const namespaceProperties = rootProperties[namespace].properties;
+
+ // Add all options for this namespace
+ for (const { 0: optionName, 1: optionType } of optionsMap) {
+ const keyWithoutPrefix = StringPrototypeReplace(optionName, '--', '');
+ namespaceProperties[keyWithoutPrefix] = createPropertyForType(optionType);
  }
+
+ // Sort the namespace properties alphabetically
+ const sortedNamespaceKeys = ArrayPrototypeSort(ObjectKeys(namespaceProperties));
+ const sortedNamespaceProperties = ObjectFromEntries(
+ ArrayPrototypeMap(sortedNamespaceKeys, (key) => [key, namespaceProperties[key]]),
+ );
+ rootProperties[namespace].properties = sortedNamespaceProperties;
  }
 
- // Sort the proerties by key alphabetically.
+ // Sort the top-level properties by key alphabetically
  const sortedKeys = ArrayPrototypeSort(ObjectKeys(nodeOptions));
  const sortedProperties = ObjectFromEntries(
  ArrayPrototypeMap(sortedKeys, (key) => [key, nodeOptions[key]]),
  );
 
  schema.properties.nodeOptions.properties = sortedProperties;
 
+ // Also sort the root level properties
+ const sortedRootKeys = ArrayPrototypeSort(ObjectKeys(rootProperties));
+ const sortedRootProperties = ObjectFromEntries(
+ ArrayPrototypeMap(sortedRootKeys, (key) => [key, rootProperties[key]]),
+ );
+
+ schema.properties = sortedRootProperties;
+
  return schema;
 }
 

lib/internal/test_runner/runner.js

@@ -98,7 +98,13 @@ let debug = require('internal/util/debuglog').debuglog('test_runner', (fn) => {
 });
 
 const kIsolatedProcessName = Symbol('kIsolatedProcessName');
-const kFilterArgs = ['--test', '--experimental-test-coverage', '--watch'];
+const kFilterArgs = [
+ '--test',
+ '--experimental-test-coverage',
+ '--watch',
+ '--experimental-default-config-file',
+ '--experimental-config-file',
+];
 const kFilterArgValues = ['--test-reporter', '--test-reporter-destination'];
 const kDiagnosticsFilterArgs = ['tests', 'suites', 'pass', 'fail', 'cancelled', 'skipped', 'todo', 'duration_ms'];
 

src/node.cc

@@ -910,7 +910,7 @@ static ExitCode InitializeNodeWithArgsInternal(
  default:
  UNREACHABLE();
  }
- node_options_from_config = per_process::config_reader.AssignNodeOptions();
+ node_options_from_config = per_process::config_reader.GetNodeOptions();
  // (@marco-ippolito) Avoid reparsing the env options again
  std::vector<std::string> env_argv_from_config =
  ParseNodeOptionsEnvVar(node_options_from_config, errors);
@@ -956,7 +956,19 @@ static ExitCode InitializeNodeWithArgsInternal(
 #endif
 
  if (!(flags & ProcessInitializationFlags::kDisableCLIOptions)) {
- const ExitCode exit_code =
+ // Parse the options coming from the config file.
+ // This is done before parsing the command line options
+ // as the cli flags are expected to override the config file ones.
+ std::vector<std::string> extra_argv =
+ per_process::config_reader.GetNamespaceFlags();
+ // [0] is expected to be the program name, fill it in from the real argv.
+ extra_argv.insert(extra_argv.begin(), argv->at(0));
+ // Parse the extra argv coming from the config file
+ ExitCode exit_code = ProcessGlobalArgsInternal(
+ &extra_argv, nullptr, errors, kDisallowedInEnvvar);
+ if (exit_code != ExitCode::kNoFailure) return exit_code;
+ // Parse options coming from the command line.
+ exit_code =
  ProcessGlobalArgsInternal(argv, exec_argv, errors, kDisallowedInEnvvar);
  if (exit_code != ExitCode::kNoFailure) return exit_code;
  }