test_runner: fix mock.method to support class instances

lib/internal/test_runner/mock.js

@@ -6,6 +6,7 @@ const {
   FunctionPrototypeCall,
   ObjectDefineProperty,
   ObjectGetOwnPropertyDescriptor,
+  ObjectGetPrototypeOf,
   Proxy,
   ReflectApply,
   ReflectConstruct,
@@ -131,8 +132,10 @@ class MockTracker {
     implementation = kDefaultFunction,
     options = kEmptyObject,
   ) {
-    validateObject(object, 'object');
     validateStringOrSymbol(methodName, 'methodName');
+    if (typeof object !== 'function') {
+      validateObject(object, 'object');
+    }
 
     if (implementation !== null && typeof implementation === 'object') {
       options = implementation;
@@ -157,8 +160,8 @@ class MockTracker {
         'options.setter', setter, "cannot be used with 'options.getter'"
       );
     }
+    const descriptor = findMethodOnPrototypeChain(object, methodName);
 
-    const descriptor = ObjectGetOwnPropertyDescriptor(object, methodName);
     let original;
 
     if (getter) {
@@ -346,4 +349,21 @@ function validateTimes(value, name) {
   validateInteger(value, name, 1);
 }
 
+function findMethodOnPrototypeChain(instance, methodName) {
+  let host = instance;
+  let descriptor;
+
+  while (host !== null) {
+    descriptor = ObjectGetOwnPropertyDescriptor(host, methodName);
+
+    if (descriptor) {
+      break;
+    }
+
+    host = ObjectGetPrototypeOf(host);
+  }
+
+  return descriptor;
+}
+
 module.exports = { MockTracker };

test/parallel/test-runner-mocking.js

@@ -319,6 +319,125 @@ test('spy functions can be bound', (t) => {
   assert.strictEqual(sum.bind(0)(2, 11), 13);
 });
 
+test('mocks prototype methods on an instance', async (t) => {
+  class Runner {
+    async someTask(msg) {
+      return Promise.resolve(msg);
+    }
+
+    async method(msg) {
+      await this.someTask(msg);
+      return msg;
+    }
+  }
+  const msg = 'ok';
+  const obj = new Runner();
+  assert.strictEqual(await obj.method(msg), msg);
+
+  t.mock.method(obj, obj.someTask.name);
+  assert.strictEqual(obj.someTask.mock.calls.length, 0);
+
+  assert.strictEqual(await obj.method(msg), msg);
+
+  const call = obj.someTask.mock.calls[0];
+
+  assert.deepStrictEqual(call.arguments, [msg]);
+  assert.strictEqual(await call.result, msg);
+  assert.strictEqual(call.target, undefined);
+  assert.strictEqual(call.this, obj);
+
+  const obj2 = new Runner();
+  // Ensure that a brand new instance is not mocked
+  assert.strictEqual(
+    obj2.someTask.mock,
+    undefined
+  );
+
+  assert.strictEqual(obj.someTask.mock.restore(), undefined);
+  assert.strictEqual(await obj.method(msg), msg);
+  assert.strictEqual(obj.someTask.mock, undefined);
+  assert.strictEqual(Runner.prototype.someTask.mock, undefined);
+});
+
+test('spies on async static class methods', async (t) => {
+  class Runner {
+    static async someTask(msg) {
+      return Promise.resolve(msg);
+    }
+
+    static async method(msg) {
+      await this.someTask(msg);
+      return msg;
+    }
+  }
+  const msg = 'ok';
+  assert.strictEqual(await Runner.method(msg), msg);
+
+  t.mock.method(Runner, Runner.someTask.name);
+  assert.strictEqual(Runner.someTask.mock.calls.length, 0);
+
+  assert.strictEqual(await Runner.method(msg), msg);
+
+  const call = Runner.someTask.mock.calls[0];
+
+  assert.deepStrictEqual(call.arguments, [msg]);
+  assert.strictEqual(await call.result, msg);
+  assert.strictEqual(call.target, undefined);
+  assert.strictEqual(call.this, Runner);
+
+  assert.strictEqual(Runner.someTask.mock.restore(), undefined);
+  assert.strictEqual(await Runner.method(msg), msg);
+  assert.strictEqual(Runner.someTask.mock, undefined);
+  assert.strictEqual(Runner.prototype.someTask, undefined);
+
+});
+
+test('given null to a mock.method it throws a invalid argument error', (t) => {
+  assert.throws(() => t.mock.method(null, {}), /ERR_INVALID_ARG_TYPE/);
+});
+
+test('it should throw given an inexistent property on a object instance', (t) => {
+  const expectedMessage = [
+    'The argument \'methodName\' must be a method. Received undefined',
+  ].join('');
+  assert.throws(() => t.mock.method({ abc: 0 }, 'non-existent'), {
+    message: expectedMessage
+  });
+});
+
+test('spy functions can be used on classes inheritance', (t) => {
+  // Makes sure that having a null-prototype doesn't throw our system off
+  class A extends null {
+    static someTask(msg) {
+      return msg;
+    }
+    static method(msg) {
+      return this.someTask(msg);
+    }
+  }
+  class B extends A {}
+  class C extends B {}
+
+  const msg = 'ok';
+  assert.strictEqual(C.method(msg), msg);
+
+  t.mock.method(C, C.someTask.name);
+  assert.strictEqual(C.someTask.mock.calls.length, 0);
+
+  assert.strictEqual(C.method(msg), msg);
+
+  const call = C.someTask.mock.calls[0];
+
+  assert.deepStrictEqual(call.arguments, [msg]);
+  assert.strictEqual(call.result, msg);
+  assert.strictEqual(call.target, undefined);
+  assert.strictEqual(call.this, C);
+
+  assert.strictEqual(C.someTask.mock.restore(), undefined);
+  assert.strictEqual(C.method(msg), msg);
+  assert.strictEqual(C.someTask.mock, undefined);
+});
+
 test('mocked functions report thrown errors', (t) => {
   const testError = new Error('test error');
   const fn = t.mock.fn(() => {