Kurs JavaScript i TypeScript · Moduł 11: Testowanie z Jest
Testowanie kodu asynchronicznego
W tej lekcji3
Skanowanie próbki DNA nie kończy się w chwili wywołania funkcji. Wynik przychodzi później, jako obietnica (Promise), a test, który na nią nie poczeka, skończy się przed nadejściem wyniku i zamelduje sukces, choć niczego nie sprawdził. Taki fałszywy spokój jest groźniejszy niż czerwony alarm.
W Parku Jurajskim wiele operacji jest asynchronicznych - skanowanie DNA, komunikacja z sensorami, pobieranie danych z satelity. Jest oferuje kilka sposobów testowania takiego kodu.
Testowanie Promise
async/await
Najbardziej czytelny sposób testowania asynchronicznego kodu wymaga dwóch kroków: oznacz funkcję testową jako async i użyj await przy wywołaniu testowanej funkcji. Zakładamy, że fetch jest tu podmieniony mockiem, jak w poprzedniej lekcji, i zwraca próbkę T-Rexa o czystości 0.95:
// Funkcja asynchroniczna do testowania
async function scanDNA(sampleId) {
const response = await fetch(`/api/dna/${sampleId}`);
const data = await response.json();
return {
species: data.species,
purity: data.purity,
viable: data.purity > 0.9
};
}
// Test z async/await
test('skanowanie DNA zwraca gatunek', async () => {
const result = await scanDNA('SAMPLE-001');
expect(result.species).toBe('T-Rex');
expect(result.purity).toBeGreaterThan(0.9);
expect(result.viable).toBe(true);
});Jest widzi, że funkcja testowa zwraca obietnicę, i czeka na nią przed oceną wyniku. Bez await zmienna result byłaby obietnicą, a nie obiektem, więc result.species dałoby undefined. Sama funkcja scanDNA się nie zmienia - zmienia się tylko to, że test cierpliwie czeka na jej odpowiedź.
resolves i rejects
Jest posiada dedykowane matchery dla Promise. .resolves rozpakowuje wartość spełnionej obietnicy, a .rejects powód odrzucenia, po czym dopisujesz zwykły matcher. Całe wyrażenie poprzedzasz await (albo zwracasz przez return). Nasz mock fetch dla próbki INVALID odrzuca obietnicę błędem "Sample not found":
// Testowanie resolve
test('DNA scan resolves with data', async () => {
await expect(scanDNA('SAMPLE-001')).resolves.toEqual({
species: 'T-Rex',
purity: 0.95,
viable: true
});
});
// Testowanie reject
test('DNA scan rejects for invalid sample', async () => {
await expect(scanDNA('INVALID')).rejects.toThrow('Sample not found');
});Brak await przed expect to klasyczny błąd: test skończy się, zanim matcher cokolwiek sprawdzi. Ta sama zasada obowiązuje przy funkcjach async, które same rzucają wyjątek - jak system obrony, który bez numeru strefy odmawia aktywacji:
// Inny przykład - testowanie odrzuconej Promise
async function activateDefense(zoneId) {
if (!zoneId) {
throw new Error('Zone ID is required');
}
return { status: 'activated', zone: zoneId };
}
test('defense rejects without zone ID', async () => {
await expect(activateDefense(null)).rejects.toThrow('Zone ID is required');
});
test('defense resolves with valid zone', async () => {
await expect(activateDefense('A')).resolves.toEqual({
status: 'activated',
zone: 'A'
});
});activateDefense jest funkcją async, więc throw w jej wnętrzu nie wybucha od razu, tylko zamienia się w odrzuconą obietnicę. Dlatego testujemy ją przez rejects.toThrow, a nie przez znane z lekcji o matcherach expect(() => ...).toThrow(). Jeśli wolisz klasyczne try/catch, dodaj na początku testu expect.assertions(1). Wtedy obietnica, która niespodziewanie się spełni, nie prześlizgnie się obok bloku catch bez żadnej asercji.
Testowanie callbacków
Starszy kod nie zwraca obietnic, tylko przyjmuje callback, czyli funkcję wywoływaną z wynikiem. fetchDinoReport wzorem Node.js przekazuje do callbacku najpierw błąd, a potem dane. Test dostaje wtedy parametr done i musi go wywołać, gdy skończy:
function fetchDinoReport(id, callback) {
setTimeout(() => {
if (id === 'unknown') {
callback(new Error('Dinosaur not found'), null);
} else {
callback(null, { id, status: 'healthy' });
}
}, 100);
}
// Test callbacku z done
test('callback zwraca raport dinozaura', (done) => {
fetchDinoReport('REX-001', (error, report) => {
try {
expect(error).toBeNull();
expect(report.status).toBe('healthy');
done(); // Sygnalizuj zakończenie testu
} catch (err) {
done(err); // Przekaż błąd do Jest
}
});
});Jeśli done nigdy nie zostanie wywołane, test padnie po przekroczeniu limitu czasu, domyślnie 5 sekund. try/catch jest potrzebny, bo nieudany expect rzuca wyjątek wewnątrz callbacku, a przekazany do done(err) trafia do raportu jako prawdziwy powód porażki. Nie łącz done z testem async, bo Jest zgłosi wtedy błąd. W nowym kodzie polecam async/await a done zostaw dla starych API.
Fake Timers
Gdy kod używa setTimeout, setInterval lub Date, możesz kontrolować czas. Czekanie 30 sekund w teście to strata czasu, więc jest.useFakeTimers() podmienia zegary na sztuczne. Oto funkcja, która ogłasza ewakuację po 30 sekundach:
// Funkcja z timeoutem
function startEmergencyCountdown(callback) {
console.log('Ewakuacja za 30 sekund!');
setTimeout(() => {
callback('Ewakuacja rozpoczęta!');
}, 30000); // 30 sekund
}A tak ją testujemy. jest.advanceTimersByTime przewija czas o podaną liczbę milisekund, natychmiast. Sztuczne zegary włączamy w beforeEach i wyłączamy w afterEach, żeby nie wpłynęły na inne testy:
describe('Emergency System', () => {
beforeEach(() => {
jest.useFakeTimers(); // Włącz sztuczne timery
});
afterEach(() => {
jest.useRealTimers(); // Przywróć prawdziwe timery
});
test('countdown wywołuje callback po 30s', () => {
const callback = jest.fn();
startEmergencyCountdown(callback);
// Callback jeszcze nie został wywołany
expect(callback).not.toHaveBeenCalled();
// Przewiń czas o 30 sekund
jest.advanceTimersByTime(30000);
// Teraz callback został wywołany!
expect(callback).toHaveBeenCalledWith('Ewakuacja rozpoczęta!');
});
test('countdown nie odpala się przed czasem', () => {
const callback = jest.fn();
startEmergencyCountdown(callback);
// Przewiń o 29 sekund
jest.advanceTimersByTime(29000);
expect(callback).not.toHaveBeenCalled();
// Przewiń o kolejną sekundę (łącznie 30s)
jest.advanceTimersByTime(1000);
expect(callback).toHaveBeenCalled();
});
});Drugi test pokazuje, że sztuczny czas jest precyzyjny: po 29 sekundach callback wciąż czeka, a po kolejnej sekundzie odpala. Oba testy trwają milisekundy, a nie pół minuty. Kod produkcyjny nie wie, że czas jest fałszywy - nie zmieniliśmy w nim ani jednej linii.
Uruchamianie oczekujących timerów
Gdy nie chcesz liczyć milisekund, jest.runAllTimers() uruchamia wszystkie oczekujące timery naraz. Ważne: sztuczne zegary trzeba włączyć, zanim kod zaplanuje timery, dlatego jest.useFakeTimers() stoi na samym początku testu:
test('runAllTimers - uruchom wszystkie timery', () => {
jest.useFakeTimers();
const steps = [];
setTimeout(() => steps.push('krok 1'), 1000);
setTimeout(() => steps.push('krok 2'), 2000);
setTimeout(() => steps.push('krok 3'), 5000);
// Uruchom WSZYSTKIE oczekujące timery naraz
jest.runAllTimers();
expect(steps).toEqual(['krok 1', 'krok 2', 'krok 3']);
jest.useRealTimers();
});Timery zaplanowane przed włączeniem sztucznych zegarów trafiłyby do prawdziwej kolejki, a runAllTimers by ich nie zobaczył, więc tablica steps zostałaby pusta. Przy setInterval uważaj: runAllTimers uruchamia też timery tworzone w trakcie, więc interwał kręciłby się bez końca, aż Jest przerwie pętlę z błędem. Wtedy użyj jest.runOnlyPendingTimers(), a gdy timery mieszają się z obietnicami, sięgnij po await jest.advanceTimersByTimeAsync(ms).
W projekcie końcowym sztuczne zegary przydadzą się do monitoringu czujników. W laboratorium poniżej zobaczysz symulację skanowania DNA z obietnicami i timerami.
Pamiętaj: w teście asynchronicznym zawsze czekaj na wynik - await to strażnik, który nie opuści posterunku, zanim skan DNA się zakończy.
Kod do tej lekcji: index.js
// Testowanie kodu asynchronicznego
console.log("=== Park Jurajski - Asynchroniczne Skanowanie DNA ===\n");
// --- async/await w testach ---
console.log("--- async/await ---\n");
async function scanDNA(sampleId) {
// Symulacja asynchronicznego skanowania
return new Promise((resolve, reject) => {
setTimeout(() => {
if (sampleId === "INVALID") {
reject(new Error("Sample not found"));
return;
}
resolve({
species: "T-Rex",
purity: 0.95,
viable: true,
});
}, 100);
});
}
// Test async/await
async function testAsyncAwait() {
try {
const result = await scanDNA("SAMPLE-001");
console.log("[PASS] DNA scan returned:", result.species);
console.log("[PASS] Purity:", result.purity, "> 0.9?", result.purity > 0.9);
console.log("[PASS] Viable:", result.viable);
} catch (e) {
console.log("[FAIL]", e.message);
}
}
// Test reject
async function testReject() {
try {
await scanDNA("INVALID");
console.log("[FAIL] Should have thrown");
} catch (e) {
console.log("[PASS] Rejected:", e.message);
}
}
// --- Callback testing ---
console.log("--- Callbacki ---\n");
function fetchDinoReport(id, callback) {
setTimeout(() => {
if (id === "unknown") {
callback(new Error("Dinosaur not found"), null);
} else {
callback(null, { id, status: "healthy" });
}
}, 50);
}
function testCallback() {
return new Promise((resolve) => {
fetchDinoReport("REX-001", (error, report) => {
if (!error && report.status === "healthy") {
console.log("[PASS] Callback: report status =", report.status);
} else {
console.log("[FAIL] Callback failed");
}
resolve();
});
});
}
// --- Fake Timers ---
console.log("--- Fake Timers ---\n");
function demonstrateFakeTimers() {
console.log("W prawdziwym Jest:");
console.log(" jest.useFakeTimers() - wlacz sztuczne timery");
console.log(" jest.advanceTimersByTime(30000) - przewin o 30s");
console.log(" jest.runAllTimers() - uruchom wszystkie timery");
console.log(" jest.useRealTimers() - przywroc prawdziwe timery");
console.log("\nPrzyklad:");
console.log(" function startCountdown(cb) {");
console.log(" setTimeout(() => cb('GO!'), 30000);");
console.log(" }");
console.log(" ");
console.log(" test('countdown', () => {");
console.log(" jest.useFakeTimers();");
console.log(" const cb = jest.fn();");
console.log(" startCountdown(cb);");
console.log(" expect(cb).not.toHaveBeenCalled();");
console.log(" jest.advanceTimersByTime(30000);");
console.log(" expect(cb).toHaveBeenCalledWith('GO!');");
console.log(" });");
}
// --- resolves/rejects ---
console.log("--- resolves / rejects matchery ---\n");
async function demonstrateResolves() {
// resolves
const goodPromise = Promise.resolve({ status: "activated", zone: "A" });
const result = await goodPromise;
const matches = result.status === "activated" && result.zone === "A";
console.log("[" + (matches ? "PASS" : "FAIL") + "] resolves.toEqual:", JSON.stringify(result));
// rejects
const badPromise = Promise.reject(new Error("Zone ID is required"));
try {
await badPromise;
console.log("[FAIL] Should have rejected");
} catch (e) {
const matches = e.message === "Zone ID is required";
console.log("[" + (matches ? "PASS" : "FAIL") + "] rejects.toThrow:", e.message);
}
}
// Uruchom testy
async function runAll() {
await testAsyncAwait();
console.log("");
await testReject();
console.log("");
await testCallback();
console.log("");
await demonstrateResolves();
console.log("");
demonstrateFakeTimers();
}
runAll();Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jak prawidłowo testować funkcję async w Jest?
2. Która metoda Jest pozwala przewinąć sztuczny czas o określoną liczbę milisekund?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kroki testowania asynchronicznej funkcji:
- Edytor kodu
Napisz testy async/await dla funkcji analyzeDNA i cloneDinosaur.
- Klikanie w kolejności
Ułóż elementy użycia fake timers w teście:
- Edytor kodu
Użyj fake timers do przetestowania systemu ewakuacji parku.