0Pricing
JavaScript Academy · Lekcja

Podejście do testów — małe asercje, AAA, red→green→refactor

Wyrabianie nawyku pisania małych testów: poznanie asercji, Arrange–Act–Assert oraz cyklu red→green→refactor

Podejście do testów — małe asercje, AAA, red→green→refactor to bezpłatna lekcja JavaScript Academy na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej JavaScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs JavaScript Academy zawiera 3 lekcji w sumie.

Dlaczego sposób myślenia oparty na testach?

Cel: Myśleć w kategoriach małych, niezawodnych testów.

  • Mały assert do sprawdzania wyników
  • AAA: Arrange → Act → Assert
  • Pętla Red → Green → Refactor
  • Nazywać testy na podstawie zachowania
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 1

Małe sprawdzenie asercją

Mały assertEqual wyświetla informację o powodzeniu lub niepowodzeniu. Odzwierciedla to działanie rzeczywistych frameworków testowych.

// Minimal assertEqual for quick checks
function assertEqual(actual, expected, name) {
  if (actual === expected) {
    console.log("✅", name);
  } else {
    console.log("❌", name, "expected:", expected, "got:", actual);
  }
}

// Demo check
assertEqual(2 + 3, 5, "adds numbers");
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 2

Arrange–Act–Assert

AAA zwiększa czytelność testów: przygotować dane, wywołać funkcję, a następnie sprawdzić wynik.

// AAA: Arrange → Act → Assert
// Arrange: prepare inputs
function sum(a, b) { return a + b; }
const a = 2;
const b = 4;

// Act: call the function
const result = sum(a, b);

// Assert: compare
assertEqual(result, 6, "sum returns a + b");
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 3

Red→Green→Refactor

Napisać test, który kończy się niepowodzeniem (red), sprawić, aby przeszedł (green), a następnie uporządkować kod (refactor).

// Red → Green → Refactor with a tiny example
// 1) Red: write a failing test (expect wrong implementation)
function greet(name) { return "Hi " + name; } // simple implementation

// Intentionally failing expectation first (red)
assertEqual(greet("Ayla"), "Hello Ayla", "greet says Hello"); // likely fails

// 2) Green: fix the code to satisfy the test
function greetFixed(name) { return "Hello " + name; }
assertEqual(greetFixed("Ayla"), "Hello Ayla", "greet says Hello (fixed)");

// 3) Refactor: improve code without changing behavior
function greetRefined(name) {
  const cleaned = String(name).trim();
  return "Hello " + cleaned;
}
assertEqual(greetRefined(" Ayla "), "Hello Ayla", "greet trims input");
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 4

Nazwy skupione na zachowaniu

Nazywać sprawdzenia na podstawie tego, co funkcja powinna robić: przypadki brzegowe i typowe.

// Clear names describe behavior, not internals
function isAdult(age) { return age >= 18; }

assertEqual(isAdult(18), true, "isAdult returns true at boundary 18");
assertEqual(isAdult(17), false, "isAdult returns false below boundary");
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 5

Małe, ukierunkowane testy

Wskazówki:

  • Utrzymywać testy małe i ukierunkowane (po jednym pomyśle na test).
  • Testować typowy poprawny przypadek oraz jeden przypadek brzegowy.
  • Preferować funkcje czyste, które łatwo testować.
  • Później automatyzować testy za pomocą Jest/Vitest; najpierw wypracować właściwy sposób myślenia.
Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 6

Quiz: wzorzec AAA

Szybkie sprawdzenie: Wzorzec AAA.

Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 7

Podsumowanie

Podsumowanie: Używać małego assert, stosować AAA i iterować według schematu Red → Green → Refactor. Zaczynać od małych kroków — dla początkujących klarowność jest ważniejsza od złożoności.

Podejście do testów — małe asercje, AAA, red→green→refactor — ilustracja 8

Często zadawane pytania

Czy lekcja „Podejście do testów — małe asercje, AAA, red→green→refactor” jest bezpłatna?

Tak — pełny tekst „Podejście do testów — małe asercje, AAA, red→green→refactor” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu JavaScript Academy, przejdź na CoddyKit PRO. Kurs JavaScript Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Podejście do testów — małe asercje, AAA, red→green→refactor”?

Wyrabianie nawyku pisania małych testów: poznanie asercji, Arrange–Act–Assert oraz cyklu red→green→refactor Ćwiczysz JavaScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć JavaScript Academy?

Nie wymagamy żadnego doświadczenia. JavaScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Podejście do testów — małe asercje, AAA, red→green→refactor”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji JavaScript Academy?

Tak. Każda lekcja JavaScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Podejście do testów — małe asercje, AAA, red→green→refactor
  2. Lintowanie za pomocą ESLint i formatowanie Prettier
  3. Podstawy CI — lint i test przy każdym pushu
← Powrót do JavaScript Academy