TESTY JEDNOSTKOWE ZASADY PRAKTYKI I WZORCE

ISBN: 978-83-283-6871-2

296 stron
format: B5
oprawa: miękka
Rok wydania: 2020

Każdy inżynier oprogramowania zna teoretyczne podstawy testowania. O tym, że sumienne przeprowadzenie testów ma podstawowe znaczenie dla jakości gotowego produktu, nie trzeba nikogo przekonywać. A jednak wciąż zbyt często okazuje się, że zaplanowanie, napisanie i przeprowadzenie testów jednostkowych w praktyce nie jest łatwym zadaniem. Co gorsza, niewłaściwe testy psują kod, mnożą błędy i zabierają mnóstwo cennego czasu i pieniędzy. Okazuje się, że dla uzyskania maksymalnej jakości projektu, który trzeba dostarczyć w krótkim czasie, konieczne jest nauczenie się praktycznego stosowania zasad i wzorców testowania jednostkowego.
Jeśli znasz już podstawy testowania jednostkowego, dzięki tej książce nauczysz się projektowania i pisania testów, które obierają za cel model domeny i pozostałe kluczowe obszary kodu. Ten przejrzyście napisany przewodnik poprowadzi Cię przez proces tworzenia zestawów testowych o optymalnej wartości, bezpiecznej automatyzacji testowania i umiejętnego włączania go w cykl życia oprogramowania. W książce znalazły się uniwersalne wskazówki dotyczące analizy dowolnych testów jednostkowych oraz porady odnoszące się do zmian testów następujących wraz ze zmianami kodu produkcyjnego. Nie zabrakło również informacji, dzięki którym sprawnie zidentyfikujesz i wykluczysz ewentualne antywzorce testowania. Materiał został bogato zilustrowany przejrzystymi przykładami kodu napisanego w C#. Naturalnie, mają one zastosowanie także dla innych języków programowania.

SPIS TREŚCI

Przedmowa
Podziękowania
O książce
O autorze

CZĘŚĆ I. SZEROKI HORYZONT
Rozdział 1. Cel testowania jednostkowego
1.1. Obecna kondycja testowania jednostkowego
1.2. Cel testowania jednostkowego
1.2.1. Co czyni test dobrym?
1.3. Stosowanie wskaźników pokrycia do mierzenia jakości zestawu testowego
1.3.1. Interpretacja wskaźnika pokrycia kodu
1.3.2. Interpretacja wskaźnika pokrycia gałęzi
1.3.3. Problemy z pokryciem gałęzi
1.3.4. Wymaganie procentowej wartości pokrycia
1.4. Właściwości dobrego zestawu testowego
1.4.1. Integracja z cyklem wytwarzania oprogramowania
1.4.2. Koncentracja na najważniejszych częściach kodu
1.4.3. Maksymalna wartość przy minimalnych kosztach
1.5. Czego nauczysz się z tej książki
Podsumowanie

Rozdział 2. Co to jest test jednostkowy?
2.1. Definicja testu jednostkowego
2.1.1. Izolacja - podejście londyńskie
2.1.2. Izolacja - podejście klasyczne
2.2. Klasyczna i londyńska szkoła testów jednostkowych
2.2.1. Obsługa zależności według szkoły londyńskiej i klasycznej
2.3. Zestawienie podejść - klasycznej i londyńskiej szkoły testowania jednostkowego
2.3.1. Testowanie jednostkowe jednej klasy na raz
2.3.2. Testowanie jednostkowe dużej mapy wzajemnie łączących się klas
2.3.3. Dokładne wskazywanie źródła błędów
2.3.4. Inne różnice między podejściem klasycznym a londyńskim
2.4. Testy integracyjne według dwóch szkół
2.4.1. Testy systemowe to podzbiór testów integracyjnych
Podsumowanie

Rozdział 3. Anatomia testu jednostkowego
3.1. Struktura testu jednostkowego
3.1.1. Zastosowanie wzorca AAA
3.1.2. Unikanie wielokrotnych sekcji przygotuj, zrób, sprawdź
3.1.3. Unikanie warunków w testach
3.1.4. Optymalna wielkość sekcji
3.1.5. Liczba weryfikacji w sekcji asercji
3.1.6. Sekwencja końcowa
3.1.7. Zróżnicowanie systemu poddawanego testom
3.1.8. Usunięcie komentarzy na temat sekcji z testów
3.2. Omówienie biblioteki testowej xUnit
3.3. Wielokrotne wykorzystanie jarzma testowego
3.3.1. Silne wiązania między testami - antywzorzec
3.3.2. Użycie konstruktora zmniejsza czytelność
3.3.3. Lepszy sposób wielokrotnego wykorzystania jarzma testowego
3.4. Nazewnictwo testów jednostkowych
3.4.1. Nazewnictwo testów jednostkowych - wytyczne
3.4.2. Przykład: zmiana nazwy testu zgodnie z wytycznymi
3.5. Zamiana na testy parametryzowane
3.5.1. Generowanie danych dla testów parametryzowanych
3.6. Biblioteka asercji i dalsze poprawianie czytelności testów
Podsumowanie

CZĘŚĆ II. TESTY, KTÓRE PRACUJĄ DLA CIEBIE

Rozdział 4. Cztery filary dobrego testu jednostkowego
4.1. Cztery filary dobrego testu jednostkowego
4.1.1. Filar pierwszy: ochrona przed regresją
4.1.2. Filar drugi: odporność na zmiany
4.1.3. Co powoduje wyniki obarczone błędem pierwszego rodzaju
4.1.4. Skup się na końcowym wyniku, a nie szczegółach implementacyjnych
4.2. Nierozerwalny związek między pierwszą a drugą cechą
4.2.1. Zwiększanie dokładności testów
4.2.2. Waga wyników fałszywie dodatnich i fałszywie ujemnych - dynamika
4.3. Filary trzeci i czwarty: szybka informacja zwrotna i utrzymywalność
4.4. W poszukiwaniu idealnego testu
4.4.1. Czy możliwe jest stworzenie idealnego testu
4.4.2. Przypadek skrajny nr 1: test systemowy
4.4.3. Przypadek skrajny nr 2: testy trywialne
4.4.4. Przypadek skrajny nr 3: niestabilne testy
4.4.5. W poszukiwaniu idealnego testu - wyniki
4.5. Omówienie dobrze znanych pojęć z zakresu testów automatycznych
4.5.1. Poziomy piramidy testów
4.5.2. Wybór między testowaniem czarno- i białoskrzynkowym
Podsumowanie

Rozdział 5. Atrapy i stabilność testów
5.1. Rozróżnienie między atrapami a zaślepkami
5.1.1. Rodzaje dublerów testowych
5.1.2. Atrapa (narzędzie) kontra atrapa (dubler testowy)
5.1.3. Nie poddawaj asercjom interakcji z zaślepkami
5.1.4. Używanie atrap i zaślepek razem
5.1.5. Związek atrap i zaślepek z poleceniami i zapytaniami
5.2. Zachowanie dające się zaobserwować a szczegóły implementacyjne
5.2.1. Dające się zaobserwować zachowanie to nie publiczny interfejs API
5.2.2. Wyciekające szczegóły implementacyjne - przykład z operacją
5.2.3. Dobrze zaprojektowany interfejs API i enkapsulacja
5.2.4. Wyciekające szczegóły implementacyjne - przykład ze stanem
5.3. Związek między atrapami a niestabilnością testów
5.3.1. Architektura heksagonalna
5.3.2. Komunikacja wewnątrzsystemowa i międzysystemowa
5.3.3. Komunikacja wewnątrzsystemowa i międzysystemowa - przykład
5.4. Klasyczna i londyńska szkoła testowania jednostkowego - raz jeszcze
5.4.1. Nie wszystkie zewnętrzne zależności należy zastępować atrapami
5.4.2. Wykorzystanie atrap do weryfikowania zachowania
Podsumowanie

Rozdział 6. Style testowania jednostkowego
6.1. Trzy style testowania jednostkowego
6.1.1. Styl oparty na rezultatach - definicja
6.1.2. Styl oparty na stanach - definicja
6.1.3. Styl oparty na komunikacji - definicja
6.2. Trzy style testowania jednostkowego - porównanie
6.2.1. Porównanie stylów pod względem ochrony przed regresją i szybkości informacji zwrotnej
6.2.2. Porównanie stylów pod względem odporności na zmiany
6.2.3. Porównanie stylów pod względem utrzymywalności
6.2.4. Porównanie stylów - wyniki
6.3. Architektura funkcyjna
6.3.1. Czym jest programowanie funkcyjne?
6.3.2. Czym jest architektura funkcyjna?
6.3.3. Porównanie architektury funkcyjnej i heksagonalnej
6.4. Przejście do architektury funkcyjnej i testowania opartego na rezultatach
6.4.1. System audytowania - wprowadzenie
6.4.2. Wykorzystanie atrap w celu oddzielenia testu od systemu plików
6.4.3. Przejście do architektury funkcyjnej
6.4.4. Potencjalne dalsze kroki
6.5. Wady architektury funkcyjnej
6.5.1. Zasadność stosowania architektury funkcyjnej
6.5.2. Wady pod względem wydajności
6.5.3. Wady pod względem rozmiaru bazy kodu
Podsumowanie

Rozdział 7. Zmiany ku bardziej wartościowym testom jednostkowym
7.1. Określenie kodu podlegającego refaktoryzacji
7.1.1. Cztery typy kodu
7.1.2. Wykorzystanie wzorca Skromny Obiekt do podziału przeszacowanego kodu
7.2. Zmiany ku bardziej wartościowym testom
7.2.1. System zarządzania kontaktami z klientami - wprowadzenie
7.2.2. Próba nr 1: ujawnienie zależności
7.2.3. Próba nr 2: wprowadzenie warstwy usług aplikacji
7.2.4. Próba nr 3: usunięcie złożoności z usługi aplikacji
7.2.5. Próba nr 4: wprowadzenie nowej klasy Company
7.3. Analiza optymalnego pokrycia testami jednostkowymi
7.3.1. Testowanie warstwy domeny i kodu pomocniczego
7.3.2. Testowanie kodu z pozostałych części diagramu
7.3.3. Czy powinno się testować warunki wstępne?
7.4. Obsługa logiki warunkowej w kontrolerach
7.4.1. Wykorzystanie wzorca Polecenie
7.4.2. Wykorzystanie zdarzeń domeny do śledzenia zmian w modelu domeny
7.5. Wnioski
Podsumowanie

CZĘŚĆ III. TESTY INTEGRACYJNE

Rozdział 8. Po co testy integracyjne?
8.1. Test integracyjny - definicja
8.1.1. Rola testów integracyjnych
8.1.2. Piramida testów - jeszcze raz
8.1.3. Testy integracyjne kontra szybka reakcja
8.2. Które zewnętrzne zależności testować bezpośrednio
8.2.1. Dwa typy zależności poza kontrolą procesu
8.2.2. Obsługa zarządzanych i niezarządzanych zależności
8.2.3. Co, jeśli nie możesz wykorzystać prawdziwej bazy danych w testach integracyjnych?
8.3. Testy integracyjne - przykład
8.3.1. Jakie scenariusze przetestować?
8.3.2. Klasyfikacja bazy danych i szyny danych
8.3.3. Co z testami systemowymi?
8.3.4. Test integracyjny - próba pierwsza
8.4. Stosowanie interfejsów do abstrakcji zależności
8.4.1. Interfejsy i luźne wiązania
8.4.2. Po co używać interfejsów dla zewnętrznych zależności?
8.4.3. Stosowanie interfejsów dla wewnętrznych zależności
8.5. Najlepsze praktyki testów integracyjnych
8.5.1. Jasno oznacz granice modelu domeny
8.5.2. Zmniejszaj liczbę warstw
8.5.3. Usuwaj zapętlone zależności
8.5.4. Użycie wielu sekcji działania w teście
8.6. Jak testować zapisywanie logów
8.6.1. Czy w ogóle powinno się testować pisanie logów
8.6.2. Jak testować pisanie logów
8.6.3. Ile logowania wystarczy
8.6.4. Jak przekazywać instancje mechanizmu logowania
8.7. Wnioski
Podsumowanie

Rozdział 9. Najlepsze praktyki modelowania za pomocą atrap
9.1. Maksymalizowanie wartości atrap
9.1.1. Weryfikacja interakcji na obrzeżach systemu
9.1.2. Zastępowanie atrap agentami
9.1.3. Co z interfejsem IDomainLogger
9.2. Najlepsze praktyki modelowania za pomocą atrap
9.2.1. Atrapy służą tylko do testów integracyjnych
9.2.2. Wiele atrap w jednym teście
9.2.3. Weryfikacja liczby żądań
9.2.4. Modeluj tylko typy, które sam utworzyłeś
Podsumowanie

Rozdział 10. Testowanie bazy danych
10.1. Warunki umożliwiające testowanie bazy danych
10.1.1. Przechowywanie bazy danych w systemie kontroli wersji
10.1.2. Dane referencyjne to część schematu bazy danych
10.1.3. Oddzielne instancje dla każdego programisty
10.1.4. Stanowe i migracyjne podejście do dostarczania bazy danych
10.2. Zarządzanie transakcjami w bazie danych
10.2.1. Zarządzanie transakcjami w kodzie produkcyjnym
10.2.2. Zarządzanie transakcjami w testach integracyjnych
10.3. Cykl życia danych testowych 2
10.3.1. Równoległe i sekwencyjne wykonanie testów
10.3.2. Sprzątanie danych pomiędzy wykonaniami testów
10.3.3. Unikanie baz danych operujących w pamięci
10.4. Wielokrotne wykorzystanie kodu w sekcjach
10.4.1. Wielokrotne użycie kodu w sekcji przygotowań
10.4.2. Wielokrotne użycie kodu w sekcji działania
10.4.3. Wielokrotne użycie kodu w sekcji asercji
10.4.4. Czy test tworzy zbyt wiele transakcji do bazy danych
10.5. Często zadawane pytania na temat testowania baz danych
10.5.1. Czy testować operacje odczytu?
10.5.2. Czy testować repozytoria
10.6. Wnioski
Podsumowanie

CZĘŚĆ IV. ANTYWZORCE TESTOWANIA JEDNOSTKOWEGO

Rozdział 11. Antywzorce testowania jednostkowego
11.1. Testowanie jednostkowe prywatnych metod
11.1.1. Metody prywatne i niestabilność testów
11.1.2. Metody prywatne i niedostateczne pokrycie
11.1.3. Kiedy testowanie metod prywatnych jest akceptowalne
11.2. Udostępnianie stanu prywatnego
11.3. Przenikanie wiedzy domenowej do testów
11.4. Zanieczyszczanie kodu
11.5. Modelowanie za pomocą atrap konkretnych klas
11.6. Praca z czasem
11.6.1. Czas jako kontekst środowiskowy
11.6.2. Czas jako jawna zależność
11.7. Wnioski
Podsumowanie