Node.js Backend Development Bootcamp · Lezione

Mock e test double in Node.js

Imparate a isolare il codice sotto test sostituendo le dipendenze reali con mock, stub e spy, così i vostri test unitari resteranno rapidi e deterministici.

Mock e test double in Node.js è una lezione Node.js Backend Development Bootcamp gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Node.js Backend Development Bootcamp, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

The Problem with Real Dependencies

A unit test should check one piece of logic in isolation. But real code calls databases, APIs, the clock, and the file system — all slow, flaky, and unpredictable.

Test doubles replace those dependencies with controllable fakes.

Types of Test Doubles

Common terms you will hear:

Stub: returns a canned value
Spy: records how it was called
Mock: a stub + spy with built-in expectations
Fake: a lightweight working implementation

Creating a Mock Function

In Jest, jest.fn() creates a mock function. It records every call and lets you assert on them later.

const callback = jest.fn();
callback('hello');
expect(callback).toHaveBeenCalledWith('hello');

Defining Return Values

Tell a mock what to return with mockReturnValue, or for async code use mockResolvedValue to resolve a promise.

const getUser = jest.fn().mockResolvedValue({ id: 1, name: 'Ada' });
const user = await getUser();
expect(user.name).toBe('Ada');

Asserting on Calls

Spies let you verify interactions:

toHaveBeenCalled()
toHaveBeenCalledTimes(n)
toHaveBeenCalledWith(args)

const save = jest.fn();
save({ id: 1 });
expect(save).toHaveBeenCalledTimes(1);

Mocking a Module

To replace an entire imported module, use jest.mock(). Every export becomes an auto-mock you can configure per test.

jest.mock('./mailer');
const mailer = require('./mailer');
mailer.send.mockResolvedValue(true);

Spying on Existing Methods

Sometimes you want to watch a real method without replacing it. jest.spyOn() wraps an existing method so you can assert and optionally override it.

const spy = jest.spyOn(console, 'log');
console.log('hi');
expect(spy).toHaveBeenCalledWith('hi');

Resetting Between Tests

Mocks accumulate state. Reset them between tests so calls from one test do not leak into another.

mockClear() clears call data
mockReset() also clears implementations

afterEach(() => {
  jest.clearAllMocks();
});

Mocking Time

Tests that depend on the current time are flaky. Jest fake timers let you control the clock so timeouts and dates are deterministic.

jest.useFakeTimers();
const fn = jest.fn();
setTimeout(fn, 1000);
jest.advanceTimersByTime(1000);
expect(fn).toHaveBeenCalled();

Dependency Injection Makes Mocking Easy

Code that receives its dependencies as arguments is far easier to test than code that imports them directly. Design for testability.

function createService(db) {
  return { getUser: id => db.find(id) };
}
const fakeDb = { find: jest.fn().mockReturnValue({ id: 1 }) };
const svc = createService(fakeDb);

Don't Over-Mock

Mocking too much produces tests that only confirm your mocks were called — not that the code works. Mock external boundaries (DB, network), but test real logic directly when you can.

Quick Check

Test your understanding of test doubles.

Recap

You learned to isolate code with test doubles:

Create mocks with jest.fn() and configure return values
Replace modules with jest.mock()
Watch real methods with jest.spyOn()
Reset mocks between tests and control time with fake timers
Inject dependencies for testability and avoid over-mocking

Good mocking keeps unit tests fast, reliable, and focused.

Domande Frequenti

La lezione «Mock e test double in Node.js» è gratuita?

Sì — il testo completo di «Mock e test double in Node.js» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Node.js Backend Development Bootcamp, passa a CoddyKit PRO. Il corso Node.js Backend Development Bootcamp include 4 lezioni in totale.

Cosa imparerò in «Mock e test double in Node.js»?

Imparate a isolare il codice sotto test sostituendo le dipendenze reali con mock, stub e spy, così i vostri test unitari resteranno rapidi e deterministici. Eserciti Node.js Backend Development Bootcamp con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Node.js Backend Development Bootcamp?

Non è richiesta alcuna esperienza precedente. Node.js Backend Development Bootcamp su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Mock e test double in Node.js»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Node.js Backend Development Bootcamp?

Sì. Ogni lezione Node.js Backend Development Bootcamp include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Node.js Backend Development Bootcamp