Testgetriebene Entwicklung mit JavaScript

Testgetriebene Entwicklung mit JavaScript

by Sebastian Springer
Released February 2015
Publisher(s): dpunkt
ISBN: 97833864902079

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

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. Cover
  2. Titel
  3. Impressum
  4. Vorwort
  5. 1 Testgetriebene Entwicklung
    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
  6. 2 Frameworks
    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
  7. 3 Workshop: Red, Green, Refactor
    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
  8. 4 Testinfrastruktur
    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
  9. 5 Spies, Stubsund Mocks
    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
  10. 6 Abhängigkeiten vom DOM
    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
  11. 7 Asynchrones Testen und Kommunikation mit dem Server
    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
  12. 8 Tests in neuen und in bestehenden Applikationen
    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
  13. 9 Testen von Node.js-Applikationen
    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
  14. 10 Tools, die das Testen einfacher machen
    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
  15. Stichwortverzeichnis

Product information

  • Title: Testgetriebene Entwicklung mit JavaScript
  • Author(s): Sebastian Springer
  • Release date: February 2015
  • Publisher(s): dpunkt
  • ISBN: 97833864902079