Details zum E-Book

TDD. Programowanie w Javie sterowane testami

TDD. Programowanie w Javie sterowane testami

Viktor Farcic, Alex Garcia

E-book
Programowanie sterowane testami (ang. test-driven development — TDD) nie jest nową metodyką. Jej praktyczne zastosowanie pozwala na rozwiązanie wielu problemów związanych z procesami rozwijania i wdrażania oprogramowania. Mimo ogromnych zalet, programowanie sterowane testami nie jest zbyt popularne wśród programistów. Wynika to z tego, że techniki TDD nie są łatwe do opanowania. Choć teoretyczne podstawy wydają się logiczne i zrozumiałe, nabranie wprawy w stosowaniu TDD wymaga długiej praktyki.

Książka, którą trzymasz w ręce, została napisana przez programistów dla programistów. Jej celem jest przekazanie podstaw TDD i omówienie najważniejszych praktyk związanych z tą metodyką, a przede wszystkim — nauczenie praktycznego stosowania TDD w pracy. Autorzy nie ukrywają, że nabranie biegłości w takim programowaniu wymaga sporo wysiłku, jednak korzyści płynące z metodyki TDD są znaczne: skrócenie czasu wprowadzania produktów na rynek, łatwiejsza refaktoryzacja, a także wyższa jakość tworzonych projektów. Z tą książką dogłębnie zrozumiesz metodykę TDD i uzyskasz wystarczającą pewność siebie, by z powodzeniem stosować to podejście w trakcie programowania aplikacji w Javie.

Dzięki tej książce:
  • Nauczysz się podstaw metodyki TDD
  • Poznasz potrzebne narzędzia, platformy i środowiska wraz ze szczegółami ich konfiguracji
  • Wykonywasz praktyczne ćwiczenia i stopniowo wdrożysz się w TDD
  • Poznasz proces „czerwone, zielone, refaktoryzacja”
  • Dowiesz się, jak pisać testy jednostkowe wykonywane w izolacji od reszty kodu
  • Dowiesz się, jak tworzyć prosty i łatwy w konserwacji kod, nauczysz się refaktoryzować już istniejący
  • Nauczysz się pracować z atrapami, stosować programowanie sterowane zachowaniami, a także udostępniać połowicznie ukończone funkcje w środowisku produkcyjnym za pomocą przełączników funkcji

Programowanie sterowane testami to metodyka dla prawdziwych profesjonalistów!

O autorach (9)

O recenzentach (11)

Przedmowa (13)

Rozdział 1. Dlaczego powinieneś zainteresować się programowaniem sterowanym testami? (17)

  • Dlaczego TDD? (18)
    • Wprowadzenie do TDD (19)
    • Czerwone, zielone, refaktoryzacja (20)
    • Liczy się szybkość (21)
    • To nie testy są najważniejsze (21)
  • Przeprowadzanie testów (22)
    • Testy funkcjonalne (22)
    • Testy strukturalne (23)
    • Różnica między sprawdzaniem jakości a zapewnianiem jakości (24)
    • Lepsze testy (24)
  • Symulowanie działań (25)
  • Wykonywalna dokumentacja (25)
  • Brak konieczności debugowania (27)
  • Podsumowanie (28)

Rozdział 2. Narzędzia, platformy i środowiska (29)

  • System Git (30)
  • Maszyny wirtualne (30)
    • Vagrant (30)
    • Docker (33)
  • Narzędzia do budowania kodu (34)
  • Środowisko IDE (36)
    • Przykładowy projekt ze środowiska IDEA (36)
  • Platformy do przeprowadzania testów jednostkowych (36)
    • JUnit (38)
    • TestNG (40)
  • Hamcrest i AssertJ (42)
    • Hamcrest (42)
    • AssertJ (44)
  • Narzędzia do określania pokrycia kodu testami (44)
    • JaCoCo (45)
  • Platformy do tworzenia zastępników (46)
    • Mockito (48)
    • EasyMock (50)
    • Dodatkowe możliwości atrap (51)
  • Testowanie interfejsu użytkownika (52)
    • Platformy do testowania stron WWW (52)
    • Selenium (52)
    • Selenide (54)
  • Programowanie sterowane zachowaniami (55)
    • JBehave (56)
    • Cucumber (58)
  • Podsumowanie (60)

Rozdział 3. Czerwone, zielone, refaktoryzacja - od porażki, przez sukces, do doskonałości (61)

  • Przygotowywanie środowiska z systemem Gradle i narzędziem JUnit (62)
    • Tworzenie w środowisku IntelliJ IDEA projektu wykorzystującego system Gradle i Javę (62)
  • Czerwone, zielone, refaktoryzacja (65)
    • Napisz test (65)
    • Uruchom wszystkie testy i upewnij się, że ostatni kończy się niepowodzeniem (66)
    • Napisz kod rozwiązania (66)
    • Wykonaj wszystkie testy (66)
    • Przeprowadź refaktoryzację (67)
    • Powtórz cały cykl (67)
  • Wymagania dotyczące programu do gry w kółko i krzyżyk (67)
  • Pisanie programu do gry w kółko i krzyżyk (68)
    • Wymaganie nr 1 (68)
    • Wymaganie nr 2 (74)
    • Wymaganie nr 3 (77)
    • Wymaganie nr 4 (83)
  • Pokrycie kodu testami (85)
  • Dodatkowe ćwiczenia (86)
  • Podsumowanie (86)

Rozdział 4. Testy jednostkowe. Koncentrowanie się na wykonywanym zadaniu, a nie na tym, co już zostało zrobione (89)

  • Testy jednostkowe (90)
    • Czym są testy jednostkowe? (90)
    • Po co stosować testy jednostkowe? (91)
    • Refaktoryzacja kodu (91)
    • Dlaczego nie ograniczyć się do stosowania samych testów jednostkowych? (91)
  • Testy jednostkowe w TDD (93)
  • Platforma TestNG (94)
    • Adnotacja @Test (94)
    • Adnotacje @BeforeSuit, @BeforeTest, @BeforeGroups, @AfterGroups, @AfterTest i @AfterSuit (95)
    • Adnotacje @BeforeClass i @AfterClass (95)
    • Adnotacje @BeforeMethod i @AfterMethod (95)
    • Argument w adnotacji @Test(enable = false) (96)
    • Argument w adnotacji @Test(expectedExceptions = NazwaKlasy.class) (96)
    • Podsumowanie porównania platform TestNG i JUnit (96)
  • Wymagania dotyczące zdalnie sterowanego statku (97)
  • Pisanie kodu do zdalnego sterowania statkiem (97)
    • Przygotowywanie projektu (97)
    • Klasy pomocnicze (99)
    • Wymaganie nr 1 (100)
    • Wymaganie nr 2 (103)
    • Wymaganie nr 3 (105)
    • Wymaganie nr 4 (106)
    • Wymaganie nr 5 (109)
    • Wymaganie nr 6 (113)
  • Podsumowanie (113)

Rozdział 5. Projekt. Jeśli czegoś nie da się przetestować, projekt jest nieprawidłowy (115)

  • Dlaczego projekt ma znaczenie? (116)
    • Zasady projektowe (116)
  • Czwórki (118)
    • Wymagania (119)
  • Testowanie ostatniej wersji programu do gry Czwórki (119)
    • Wymaganie nr 1 (120)
    • Wymaganie nr 2 (121)
    • Wymaganie nr 3 (121)
    • Wymaganie nr 4 (122)
    • Wymaganie nr 5 (124)
    • Wymaganie nr 6 (124)
    • Wymaganie nr 7 (125)
    • Wymaganie nr 8 (126)
  • Program do gry w Czwórki napisany za pomocą TDD (127)
    • Hamcrest (128)
    • Wymaganie nr 1 (128)
    • Wymaganie nr 2 (129)
    • Wymaganie nr 3 (132)
    • Wymaganie nr 4 (133)
    • Wymaganie nr 5 (135)
    • Wymaganie nr 6 (135)
    • Wymaganie nr 7 (137)
    • Wymaganie nr 8 (138)
  • Podsumowanie (140)

Rozdział 6. Eliminowanie zewnętrznych zależności za pomocą atrap (141)

  • Tworzenie zastępników (142)
    • Po co tworzyć atrapy? (143)
    • Terminologia (144)
    • Obiekty pełniące funkcję atrap (144)
  • Platforma Mockito (145)
  • Wymagania dotyczące drugiej wersji programu do gry w kółko i krzyżyk (146)
  • Rozwijanie drugiej wersji programu do gry w kółko i krzyżyk (146)
    • Wymaganie nr 1 (147)
    • Wymaganie nr 2 (158)
  • Testy integracyjne (164)
    • Oddzielanie testów od siebie (165)
    • Test integracyjny (166)
  • Podsumowanie (168)

Rozdział 7. Programowanie sterowane zachowaniami - współpraca w ramach całego zespołu (169)

  • Różne specyfikacje (170)
    • Dokumentacja (170)
    • Dokumentacja dla programistów (171)
    • Dokumentacja dla nieprogramistów (172)
  • Programowanie sterowane zachowaniami (173)
    • Narracja (173)
    • Scenariusze (175)
  • Historia BDD dotycząca księgarni (176)
  • JBehave (179)
    • Klasa Runner dla platformy JBehave (179)
    • Niegotowe kroki (181)
    • Selenium i Selenide (183)
    • Kroki w platformie JBehave (184)
    • Ostateczne sprawdzanie poprawności (190)
  • Podsumowanie (191)

Rozdział 8. Refaktoryzacja zastanego kodu w celu "odmłodzenia" go (193)

  • Zastany kod (194)
    • Przykładowy zastany kod (194)
  • Ćwiczenie kata (204)
    • Kata dotyczące zastanego kodu (204)
    • Opis (205)
    • Komentarze techniczne (205)
    • Dodawanie nowych funkcji (205)
    • Testy funkcjonalne i testy badawcze (205)
    • Wstępne analizy (206)
    • Stosowanie algorytmu modyfikowania zastanego kodu (210)
    • Wyodrębnianie i przesłanianie wywołania (216)
    • Eliminowanie nadużywania typów podstawowych w przypadku statusu zwracanego jako wartość typu int (220)
  • Podsumowanie (223)

Rozdział 9. Przełączniki funkcji - wdrażanie częściowo ukończonych funkcji w środowisku produkcyjnym (225)

  • Ciągła integracja, ciągłe dostarczanie i ciągłe wdrażanie (226)
  • Przełączniki funkcji (228)
  • Przykład zastosowania przełącznika funkcji (229)
    • Pisanie kodu usługi wyznaczającej liczby Fibonacciego (233)
    • Korzystanie z silnika obsługi szablonów (236)
  • Podsumowanie (240)

Rozdział 10. Łączenie wszystkich informacji (241)

  • TDD w pigułce (241)
  • Najlepsze praktyki (243)
    • Konwencje nazewnicze (243)
    • Procesy (245)
    • Praktyki związane z pisaniem kodu (247)
    • Narzędzia (251)
  • To tylko początek (252)
  • To nie musi być koniec (252)

Skorowidz (253)

  • Titel: TDD. Programowanie w Javie sterowane testami
  • Autor: Viktor Farcic, Alex Garcia
  • Originaler Titel: Test-Driven Java Development
  • Übersetzung: Tomasz Walczak
  • ISBN: 978-83-283-2342-1, 9788328323421
  • Veröffentlichungsdatum: 2016-05-13
  • Format: E-book
  • Artikelkennung: tddpro
  • Verleger: Helion