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)

• Tytuł: TDD. Programowanie w Javie sterowane testami
• Autor: Viktor Farcic, Alex Garcia
• Tytuł oryginału: Test-Driven Java Development
• Tłumaczenie: Tomasz Walczak
• ISBN: 978-83-283-2342-1, 9788328323421
• Data wydania: 2016-05-13
• Format: Ebook
• Identyfikator pozycji: tddpro
• Wydawca: Helion