You are previewing Testgetriebene Entwicklung mit JavaScript.
O'Reilly logo
Testgetriebene Entwicklung mit JavaScript

Book Description

Dieses Buch zeigt wie testgetriebene Entwicklung mit JavaScript in der Praxis funktionieren kann. Der Leser lernt dabei Grundlagen kennen wie den Aufbau von testbaren Datenstrukturen in JavaScript sowie Aufbau und die Funktionsweise von Unit.Tests . Darüber hinaus werden Best Practices und Architekturformen beschrieben, die es erlauben testgetrieben zu entwickeln. Praktische Beispiele reichen vom einfachen Beispiel einer unabhängigen JavaScript-Klasse bis hin zur testgetriebenen Entwicklung in Bestandscode.Behandelt werden u.a. die Testframeworks qunit, jsTestDriver, Jasmine und sinon.js.

Table of Contents

    1. 1.1 Was ist testgetriebene Entwicklung?
    2. 1.2 Woher kommt testgetriebene Entwicklung?
    3. 1.3 Wie funktioniert testgetriebene Entwicklung?
    4. 1.4 Warum sollte man testgetrieben entwickeln?
    5. 1.5 Voraussetzungen für testgetriebene Entwicklung
      1. 1.5.1 Werkzeuge
      2. 1.5.2 Methoden
    6. 1.6 Testgetriebene Entwicklung und Unit-Tests
    7. 1.7 Vor- und Nachteile
      1. 1.7.1 Vorteile
      2. 1.7.2 Nachteile
    8. 1.8 Anforderungen an einen Unit-Test
      1. 1.8.1 Codequalität
      2. 1.8.2 Unabhängigkeit
      3. 1.8.3 Dokumentation
      4. 1.8.4 Ressourcen
      5. 1.8.5 Nur ein Testfall pro Test
    9. 1.9 Zusammenfassung
    1. 2.1 Die Frameworks im Überblick
    2. 2.2 Clientseitige Frameworks
    3. 2.3 QUnit
    4. 2.4 Jasmine
    5. 2.5 Nachteile clientseitiger Frameworks
    6. 2.6 Serverseitige Frameworks
    7. 2.7 JsTestDriver
    8. 2.8 Karma
    9. 2.9 Zusammenfassung
    1. 3.1 Die Aufgabenstellung
    2. 3.2 Konzeptarbeit
    3. 3.3 Setup
      1. 3.3.1 Dateistruktur
    4. 3.4 Die ersten Schritte
      1. 3.4.1 Red – der erste Test
      2. 3.4.2 Green – der Test läuft erfolgreich ab
    5. 3.5 Der nächste Schritt
      1. 3.5.1 Red – mehr Einsicht
      2. 3.5.2 Green – fake it
      3. 3.5.3 Refactor – dynamischer Rückgabewert
    6. 3.6 innerSpace – ein Teilproblem
      1. 3.6.1 Red – ein erster Test für innerSpace
      2. 3.6.2 Green – Implementierung der innerSpace-Methode
      3. 3.6.3 Refactor – Duplikate reduzieren
    7. 3.7 Erweiterung der innerSpace-Methode
      1. 3.7.1 Red – Triangulation
      2. 3.7.2 Green – erweiterte Fake-it-Lösung
      3. 3.7.3 Refactor – innerSpace für alle Buchstaben
    8. 3.8 Erklärende Tests
      1. 3.8.1 Grenzfälle testen
    9. 3.9 Fehlerfälle abtesten
      1. 3.9.1 Red – innerSpace soll eine Exception werfen
      2. 3.9.2 Green – Exception werfen
      3. 3.9.3 Refactor – den gültigen Wertebereich definieren
    10. 3.10 outerSpace
      1. 3.10.1 Red – Leerzeichen in outerSpace
      2. 3.10.2 Green – fake it – outerSpace
      3. 3.10.3 Red – Triangulation von outerSpace
      4. 3.10.4 Green – Erweiterung der outerSpace-Methode
      5. 3.10.5 Refactor – dynamische Version von outerSpace
    11. 3.11 Auslagerung von Funktionalität
      1. 3.11.1 Red – die getIndexOf-Methode
      2. 3.11.2 Green – Implementierung der getIndexOf-Methode
      3. 3.11.3 Refactor – dynamische Version der getIndexOf-Methode
      4. 3.11.4 Red – Fehlerbehandlung innerhalb der getIndexOf-Methode
      5. 3.11.5 Green – Integration der Fehlerbehandlungsroutine
      6. 3.11.6 Refactor – Integration der getIndexOf-Methode
    12. 3.12 Fehlerbehandlung in der outerSpace-Methode
      1. 3.12.1 Red – Test für die Fehlerbehandlung in outerSpace
      2. 3.12.2 Green – erfolgreiche Fehlerbehandlung in der outerSpace-Methode
      3. 3.12.3 Refactor – Anpassung der Fehlerbehandlung in outerSpace
    13. 3.13 Eine Zeile des Diamanten
      1. 3.13.1 Red – ein Test für eine Zeile
      2. 3.13.2 Green – Ausgabe einer statischen Zeile
      3. 3.13.3 Red – ein zweiter Test für eine Zeile
      4. 3.13.4 Green – dynamische Ausgabe einer Zeile
      5. 3.13.5 Red – die erste und letzte Zeile
      6. 3.13.6 Green – die erste und letzte Zeile
      7. 3.13.7 Refactor – die erste und letzte Zeile
    14. 3.14 Zusammenführung der Komponenten
      1. 3.14.1 Red – Test für die obere Hälfte des Diamanten
      2. 3.14.2 Green – upperHalf gibt den korrekten Wert zurück
      3. 3.14.3 Refactor – Umbau der upperHalf-Methode
      4. 3.14.4 Red – Test für die lowerHalf-Methode
      5. 3.14.5 Green – die lowerHalf-Methode gibt einen statischen Wert zurück
      6. 3.14.6 Refactor – Erweiterung der lowerHalf-Methode
    15. 3.15 Der letzte Schritt – die Integration
      1. 3.15.1 Red – Test für einen vollständigen Diamanten
      2. 3.15.2 Green – fake it der toString-Methode
      3. 3.15.3 Refactor – finale Implementierung der toString-Methode
    16. 3.16 Refactorings
      1. 3.16.1 Refactoring #1 – charCodeAt
      2. 3.16.2 Refactoring #2 – upperHalf und lowerHalf
    17. 3.17 Zusammenfassung
    1. 4.1 Funktionsweise
      1. 4.1.1 Die Serverkomponente
      2. 4.1.2 Manuelle Testausführung
      3. 4.1.3 Der Browser
    2. 4.2 Workflow
    3. 4.3 Debugging innerhalb der Testumgebung
    4. 4.4 System mit Fehlertoleranz
    5. 4.5 Zusammenfassung
    1. 5.1 Sinon.JS
      1. 5.1.1 Installation und Konfiguration
      2. 5.1.2 Test der Installation
    2. 5.2 Jasmine
    3. 5.3 Test Doubles
    4. 5.4 Spies
      1. 5.4.1 Wann kommen Spies zum Einsatz?
      2. 5.4.2 Spies verwenden
      3. 5.4.3 Die Spy-Schnittstelle
      4. 5.4.4 Spies im konkreten Beispiel
      5. 5.4.5 Spies in Jasmine
    5. 5.5 Stubs
      1. 5.5.1 Wann kommen Stubs zum Einsatz?
      2. 5.5.2 Stubs verwenden
      3. 5.5.3 Die Stub-Schnittstelle
      4. 5.5.4 Stubs im konkreten Beispiel
      5. 5.5.5 Stubs in Jasmine
    6. 5.6 Mocks
      1. 5.6.1 Wann kommen Mocks zum Einsatz?
      2. 5.6.2 Mocks verwenden
      3. 5.6.3 Die Mock-Schnittstelle
    7. 5.7 Zusammenfassung
    1. 6.1 Abhängigkeiten
    2. 6.2 Fixtures
    3. 6.3 Selbst erstellte HTML Fixtures
      1. 6.3.1 Die Aufgabenstellung
      2. 6.3.2 Setup
      3. 6.3.3 Ein einfacher Test
      4. 6.3.4 HTML Fixture
      5. 6.3.5 Green – Anzeige der Nachrichten
      6. 6.3.6 Triangulate
      7. 6.3.7 Cleanup
      8. 6.3.8 Green – dynamischer Validator
    4. 6.4 jasmine-jquery
      1. 6.4.1 Installation
      2. 6.4.2 Fixtures laden
      3. 6.4.3 Zusätzliche Matcher
    5. 6.5 Karma html2js
    6. 6.6 Zusammenfassung
    1. 7.1 Asynchrone Funktionen
      1. 7.1.1 Ein erstes asynchrones Beispiel
      2. 7.1.2 Asynchronität mit Promises
      3. 7.1.3 Promises mit Q
      4. 7.1.4 Promises testen
    2. 7.2 Zeitabhängige Funktionen
      1. 7.2.1 Problemstellungen bei zeitabhängiger Programmierung
      2. 7.2.2 Einsatz von Fake-Timern
      3. 7.2.3 Abhängigkeit vom Datum
    3. 7.3 Abhängigkeiten vom Server
      1. 7.3.1 Problemstellung bei der Kommunikation mit dem Server
      2. 7.3.2 Tests mit Abhängigkeit vom Server
      3. 7.3.3 Einsatz von Fake-Servern
    4. 7.4 Zusammenfassung
    1. 8.1 Neue Applikationen
    2. 8.2 Auswahl der Technologien
    3. 8.3 Setup der Umgebung
      1. 8.3.1 Konzeption und Anforderungen
      2. 8.3.2 Erste Tests
      3. 8.3.3 Weiteres Vorgehen nach dem ersten Test
    4. 8.4 Bestandscode
      1. 8.4.1 Testgetriebene Entwicklung im Bestandscode
      2. 8.4.2 Problemstellungen im Bestandscode
      3. 8.4.3 Umgebung in bestehenden Applikationen
      4. 8.4.4 Strategien für die Erstellung von Tests
      5. 8.4.5 Testgetriebene Entwicklung neuer Features
      6. 8.4.6 Testgetriebene Entwicklung bei der Überarbeitung von Quellcode
    5. 8.5 Zusammenfassung
    1. 9.1 Serverseitige Entwicklung mit Node.js
      1. 9.1.1 Installation
      2. 9.1.2 Betrieb
      3. 9.1.3 Der NPM
    2. 9.2 Testframeworks für Node.js
      1. 9.2.1 Assert
      2. 9.2.2 Nodeunit
      3. 9.2.3 Mocha
      4. 9.2.4 Weitere Testframeworks für Node.js
    3. 9.3 Testgetriebene Entwicklung mit Node.js
      1. 9.3.1 Konzeption
      2. 9.3.2 Installation von expect.js
      3. 9.3.3 Struktur und erster Test
      4. 9.3.4 Umsetzung der Businesslogik
      5. 9.3.5 Integration
    4. 9.4 Test Doubles in Node.js
      1. 9.4.1 Sinon.js
      2. 9.4.2 nock
      3. 9.4.3 mockery
    5. 9.5 Zusammenfassung
    1. 10.1 Die Entwicklungsumgebung
      1. 10.1.1 WebStorm
    2. 10.2 Code Coverage
      1. 10.2.1 Installation des Coverage-Plug-ins
      2. 10.2.2 Konfiguration des Coverage-Plug-ins
      3. 10.2.3 Der Coverage-Report
      4. 10.2.4 WebStorm und Code Coverage
      5. 10.2.5 Ignorieren von Quellcode
      6. 10.2.6 Nachteile der Code Coverage
    3. 10.3 Grunt und Gulp
      1. 10.3.1 Installation von Grunt
      2. 10.3.2 Testen mit Grunt
      3. 10.3.3 Installation von Gulp
      4. 10.3.4 Testen mit Gulp
    4. 10.4 Zusammenfassung