test_runner: reject mixed module mock options

Throw when options.exports is combined with the legacy
defaultExport or namedExports options.

This keeps the behavior explicit during the transition and
avoids merge or precedence rules for mixed usage.

Author: Han5991

doc/api/test.md

@@ -2486,6 +2486,7 @@ changes:
   * `exports` {Object} Optional mocked exports. The `default` property, if
     provided, is used as the mocked module's default export. All other own
     enumerable properties are used as named exports.
+    This option cannot be used with `defaultExport` or `namedExports`.
     * If the mock is a CommonJS or builtin module, `exports.default` is used as
       the value of `module.exports`.
     * If `exports.default` is not provided for a CommonJS or builtin mock,
@@ -2497,13 +2498,15 @@ changes:
     export. If the mock is a CommonJS or builtin module, this setting is used as
     the value of `module.exports`. If this value is not provided, CJS and builtin
     mocks use an empty object as the value of `module.exports`.
+    This option cannot be used with `options.exports`.
     This option is deprecated and will be removed in a later version.
     Prefer `options.exports.default`.
   * `namedExports` {Object} An optional object whose keys and values are used to
     create the named exports of the mock module. If the mock is a CommonJS or
     builtin module, these values are copied onto `module.exports`. Therefore, if a
     mock is created with both named exports and a non-object default export, the
     mock will throw an exception when used as a CJS or builtin module.
+    This option cannot be used with `options.exports`.
     This option is deprecated and will be removed in a later version.
     Prefer `options.exports`.
 * Returns: {MockModuleContext} An object that can be used to manipulate the mock.

lib/internal/test_runner/mock/mock.js

@@ -819,22 +819,44 @@ function normalizeModuleMockOptions(options) {
   const { cache = false } = options;
   validateBoolean(cache, 'options.cache');
 
+  const hasExports = 'exports' in options;
+  const hasNamedExports = 'namedExports' in options;
+  const hasDefaultExport = 'defaultExport' in options;
+
   deprecateNamedExports(options);
   deprecateDefaultExport(options);
 
   const moduleExports = { __proto__: null };
 
-  if ('exports' in options) {
+  if (hasExports) {
     validateObject(options.exports, 'options.exports');
-    copyOwnProperties(options.exports, moduleExports);
   }
 
-  if ('namedExports' in options) {
+  if (hasNamedExports) {
     validateObject(options.namedExports, 'options.namedExports');
+  }
+
+  if (hasExports && (hasNamedExports || hasDefaultExport)) {
+    let reason = "cannot be used with 'options.namedExports'";
+
+    if (hasDefaultExport) {
+      reason = hasNamedExports ?
+        "cannot be used with 'options.namedExports' or 'options.defaultExport'" :
+        "cannot be used with 'options.defaultExport'";
+    }
+
+    throw new ERR_INVALID_ARG_VALUE('options.exports', options.exports, reason);
+  }
+
+  if (hasExports) {
+    copyOwnProperties(options.exports, moduleExports);
+  }
+
+  if (hasNamedExports) {
     copyOwnProperties(options.namedExports, moduleExports);
   }
 
-  if ('defaultExport' in options) {
+  if (hasDefaultExport) {
     ObjectDefineProperty(
       moduleExports,
       'default',

test/parallel/test-runner-module-mocking.js

@@ -48,23 +48,32 @@ test('input validation', async (t) => {
     }, { code: 'ERR_INVALID_ARG_TYPE' });
   });
 
-  await t.test('allows exports to be used with legacy options', async (t) => {
-    const fixturePath = fixtures.path('module-mocking', 'basic-cjs.js');
-    const fixture = pathToFileURL(fixturePath);
-
-    t.mock.module(fixture, {
-      exports: { value: 'from exports' },
-      namedExports: { value: 'from namedExports' },
-      defaultExport: { from: 'defaultExport' },
-    });
+  await t.test('throws if exports is used with namedExports', async (t) => {
+    assert.throws(() => {
+      t.mock.module(__filename, {
+        exports: {},
+        namedExports: {},
+      });
+    }, { code: 'ERR_INVALID_ARG_VALUE' });
+  });
 
-    const cjsMock = require(fixturePath);
-    const esmMock = await import(fixture);
+  await t.test('throws if exports is used with defaultExport', async (t) => {
+    assert.throws(() => {
+      t.mock.module(__filename, {
+        exports: {},
+        defaultExport: {},
+      });
+    }, { code: 'ERR_INVALID_ARG_VALUE' });
+  });
 
-    assert.strictEqual(cjsMock.value, 'from namedExports');
-    assert.strictEqual(cjsMock.from, 'defaultExport');
-    assert.strictEqual(esmMock.value, 'from namedExports');
-    assert.strictEqual(esmMock.default.from, 'defaultExport');
+  await t.test('throws if exports is used with both legacy options', async (t) => {
+    assert.throws(() => {
+      t.mock.module(__filename, {
+        exports: {},
+        namedExports: {},
+        defaultExport: {},
+      });
+    }, { code: 'ERR_INVALID_ARG_VALUE' });
   });
 });