Spy on an existing object method

This is what jest.spyOn does. You replace a method on an object you do not own, record what it is called with while letting it behave exactly as before, and restore it when the test ends so nothing leaks into the next one. The this handling is where naive attempts break: the replacement is called as a method, so it must forward that receiver to the original or the original loses access to the object's own state.

Implement spyOn(object, methodName). It replaces object[methodName] with a wrapper that records the call and then invokes the original method with the same this and arguments, returning the original's result unchanged. It returns a spy handle with calls, an array holding one array of arguments per recorded call in order; callCount, the number of recorded calls, starting at 0; and restore(), which puts the original function back so that object[methodName] is once again the exact same function reference it was before, after which calls are no longer recorded. Spying on two different methods of the same object gives two independent handles.

const api = { total: 0, add(n) { this.total += n; return this.total; } };
const spy = spyOn(api, "add");

api.add(2);        // 2 — original behaviour preserved
api.add(3);        // 5
spy.calls;         // [[2], [3]]
spy.callCount;     // 2
spy.restore();     // api.add is the original function again

const user = { name: "Ada", greet(g) { return g + ", " + this.name; } };
const spy = spyOn(user, "greet");

user.greet("Hi"); // "Hi, Ada" — `this` still reaches the method
spy.calls;        // [["Hi"]]