Replace getters with td.replace(object, property)

td.replace(object, property) swapped the property by assignment, both
when replacing and when restoring on reset. Assigning to a getter with
no setter throws in strict mode, so it failed with "Cannot set property
... which has only a getter".

For a getter with no setter, define the fake as a data property
instead:

- An own, configurable getter (as tsc defines re-exports) is redefined,
  and reset puts the original descriptor back exactly.
- An inherited getter (a class getter, replaced through an instance) is
  shadowed by an own property, which reset deletes.
- An own, non-configurable getter (as SWC defines exports) can't be
  redefined, so it gets an error that points to replacing the whole
  module with td.replace(path) instead.

Data properties and getters with setters are still replaced by
assignment, as before.

Author: rosston

CHANGELOG.md

@@ -33,6 +33,12 @@
   `td.constructor` and `td.imitate`. Most visibly, every export of a module
   compiled by SWC, and re-exports compiled by Babel or `tsc`, couldn't be
   stubbed [#526](https://github.com/testdouble/testdouble.js/issues/526)
+* Fix `td.replace(object, 'property')` throwing `Cannot set property ... which
+  has only a getter` when the property is a getter with no setter. It now
+  replaces the getter, and `td.reset()` restores the original getter. A getter
+  that can't be redefined (as SWC defines exports) gets an error that suggests
+  `td.replace('path/to/module')` instead
+  [#526](https://github.com/testdouble/testdouble.js/issues/526)
 * **Behavior change:** when imitating an object, testdouble now calls its
   getters and imitates what they return, instead of using `undefined`. Any side
   effects of those getters now run. Getters that throw, getters on prototypes

src/replace/property.js

@@ -10,11 +10,23 @@ export default function (object, property, manualReplacement) {
     Object.prototype.hasOwnProperty.call(object, property)
 
   if (isManual || realThingExists) {
+    const getter = findGetterOnly(object, property)
+    if (getter && getter.isOwn && !getter.descriptor.configurable) {
+      return log.error('td.replace', `"${property}" is defined with a getter that cannot be redefined. Compilers like SWC and Babel define ES module exports this way. To replace a module's export, replace the whole module with td.replace('path/to/module') instead.`)
+    }
     const realThing = object[property]
     return _.tap(getFake(isManual, property, manualReplacement, realThing), (fakeThing) => {
-      object[property] = fakeThing
+      if (getter) {
+        defineValue(object, property, fakeThing, getter.descriptor.enumerable)
+      } else {
+        object[property] = fakeThing
+      }
       reset.onNextReset(() => {
-        if (realThingExists) {
+        if (getter && getter.isOwn) {
+          Object.defineProperty(object, property, getter.descriptor)
+        } else if (getter) {
+          delete object[property]
+        } else if (realThingExists) {
           object[property] = realThing
         } else {
           delete object[property]
@@ -26,6 +38,30 @@ export default function (object, property, manualReplacement) {
   }
 }
 
+// Assigning to a getter with no setter throws, so find any such accessor
+// (on the object or up its prototype chain) to replace it by definition
+const findGetterOnly = (object, property) => {
+  let thing = object
+  while (thing != null) {
+    const descriptor = Object.getOwnPropertyDescriptor(thing, property)
+    if (descriptor) {
+      return descriptor.get && !descriptor.set
+        ? { descriptor, isOwn: thing === object }
+        : undefined
+    }
+    thing = Object.getPrototypeOf(thing)
+  }
+}
+
+const defineValue = (object, property, value, enumerable) => {
+  Object.defineProperty(object, property, {
+    configurable: true,
+    writable: true,
+    enumerable,
+    value
+  })
+}
+
 const getFake = (isManual, property, manualReplacement, realThing) => {
   if (isManual) {
     warnIfTypeMismatch(property, manualReplacement, realThing)

test/safe/replace.test.js

@@ -149,6 +149,134 @@ module.exports = {
         assert._isEqual(Object.prototype.hasOwnProperty.call(dependency, 'notAThing'), false)
       }
     },
+    'Replacing a property defined with a getter': {
+      'own and configurable (tsc re-exports)': {
+        beforeEach () {
+          Object.defineProperty(dependency, 'beep', {
+            configurable: true,
+            enumerable: true,
+            get: () => () => 'og beep'
+          })
+        },
+        'using automatic replacement' () {
+          const ogDescriptor = Object.getOwnPropertyDescriptor(dependency, 'beep')
+
+          const double = td.replace(dependency, 'beep')
+
+          assert._isEqual(td.explain(double).isTestDouble, true)
+          assert._isEqual(dependency.beep, double)
+
+          // phase 2: reset puts the getter itself back
+          td.reset()
+          assert._isEqual(Object.getOwnPropertyDescriptor(dependency, 'beep'), ogDescriptor)
+          assert._isEqual(dependency.beep(), 'og beep')
+        },
+        'with manual replacement' () {
+          const ogDescriptor = Object.getOwnPropertyDescriptor(dependency, 'beep')
+
+          const fake = td.replace(dependency, 'beep', () => 'fake beep')
+
+          assert._isEqual(dependency.beep, fake)
+
+          // phase 2: reset puts the getter itself back
+          td.reset()
+          assert._isEqual(Object.getOwnPropertyDescriptor(dependency, 'beep'), ogDescriptor)
+        }
+      },
+      'inherited from a class': {
+        beforeEach () {
+          class Horn {
+            get beep () { return () => 'og beep' }
+          }
+          dependency = new Horn()
+        },
+        'using automatic replacement' () {
+          const double = td.replace(dependency, 'beep')
+
+          assert._isEqual(td.explain(double).isTestDouble, true)
+          assert._isEqual(dependency.beep, double)
+          assert._isEqual(Object.prototype.hasOwnProperty.call(dependency, 'beep'), true)
+
+          // phase 2: reset uncovers the inherited getter again
+          td.reset()
+          assert._isEqual(Object.prototype.hasOwnProperty.call(dependency, 'beep'), false)
+          assert._isEqual(dependency.beep(), 'og beep')
+        },
+        'with manual replacement' () {
+          const fake = td.replace(dependency, 'beep', () => 'fake beep')
+
+          assert._isEqual(dependency.beep, fake)
+
+          // phase 2: reset uncovers the inherited getter again
+          td.reset()
+          assert._isEqual(Object.prototype.hasOwnProperty.call(dependency, 'beep'), false)
+          assert._isEqual(dependency.beep(), 'og beep')
+        }
+      },
+      'own and non-configurable (SWC exports)': {
+        beforeEach () {
+          Object.defineProperty(dependency, 'beep', {
+            enumerable: true,
+            get: () => () => 'og beep'
+          })
+        },
+        'using automatic replacement' () {
+          const ogDescriptor = Object.getOwnPropertyDescriptor(dependency, 'beep')
+
+          try {
+            td.replace(dependency, 'beep')
+            assert.fail('should error!')
+          } catch (e) {
+            assert._isEqual(e.message, 'Error: testdouble.js - td.replace - "beep" is defined with a getter that cannot be redefined. Compilers like SWC and Babel define ES module exports this way. To replace a module\'s export, replace the whole module with td.replace(\'path/to/module\') instead.')
+          }
+          assert._isEqual(Object.getOwnPropertyDescriptor(dependency, 'beep'), ogDescriptor)
+        },
+        'with manual replacement' () {
+          const ogDescriptor = Object.getOwnPropertyDescriptor(dependency, 'beep')
+
+          try {
+            td.replace(dependency, 'beep', () => 'fake beep')
+            assert.fail('should error!')
+          } catch (e) {
+            assert._isEqual(e.message, 'Error: testdouble.js - td.replace - "beep" is defined with a getter that cannot be redefined. Compilers like SWC and Babel define ES module exports this way. To replace a module\'s export, replace the whole module with td.replace(\'path/to/module\') instead.')
+          }
+          assert._isEqual(Object.getOwnPropertyDescriptor(dependency, 'beep'), ogDescriptor)
+        }
+      },
+      'with a setter': {
+        beforeEach () {
+          let beep = () => 'og beep'
+          Object.defineProperty(dependency, 'beep', {
+            configurable: true,
+            enumerable: true,
+            get: () => beep,
+            set: (value) => { beep = value }
+          })
+        },
+        'using automatic replacement' () {
+          const ogDescriptor = Object.getOwnPropertyDescriptor(dependency, 'beep')
+
+          const double = td.replace(dependency, 'beep')
+
+          assert._isEqual(td.explain(double).isTestDouble, true)
+          assert._isEqual(dependency.beep, double)
+          assert._isEqual(Object.getOwnPropertyDescriptor(dependency, 'beep'), ogDescriptor)
+
+          // phase 2: reset restores through the setter
+          td.reset()
+          assert._isEqual(dependency.beep(), 'og beep')
+        },
+        'with manual replacement' () {
+          const fake = td.replace(dependency, 'beep', () => 'fake beep')
+
+          assert._isEqual(dependency.beep, fake)
+
+          // phase 2: reset restores through the setter
+          td.reset()
+          assert._isEqual(dependency.beep(), 'og beep')
+        }
+      }
+    },
     'Manually specifying the override': {
       beforeEach () {
         ogWarn = console.warn