Softwarequalität in PHP-Projekten

Inhaltsverzeichnis

Geleitwort

Vorwort

Teil I Grundlagen

Kapitel 1 Software-Qualität

1.1 Was ist Software-Qualität

1.1.1 Externe Qualität

1.1.2 Interne Qualität

1.2 Technical Debt

1.3 Konstruktive Qualitätssicherung

1.4 Sauberer Code

1.4.1 Explizite und minimale Abhängigkeiten

1.4.2 Klare Verantwortlichkeiten

1.4.3 Keine Duplikation

1.4.4 Kurze Methoden mit wenigen Ausführungszweigen

1.5 Software-Metriken

1.5.1 Zyklomatische Komplexität und NPath-Komplexität

1.5.2 Change Risk Anti-Patterns (CRAP) Index

1.5.3 Non-Mockable Total Recursive Cyclomatic Complexity

1.5.4 GlobalMutable State

1.5.5 Kohäsion und Kopplung

1.6 Werkzeuge

1.7 Fazit

Kapitel 2 Testen von Software

2.1 Black-Box- und White-Box-Tests

2.2 Wie viele Tests braucht man?

2.3 Systemtests

2.3.1 Testen im Browser

2.3.2 Automatisierte Tests

2.3.3 Testisolation

2.3.4 Akzeptanztests

2.3.5 Grenzen von Systemtests

2.4 Unit-Tests

2.4.1 Rückgabewerte

2.4.2 Abhängigkeiten

2.4.3 Seiteneffekte

2.5 Praxisbeispiel

2.5.1 Den zu testenden Code analysieren

2.5.2 Eine Testumgebung aufbauen

2.5.3 Globale Abhängigkeiten vermeiden

2.5.4 Unabhängig von Datenquellen testen

2.5.5 Asynchrone Vorgänge testen

2.5.6 Änderungen in der Datenbank speichern

2.5.7 Nicht vorhersagbare Ergebnisse

2.5.8 Eingabedaten kapseln

2.5.9 Weiterführende Überlegungen

2.6 Fazit

Teil II Best Practices

Kapitel 3 TYPO3: die agile Zukunft eines schwergewichtigen Projekts

3.1 Einführung

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

3.1.2 Den Neuanfang wagen!

3.1.3 Unsere Erfahrungen mit dem Testen

3.2 Grundsätze und Techniken

3.2.1 Bittersüße Elefantenstückchen

3.2.2 Testgetriebene Entwicklung

3.2.3 Tests als Dokumentation

3.2.4 Kontinuierliche Integration

3.2.5 Sauberer Code

3.2.6 Refaktorierung

3.2.7 Programmierrichtlinien

3.2.8 Domänengetriebenes Design

3.3 Vorgehen bei der Entwicklung

3.3.1 Neuen Code entwickeln

3.3.2 Code erweitern und ändern

3.3.3 Code optimieren

3.3.4 Fehler finden und beheben

3.3.5 Alten Code fachgerecht entsorgen

3.4 Testrezepte

3.4.1 Ungewollt funktionale Unit-Tests

3.4.2 Zugriffe auf das Dateisystem

3.4.3 Konstruktoren in Interfaces

3.4.4 Abstrakte Klassen testen

3.4.5 Testen von geschützten Methoden

3.4.6 Verwendung von Callbacks

3.5 Auf in die Zukunft

Kapitel 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

Kapitel 5 Qualitätssicherung bei Digg

5.1 Die Ausgangssituation

5.1.1 Unsere Probleme

5.1.2 Code-Altlasten

5.1.3 Wie lösen wir unsere Probleme?

5.1.4 Ein Test-Framework wählen

5.1.5 Mit einem Experten arbeiten

5.2 Das Team trainieren

5.3 Testbaren Code schreiben

5.3.1 Statische Methoden vermeiden

5.3.2 Dependency Injection

5.4 Mock-Objekte

5.4.1 Überblick

5.4.2 Datenbank

5.4.3 Lose gekoppelte Abhängigkeiten

5.4.4 Beobachter für klasseninternes Verhalten

5.4.5 Memcache

5.4.6 Mocken einer serviceorientierten Architektur

5.5 Der Qualitätssicherungsprozess bei Digg

5.5.1 Testen

5.5.2 Vorteile

5.5.3 Herausforderungen

5.6 Fazit

Teil III Server und Services

Kapitel 6 Testen von serviceorientierten APIs

6.1 Die Probleme

6.2 API-Zugangskennungen

6.3 API-Beschränkungen

6.4 Service-Protokolle offline testen

6.5 Konkrete Services offline testen

6.6 Fazit

Kapitel 7 Wie man einen WebDAV-Server testet

7.1 Über die eZ WebDAV-Komponente

7.1.1 WebDAV

7.1.2 Architektur

7.2 Herausforderungen bei der Entwicklung

7.2.1 Anforderungsanalyse

7.2.2 TDD nach RFC

7.2.3 Den Server testen

7.3 Automatisierte Akzeptanztests mit PHPUnit

7.3.1 Test-Trails aufzeichnen

7.3.2 Das Testrezept

7.3.3 Integration mit PHPUnit

7.4 Fazit

Teil IV Architektur

Kapitel 8 Testen von Symfony und Symfony-Projekten

8.1 Einführung

8.2 Ein Framework testen

8.2.1 Der Release-Management-Prozess von Symfony

8.2.2 Verhältnis von Testcode und getestetem Code

8.2.3 Die Ausführung der Testsuite muss schnell sein

8.2.4 Gesammelte Erfahrungen

8.3 Testen von Webanwendungen

8.3.1 Die Hemmschwelle für das Testen abbauen

8.3.2 Unit-Tests

8.3.3 Funktionale Tests

8.4 Fazit

Kapitel 9 Testen von Grafikausgaben

9.1 Einführung

9.2 Entwicklungsphilosophie

9.3 Die ezcGraph-Komponente

9.3.1 Architektur

9.3.2 Anforderungen an die Tests

9.4 Ausgabetreiber durchMock-Objekt ersetzen

9.4.1 Mehrfache Erwartungen

9.4.2 Structs

9.4.3 Generierung der Erwartungen

9.4.4 Zusammenfassung

9.5 Binäre Ausgaben testen

9.5.1 Die Ausgabetreiber

9.5.2 Generierung der Erwartungen

9.5.3 SVG

9.5.4 Bitmap-Erzeugung

9.5.5 Flash

9.6 Fazit

Kapitel 10 Testen von Datenbank-Interaktionen

10.1 Einführung

10.2 Pro und Kontra

10.2.1 Was gegen Datenbanktests spricht

10.2.2 Warum wir Datenbanktests schreiben sollten

10.3 Was wir testen sollten

10.4 Datenbanktests schreiben

10.4.1 Die Datenbankverbindung mocken

10.4.2 Die Datenbankerweiterung von PHPUnit

10.4.3 Die Klasse für Datenbanktestfälle

10.4.4 Die Verbindung zur Testdatenbank aufbauen

10.4.5 Datenbestände erzeugen

10.4.6 Operationen auf den Daten

10.4.7 Tests schreiben

10.4.8 Den Datenbanktester benutzen

10.5 Testgetriebene Entwicklung und Datenbanktests

10.6 Datenbanktests als Regressionstests

10.6.1 Probleme mit den Daten testen

10.6.2 Probleme testen, die durch Daten sichtbar werden

10.7 Zusammenfassung

Teil V QA im Großen

Kapitel 11 Qualitätssicherung bei studiVZ

11.1 Einführung

11.2 Akzeptanztests

11.3 Selenium

11.3.1 Die Selenium-Erweiterung von PHPUnit

11.4 Technisches Setup von studiVZ

11.4.1 Codeumgebung

11.4.2 Testumgebung

11.5 Best Practices

11.5.1 Jugendsünden

11.5.2 Strategiewechsel

11.6 Eine DSL muss her

11.6.1 Interne DSL

11.6.2 Testing SeleniumDSL 1.0

11.6.3 Testing SeleniumDSL 2.0 – ein Entwurf

11.7 Fazit

Kapitel 12 Kontinuierliche Integration

12.1 Einführung

12.1.1 Kontinuierliche Integration

12.1.2 Statische Analyse

12.2 Installation und Inbetriebnahme

12.3 Konfiguration

12.3.1 Statische Tests

12.3.2 Dynamische Tests

12.3.3 Reporting

12.3.4 Deliverables erzeugen

12.4 Betrieb

12.5 Weiterführende Themen

12.5.1 Continuous Deployment

12.5.2 Einen Reverse Proxy nutzen

12.5.3 Kontinuierliche Integration und agile Paradigmen

12.6 Fazit

Kapitel 13 swoodoo – eine wahrhaft agile Geschichte

13.1 Einührung

13.2 Evolution: Nur die Starken überleben

13.3 Wie wir die ”eXtreme Seite” erreichten

13.3.1 Kontinuierliche Integration

13.3.2 Testgetriebene Entwicklung

13.3.3 Tägliche Standup-Meetings

13.4 Und wo wir schon einmal dabei sind ...

13.4.1 User Storys und Story Points

13.4.2 Velocity

13.4.3 Iterationsplanung

13.4.4 Programmieren in Paaren

13.4.5 Kollektives Eigentum

13.4.6 Offenheit für Änderungen

13.4.7 Überstunden

13.5 Die Kunst der Evolution

13.6 KISS und YAGNI – zwei Seiten einer Medaille

13.7 Evolutionstheorie und Fazit

Teil VI Nichtfunktionale Aspekte

Kapitel 14 Gebrauchstauglichkeit

14.1 Einführung

14.2 Anything goes – aber zu welchem Preis?

14.3 Designaspekte

14.3.1 Barrierefreiheit

14.3.2 Lesbarkeit

14.3.3 Label für Formularelemente

14.3.4 Tastaturbedienbare Webseite

14.3.5 Gute Farbkontraste

14.3.6 Logo zur Startseite verlinken

14.3.7 Alternativtexte für Bilder

14.3.8 Hintergrundbild mit Hintergrundfarbe

14.3.9 Druckversion nicht vergessen

14.3.10 Erkennbare Links

14.3.11 Gute Bookmarks

14.3.12 Keine Frames

14.3.13 Skalierbare Schrift

14.4 Technische Aspekte

14.4.1 Performanz

14.4.2 JavaScript

14.5 Benutzerführung

14.5.1 Der Mythos des Falzes

14.5.2 Feedback bei Interaktionen

14.5.3 Navigation

14.5.4 Popups und andere Störenfriede

14.5.5 Gewohnheiten bedienen, Erwartungen nicht enttäuschen

14.5.6 Fehlertoleranz und Feedback

14.6 Testen der Usability

14.7 Fazit

Kapitel 15 Performanz

15.1 Einführung

15.1.1 Werkzeuge

15.1.2 Umgebungsbezogene Gesichtspunkte

15.2 Lasttests

15.2.1 Apache Bench

15.2.2 Pylot

15.2.3 Weitere Werkzeuge für Lasttests

15.3 Profiling

15.3.1 Callgrind

15.3.2 APD

15.3.3 Xdebug

15.3.4 XHProf

15.3.5 OProfile

15.4 Systemmetriken

15.4.1 strace

15.4.2 Sysstat

15.4.3 Lösungen im Eigenbau

15.5 Übliche Fallstricke

15.5.1 Entwicklungsumgebung gegen Produktivumgebung

15.5.2 CPU-Zeit

15.5.3 Mikro-Optimierungen

15.5.4 PHP als Glue Language

15.5.5 Priorisierung von Optimierungen

15.6 Fazit

Kapitel 16 Sicherheit

16.1 Was ist eigentlich Sicherheit?

16.2 Secure by Design

16.2.1 Der Betrieb

16.2.2 Physikalischer Zugang

16.2.3 Software-Entwicklung

16.3 Was kostet Sicherheit?

16.4 Die häufigsten Probleme

16.4.1 A10 – Transportschicht

16.4.2 A9 – Kryptografie

16.4.3 A8 –Weiterleitungen

16.4.4 A7 – Zugriffsschutz

16.4.5 A6 – Konfiguration

16.4.6 A5 – Cross Site Request Forgery (CSRF/XSRF)

16.4.7 A4 – Direkte Zugriffe

16.4.8 A3 – Authentifizierung und Session-Management

16.4.9 A2 – Cross Site Scripting (XSS)

16.4.10 A1 – Injections

16.5 Fazit

Teil VII Schlussbetrachtungen

Literaturverzeichnis

Stichwortverzeichnis