Build a Minimal jest.fn()-Style Spy/Mock Utility

Q: Build a Minimal jest.fn()-Style Spy/Mock Utility

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Hard > **How to read this doc:** the full real behavior contract — forwarding to a real implementation by default, recording every real call, correctly answering assertion-style queries, and `mockReturnValue` overriding real behavior entirely — was verified directly against a real, wrapped addition function. ## 1. The problem, restated A test spy wraps a function so that CALLING the spy behaves like calling the original (by default, genuinely forwarding to a real, wrapped implementation), while also RECORDING everything about each call — its arguments and its result — so test assertions can later inspect what actually happened, without the code under test needing to know or care it is being observed. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Forward to the real implementation by default? | Yes, the real, common convention — a

Function spy logs | JS Coding Challenge

The problem

Problem, as an interviewer would state it: "Implement a minimal createSpy(implementation) — like jest.fn() — that wraps a function, RECORDS every real call's arguments and return value, and supports mockReturnValue, toHaveBeenCalledWith, and toHaveBeenCalledTimes."

Examples:

Code

const add = createSpy((a, b) => a + b);
add(2, 3);
add.toHaveBeenCalledWith(2, 3); // true

Clarifying questions expected:

Should the spy still call the REAL wrapped implementation by default, or only ever track calls without invoking anything?
Does mockReturnValue need to override the real implementation entirely, regardless of the arguments the spy is called with?
Should call arguments be compared by DEEP equality for toHaveBeenCalledWith, not just reference equality?

Code / implementation expected: Yes — real, direct proof that the spy correctly forwards to a real implementation, records real calls, and correctly answers toHaveBeenCalledWith/Times queries, plus mockReturnValue overriding real behavior.

js-coding
utility
algorithm

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Hard

How to read this doc: the full real behavior contract — forwarding to a real implementation by default, recording every real call, correctly answering assertion-style queries, and mockReturnValue overriding real behavior entirely — was verified directly against a real, wrapped addition function.

1. The problem, restated

A test spy wraps a function so that CALLING the spy behaves like calling the original (by default, genuinely forwarding to a real, wrapped implementation), while also RECORDING everything about each call — its arguments and its result — so test assertions can later inspect what actually happened, without the code under test needing to know or care it is being observed.

2. Clarifying questions a strong candidate asks

| Question | Why it matters | | :

The solution is hidden so you can try first

7 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: the spy correctly forwards to a real implementation, records real calls, and mockReturnValue correctly overrides regardless of arguments