Fix issue 2534: spies are not restored (#2535)

* Document the custom property descriptor type used in Sinon

* Fix issue #2534

* prettify

lib/sinon/sandbox.js

@@ -218,6 +218,7 @@ function Sandbox() {
                 delete object[property];
             }
         }
+
         restorer.object = object;
         restorer.property = property;
         return restorer;
@@ -355,8 +356,7 @@ function Sandbox() {
     };
 
     function commonPostInitSetup(args, spy) {
-        const object = args[0];
-        const property = args[1];
+        const [object, property, types] = args;
 
         const isSpyingOnEntireObject =
             typeof property === "undefined" && typeof object === "object";
@@ -369,6 +369,11 @@ function Sandbox() {
             });
 
             usePromiseLibrary(promiseLib, ownMethods);
+        } else if (Array.isArray(types)) {
+            for (const accessorType of types) {
+                addToCollection(spy[accessorType]);
+                usePromiseLibrary(promiseLib, spy[accessorType]);
+            }
         } else {
             addToCollection(spy);
             usePromiseLibrary(promiseLib, spy);

lib/sinon/util/core/get-property-descriptor.js

@@ -1,6 +1,28 @@
 "use strict";
 
-module.exports = function getPropertyDescriptor(object, property) {
+/* eslint-disable jsdoc/valid-types */
+/*
+ * The following type def is strictly an illegal JSDoc, but the expression forms a
+ * legal Typescript union type and is understood by Visual Studio and the IntelliJ
+ * family of editors. The "TS" flavor of JSDoc is becoming the de-facto standard these
+ * days for that reason (and the fact that JSDoc is essentially unmaintained)
+ */
+
+/**
+ * @typedef {{isOwn: boolean} & PropertyDescriptor} SinonPropertyDescriptor
+ * a slightly enriched property descriptor
+ * @property {boolean} isOwn true if the descriptor is owned by this object, false if it comes from the prototype
+ */
+/* eslint-enable jsdoc/valid-types */
+
+/**
+ * Returns a slightly modified property descriptor that one can tell is from the object or the prototype
+ *
+ * @param {*} object
+ * @param {string} property
+ * @returns {SinonPropertyDescriptor}
+ */
+function getPropertyDescriptor(object, property) {
     let proto = object;
     let descriptor;
     const isOwn = Boolean(
@@ -19,4 +41,6 @@ module.exports = function getPropertyDescriptor(object, property) {
     }
 
     return descriptor;
-};
+}
+
+module.exports = getPropertyDescriptor;

test/issues/issues-test.js

@@ -899,4 +899,19 @@ describe("issues", function () {
             this.sandbox.restore();
         });
     });
+
+    it("#2534 - spies on accessors are not being cleaned up", function () {
+        const object = {
+            get prop() {
+                return "bar";
+            },
+        };
+        const spy = sinon.spy(object, "prop", ["get"]);
+        /* eslint-disable no-unused-expressions */
+        object.prop;
+        assert.equals(spy.get.callCount, 1);
+        sinon.restore();
+        object.prop;
+        assert.equals(spy.get.callCount, 1); // should remain unchanged
+    });
 });

test/sandbox-test.js

@@ -2205,7 +2205,7 @@ describe("Sandbox", function () {
             assert.equals(object.prop, "blabla");
         });
 
-        it("allows restoring setters", function () {
+        it("allows putting setters on fields and subsequently restoring them", function () {
             const object = {
                 prop: "bar",
             };
@@ -2221,6 +2221,37 @@ describe("Sandbox", function () {
 
             assert.equals(object.prop, "bla");
         });
+
+        it("allows replacing setters on fields and subsequently restoring them", function () {
+            const object = {
+                get prop() {
+                    return "bar";
+                },
+            };
+
+            const sandbox = new Sandbox();
+            const getter = sandbox.spy(() => "foobar");
+            sandbox.stub(object, "prop").get(getter);
+            assert.equals(object.prop, "foobar");
+            assert.equals(getter.callCount, 1);
+
+            sandbox.restore();
+            assert.equals(object.prop, "bar");
+        });
+
+        it("allows spying on accessors and subsequently restoring them", function () {
+            const object = {
+                get prop() {
+                    return "bar";
+                },
+            };
+            const sandbox = new Sandbox();
+            const spy = sandbox.spy(object, "prop", ["get"]);
+            sandbox.restore();
+            const descriptor = Object.getOwnPropertyDescriptor(object, "prop");
+            const getter = descriptor.get;
+            refute.equals(getter, spy.get);
+        });
     });
 
     describe(".assert", function () {