Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ JAVA

TDD. Programowanie w Javie sterowane testami Język: 1

978-83-283-2341-4

Cena Brutto: 59.00

Cena netto: 56.19

Ilość:
Wersja: Drukowana
Autor Viktor Farcic, Alex Garcia
Liczba_stron 256
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2016-05-13

TDD

. Programowanie w Javie sterowane testami



Programowanie sterowane testami (ang. test-driven developmentTDD) 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)
powrót
 
Produkty Podobne
Java dla zupełnie początkujących. Owoce programowania. Wydanie VII
Algorytmy, struktury danych i techniki programowania dla programistów Java
Java EE 8. Wzorce projektowe i najlepsze praktyki
Struktury danych i algorytmy w języku Java. Przewodnik dla początkujących
Modularny JavaScript dla zaawansowanych
Core Java, Volume II--Advanced Features, 11th Edition
Java. Kompendium programisty. Wydanie X
Kotlin w akcji
Nowoczesna Java w działaniu. Wyrażenia lambda, strumienie, programowanie funkcyjne i reaktywne
Java. Przewodnik dla początkujących. Wydanie VII
Więcej produktów