Softwarequalität in PHP-Projekten

Inhalt

Geleitwort

Vorwort

Teil I Grundlagen

1 Softwarequalität

1.1 Was ist Softwarequalität?

1.2 Externe Qualität

1.3 Interne Qualität

1.4 Technische Schulden

1.5 Konstruktive Qualitätssicherung

1.6 Sauberer Code

1.6.1 Explizite und minimale Abhängigkeiten

1.6.2 Klare Verantwortlichkeiten

1.6.3 Keine Duplikation

1.6.4 Kurze Methoden mit wenigen Ausführungszweigen

1.7 Software-Metriken

1.7.1 Zyklomatische Komplexität und NPath-Komplexität

1.7.2 Change Risk Anti-Patterns (CRAP) Index

1.7.3 Non-Mockable Total Recursive Cyclomatic Complexity

1.7.4 Global Mutable State

1.7.5 Kohäsion und Kopplung

1.8 Werkzeuge

1.9 Fazit

2 Testen von Software

2.1 Einführung

2.2 Systemtests

2.2.1 Testen im Browser

2.2.2 Automatisierte Tests

2.2.3 Testisolation

2.2.4 Akzeptanztests

2.2.5 Grenzen von Systemtests

2.3 Unit-Tests

2.3.1 Rückgabewerte

2.3.2 Abhängigkeiten

2.3.3 Seiteneffekte

2.3.4 Stub- und Mock-Objekte

2.4 Die Softwaretestpyramide

2.5 Integrationstests

2.5.1 Kollaborierende Systeme ersetzen

2.5.2 Datenbanken ersetzen

2.5.3 Die GUI (zunächst) ignorieren

2.5.4 Frontend-Tests

2.5.5 PHPUnit als Infrastruktur

2.5.6 Realisierung

2.6 Fazit

3 Testen von Legacy Code

3.1 Einführung

3.2 Praxisbeispiel

3.2.1 Vorbereitungen

3.2.2 Globale Abhängigkeiten

3.2.3 Datenquellen

3.2.4 Asynchrone Vorgänge

3.2.5 Änderungen in der Datenbank

3.2.6 Nicht vorhersagbare Ergebnisse

3.2.7 Eingabedaten

3.2.8 Weiterführende Überlegungen

3.3 Fazit

Teil II Fortgeschrittene Themen

4 Bad Practices in Unit-Tests

4.1 Einführung

4.2 Warum guter Testcode wichtig ist

4.3 Bad Practices und Test-Smells

4.3.1 Duplizierter Testcode

4.3.2 Zusicherungsroulette und begierige Tests

4.3.3 Fragile Tests

4.3.4 Obskure Tests

4.3.5 Lügende Tests

4.3.6 Langsame Tests

4.3.7 Konditionale Logik in Tests

4.3.8 Selbstvalidierende Tests

4.3.9 Websurfende Tests

4.3.10 Mock-Overkill

4.3.11 Skip-Epidemie

4.4 Fazit

5 Kontinuierliche Integration

5.1 Einführung

5.1.1 Kontinuierliche Integration

5.1.2 Statische Analyse

5.2 Installation und Inbetriebnahme

5.3 Konfiguration

5.3.1 Statische Tests

5.3.2 Dynamische Tests

5.3.3 Reporting

5.3.4 Deliverables erzeugen

5.4 Betrieb

5.5 Weiterführende Themen

5.5.1 Continuous Deployment

5.5.2 Einen Reverse Proxy nutzen

5.5.3 Kontinuierliche Integration und agile Paradigmen

5.6 Fazit

6 Testen von Datenbank-Interaktionen

6.1 Einführung

6.2 Pro und Kontra

6.2.1 Was gegen Datenbanktests spricht

6.2.2 Warum wir Datenbanktests schreiben sollten

6.3 Was wir testen sollten

6.4 Datenbanktests schreiben

6.4.1 Die Datenbankverbindung mocken

6.4.2 Die Datenbankerweiterung von PHPUnit

6.4.3 Die Klasse für Datenbanktestfälle

6.4.4 Die Verbindung zur Testdatenbank aufbauen

6.4.5 Datenbestände erzeugen

6.4.6 Operationen auf den Daten

6.4.7 Tests schreiben

6.4.8 Den Datenbanktester benutzen

6.5 Testgetriebene Entwicklung und Datenbanktests

6.6 Datenbanktests als Regressionstests

6.6.1 Probleme mit den Daten testen

6.6.2 Probleme testen, die durch Daten sichtbar werden

6.7 Fazit

7 Gebrauchstauglichkeit

7.1 Einführung

7.2 Anything goes – aber zu welchem Preis?

7.3 Designaspekte

7.3.1 Barrierefreiheit

7.3.2 Lesbarkeit

7.3.3 Label für Formularelemente

7.3.4 Tastaturbedienbare Webseite

7.3.5 Gute Farbkontraste

7.3.6 Logo zur Startseite verlinken

7.3.7 Alternativtexte für Bilder

7.3.8 Hintergrundbild mit Hintergrundfarbe

7.3.9 Druckversion nicht vergessen

7.3.10 Erkennbare Links

7.3.11 Gute Bookmarks

7.3.12 Keine Frames

7.3.13 Skalierbare Schrift

7.4 Technische Aspekte

7.4.1 Performanz

7.4.2 JavaScript

7.5 Benutzerführung

7.5.1 Der Mythos des Falzes

7.5.2 Feedback bei Interaktionen

7.5.3 Navigation

7.5.4 Popups und andere Störenfriede

7.5.5 Gewohnheiten bedienen, Erwartungen nicht enttäuschen

7.5.6 Fehlertoleranz und Feedback

7.6 Testen der Usability

7.7 Fazit

8 Performanz

8.1 Einführung

8.1.1 Werkzeuge

8.1.2 Umgebungsbezogene Gesichtspunkte

8.2 Lasttests

8.2.1 Apache Bench

8.2.2 Pylot

8.2.3 Weitere Werkzeuge für Lasttests

8.3 Profiling

8.3.1 Callgrind

8.3.2 APD

8.3.3 Xdebug

8.3.4 XHProf

8.3.5 OProfile

8.4 Systemmetriken

8.4.1 strace

8.4.2 Sysstat

8.4.3 Lösungen im Eigenbau

8.5 Übliche Fallstricke

8.5.1 Entwicklungsumgebung gegen Produktivumgebung

8.5.2 CPU-Zeit

8.5.3 Mikro-Optimierungen

8.5.4 PHP als Glue Language

8.5.5 Priorisierung von Optimierungen

8.6 Fazit

9 Sicherheit

9.1 Was ist eigentlich Sicherheit?

9.2 Secure by Design

9.2.1 Der Betrieb

9.2.2 Physikalischer Zugang

9.2.3 Software-Entwicklung

9.3 Was kostet Sicherheit?

9.4 Die häufigsten Probleme

9.5 Fazit

10 Testbasierte Entwicklung verkaufen

10.1 Vom prozeduralen Code zum testbasierten Vorgehen

10.2 Ziele der testbasierten Entwicklung

10.3 Aufwände für Software-Entwicklung

10.4 Möglichst wenige technische Schulden aufnehmen!

10.5 Offenlegung von Risiken mit ATAM

10.5.1 Diskutieren und entscheiden

10.5.2 Mit ATAM transparente Entscheidungen herbeiführen

10.6 Kalkulation testbasierter Entwicklung

10.6.1 Risiken als Argumentationshilfe berechnen

10.6.2 Langsamere Entwicklung bei höherer Qualität

10.6.3 Automatisierungs- und Abdeckungsgrad durch Tests bestimmen

10.7 Strategische Argumente für die Einführung testbasierter Entwicklung

10.7.1 Qualität und Nachhaltigkeit als Teil des Leistungsversprechens

10.7.2 Initiale Mehraufwände, die sich für den Auftraggeber lohnen

10.8 Das Angebot richtig verhandeln

10.9 Formulierung des Angebots

10.9.1 Inhalte des Angebots

10.9.2 Ein Angebot ohne Verhandlung abgeben?

10.10 Fazit

Teil III Fallstudien: Open-Source

11 TYPO3: die agile Zukunft eines schwergewichtigen Projekts

11.1 Einführung

11.1.1 Die Geschichte von TYPO3 – 13 Jahre in 13 Absätzen

11.1.2 Den Neuanfang wagen!

11.1.3 Unsere Erfahrungen mit dem Testen

11.2 Grundsätze und Techniken

11.2.1 Bittersüße Elefantenstückchen

11.2.2 Testgetriebene Entwicklung

11.2.3 Tests als Dokumentation

11.2.4 Kontinuierliche Integration

11.2.5 Sauberer Code

11.2.6 Refaktorierung

11.2.7 Programmierrichtlinien

11.2.8 Domänengetriebenes Design

11.3 Vorgehen bei der Entwicklung

11.3.1 Neuen Code entwickeln

11.3.2 Code erweitern und ändern

11.3.3 Code optimieren

11.3.4 Fehler finden und beheben

11.3.5 Alten Code fachgerecht entsorgen

11.4 Testrezepte

11.4.1 Ungewollt funktionale Unit-Tests

11.4.2 Zugriffe auf das Dateisystem

11.4.3 Konstruktoren in Interfaces

11.4.4 Abstrakte Klassen testen

11.4.5 Testen von geschützten Methoden

11.4.6 Verwendung von Callbacks

11.5 Auf in die Zukunft

12 Testen von Symfony und Symfony-Projekten

12.1 Einführung

12.2 Ein Framework testen

12.2.1 Der Release-Management-Prozess von Symfony

12.2.2 Verhältnis von Testcode und getestetem Code

12.2.3 Die Ausführung der Testsuite muss schnell sein

12.2.4 Gesammelte Erfahrungen

12.3 Testen von Webanwendungen

12.3.1 Die Hemmschwelle für das Testen abbauen

12.3.2 Unit-Tests

12.3.3 Funktionale Tests

12.4 Fazit

13 Testen von Grafikausgaben

13.1 Einführung

13.2 Entwicklungsphilosophie

13.3 Die ezcGraph-Komponente

13.3.1 Architektur

13.4 Ausgabetreiber durch Mock-Objekt ersetzen

13.4.1 Mehrfache Erwartungen

13.4.2 Structs

13.4.3 Generierung der Erwartungen

13.4.4 Zusammenfassung

13.5 Binäre Ausgaben testen

13.5.1 Die Ausgabetreiber

13.5.2 Generierung der Erwartungen

13.5.3 SVG

13.5.4 Bitmap-Erzeugung

13.5.5 Flash

13.6 Fazit

14 Testen von serviceorientierten APIs

14.1 Die Probleme

14.2 API-Zugangskennungen

14.3 API-Beschränkungen

14.4 Service-Protokolle offline testen

14.5 Konkrete Services offline testen

14.6 Fazit

15 Wie man einen WebDAV-Server testet

15.1 Über die eZ WebDAV-Komponente

15.1.1 WebDAV

15.1.2 Architektur

15.2 Herausforderungen bei der Entwicklung

15.2.1 Anforderungsanalyse

15.2.2 TDD nach RFC

15.2.3 Den Server testen

15.3 Automatisierte Akzeptanztests mit PHPUnit

15.3.1 Test-Trails aufzeichnen

15.3.2 Das Testrezept

15.3.3 Integration mit PHPUnit

15.4 Fazit

Teil IV Fallstudien: Unternehmen

16 swoodoo – eine wahrhaft agile Geschichte

16.1 Einführung

16.2 Evolution: Nur die Starken überleben

16.3 Wie wir die „eXtreme Seite“ erreichten

16.3.1 Kontinuierliche Integration

16.3.2 Testgetriebene Entwicklung

16.3.3 Tägliche Standup-Meetings

16.4 Wo wir schon einmal dabei sind ...

16.4.1 User Storys und Story Points

16.4.2 Velocity

16.4.3 Iterationsplanung

16.4.4 Programmieren in Paaren

16.4.5 Kollektives Eigentum

16.4.6 Offenheit für Änderungen

16.4.7 Überstunden

16.5 Die Kunst der Evolution

16.6 KISS und YAGNI – zwei Seiten einer Medaille

16.7 Evolutionstheorie und Fazit

17 Qualitätssicherung bei studiVZ

17.1 Einführung

17.2 Akzeptanztests

17.3 Selenium

17.3.1 Die Selenium-Erweiterung von PHPUnit

17.4 Technisches Setup von studiVZ

17.4.1 Codeumgebung

17.4.2 Testumgebung

17.5 Best Practices

17.5.1 Jugendsünden

17.5.2 Strategiewechsel

17.6 Eine DSL muss her

17.6.1 Interne DSL

17.6.2 Testing_SeleniumDSL 1.0

17.6.3 Testing_SeleniumDSL 2.0 – ein Entwurf

17.7 Fazit

18 Qualitätssicherung bei Digg

18.1 Die Ausgangssituation

18.1.1 Unsere Probleme

18.1.2 Code-Altlasten

18.1.3 Wie lösen wir unsere Probleme?

18.1.4 Ein Test-Framework wählen

18.1.5 Mit einem Experten arbeiten

18.2 Das Team trainieren

18.3 Testbaren Code schreiben

18.3.1 Statische Methoden vermeiden

18.3.2 Dependency Injection

18.4 Mock-Objekte

18.4.1 Überblick

18.4.2 Datenbank

18.4.3 Lose gekoppelte Abhängigkeiten

18.4.4 Beobachter für klasseninternes Verhalten

18.4.5 Memcache

18.4.6 Mocken einer serviceorientierten Architektur

18.5 Der Qualitätssicherungsprozess bei Digg

18.5.1 Testen

18.5.2 Vorteile

18.5.3 Herausforderungen

18.6 Fazit

Schlussbetrachtungen

Literatur

Stichwortverzeichnis