From b11715187c9f9e501bb2d32a95c4ed14e0a05bd1 Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Fri, 23 May 2025 20:28:54 +0300
Subject: [PATCH 1/9] test_runner: support object property mocking

---
 doc/api/test.md                       |  40 ++++++++
 lib/internal/test_runner/mock/mock.js | 133 +++++++++++++++++++++++++-
 test/parallel/test-runner-mocking.js  |  65 +++++++++++++
 3 files changed, 237 insertions(+), 1 deletion(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index b13b4fdeb30cdb..5fdfd372085be5 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2240,6 +2240,46 @@ test('mocks a builtin module in both module systems', async (t) => {
 });
 ```
 
+### `mock.value(object, valueName, value)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `object` {Object} The object whose value is being mocked.
+* `valueName` {string|symbol} The identifier of the value on object to mock.
+* `value` {any} A value used as the mock value for `object[valueName]`.
+
+Creates a mock for a property value on an object. This allows you to track and control access to a specific property, including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
+
+```js
+test('mocks a property value', (t) => {
+  const obj = { foo: 42 };
+  const valueMock = t.mock.value(obj, 'foo', 100);
+
+  assert.strictEqual(obj.foo, 100);
+  assert.strictEqual(valueMock.callGetterCount(), 1);
+
+  obj.foo = 200;
+  assert.strictEqual(obj.foo, 200);
+  assert.strictEqual(valueMock.callSetterCount(), 1);
+
+  valueMock.restore();
+  assert.strictEqual(obj.foo, 42);
+});
+```
+
+The returned mock object provides the following methods:
+
+- `callGetterCount()`: Retrieves the number of times the property was read.
+- `callSetterCount()`: Retrieves the number of times the property was written.
+- `callCount()`: Retrieves the total number of times the property was accessed (getter or setter).
+- `mockValue(value)`: Sets the current mock value.
+- `resetCallGetters()`: Resets only the getter call count.
+- `resetCallSetters()`: Resets only the setter call count.
+- `resetCalls()`: Resets both getter and setter call counts.
+- `restore()`: Restores the original property value and descriptor.
+
 ### `mock.reset()`
 
 <!-- YAML
diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js
index 178da37efc16c8..77cf8c1d952f4e 100644
--- a/lib/internal/test_runner/mock/mock.js
+++ b/lib/internal/test_runner/mock/mock.js
@@ -284,6 +284,113 @@ class MockModuleContext {
 
 const { restore: restoreModule } = MockModuleContext.prototype;
 
+class MockValueContext {
+  #object;
+  #valueName;
+  #value;
+  #originalValue;
+  #callGetterCount = 0;
+  #callSetterCount = 0;
+  #descriptor;
+
+  constructor(object, valueName, value) {
+    this.#object = object;
+    this.#valueName = valueName;
+    this.#value = value;
+    this.#originalValue = object[valueName];
+    this.#descriptor = ObjectGetOwnPropertyDescriptor(object, valueName);
+
+    const { configurable, enumerable, writable } = this.#descriptor;
+    ObjectDefineProperty(object, valueName, {
+      __proto__: null,
+      configurable: configurable,
+      enumerable: enumerable,
+      get: () => {
+        this.#callGetterCount++;
+        return this.#value;
+      },
+      set: writable ?
+        (newValue) => {
+          this.#callSetterCount++;
+          this.#value = newValue;
+        } :
+        () => {
+          throw new ERR_INVALID_ARG_VALUE(
+            'valueName', valueName, 'cannot be set',
+          );
+        },
+    });
+  }
+
+  /**
+   * Retrieves the number of times the property was read.
+   * @returns {number} The number of times the getter was called.
+   */
+  callGetterCount() {
+    return this.#callGetterCount;
+  }
+
+  /**
+   * Retrieves the number of times the property was written.
+   * @returns {number} The number of times the setter was called.
+   */
+  callSetterCount() {
+    return this.#callSetterCount;
+  }
+
+  /**
+   * Retrieves the total number of times the property was accessed (getter or setter)
+   * @returns {number} The total number of calls.
+   */
+  callCount() {
+    return this.callGetterCount() + this.callSetterCount();
+  }
+
+  /**
+   * Sets a new value for the property.
+   * @param {any} value - The new value to be set.
+   * @throws {Error} If the property is not writable.
+   */
+  mockValue(value) {
+    this.#value = value;
+  }
+
+  /**
+   * Resets the call count for the getter.
+   */
+  resetCallGetters() {
+    this.#callGetterCount = 0;
+  }
+
+  /**
+   * Resets the call count for the setter.
+   */
+  resetCallSetters() {
+    this.#callSetterCount = 0;
+  }
+
+  /**
+   * Resets the call counts for both getter and setter.
+   */
+  resetCalls() {
+    this.resetCallGetters();
+    this.resetCallSetters();
+  }
+
+  /**
+   * Restores the original value of the property that was mocked.
+   */
+  restore() {
+    ObjectDefineProperty(this.#object, this.#valueName, {
+      __proto__: null,
+      ...this.#descriptor,
+      value: this.#originalValue,
+    });
+  }
+}
+
+const { restore: restoreValue } = MockValueContext.prototype;
+
 class MockTracker {
   #mocks = [];
   #timers;
@@ -573,6 +680,30 @@ class MockTracker {
     return ctx;
   }
 
+  /**
+   * Creates a value tracker for a specified object.
+   * @param {(object)} object - The object whose value is being tracked.
+   * @param {string} valueName - The identifier of the value on object to be tracked.
+   * @param {any} value - A value used as the mock value for object[valueName].
+   * @returns {MockValueContext} The mock value tracker.
+   */
+  value(
+    object,
+    valueName,
+    value,
+  ) {
+    validateObject(object, 'object');
+    validateStringOrSymbol(valueName, 'valueName');
+
+    const ctx = new MockValueContext(object, valueName, value);
+    ArrayPrototypePush(this.#mocks, {
+      __proto__: null,
+      ctx,
+      restore: restoreValue,
+    });
+    return ctx;
+  }
+
   /**
    * Resets the mock tracker, restoring all mocks and clearing timers.
    */
@@ -726,7 +857,7 @@ function cjsMockModuleLoad(request, parent, isMain) {
   const exportNames = ObjectKeys(namedExports);
 
   if ((typeof modExports !== 'object' || modExports === null) &&
-      exportNames.length > 0) {
+    exportNames.length > 0) {
     // eslint-disable-next-line no-restricted-syntax
     throw new Error(kBadExportsMessage);
   }
diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index b5ef955be6926f..1705cac2b67b5d 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -1054,3 +1054,68 @@ test('setter() fails if getter options is true', (t) => {
     t.mock.setter({}, 'method', { getter: true });
   }, /The property 'options\.setter' cannot be used with 'options\.getter'/);
 });
+
+test('spies on a property value', (t) => {
+  const obj = { foo: 42 };
+  const valueMock = t.mock.value(obj, 'foo', 100);
+
+  assert.strictEqual(obj.foo, 100);
+  assert.strictEqual(valueMock.callCount(), 1);
+  assert.strictEqual(valueMock.callGetterCount(), 1);
+  assert.strictEqual(valueMock.callSetterCount(), 0);
+
+  obj.foo = 200;
+  assert.strictEqual(obj.foo, 200);
+  assert.strictEqual(valueMock.callCount(), 3);
+  assert.strictEqual(valueMock.callGetterCount(), 2);
+  assert.strictEqual(valueMock.callSetterCount(), 1);
+
+  obj.foo = 300;
+  assert.strictEqual(obj.foo, 300);
+  assert.strictEqual(valueMock.callSetterCount(), 2);
+
+  valueMock.mockValue(400);
+  assert.strictEqual(obj.foo, 400);
+  assert.strictEqual(valueMock.callGetterCount(), 4);
+
+  valueMock.resetCalls();
+  assert.strictEqual(valueMock.callCount(), 0);
+  assert.strictEqual(valueMock.callGetterCount(), 0);
+  assert.strictEqual(valueMock.callSetterCount(), 0);
+
+  obj.foo = 500;
+  assert.strictEqual(valueMock.callSetterCount(), 1);
+
+  valueMock.resetCallSetters();
+  assert.strictEqual(valueMock.callSetterCount(), 0);
+
+  assert.strictEqual(obj.foo, 500);
+  assert.strictEqual(valueMock.callGetterCount(), 1);
+
+  valueMock.resetCallGetters();
+  assert.strictEqual(valueMock.callGetterCount(), 0);
+
+  valueMock.restore();
+  assert.strictEqual(obj.foo, 42);
+
+  obj.foo = 600;
+  assert.strictEqual(obj.foo, 600);
+  assert.strictEqual(valueMock.callCount(), 0);
+});
+
+test('spies on a non-writable property value', (t) => {
+  const obj = {};
+  Object.defineProperty(obj, 'bar', {
+    value: 1,
+    writable: false,
+    configurable: true,
+    enumerable: true,
+  });
+
+  const valueMock = t.mock.value(obj, 'bar', 2);
+  assert.strictEqual(obj.bar, 2);
+  assert.throws(() => { obj.bar = 3; }, /cannot be set/);
+
+  valueMock.restore();
+  assert.strictEqual(obj.bar, 1);
+});

From 691f4d5e86794ed4014f84fd06895d5d22b9e637 Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Fri, 23 May 2025 20:40:36 +0300
Subject: [PATCH 2/9] fix: lint

---
 doc/api/test.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index 5fdfd372085be5..ab8d10376a0b9f 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2250,7 +2250,8 @@ added: REPLACEME
 * `valueName` {string|symbol} The identifier of the value on object to mock.
 * `value` {any} A value used as the mock value for `object[valueName]`.
 
-Creates a mock for a property value on an object. This allows you to track and control access to a specific property, including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
+Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
+including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
 
 ```js
 test('mocks a property value', (t) => {

From bccd7e2c934fe135881df82a18b49881ce32bc5b Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Fri, 23 May 2025 20:45:56 +0300
Subject: [PATCH 3/9] fix: lint

---
 doc/api/test.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index ab8d10376a0b9f..fd457611cd60d5 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2272,14 +2272,14 @@ test('mocks a property value', (t) => {
 
 The returned mock object provides the following methods:
 
-- `callGetterCount()`: Retrieves the number of times the property was read.
-- `callSetterCount()`: Retrieves the number of times the property was written.
-- `callCount()`: Retrieves the total number of times the property was accessed (getter or setter).
-- `mockValue(value)`: Sets the current mock value.
-- `resetCallGetters()`: Resets only the getter call count.
-- `resetCallSetters()`: Resets only the setter call count.
-- `resetCalls()`: Resets both getter and setter call counts.
-- `restore()`: Restores the original property value and descriptor.
+* `callGetterCount()`: Retrieves the number of times the property was read.
+* `callSetterCount()`: Retrieves the number of times the property was written.
+* `callCount()`: Retrieves the total number of times the property was accessed (getter or setter).
+* `mockValue(value)`: Sets the current mock value.
+* `resetCallGetters()`: Resets only the getter call count.
+* `resetCallSetters()`: Resets only the setter call count.
+* `resetCalls()`: Resets both getter and setter call counts.
+* `restore()`: Restores the original property value and descriptor.
 
 ### `mock.reset()`
 

From e3f66f067b16e5820e0767c4d2d2e67362c39bcb Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Sat, 24 May 2025 05:21:23 +0300
Subject: [PATCH 4/9] cr fixes: - `mock.value` -> `mock.property`. - `value`
 parameter is now optional. - add `MockValueContext` section to the docs. -
 align API with the rest of the mocking framework. - add more tests

---
 doc/api/test.md                       |  79 ++++++++++---
 lib/internal/test_runner/mock/mock.js | 144 ++++++++++++-----------
 test/parallel/test-runner-mocking.js  | 162 ++++++++++++++++++++------
 3 files changed, 262 insertions(+), 123 deletions(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index fd457611cd60d5..743343396874d6 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2036,6 +2036,50 @@ added:
 
 Resets the implementation of the mock module.
 
+## Class: `MockPropertyContext`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `MockPropertyContext` class is used to inspect or manipulate the behavior
+of property mocks created via the [`MockTracker`][] APIs.
+
+### `ctx.accesses`
+
+* {Array}
+
+A getter that returns a copy of the internal array used to track accesses (get/set) to
+the mocked property. Each entry in the array is an object with the following properties:
+
+* `type` {string} Either `'get'` or `'set'`, indicating the type of access.
+* `value` {any} The value that was read (for `'get'`) or written (for `'set'`).
+* `stack` {Error} An `Error` object whose stack can be used to determine the
+  callsite of the mocked function invocation.
+
+### `ctx.accessCount()`
+
+* Returns: {integer} The number of times that the property was accessed (read or written).
+
+This function returns the number of times that the property was accessed.
+This function is more efficient than checking `ctx.accesses.length` because
+`ctx.accesses` is a getter that creates a copy of the internal access tracking array.
+
+### `ctx.mockImplementation(value)`
+
+* `value` {any} The new value to be set as the mocked property value.
+
+This function is used to change the value returned by the mocked property getter.
+
+### `ctx.resetAccesses()`
+
+Resets the access history of the mocked property.
+
+### `ctx.restore()`
+
+Resets the implementation of the mock property to its original behavior. The
+mock can still be used after calling this function.
+
 ## Class: `MockTracker`
 
 <!-- YAML
@@ -2240,15 +2284,18 @@ test('mocks a builtin module in both module systems', async (t) => {
 });
 ```
 
-### `mock.value(object, valueName, value)`
+### `mock.property(object, propertyName[, value])`
 
 <!-- YAML
 added: REPLACEME
 -->
 
 * `object` {Object} The object whose value is being mocked.
-* `valueName` {string|symbol} The identifier of the value on object to mock.
-* `value` {any} A value used as the mock value for `object[valueName]`.
+* `propertyName` {string|symbol} The identifier of the property on `object` to mock.
+* `value` {any} An optional value used as the mock value for `object[valueName]`. **Default:** The original property value.
+* Returns: {Proxy} A proxy to the mocked object. The mocked object contains a
+  special `mock` property, which is an instance of [`MockPropertyContext`], and
+  can be used for inspecting and changing the behavior of the mocked property.
 
 Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
 including how many times it is read (getter) or written (setter), and to restore the original value after mocking.
@@ -2256,31 +2303,23 @@ including how many times it is read (getter) or written (setter), and to restore
 ```js
 test('mocks a property value', (t) => {
   const obj = { foo: 42 };
-  const valueMock = t.mock.value(obj, 'foo', 100);
+  const prop = t.mock.property(obj, 'foo', 100);
 
   assert.strictEqual(obj.foo, 100);
-  assert.strictEqual(valueMock.callGetterCount(), 1);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
+  assert.strictEqual(prop.mock.accesses[0].value, 100);
 
   obj.foo = 200;
-  assert.strictEqual(obj.foo, 200);
-  assert.strictEqual(valueMock.callSetterCount(), 1);
+  assert.strictEqual(prop.mock.accessCount(), 2);
+  assert.strictEqual(prop.mock.accesses[1].type, 'set');
+  assert.strictEqual(prop.mock.accesses[1].value, 200);
 
-  valueMock.restore();
+  prop.mock.restore();
   assert.strictEqual(obj.foo, 42);
 });
 ```
 
-The returned mock object provides the following methods:
-
-* `callGetterCount()`: Retrieves the number of times the property was read.
-* `callSetterCount()`: Retrieves the number of times the property was written.
-* `callCount()`: Retrieves the total number of times the property was accessed (getter or setter).
-* `mockValue(value)`: Sets the current mock value.
-* `resetCallGetters()`: Resets only the getter call count.
-* `resetCallSetters()`: Resets only the setter call count.
-* `resetCalls()`: Resets both getter and setter call counts.
-* `restore()`: Restores the original property value and descriptor.
-
 ### `mock.reset()`
 
 <!-- YAML
@@ -3815,8 +3854,10 @@ Can be used to abort test subtasks when the test has been aborted.
 [`--test-update-snapshots`]: cli.md#--test-update-snapshots
 [`--test`]: cli.md#--test
 [`MockFunctionContext`]: #class-mockfunctioncontext
+[`MockPropertyContext`]: #class-mockpropertycontext
 [`MockTimers`]: #class-mocktimers
 [`MockTracker.method`]: #mockmethodobject-methodname-implementation-options
+[`MockTracker.property`]: #mockpropertyobject-propertyName-value
 [`MockTracker`]: #class-mocktracker
 [`NODE_V8_COVERAGE`]: cli.md#node_v8_coveragedir
 [`SuiteContext`]: #class-suitecontext
diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js
index 77cf8c1d952f4e..f6fbc8323baad6 100644
--- a/lib/internal/test_runner/mock/mock.js
+++ b/lib/internal/test_runner/mock/mock.js
@@ -284,66 +284,61 @@ class MockModuleContext {
 
 const { restore: restoreModule } = MockModuleContext.prototype;
 
-class MockValueContext {
+class MockPropertyContext {
   #object;
-  #valueName;
+  #propertyName;
   #value;
   #originalValue;
-  #callGetterCount = 0;
-  #callSetterCount = 0;
   #descriptor;
+  #accesses;
 
-  constructor(object, valueName, value) {
+  constructor(object, propertyName, value) {
+    this.#accesses = [];
     this.#object = object;
-    this.#valueName = valueName;
-    this.#value = value;
-    this.#originalValue = object[valueName];
-    this.#descriptor = ObjectGetOwnPropertyDescriptor(object, valueName);
+    this.#propertyName = propertyName;
+    this.#originalValue = object[propertyName];
+    this.#value = value ?? this.#originalValue;
+    this.#descriptor = ObjectGetOwnPropertyDescriptor(object, propertyName);
+    if (!this.#descriptor) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'propertyName', propertyName, 'is not a property of the object',
+      );
+    }
 
-    const { configurable, enumerable, writable } = this.#descriptor;
-    ObjectDefineProperty(object, valueName, {
+    const { configurable, enumerable } = this.#descriptor;
+    ObjectDefineProperty(object, propertyName, {
       __proto__: null,
-      configurable: configurable,
-      enumerable: enumerable,
+      configurable,
+      enumerable,
       get: () => {
-        this.#callGetterCount++;
+        const access = {
+          __proto__: null,
+          type: 'get',
+          value: this.#value,
+          // eslint-disable-next-line no-restricted-syntax
+          stack: new Error(),
+        };
+        ArrayPrototypePush(this.#accesses, access);
         return this.#value;
       },
-      set: writable ?
-        (newValue) => {
-          this.#callSetterCount++;
-          this.#value = newValue;
-        } :
-        () => {
-          throw new ERR_INVALID_ARG_VALUE(
-            'valueName', valueName, 'cannot be set',
-          );
-        },
+      set: this.mockImplementation.bind(this),
     });
   }
 
   /**
-   * Retrieves the number of times the property was read.
-   * @returns {number} The number of times the getter was called.
+   * Gets an array of recorded accesses (get/set) to the property.
+   * @returns {Array} An array of access records.
    */
-  callGetterCount() {
-    return this.#callGetterCount;
+  get accesses() {
+    return ArrayPrototypeSlice(this.#accesses, 0);
   }
 
   /**
-   * Retrieves the number of times the property was written.
-   * @returns {number} The number of times the setter was called.
+   * Retrieves the number of times the property was accessed (get or set).
+   * @returns {number} The total number of accesses.
    */
-  callSetterCount() {
-    return this.#callSetterCount;
-  }
-
-  /**
-   * Retrieves the total number of times the property was accessed (getter or setter)
-   * @returns {number} The total number of calls.
-   */
-  callCount() {
-    return this.callGetterCount() + this.callSetterCount();
+  accessCount() {
+    return this.#accesses.length;
   }
 
   /**
@@ -351,37 +346,35 @@ class MockValueContext {
    * @param {any} value - The new value to be set.
    * @throws {Error} If the property is not writable.
    */
-  mockValue(value) {
+  mockImplementation(value) {
+    if (!this.#descriptor.writable) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'propertyName', this.#propertyName, 'cannot be set',
+      );
+    }
+    const access = {
+      __proto__: null,
+      type: 'set',
+      value: value,
+      // eslint-disable-next-line no-restricted-syntax
+      stack: new Error(),
+    };
+    ArrayPrototypePush(this.#accesses, access);
     this.#value = value;
   }
 
   /**
-   * Resets the call count for the getter.
+   * Resets the recorded accesses to the property.
    */
-  resetCallGetters() {
-    this.#callGetterCount = 0;
-  }
-
-  /**
-   * Resets the call count for the setter.
-   */
-  resetCallSetters() {
-    this.#callSetterCount = 0;
-  }
-
-  /**
-   * Resets the call counts for both getter and setter.
-   */
-  resetCalls() {
-    this.resetCallGetters();
-    this.resetCallSetters();
+  resetAccesses() {
+    this.#accesses = [];
   }
 
   /**
    * Restores the original value of the property that was mocked.
    */
   restore() {
-    ObjectDefineProperty(this.#object, this.#valueName, {
+    ObjectDefineProperty(this.#object, this.#propertyName, {
       __proto__: null,
       ...this.#descriptor,
       value: this.#originalValue,
@@ -389,7 +382,7 @@ class MockValueContext {
   }
 }
 
-const { restore: restoreValue } = MockValueContext.prototype;
+const { restore: restoreProperty } = MockPropertyContext.prototype;
 
 class MockTracker {
   #mocks = [];
@@ -681,27 +674,36 @@ class MockTracker {
   }
 
   /**
-   * Creates a value tracker for a specified object.
+   * Creates a property tracker for a specified object.
    * @param {(object)} object - The object whose value is being tracked.
-   * @param {string} valueName - The identifier of the value on object to be tracked.
+   * @param {string} propertyName - The identifier of the property on object to be tracked.
    * @param {any} value - A value used as the mock value for object[valueName].
-   * @returns {MockValueContext} The mock value tracker.
+   * @returns {ProxyConstructor} The mock property tracker.
    */
-  value(
+  property(
     object,
-    valueName,
+    propertyName,
     value,
   ) {
     validateObject(object, 'object');
-    validateStringOrSymbol(valueName, 'valueName');
+    validateStringOrSymbol(propertyName, 'propertyName');
 
-    const ctx = new MockValueContext(object, valueName, value);
+    const ctx = new MockPropertyContext(object, propertyName, value);
     ArrayPrototypePush(this.#mocks, {
       __proto__: null,
       ctx,
-      restore: restoreValue,
+      restore: restoreProperty,
+    });
+
+    return new Proxy(object, {
+      __proto__: null,
+      get(target, property, receiver) {
+        if (property === 'mock') {
+          return ctx;
+        }
+        return ReflectGet(target, property, receiver);
+      },
     });
-    return ctx;
   }
 
   /**
@@ -857,7 +859,7 @@ function cjsMockModuleLoad(request, parent, isMain) {
   const exportNames = ObjectKeys(namedExports);
 
   if ((typeof modExports !== 'object' || modExports === null) &&
-    exportNames.length > 0) {
+      exportNames.length > 0) {
     // eslint-disable-next-line no-restricted-syntax
     throw new Error(kBadExportsMessage);
   }
diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index 1705cac2b67b5d..c755c58793cd38 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -391,7 +391,7 @@ test('spies on async static class methods', async (t) => {
 
 });
 
-test('given null to a mock.method it throws a invalid argument error', (t) => {
+test('given null to a mock.method it throws an invalid argument error', (t) => {
   assert.throws(() => t.mock.method(null, {}), { code: 'ERR_INVALID_ARG_TYPE' });
 });
 
@@ -1057,53 +1057,68 @@ test('setter() fails if getter options is true', (t) => {
 
 test('spies on a property value', (t) => {
   const obj = { foo: 42 };
-  const valueMock = t.mock.value(obj, 'foo', 100);
+  const prop = t.mock.property(obj, 'foo', 100);
 
   assert.strictEqual(obj.foo, 100);
-  assert.strictEqual(valueMock.callCount(), 1);
-  assert.strictEqual(valueMock.callGetterCount(), 1);
-  assert.strictEqual(valueMock.callSetterCount(), 0);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
+  assert.strictEqual(prop.mock.accesses[0].value, 100);
 
   obj.foo = 200;
   assert.strictEqual(obj.foo, 200);
-  assert.strictEqual(valueMock.callCount(), 3);
-  assert.strictEqual(valueMock.callGetterCount(), 2);
-  assert.strictEqual(valueMock.callSetterCount(), 1);
+  assert.strictEqual(prop.mock.accesses.length, 3);
+  assert.strictEqual(prop.mock.accesses[1].type, 'set');
+  assert.strictEqual(prop.mock.accesses[1].value, 200);
+  assert.strictEqual(prop.mock.accesses[2].type, 'get');
+  assert.strictEqual(prop.mock.accesses[2].value, 200);
 
   obj.foo = 300;
   assert.strictEqual(obj.foo, 300);
-  assert.strictEqual(valueMock.callSetterCount(), 2);
+  assert.strictEqual(prop.mock.accessCount(), 5);
+  assert.strictEqual(prop.mock.accesses[3].type, 'set');
+  assert.strictEqual(prop.mock.accesses[3].value, 300);
+  assert.strictEqual(prop.mock.accesses[4].type, 'get');
+  assert.strictEqual(prop.mock.accesses[4].value, 300);
 
-  valueMock.mockValue(400);
-  assert.strictEqual(obj.foo, 400);
-  assert.strictEqual(valueMock.callGetterCount(), 4);
-
-  valueMock.resetCalls();
-  assert.strictEqual(valueMock.callCount(), 0);
-  assert.strictEqual(valueMock.callGetterCount(), 0);
-  assert.strictEqual(valueMock.callSetterCount(), 0);
+  prop.mock.resetAccesses();
+  assert.strictEqual(prop.mock.accessCount(), 0);
 
   obj.foo = 500;
-  assert.strictEqual(valueMock.callSetterCount(), 1);
+  assert.strictEqual(obj.foo, 500);
+  assert.strictEqual(prop.mock.accessCount(), 2);
+  assert.strictEqual(prop.mock.accesses[0].type, 'set');
+  assert.strictEqual(prop.mock.accesses[1].type, 'get');
 
-  valueMock.resetCallSetters();
-  assert.strictEqual(valueMock.callSetterCount(), 0);
+  prop.mock.resetAccesses();
+  assert.strictEqual(prop.mock.accessCount(), 0);
 
   assert.strictEqual(obj.foo, 500);
-  assert.strictEqual(valueMock.callGetterCount(), 1);
-
-  valueMock.resetCallGetters();
-  assert.strictEqual(valueMock.callGetterCount(), 0);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
 
-  valueMock.restore();
+  prop.mock.restore();
   assert.strictEqual(obj.foo, 42);
+});
+
+test('property() works with symbol property names', (t) => {
+  const symbol = Symbol('foo');
+  const obj = { [symbol]: 123 };
+  const prop = t.mock.property(obj, symbol, 456);
+
+  assert.strictEqual(obj[symbol], 456);
+  assert.strictEqual(prop.mock.accessCount(), 1);
 
-  obj.foo = 600;
-  assert.strictEqual(obj.foo, 600);
-  assert.strictEqual(valueMock.callCount(), 0);
+  obj[symbol] = 789;
+  assert.strictEqual(obj[symbol], 789);
+  assert.strictEqual(prop.mock.accessCount(), 3);
+  assert.strictEqual(prop.mock.accesses[1].type, 'set');
+  assert.strictEqual(prop.mock.accesses[2].type, 'get');
+
+  prop.mock.restore();
+  assert.strictEqual(obj[symbol], 123);
 });
 
-test('spies on a non-writable property value', (t) => {
+test('throws if attempting to change a property which is not writable', (t) => {
   const obj = {};
   Object.defineProperty(obj, 'bar', {
     value: 1,
@@ -1112,10 +1127,91 @@ test('spies on a non-writable property value', (t) => {
     enumerable: true,
   });
 
-  const valueMock = t.mock.value(obj, 'bar', 2);
+  t.mock.property(obj, 'bar', 2);
   assert.strictEqual(obj.bar, 2);
-  assert.throws(() => { obj.bar = 3; }, /cannot be set/);
 
-  valueMock.restore();
-  assert.strictEqual(obj.bar, 1);
+  assert.throws(() => { obj.bar = 3; }, { code: 'ERR_INVALID_ARG_VALUE' });
+});
+
+test('mock property can be changed dynamically', (t) => {
+  const obj = { foo: 1 };
+
+  const prop = t.mock.property(obj, 'foo', 2);
+  assert.strictEqual(obj.foo, 2);
+
+  prop.mock.mockImplementation(99);
+  assert.strictEqual(obj.foo, 99);
+
+  prop.mock.mockImplementation(undefined);
+  assert.strictEqual(obj.foo, undefined);
+});
+
+test('resetAccesses does not affect property value', (t) => {
+  const obj = { foo: 1 };
+  const prop = t.mock.property(obj, 'foo', 2);
+
+  obj.foo = 5;
+  assert.strictEqual(obj.foo, 5);
+  assert.strictEqual(prop.mock.accessCount(), 2);
+
+  prop.mock.resetAccesses();
+  assert.strictEqual(obj.foo, 5);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
+});
+
+test('restore resets to the original value', (t) => {
+  const obj = {
+    foo: 10,
+  };
+
+  const prop = t.mock.property(obj, 'foo', 20);
+  assert.strictEqual(obj.foo, 20);
+
+  prop.mock.restore();
+  assert.strictEqual(obj.foo, 10);
+});
+
+test('given a property name that does not exist, it throws an invalid argument value error', (t) => {
+  assert.throws(() => {
+    t.mock.property({}, 'doesNotExist', 1);
+  }, { code: 'ERR_INVALID_ARG_VALUE' });
+});
+
+test('given null instead of an object, mock.property throws an invalid argument type error', (t) => {
+  assert.throws(() => {
+    t.mock.property(null, 'foo', 1);
+  }, { code: 'ERR_INVALID_ARG_TYPE' });
+});
+
+test('local property mocks are auto restored after the test finishes', async (t) => {
+  const obj = { foo: 111, bar: 222 };
+
+  assert.strictEqual(obj.foo, 111);
+  assert.strictEqual(obj.bar, 222);
+
+  t.mock.property(obj, 'foo', 888);
+
+  assert.strictEqual(obj.foo, 888);
+  assert.strictEqual(obj.bar, 222);
+
+  t.beforeEach(() => {
+    assert.strictEqual(obj.foo, 888);
+    assert.strictEqual(obj.bar, 222);
+  });
+
+  t.afterEach(() => {
+    assert.strictEqual(obj.foo, 888);
+    assert.strictEqual(obj.bar, 999);
+  });
+
+  await t.test('creates property mocks that are auto restored', (t) => {
+    t.mock.property(obj, 'bar', 999);
+
+    assert.strictEqual(obj.foo, 888);
+    assert.strictEqual(obj.bar, 999);
+  });
+
+  assert.strictEqual(obj.foo, 888);
+  assert.strictEqual(obj.bar, 222);
 });

From 5dfa82690a13b822d2a6d6460ed295a0ad7fa52d Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Sat, 24 May 2025 05:29:33 +0300
Subject: [PATCH 5/9] fix: lint

---
 doc/api/test.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index 743343396874d6..37bdd2a448ff3c 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2292,9 +2292,10 @@ added: REPLACEME
 
 * `object` {Object} The object whose value is being mocked.
 * `propertyName` {string|symbol} The identifier of the property on `object` to mock.
-* `value` {any} An optional value used as the mock value for `object[valueName]`. **Default:** The original property value.
+* `value` {any} An optional value used as the mock value
+  for `object[valueName]`. **Default:** The original property value.
 * Returns: {Proxy} A proxy to the mocked object. The mocked object contains a
-  special `mock` property, which is an instance of [`MockPropertyContext`], and
+  special `mock` property, which is an instance of [`MockPropertyContext`][], and
   can be used for inspecting and changing the behavior of the mocked property.
 
 Creates a mock for a property value on an object. This allows you to track and control access to a specific property,
@@ -3857,7 +3858,6 @@ Can be used to abort test subtasks when the test has been aborted.
 [`MockPropertyContext`]: #class-mockpropertycontext
 [`MockTimers`]: #class-mocktimers
 [`MockTracker.method`]: #mockmethodobject-methodname-implementation-options
-[`MockTracker.property`]: #mockpropertyobject-propertyName-value
 [`MockTracker`]: #class-mocktracker
 [`NODE_V8_COVERAGE`]: cli.md#node_v8_coveragedir
 [`SuiteContext`]: #class-suitecontext

From e02bd78a810ce976940721ed6d166964468120b9 Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Sat, 24 May 2025 15:10:41 +0300
Subject: [PATCH 6/9] add test to ensure original value is spied when `value`
 param is not provided

and rename property mock tests to align with the ones in `test-runner-mocking.js`.
---
 test/parallel/test-runner-mocking.js | 63 ++++++++++++++++++----------
 1 file changed, 42 insertions(+), 21 deletions(-)

diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index c755c58793cd38..0c66d1691c549c 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -1055,7 +1055,7 @@ test('setter() fails if getter options is true', (t) => {
   }, /The property 'options\.setter' cannot be used with 'options\.getter'/);
 });
 
-test('spies on a property value', (t) => {
+test('spies on a property', (t) => {
   const obj = { foo: 42 };
   const prop = t.mock.property(obj, 'foo', 100);
 
@@ -1100,7 +1100,28 @@ test('spies on a property value', (t) => {
   assert.strictEqual(obj.foo, 42);
 });
 
-test('property() works with symbol property names', (t) => {
+test('spies on a property without providing a value', (t) => {
+  const obj = { foo: 123 };
+  const prop = t.mock.property(obj, 'foo');
+
+  assert.strictEqual(obj.foo, 123);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
+  assert.strictEqual(prop.mock.accesses[0].value, 123);
+
+  obj.foo = 456;
+  assert.strictEqual(obj.foo, 456);
+  assert.strictEqual(prop.mock.accessCount(), 3);
+  assert.strictEqual(prop.mock.accesses[1].type, 'set');
+  assert.strictEqual(prop.mock.accesses[1].value, 456);
+  assert.strictEqual(prop.mock.accesses[2].type, 'get');
+  assert.strictEqual(prop.mock.accesses[2].value, 456);
+
+  prop.mock.restore();
+  assert.strictEqual(obj.foo, 123);
+});
+
+test('spies on a symbol property', (t) => {
   const symbol = Symbol('foo');
   const obj = { [symbol]: 123 };
   const prop = t.mock.property(obj, symbol, 456);
@@ -1118,22 +1139,7 @@ test('property() works with symbol property names', (t) => {
   assert.strictEqual(obj[symbol], 123);
 });
 
-test('throws if attempting to change a property which is not writable', (t) => {
-  const obj = {};
-  Object.defineProperty(obj, 'bar', {
-    value: 1,
-    writable: false,
-    configurable: true,
-    enumerable: true,
-  });
-
-  t.mock.property(obj, 'bar', 2);
-  assert.strictEqual(obj.bar, 2);
-
-  assert.throws(() => { obj.bar = 3; }, { code: 'ERR_INVALID_ARG_VALUE' });
-});
-
-test('mock property can be changed dynamically', (t) => {
+test('changes mocked property value dynamically', (t) => {
   const obj = { foo: 1 };
 
   const prop = t.mock.property(obj, 'foo', 2);
@@ -1160,7 +1166,7 @@ test('resetAccesses does not affect property value', (t) => {
   assert.strictEqual(prop.mock.accesses[0].type, 'get');
 });
 
-test('restore resets to the original value', (t) => {
+test('restores original property value', (t) => {
   const obj = {
     foo: 10,
   };
@@ -1172,13 +1178,28 @@ test('restore resets to the original value', (t) => {
   assert.strictEqual(obj.foo, 10);
 });
 
-test('given a property name that does not exist, it throws an invalid argument value error', (t) => {
+test('throws if setting a non-writable property', (t) => {
+  const obj = {};
+  Object.defineProperty(obj, 'bar', {
+    value: 1,
+    writable: false,
+    configurable: true,
+    enumerable: true,
+  });
+
+  t.mock.property(obj, 'bar', 2);
+  assert.strictEqual(obj.bar, 2);
+
+  assert.throws(() => { obj.bar = 3; }, { code: 'ERR_INVALID_ARG_VALUE' });
+});
+
+test('throws if property does not exist', (t) => {
   assert.throws(() => {
     t.mock.property({}, 'doesNotExist', 1);
   }, { code: 'ERR_INVALID_ARG_VALUE' });
 });
 
-test('given null instead of an object, mock.property throws an invalid argument type error', (t) => {
+test('throws if object is null', (t) => {
   assert.throws(() => {
     t.mock.property(null, 'foo', 1);
   }, { code: 'ERR_INVALID_ARG_TYPE' });

From aaef61a810bcd7dafa7642f34cb9a8c35c4a879f Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Mon, 26 May 2025 03:07:36 +0300
Subject: [PATCH 7/9] fix: `MockPropertyContext` distinguish between passing
 `undefined` and not passing value parameter at all

and add test for undefined mock property value
---
 lib/internal/test_runner/mock/mock.js |  8 +++++---
 test/parallel/test-runner-mocking.js  | 13 +++++++++++++
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js
index f6fbc8323baad6..002944ca0a1613 100644
--- a/lib/internal/test_runner/mock/mock.js
+++ b/lib/internal/test_runner/mock/mock.js
@@ -297,7 +297,7 @@ class MockPropertyContext {
     this.#object = object;
     this.#propertyName = propertyName;
     this.#originalValue = object[propertyName];
-    this.#value = value ?? this.#originalValue;
+    this.#value = arguments.length > 2 ? value : this.#originalValue;
     this.#descriptor = ObjectGetOwnPropertyDescriptor(object, propertyName);
     if (!this.#descriptor) {
       throw new ERR_INVALID_ARG_VALUE(
@@ -677,7 +677,7 @@ class MockTracker {
    * Creates a property tracker for a specified object.
    * @param {(object)} object - The object whose value is being tracked.
    * @param {string} propertyName - The identifier of the property on object to be tracked.
-   * @param {any} value - A value used as the mock value for object[valueName].
+   * @param {any} value - An optional replacement value used as the mock value for object[valueName].
    * @returns {ProxyConstructor} The mock property tracker.
    */
   property(
@@ -688,7 +688,9 @@ class MockTracker {
     validateObject(object, 'object');
     validateStringOrSymbol(propertyName, 'propertyName');
 
-    const ctx = new MockPropertyContext(object, propertyName, value);
+    const ctx = arguments.length > 2 ?
+      new MockPropertyContext(object, propertyName, value) :
+      new MockPropertyContext(object, propertyName);
     ArrayPrototypePush(this.#mocks, {
       __proto__: null,
       ctx,
diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index 0c66d1691c549c..6297cbae8e0cc1 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -1152,6 +1152,19 @@ test('changes mocked property value dynamically', (t) => {
   assert.strictEqual(obj.foo, undefined);
 });
 
+test('mocks property value to undefined', (t) => {
+  const obj = { foo: 123 };
+  const prop = t.mock.property(obj, 'foo', undefined);
+
+  assert.strictEqual(obj.foo, undefined);
+  assert.strictEqual(prop.mock.accessCount(), 1);
+  assert.strictEqual(prop.mock.accesses[0].type, 'get');
+  assert.strictEqual(prop.mock.accesses[0].value, undefined);
+
+  prop.mock.restore();
+  assert.strictEqual(obj.foo, 123);
+});
+
 test('resetAccesses does not affect property value', (t) => {
   const obj = { foo: 1 };
   const prop = t.mock.property(obj, 'foo', 2);

From 1d0288822cc77f720fb296d400f061c6b9c60653 Mon Sep 17 00:00:00 2001
From: idango10 <idan.goshen@gmail.com>
Date: Mon, 26 May 2025 22:26:58 +0300
Subject: [PATCH 8/9] feat: add `mockImplementationOnce` method to
 `MockPropertyContext` for single invocation behavior

---
 doc/api/test.md                       | 37 +++++++++++++++++++++++++++
 lib/internal/test_runner/mock/mock.js | 36 +++++++++++++++++++++++---
 test/parallel/test-runner-mocking.js  | 23 +++++++++++++++++
 3 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index 37bdd2a448ff3c..1eb9d04f4b4c0a 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2071,6 +2071,43 @@ This function is more efficient than checking `ctx.accesses.length` because
 
 This function is used to change the value returned by the mocked property getter.
 
+### `ctx.mockImplementationOnce(value[, onAccess])`
+
+* `value` {any} The value to be used as the mock's
+  implementation for the invocation number specified by `onAccess`.
+* `onAccess` {integer} The invocation number that will use `value`. If
+  the specified invocation has already occurred then an exception is thrown.
+  **Default:** The number of the next invocation.
+
+This function is used to change the behavior of an existing mock for a single
+invocation. Once invocation `onAccess` has occurred, the mock will revert to
+whatever behavior it would have used had `mockImplementationOnce()` not been
+called.
+
+The following example creates a mock function using `t.mock.property()`, calls the
+mock property, changes the mock implementation to a different value for the
+next invocation, and then resumes its previous behavior.
+
+```js
+test('changes a mock behavior once', (t) => {
+  const obj = { foo: 1 };
+
+  const prop = t.mock.property(obj, 'foo', 5);
+
+  assert.strictEqual(obj.foo, 5);
+  prop.mock.mockImplementationOnce(25);
+  assert.strictEqual(obj.foo, 25);
+  assert.strictEqual(obj.foo, 5);
+});
+```
+
+#### Caveat
+
+For consistency with the rest of the mocking API, this function treats both property gets and sets
+as accesses. If a property set occurs at the same access index, the "once" value will be consumed
+by the set operation, and the mocked property value will be changed to the "once" value. This may
+lead to unexpected behavior if you intend the "once" value to only be used for a get operation.
+
 ### `ctx.resetAccesses()`
 
 Resets the access history of the mocked property.
diff --git a/lib/internal/test_runner/mock/mock.js b/lib/internal/test_runner/mock/mock.js
index 002944ca0a1613..f0a0d9d9b59624 100644
--- a/lib/internal/test_runner/mock/mock.js
+++ b/lib/internal/test_runner/mock/mock.js
@@ -291,8 +291,10 @@ class MockPropertyContext {
   #originalValue;
   #descriptor;
   #accesses;
+  #onceValues;
 
   constructor(object, propertyName, value) {
+    this.#onceValues = new SafeMap();
     this.#accesses = [];
     this.#object = object;
     this.#propertyName = propertyName;
@@ -311,15 +313,16 @@ class MockPropertyContext {
       configurable,
       enumerable,
       get: () => {
+        const nextValue = this.#getAccessValue(this.#value);
         const access = {
           __proto__: null,
           type: 'get',
-          value: this.#value,
+          value: nextValue,
           // eslint-disable-next-line no-restricted-syntax
           stack: new Error(),
         };
         ArrayPrototypePush(this.#accesses, access);
-        return this.#value;
+        return nextValue;
       },
       set: this.mockImplementation.bind(this),
     });
@@ -352,15 +355,40 @@ class MockPropertyContext {
         'propertyName', this.#propertyName, 'cannot be set',
       );
     }
+    const nextValue = this.#getAccessValue(value);
     const access = {
       __proto__: null,
       type: 'set',
-      value: value,
+      value: nextValue,
       // eslint-disable-next-line no-restricted-syntax
       stack: new Error(),
     };
     ArrayPrototypePush(this.#accesses, access);
-    this.#value = value;
+    this.#value = nextValue;
+  }
+
+  #getAccessValue(value) {
+    const accessIndex = this.#accesses.length;
+    let accessValue;
+    if (this.#onceValues.has(accessIndex)) {
+      accessValue = this.#onceValues.get(accessIndex);
+      this.#onceValues.delete(accessIndex);
+    } else {
+      accessValue = value;
+    }
+    return accessValue;
+  }
+
+  /**
+   * Sets a value to be used only for the next access (get or set), or a specific access index.
+   * @param {any} value - The value to be used once.
+   * @param {number} [onAccess] - The access index to be replaced.
+   */
+  mockImplementationOnce(value, onAccess) {
+    const nextAccess = this.#accesses.length;
+    const accessIndex = onAccess ?? nextAccess;
+    validateInteger(accessIndex, 'onAccess', nextAccess);
+    this.#onceValues.set(accessIndex, value);
   }
 
   /**
diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index 6297cbae8e0cc1..c43a04c269607d 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -1144,9 +1144,32 @@ test('changes mocked property value dynamically', (t) => {
 
   const prop = t.mock.property(obj, 'foo', 2);
   assert.strictEqual(obj.foo, 2);
+  assert.strictEqual(prop.mock.accessCount(), 1);
 
   prop.mock.mockImplementation(99);
   assert.strictEqual(obj.foo, 99);
+  assert.strictEqual(prop.mock.accessCount(), 3);
+
+  prop.mock.mockImplementationOnce(42);
+  assert.strictEqual(obj.foo, 42);
+  assert.strictEqual(obj.foo, 99);
+  assert.strictEqual(prop.mock.accessCount(), 5);
+
+  assert.throws(() => {
+    prop.mock.mockImplementationOnce(55, 4);
+  }, /The value of "onAccess" is out of range\. It must be >= 5/);
+
+  prop.mock.mockImplementationOnce(100, 5);
+  prop.mock.mockImplementationOnce(200, 6);
+  assert.strictEqual(obj.foo, 100);
+  assert.strictEqual(obj.foo, 200);
+  assert.strictEqual(obj.foo, 99);
+  assert.strictEqual(prop.mock.accessCount(), 8);
+
+  prop.mock.mockImplementationOnce(555, 10);
+  assert.strictEqual(obj.foo, 99);
+  assert.strictEqual(obj.foo, 99);
+  assert.strictEqual(obj.foo, 555);
 
   prop.mock.mockImplementation(undefined);
   assert.strictEqual(obj.foo, undefined);

From e1d143f1fa8c2cc44c5f3813026a151947315514 Mon Sep 17 00:00:00 2001
From: Idan Goshen <idan.goshen@gmail.com>
Date: Thu, 29 May 2025 14:20:51 +0300
Subject: [PATCH 9/9] fix: typo in `mock.property` value description

valueName -> propertyName
---
 doc/api/test.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/test.md b/doc/api/test.md
index 1eb9d04f4b4c0a..4adaa53262f74e 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -2330,7 +2330,7 @@ added: REPLACEME
 * `object` {Object} The object whose value is being mocked.
 * `propertyName` {string|symbol} The identifier of the property on `object` to mock.
 * `value` {any} An optional value used as the mock value
-  for `object[valueName]`. **Default:** The original property value.
+  for `object[propertyName]`. **Default:** The original property value.
 * Returns: {Proxy} A proxy to the mocked object. The mocked object contains a
   special `mock` property, which is an instance of [`MockPropertyContext`][], and
   can be used for inspecting and changing the behavior of the mocked property.