From b942f93b5bfd70ad8f245c94048cfaffda4ee56a Mon Sep 17 00:00:00 2001
From: MURAKAMI Masahiko <fossamagna2@gmail.com>
Date: Fri, 18 Nov 2022 18:31:49 +0900
Subject: [PATCH] feat: add getter and setter to MockTracker

This commit allows tests in test runner to use the
`getter` and `setter` methods as "syntax sugar" for
`MockTracker.method` with the `options.getter` or
`options.setter` set to true in the options.

Refs: https://github.com/nodejs/node/pull/45326#discussion_r1014727289
PR-URL: https://github.com/nodejs/node/pull/45506
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
(cherry picked from commit afed1afa55962211b6b56c2068d520b4d8a08888)
---
 README.md                            | 19 ++++++
 lib/internal/test_runner/mock.js     | 56 ++++++++++++++++-
 test/parallel/test-runner-mocking.js | 89 +++++++++++++++++++++++++++-
 3 files changed, 162 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 7ff8afc..10cd238 100644
--- a/README.md
+++ b/README.md
@@ -866,6 +866,15 @@ test('mocks a counting function', (t) => {
 });
 ```
 
+### `mock.getter(object, methodName[, implementation][, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+This function is syntax sugar for [`MockTracker.method`][] with `options.getter`
+set to `true`.
+
 ### `mock.method(object, methodName[, implementation][, options])`
 
 <!-- YAML
@@ -943,6 +952,15 @@ This function restores the default behavior of all mocks that were previously
 created by this `MockTracker`. Unlike `mock.reset()`, `mock.restoreAll()` does
 not disassociate the mocks from the `MockTracker` instance.
 
+### `mock.setter(object, methodName[, implementation][, options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+This function is syntax sugar for [`MockTracker.method`][] with `options.setter`
+set to `true`.
+
 ## Class: `TapStream`
 
 <!-- YAML
@@ -1153,6 +1171,7 @@ The name of the suite.
 [`AbortSignal`]: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
 [TAP]: https://testanything.org/
 [`MockFunctionContext`]: #class-mockfunctioncontext
+[`MockTracker.method`]: #mockmethodobject-methodname-implementation-options
 [`MockTracker`]: #class-mocktracke
 [`SuiteContext`]: #class-suitecontext
 [`TestContext`]: #class-testcontext
diff --git a/lib/internal/test_runner/mock.js b/lib/internal/test_runner/mock.js
index d7c380c..9959825 100644
--- a/lib/internal/test_runner/mock.js
+++ b/lib/internal/test_runner/mock.js
@@ -1,4 +1,4 @@
-// https://github.com/nodejs/node/blob/7c6682957b3c5f86d0616cebc0ad09cc2a1fd50d/lib/internal/test_runner/mock.js
+// https://github.com/nodejs/node/blob/afed1afa55962211b6b56c2068d520b4d8a08888/lib/internal/test_runner/mock.js
 'use strict'
 const {
   ArrayPrototypePush,
@@ -204,6 +204,60 @@ class MockTracker {
     return mock
   }
 
+  getter (
+    object,
+    methodName,
+    implementation = kDefaultFunction,
+    options = kEmptyObject
+  ) {
+    if (implementation !== null && typeof implementation === 'object') {
+      options = implementation
+      implementation = kDefaultFunction
+    } else {
+      validateObject(options, 'options')
+    }
+
+    const { getter = true } = options
+
+    if (getter === false) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.getter', getter, 'cannot be false'
+      )
+    }
+
+    return this.method(object, methodName, implementation, {
+      ...options,
+      getter
+    })
+  }
+
+  setter (
+    object,
+    methodName,
+    implementation = kDefaultFunction,
+    options = kEmptyObject
+  ) {
+    if (implementation !== null && typeof implementation === 'object') {
+      options = implementation
+      implementation = kDefaultFunction
+    } else {
+      validateObject(options, 'options')
+    }
+
+    const { setter = true } = options
+
+    if (setter === false) {
+      throw new ERR_INVALID_ARG_VALUE(
+        'options.setter', setter, 'cannot be false'
+      )
+    }
+
+    return this.method(object, methodName, implementation, {
+      ...options,
+      setter
+    })
+  }
+
   reset () {
     this.restoreAll()
     this.#mocks = []
diff --git a/test/parallel/test-runner-mocking.js b/test/parallel/test-runner-mocking.js
index c8ac8ea..6bcff47 100644
--- a/test/parallel/test-runner-mocking.js
+++ b/test/parallel/test-runner-mocking.js
@@ -1,4 +1,4 @@
-// https://github.com/nodejs/node/blob/7c6682957b3c5f86d0616cebc0ad09cc2a1fd50d/test/parallel/test-runner-mocking.js
+// https://github.com/nodejs/node/blob/afed1afa55962211b6b56c2068d520b4d8a08888/test/parallel/test-runner-mocking.js
 'use strict'
 const common = require('../common')
 const assert = require('node:assert')
@@ -535,6 +535,69 @@ test('mocks a setter', (t) => {
   assert.strictEqual(obj.prop, 65)
 })
 
+test('mocks a getter with syntax sugar', (t) => {
+  const obj = {
+    prop: 5,
+    get method () {
+      return this.prop
+    }
+  }
+
+  function mockMethod () {
+    return this.prop - 1
+  }
+  const getter = t.mock.getter(obj, 'method', mockMethod)
+  assert.strictEqual(getter.mock.calls.length, 0)
+  assert.strictEqual(obj.method, 4)
+
+  const call = getter.mock.calls[0]
+
+  assert.deepStrictEqual(call.arguments, [])
+  assert.strictEqual(call.result, 4)
+  assert.strictEqual(call.target, undefined)
+  assert.strictEqual(call.this, obj)
+
+  assert.strictEqual(getter.mock.restore(), undefined)
+  assert.strictEqual(obj.method, 5)
+})
+
+test('mocks a setter with syntax sugar', (t) => {
+  const obj = {
+    prop: 100,
+    // eslint-disable-next-line accessor-pairs
+    set method (val) {
+      this.prop = val
+    }
+  }
+
+  function mockMethod (val) {
+    this.prop = -val
+  }
+
+  assert.strictEqual(obj.prop, 100)
+  obj.method = 88
+  assert.strictEqual(obj.prop, 88)
+
+  const setter = t.mock.setter(obj, 'method', mockMethod)
+
+  assert.strictEqual(setter.mock.calls.length, 0)
+  obj.method = 77
+  assert.strictEqual(obj.prop, -77)
+  assert.strictEqual(setter.mock.calls.length, 1)
+
+  const call = setter.mock.calls[0]
+
+  assert.deepStrictEqual(call.arguments, [77])
+  assert.strictEqual(call.result, undefined)
+  assert.strictEqual(call.target, undefined)
+  assert.strictEqual(call.this, obj)
+
+  assert.strictEqual(setter.mock.restore(), undefined)
+  assert.strictEqual(obj.prop, -77)
+  obj.method = 65
+  assert.strictEqual(obj.prop, 65)
+})
+
 test('mocked functions match name and length', (t) => {
   function getNameAndLength (fn) {
     return {
@@ -800,3 +863,27 @@ test('spies on a class prototype method', (t) => {
   assert.strictEqual(call.target, undefined)
   assert.strictEqual(call.this, instance)
 })
+
+test('getter() fails if getter options set to false', (t) => {
+  assert.throws(() => {
+    t.mock.getter({}, 'method', { getter: false })
+  }, /The property 'options\.getter' cannot be false/)
+})
+
+test('setter() fails if setter options set to false', (t) => {
+  assert.throws(() => {
+    t.mock.setter({}, 'method', { setter: false })
+  }, /The property 'options\.setter' cannot be false/)
+})
+
+test('getter() fails if setter options is true', (t) => {
+  assert.throws(() => {
+    t.mock.getter({}, 'method', { setter: true })
+  }, /The property 'options\.setter' cannot be used with 'options\.getter'/)
+})
+
+test('setter() fails if getter options is true', (t) => {
+  assert.throws(() => {
+    t.mock.setter({}, 'method', { getter: true })
+  }, /The property 'options\.setter' cannot be used with 'options\.getter'/)
+})