Testowanie aplikacji Java za pomoca JUnit.pdf

(1248 KB) Pobierz
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi
ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje
były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie,
ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz
Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody
wynikłe z wykorzystania informacji zawartych w książce.
Redaktor prowadzący: Małgorzata Kulik
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
Grafika na okładce została wykorzystana za zgodą Shutterstock.com
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail:
helion@helion.pl
WWW:
http://helion.pl
(księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/teapja
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Kody źródłowe wybranych przykładów dostępne są pod adresem:
ftp://ftp.helion.pl/przyklady/teapja.zip
ISBN: 978-83-283-3828-9
Copyright © Helion 2018
Printed in Poland.
•
Kup książkę
•
Poleć książkę
•
Oceń książkę
•
Księgarnia internetowa
•
Lubię to! » Nasza społeczność
Spis treści
Wstęp ................................................................................................................. 7
Rozdział 1. Testy jednostkowe ............................................................................ 11
1.1. Pierwszy przykład .............................................................................................................. 12
1.2. Ścieżki kodu ........................................................................................................................ 13
1.3. Testy jednostkowe ............................................................................................................. 17
1.3.1. Wykorzystanie biblioteki JUnit ............................................................................ 18
1.3.2. Klasy testów ............................................................................................................. 18
1.3.3. Szkielet klasy testu .................................................................................................. 18
1.3.4. Pierwsze testy ........................................................................................................... 20
1.3.5. Uruchomienie testów ............................................................................................. 22
1.3.6. Raport z testów ........................................................................................................ 24
1.3.7. Spodziewanie się sytuacji wyjątkowej .................................................................. 25
1.3.8. Cykl życia klasy testów ........................................................................................... 29
1.3.9. Inne założenia testowe ........................................................................................... 34
1.3.10. Ignorowanie testów .............................................................................................. 35
1.3.11. Pokrycie testami .................................................................................................... 36
1.4. Refaktoryzacja .................................................................................................................... 38
1.4.1. Klasa poddawana refaktoryzacji ........................................................................... 39
1.4.2. Testy .......................................................................................................................... 40
1.4.3. Klasa po poprawkach ............................................................................................. 45
1.4.4. Refaktoryzacja ......................................................................................................... 48
1.5. Podsumowanie ................................................................................................................... 49
Rozdział 2. Imitacje ............................................................................................ 51
2.1. Klasy imitacji ...................................................................................................................... 52
2.1.1. Podstawy .................................................................................................................. 53
2.1.2. Główny moduł aplikacji przed dostosowaniem do testów ............................... 57
2.1.3. Dostosowanie głównego modułu aplikacji do testów ........................................ 58
Kup książkę
Poleć książkę
4
Testowanie aplikacji Java za pomocą JUnit
2.1.4. Utworzenie imitacji klasy przechowywania danych .......................................... 60
2.1.5. Testowanie głównego modułu aplikacji .............................................................. 61
2.1.6. Usuwanie usterek .................................................................................................... 64
2.2. Obiekty imitacji ................................................................................................................. 65
2.2.1. Biblioteka Mockito ................................................................................................. 66
2.2.2. Najprostszy przykład wykorzystania .................................................................... 67
2.2.3. Imitacja modułu składowania danych ocen ........................................................ 72
2.2.4. Swobodne konfigurowanie obiektów imitacji .................................................... 77
2.2.5. Zliczanie wywołań imitowanych metod .............................................................. 79
2.2.6. Tworzenie obiektów imitacji na bazie klas imitacji ........................................... 81
2.3. Podsumowanie ................................................................................................................... 84
Rozdział 3. Płynne definicje testów ..................................................................... 87
3.1. Biblioteka AssertJ .............................................................................................................. 88
3.2. Budowanie kryteriów ........................................................................................................ 88
3.2.1. Klasa przykładowa .................................................................................................. 88
3.2.2. Testy jednostkowe ................................................................................................... 89
3.2.3. Kompletna treść przykładu ................................................................................... 99
3.3. Inne kryteria ..................................................................................................................... 102
3.3.1. Typy skalarne ......................................................................................................... 102
3.3.2. Typy tablicowe i kolekcje ..................................................................................... 105
3.4. Podsumowanie ................................................................................................................. 107
Rozdział 4. Programowanie ukierunkowane na testy ......................................... 109
4.1. Programowanie bazujące na kontraktach .................................................................... 110
4.1.1. Kontrakty wejściowe ............................................................................................ 110
4.1.2. Kontrakty wyjściowe ............................................................................................ 115
4.2. Programowanie ukierunkowane na testy ..................................................................... 116
4.2.1. Projekt klasy ........................................................................................................... 117
4.2.2. Testy jednostkowe ................................................................................................. 118
4.2.3. Uzupełnianie implementacji ............................................................................... 121
4.2.4. Kompletna implementacja .................................................................................. 124
4.3. Programowanie wspomagane testami .......................................................................... 125
4.3.1. Interfejs klasy ......................................................................................................... 126
4.3.2. Szkielet klasy .......................................................................................................... 127
4.3.3. Implementacja i testy ........................................................................................... 128
4.4. Podsumowanie ................................................................................................................. 145
Kup książkę
Poleć książkę
Spis treści
5
Rozdział 5. Imitowanie baz danych ................................................................... 147
5.1. Dołączanie Derby do projektu ....................................................................................... 148
5.2. Definiowanie testowej jednostki utrwalania ................................................................ 149
5.3. Tworzenie zarządcy utrwalania ..................................................................................... 150
5.4. Szkielet klasy testowej ..................................................................................................... 151
5.5. Przykład wykorzystania .................................................................................................. 154
5.5.1. Klasa encji zakładki strony .................................................................................. 154
5.5.2. Klasa usługi zarządzania zakładkami ................................................................. 159
5.5.3. Całość tekstu źródłowego .................................................................................... 165
5.6. Podsumowanie ................................................................................................................. 169
Skorowidz ...................................................................................................... 171
Kup książkę
Poleć książkę

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin