Aufgrund einer technischen Störung sind wir derzeit telefonisch nicht erreichbar. Wir arbeiten bereits an der Behebung. Vielen Dank für Ihr Verständnis.
E-Book, Deutsch, 575 Seiten
Reihe: SAP Press
Schwarzmann Agile ABAP-Entwicklung
1. Auflage 2018
ISBN: 978-3-8362-8186-7
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection
E-Book, Deutsch, 575 Seiten
Reihe: SAP Press
ISBN: 978-3-8362-8186-7
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection
Let's go agile! Geht das überhaupt mit ABAP? Dieses Buch führt Sie passgenau in die agile Entwicklung ein und setzt dabei genau da an, wo Sie sich auskennen: bei Ihrem Legacy Code . Sie lesen, wie Sie Ihre Programme Schritt für Schritt verbessern und erlernen dabei die wichtigsten Methoden der testgetriebenen Entwicklung. Anschließend erfahren Sie, wie Sie diese und viele weitere Techniken auch in neuen Entwicklungsprojekten einsetzen können. Clean Code, Walking Skeleton, Shared Code Ownership, Executable Documentation und Co. sind schon bald keine Fremdwörter mehr für Sie!
Die englische Ausgabe dieses Buches ist unter dem Titel »Test-driven development with ABAP Objects« (ISBN 1493218328) erschienen.
Aus dem Inhalt:
- Testgetriebene Entwicklung
- Objektorientiertes Design
- Test-Doubles
- ABAP Unit
- Redesign und Neuentwicklung
- Kontinuierliche Verbesserung
- Der perfekte Sprint
- ABAP Test Isolation Tools
- ABAP Development Tools (ABAP in Eclipse)
- Ausbildungsstrategie und Skalierbarkeit
Autoren/Hrsg.
Weitere Infos & Material
Vorwort ... 21
Einleitung ... 23
1. Einführung ... 31
1.1 ... Nachhaltigkeit: Entwicklung und Wartung mit einer Testinfrastruktur ... 32
1.2 ... Agilität: Praktiken des Agile Software Engineerings ... 37
1.3 ... Effizienz: Einhaltung von Designprinzipien ... 38
1.4 ... Kommunikation: Diagramme als Gesprächsgrundlage ... 42
TEIL I Aufbau einer Testinfrastruktur ... 45
2. Beispielanwendung für diesen Buchteil ... 47
2.1 ... Stammdatenmanagement ... 48
2.2 ... Benutzeroberfläche ... 50
2.3 ... Backend ... 51
3. Codebasierte Verbesserung eines Tests ... 55
3.1 ... Einführung in den Testcode ... 55
3.2 ... Allgemeine Clean-Code-Prinzipien ... 67
3.3 ... Testorientierte Clean-Code-Prinzipien ... 76
4. Designbasierte Verbesserung des Tests ... 85
4.1 ... Basisklasse von Testklassen ... 85
4.2 ... Verwendung von Hilfsklassen durch Testklassen ... 91
5. Robuster Integrationstest ... 99
5.1 ... Verbesserungsprozess ... 99
5.2 ... Unabhängigkeit von Testmethoden ... 100
5.3 ... Wiederholbarkeit von Testmethoden ... 105
6. Minimierung von Abhängigkeiten ... 113
6.1 ... Vereinfachung einer Verwendung ... 114
6.2 ... Abgrenzung einer Verwendung ... 121
6.3 ... Unabhängigkeit von einer Erzeugung ... 125
6.4 ... Unabhängigkeit von einer Erweiterung ... 131
7. Isolierter Komponententest ... 137
7.1 ... Transformation des Integrationstests ... 138
7.2 ... Skalierung mit einer Testsprache ... 150
7.3 ... Testgetriebene Entwicklung ... 157
7.4 ... Liskov-Substitution-Prinzip ... 161
8. Redesign mit Unit-Tests ... 165
8.1 ... Objektorientierte API für Entitäten ... 167
8.2 ... Hervorheben von Änderungen als eigenständige Einheit ... 170
8.3 ... Tests für die Highlight-Changes-Klasse ... 177
8.4 ... Zusammenfassung des ersten Teils ... 182
TEIL II Testorientiertes ABAP-Design ... 185
9. Design von Methoden ... 187
9.1 ... Regeln zur Implementierung einer Methode ... 188
9.2 ... Regeln für die Signatur einer Methode ... 196
10. Design von Klassen ... 209
10.1 ... Erzeugung eines Objekts durch seine Klasse ... 210
10.2 ... Erzeugung eines Objekts durch eine Factory-Klasse ... 213
10.3 ... Abhängigkeitsarten zwischen Klassen ... 217
10.4 ... Interfaces einer Klasse ... 220
10.5 ... Abstraktionsebenen innerhalb einer Klasse ... 222
10.6 ... Katalog-Entwurfsmuster ... 229
10.7 ... Innerer Zusammenhalt ... 231
11. Design von Paketen ... 237
11.1 ... Paketkonzept ... 237
11.2 ... Produktpakete ... 244
11.3 ... Testpakete ... 246
12. Testfälle ... 249
12.1 ... Testdesign ... 250
12.2 ... Testpyramide ... 253
12.3 ... Testabdeckung ... 256
13. Testdoubles ... 259
13.1 ... Vorteile von Testdoubles ... 259
13.2 ... Spezifikation von Testdoubles ... 263
13.3 ... Design von Testdoubles ... 269
13.4 ... Injektion von Testdoubles ... 275
14. Globale Testdoubles ... 289
14.1 ... Testdouble für eine DOM-Methode ... 290
14.2 ... Testdouble für zwei DOM-Methoden ... 295
14.3 ... Kombination zweier Methodendoubles ... 301
14.4 ... Globalisierung von Testdoubles ... 307
14.5 ... Design globaler Testdoubles ... 310
14.6 ... Anpassung globaler Testdoubles ... 313
15. Testklassen ... 319
15.1 ... Lokale Testklassen ... 321
15.2 ... Entwurfsmuster ... 324
15.3 ... Testklassenhierarchien ... 327
15.4 ... Globale Testklassen ... 331
15.5 ... Namenskonventionen für Testcode ... 333
16. Testdaten ... 335
16.1 ... Testdatencontainer ... 335
16.2 ... Testdatenobjekte ... 343
17. Testinfrastruktur ... 355
17.1 ... Anwendungsszenarien für eine globale Testinfrastruktur ... 357
17.2 ... Entwicklungsprozesse mithilfe einer Testinfrastruktur ... 362
17.3 ... Zusammenfassung des zweiten Teils ... 365
TEIL III Agile Neuentwicklung ... 367
18. Planung und Vorarbeit ... 369
18.1 ... Spezifikation der Beispielanwendung ... 370
18.2 ... Architektur und Design der Beispielanwendung ... 372
18.3 ... Teststrategie für die Beispielanwendung ... 377
18.4 ... Vorbereitung der testgetriebenen Entwicklung ... 380
19. Testgetriebene Entwicklung ... 393
19.1 ... Akzeptanztestgetriebene Entwicklung ... 393
19.2 ... Komponententestgetriebene Entwicklung ... 396
19.3 ... Unit-Test-getriebene Entwicklung ... 401
19.4 ... Objektbasierte Überprüfung ... 403
19.5 ... Testen des Änderns und Sicherns eines Vertrags ... 407
19.6 ... Zusammenfassung des dritten Teils ... 413
TEIL IV Agile Methoden ... 415
20. Scrum ... 417
20.1 ... Artefakte ... 417
20.2 ... Rollen ... 423
20.3 ... Meetings ... 424
20.4 ... Eigenschaften ... 429
21. Agile Software Engineering ... 433
21.1 ... Refactoring ... 434
21.2 ... Testgetriebene Entwicklung ... 437
21.3 ... Paarweise Programmierung ... 441
21.4 ... Walking Skeleton ... 447
21.5 ... Gemeinsame Codeverantwortung ... 453
21.6 ... Kontinuierliche Integration ... 459
22. Lean-Entwicklungsmodell ... 463
22.1 ... Grundlagen ... 463
22.2 ... Umsetzung der Lean-Prinzipien mit Agile Software Engineering ... 465
22.3 ... Testinfrastruktur ... 467
22.4 ... Agile Coaching ... 468
23. Entwicklung der Teams ... 469
23.1 ... Nachhaltige Ausbildung ... 469
23.2 ... Lücken in der Ausbildung ... 473
23.3 ... Agile Coaching ... 476
23.4 ... Netzwerk für Agile Coaching ... 483
24. Entwicklung des Backlogs ... 485
24.1 ... Design Thinking ... 486
24.2 ... User Story Mapping ... 492
25. Entwicklung des Produkts ... 497
25.1 ... Nachhaltige Entwicklung ... 498
25.2 ... Entwicklungsstrategien für Legacy Code ... 501
25.3 ... Entwicklungsstrategien für neuen Code ... 502
25.4 ... Zusammenfassung des vierten Teils ... 504
TEIL V Testorientierte ABAP-Werkzeuge ... 505
26. ABAP Unit ... 507
26.1 ... Klasse CL_ABAP_UNIT_ASSERT ... 507
26.2 ... Ausführung von Tests ... 512
26.3 ... Entwicklungsobjekte ... 518
27. ABAP Development Tools ... 521
27.1 ... Einführung ... 521
27.2 ... Testgetriebene Entwicklung mit den ABAP Development Tools ... 525
28. ABAP-Werkzeuge zur Testisolierung ... 545
28.1 ... Beispielklasse ... 545
28.2 ... Open SQL Test Double Framework ... 548
28.3 ... Test Seams ... 551
28.4 ... ABAP Test Double Framework ... 553
28.5 ... Zusammenfassung des fünften Teils und des gesamten Buches ... 557
Anhang ... 559
A. Namenskonventionen ... 561
B. Literaturverzeichnis ... 563
C. Der Autor ... 564
Index ... 565
Einleitung
Woran liegt es, dass selbst neu entwickelte Anwendungen schon nach kurzer Zeit Eigenschaften von Legacy Code aufweisen? Wissen ist nicht ausreichend vorhanden oder verteilt, Komponenten sind komplex und inkonsistent, und vor allem: Es gibt zu wenige oder keine Tests. Dieses Buch zeigt klar auf, wie solche Fehlentwicklungen vermieden oder nachträglich behoben werden können. Mit vielen Diagrammen und Anwendungsbeispielen aus der Praxis führt es detailliert aus, wie Sie Refactoring und Redesign von Legacy Code effizient und sicher durchführen und eine agile Neuentwicklung architektonisch vorbereiten können. Für die nachhaltige Weiterbildung von ABAP-Entwicklungsteams beschreibt es zudem eine agile Coaching-Methode, die auf einem testorientierten Verbesserungsprozess aufsetzt. Kurz, dies ist ein Buch über agile Entwicklung, ausschließlich mit ABAP-Code!
Kontinuierliche Verbesserungen
Testautomatisierung spielt dabei eine fundamentale Rolle. Die Vergangenheit hat zwar gezeigt, dass große Anwendungen auch ohne ABAP-Unit-Tests entstehen können. Allerdings hat sich inzwischen der Innovationsdruck deutlich erhöht. Zum einen entwickeln sich die Technik und mit ihr auch die betriebswirtschaftlichen Möglichkeiten rasend weiter. Zum anderen versetzt die Cloud SAP-Kunden in die Lage, auf eine schleppende Versorgung mit Innovationen tatsächlich zu reagieren.
Bei immer kürzeren Auslieferungszyklen kann das manuelle Testen zeit- und kostentechnisch nicht mehr bewerkstelligt werden. Die schnellere und breitere Verfügbarkeit von Releases lässt den Softwareunternehmen zudem keinen Spielraum mehr für größere Nachbesserungen. Testautomatisierung schützt in diesem Kontext auch vor Regression bei kurzfristigen Korrekturen.
Diese Absicherung ist wichtig, weil stabile, technisch und betriebswirtschaftlich erfahrene Teams nicht mehr die Regel sind. Neben vermeintlichen Kosteneinsparungen ist es vor allem die Diskontinuität des Marktes, die von den Entwicklern mehr Flexibilität verlangt. Entwickler können sich aber nur dann schnell in neue Gebiete einarbeiten und bei Bedarf problemlos in alte zurückkehren, wenn sie eine saubere Codebasis vorfinden. Doch eine solche Codebasis ist weniger das Ergebnis umfangreicher Planung als vielmehr das Resultat kontinuierlicher Verbesserungen. Ohne Testautomatisierung sind solche Mikroreleases praktisch nicht durchführbar.
Agile Methoden
Kontinuierliche Verbesserungen von Code und Design sind aber auch wichtig, weil agile Projektmanagementmethoden wie Scrum diese implizit voraussetzen, wenn sie von gleichbleibender Entwicklungsgeschwindigkeit ausgehen. Wo immer diese geplanten und unge planten Verbesserungen aber nicht zur Entwicklungskultur gehören, bleiben der erhoffte Effizienzgewinn und auch die breite Akzeptanz aus.
Eine Entwicklungskultur wird maßgeblich dadurch geprägt, in welchem Umfang Agile Software Engineering (ASE) angewendet wird. Neben funktionaler Richtigkeit streben die unter diesem Begriff zusammengefassten Praktiken sauberen Code und ein nachhaltiges Management von Wissen an.
Eine agile Entwicklungskultur lässt sich allerdings weder anordnen noch einkaufen. Vielmehr kommt es darauf an, sich erfolgreich auf den Weg zu machen. Schulungen sind dabei wichtig, denn mit erweitertem Wissen fängt alles Neue an. Entscheidender ist allerdings, auf welchen Boden dieses Wissen in den jeweiligen Abteilungen und Firmen fällt. Entwicklungskultur ist etwas, wofür sich Product Owner, Scrum Master und Manager sowie Architekten und Qualitätsexperten gemeinsam verantwortlich fühlen müssen.
Ich lege deshalb viel Wert darauf, diese enge Verbindung zwischen Scrum und ASE zu erklären und mit praktischen Methoden zu untermauern.
Zielgruppe und Voraussetzungen
Mit diesem Buch können Sie als ABAP-Entwickler viel Wissenswertes über die Anwendung von ABAP Objects und ABAP Unit in der Praxis erfahren. Mit dem Fokus auf Entwicklungsprozessen verbessert dieses Buch Ihre Chancen, dieses Wissen gezielt zu Fähigkeiten auszubauen. Es ist definitiv kein Buch, um ABAP Objects zu erlernen. Vielmehr sollten Sie den Kurs BC401 nicht nur besucht, sondern seinen Inhalt schon professionell angewendet haben. Praktische Erfahrungen mit ABAP Unit sind ebenfalls hilfreich, können aber auch lesebegleitend erworben werden.
Die gezeigten Codebeispiele setzen alle auf ABAP 7.53 auf. Dieser Stand ist für das Verständnis aber in keiner Weise entscheidend. Die Herausforderung bei den Codebeispielen liegt eher in der Objektorientierung, weshalb ich viele um Diagramme und Schaubilder ergänzt habe.
Wenn Sie Entwickler einer anderen objektorientierten Programmiersprache sind, dürften Ihnen die ABAP-spezifischen Anweisungen anfangs neu, aber trotzdem verständlich sein. Da es mein Ansatz ist, technische Details frühzeitig in allgemeinverständlichen Hilfsmethoden zu kapseln, kommt Sprachunterschieden in diesem Buch nur eine untergeordnete Rolle zu. Zudem: Wir ABAP-Entwickler sind schon seit vielen Jahren in der Lage, Fachbücher mit Codebeispielen zu C++ oder Java mit Erfolg zu lesen. Es gibt also keinen Grund, weshalb Ihnen das Gleiche nicht auch mit diesem ABAP-Buch gelingen sollte.
Für Scrum Master, Quality Engineers, Product Owner und Manager sollte schon ein wenig eigene Programmiererfahrung ausreichen, um den Verbesserungen von Code und Design folgen und somit meine strategischen und prozessorientierten Vorschläge verstehen und beurteilen zu können.
Aufbau des Buches
Mit Kapitel 1, »Einführung«, können Sie sich einen Überblick über die Ziele und Praktiken agiler Entwicklung verschaffen. Der Rest des Buches folgt dem Walking-Skeleton-Ansatz. Schon im ersten Teil lasse ich Sie an einem kompletten Prozess anhand eines Praxisbeispiels teilhaben. Konkret demonstriere ich einen testorientierten Verbesserungsprozess von Code und Design, der sowohl für die Neu- als auch für die Weiterentwicklung von zentraler Bedeutung ist.
Erst danach gehe ich mit weitestgehend unabhängigen Kapiteln thematisch in die Breite und in die Tiefe: im zweiten Teil des Buches in Richtung Design, im dritten Teil in Richtung Architektur, im vierten Teil in Richtung agile Methoden und im fünften Teil in Richtung Werkzeuge.
Sie können die Lesereihenfolge weitestgehend frei wählen. Ich empfehle Ihnen nur, mit dem ersten Teil zu beginnen, weil ich in ihm den komplexen Begriff der Testinfrastruktur praxisnah einführe und in den folgenden Teilen als bekannt voraussetze.
Teil I: Aufbau einer Testinfrastruktur
Kapitel 2, »Beispielanwendung für diesen Buchteil«, stellt kurz die reale Anwendung vor, die im ersten Teil des Buches um eine neue Funktionalität erweitert werden soll. Um Regression zu vermeiden, soll zuerst die bisherige Funktionalität mit ABAP-Unit-Tests abgesichert werden.
Kapitel 3, »Codebasierte Verbesserung eines Tests«, beschäftigt sich mit der Lesbarkeit von Testmethoden und damit, wie Dopplungen in Testmethoden vermieden werden können.
Kapitel 4, »Designbasierte Verbesserung des Tests«, führt diesen Verbesserungsprozess auf Ebene der Testklassen fort. Die Verbesserungen basieren dabei auf Prinzipien, Entwurfsmustern und Regeln für sauberen Code, wie sie Robert C. Martin (Clean Code, 2009) vorgestellt hat.
Kapitel 5, »Robuster Integrationstest«, beschäftigt sich mit der Unabhängigkeit und Wiederholbarkeit nicht isolierter Testmethoden.
Kapitel 6, »Minimierung von Abhängigkeiten«, stellt die objektorientierte Verschalung einer Legacy-API als effektives Mittel zur Entkopplung von Testcode und Produktcode vor. Daneben geht dieses Kapitel noch auf Factory-Klassen zur Erzeugung von Testdatenobjekten ein.
Kapitel 7, »Isolierter Komponententest«, gibt eine Einführung zu Testdoubles und demonstriert, dass auch für Legacy Code testgetriebene Weiterentwicklung möglich ist.
Kapitel 8, »Redesign mit Unit-Tests«, zeigt schließlich, wie ein Teil der Legacy-Anwendung mit bestehenden Tests neu implementiert werden kann.
Insgesamt entspricht der in diesem Teil vorgeschlagene Verbesserungsprozess einer lokalen Optimierung des Test- und Produktcodes einer Anwendung. Diese Optimierung orientiert sich stets daran, welchen Effizienzgewinn eine bestimmte Maßnahme kurzfristig einbringt.
Teil II: Testorientiertes ABAP-Design
In Kapitel 9, »Design von Methoden«, steht unter anderem die Signatur einer Methode im Fokus. Kompakte Methodensignaturen mit wenigen objektbasierten Parametern sind dabei das Ziel.
Kapitel 10, »Design von Klassen«, erklärt, warum eine Klasse einen hohen Zusammenhalt und eine geringe Kopplung an andere Klassen aufweisen sollte. Für die Erzeugung von Objekten sind Factory-Klassen und für die Verwendung dieser Objekte sind Interfaces von zentraler Bedeutung.
Kapitel 11, »Design von Paketen«, stellt die Kapselung von Klassen als eine Hauptaufgabe eines Pakets heraus. Das Ziel...
