Was ist Jasmine?

Jasmine ist ein beliebtes Open-Source-Framework für Behavior-Driven Development (BDD) Tests in JavaScript. Man verwendet es hauptsächlich, um das Verhalten von JavaScript-Code durch das Schreiben von Test-Spezifikationen zu überprüfen. Jasmine bietet eine saubere, leicht verständliche Syntax und ermöglicht Entwicklern, ihre Tests unabhängig von ihrer Implementierung auszuführen. Dadurch können sie schnell und effizient sicherstellen, dass ihr Code wie erwartet funktioniert.

Vorteile:

• Einfachheit: Man hat Jasmine entwickelt, um leicht verständlich und zugänglich für Entwickler zu sein. Die Test-Syntax ist klar und einfach, sodass selbst Entwickler, die neu in der Testautomatisierung sind, schnell damit arbeiten können.
• Unabhängigkeit: Jasmine ist unabhängig von anderen JavaScript–Frameworks, Browsern und DOM-Manipulationsbibliotheken, was bedeutet, dass man es praktisch jedem JavaScript-Projekt verwenden kann, unabhängig von der verwendeten Technologie.
• Flexibilität: Entwickler können Jasmine für Unit-Tests, Integrationstests und sogar für End-to-End-Tests verwenden. Dies gibt ihnen die Möglichkeit, das gesamte Verhalten ihrer Anwendung mit einem einzigen Tool abzudecken.

Wie funktioniert Jasmine?

Jasmine basiert auf einer Hierarchie von Suites und Specs. Suites sind Gruppen von verwandten Tests, während Specs einzelne Testfälle sind. Diese Hierarchie ermöglicht es Entwicklern, ihre Tests klar zu strukturieren und den Code leicht zu organisieren.

Es verwendet das „describe“-Konstrukt, um Test-Suites zu definieren. Jede Suite kann mehrere Test-Spezifikationen (Specs) enthalten, die mit dem „it“-Konstrukt definiert werden. Diese Specs enthalten Erwartungen (Expectations) in Bezug auf das zu testende Verhalten des Codes.

Ein einfaches Beispiel für eine Jasmine Test-Suite sieht wie folgt aus:

describe("A suite is just a function", function() {
  let a;

  it("and so is a spec", function() {
    a = true;

    expect(a).toBe(true);
  });
});

oder

describe('Array', () => {
  describe('#indexOf()', () => {
    it('sollte -1 zurückgeben, wenn der Wert nicht im Array vorhanden ist', () => {
      expect([1, 2, 3].indexOf(4)).toBe(-1);
    });
  });
});

Integration in die Softwareentwicklung

Man kann Jasmine problemlos in moderne JavaScript-Projekte und Build-Tools integrieren. Mit Integrationen für Tools wie Grunt, Gulp und Webpack lässt es sich nahtlos in bestehende Entwicklungsprozesse einfügen. Darüber hinaus gibt es auch Jasmine-Plugins für gängige Entwicklungsumgebungen wie Visual Studio Code oder IntelliJ, die das Schreiben und Ausführen von Tests noch einfacher und bequemer gestalten.

Man kann es auch mit anderen Testing-Tools und Libraries kombinieren, um noch umfassendere Testlösungen zu schaffen. Beispielsweise kann man es mit Karma (einem JavaScript-Test-Runner) verwenden, um Tests in verschiedenen Browsern auszuführen, oder mit Protractor für End-to-End-Tests in Angular-Anwendungen.

Best Practices für Jasmine-Tests

Um das Beste aus Jasmine herauszuholen und effektive Tests zu erstellen, sind hier einige bewährte Vorgehensweisen:

• Klare Testbeschreibungen: Man sollte aussagekräftige und präzise Beschreibungen für Suites und Specs verwenden. Dies erleichtert das Verständnis des Testzwecks und die Identifizierung von Fehlern.
• Kleine, fokussierte Tests: Es ist ratsam, Tests zu schreiben, die nur eine Funktion oder ein Verhalten testen. Dies erleichtert das Auffinden und Beheben von Fehlern, da man dadurch genau im Blick behält, welcher Teil des Codes betroffen ist.
• Testabdeckung: Man sollte sicherstellen, dass man eine ausreichende Testabdeckung für den Code hat. Dies bedeutet, dass man alle wichtigen Funktionen und Szenarien in den Tests berücksichtigt.
• Mocking und Spies: Es ist zu empfehlen, Mock-Objekte und Spies zu verwenden, um externe Abhängigkeiten zu isolieren und den Testfokus auf den zu testenden Code zu richten. Jasmine bietet dafür eingebaute Funktionen wie createSpy und spyOn.
• Regelmäßige Testausführung: Man sollte die Tests regelmäßig ausführen, um sicherzustellen, dass Änderungen im Code nicht zu unerwarteten Fehlern führen. Daher ist es ratsam, Jasmine in den Continuous Integration (CI) bzw. Continuous Deployment (CI/CD) Prozess integrieren, um automatisch Tests auszuführen, sobald man Codeänderungen vornimmt.

Fazit

Jasmine ist ein leistungsstarkes und vielseitiges Framework für das Testen von JavaScript-Anwendungen. Mit seiner klaren Syntax, Flexibilität und Integration in moderne Entwicklungsprozesse ist es ein unverzichtbares Werkzeug für jeden JavaScript-Entwickler. Durch die Befolgung der Best Practices und die regelmäßige Ausführung von Tests können Entwickler sicherstellen, dass ihr Code zuverlässig und fehlerfrei funktioniert. Insgesamt trägt Jasmine dazu bei, die Qualität von JavaScript-Anwendungen zu verbessern und die Entwicklungszeit zu reduzieren.

Der Beitrag Jasmine – JavaScript Testautomatisierung erschien zuerst auf CEOsBay.

Continuous Integration (CI)

CI ist eine Praxis der Softwareentwicklung, bei der Entwickler ihre Änderungen am Code regelmäßig in einer zentralen Repository integrieren, in der Regel mehrmals täglich. Dieser Ansatz soll Probleme wie Merge-Konflikte oder schwer auffindbare Fehler aufgrund von Inkonsistenzen im Code frühzeitig erkennen und beheben.

Vor- und Nachteile von CI/CD

Einige der Hauptvorteile von CI sind:

• Früherkennung von Fehlern und Konflikten: Durch regelmäßige Integration und automatisierte Tests findet die Fehlerfindung und dadurch die Behebung der Fehler frühzeitig statt, bevor sie zu größeren Problemen führen.
• Reduzierung von Risiken: Da man Änderungen in kleineren Schritten und häufiger integriert, reduziert sich das Risiko, dass neue Funktionen bestehende Funktionen beeinträchtigen.
• Verbesserung der Codequalität: CI ermutigt Entwickler, Code häufiger zu testen, was zur Verbesserung der Codequalität beiträgt.

CI-Tools:

Es gibt eine Vielzahl von CI-Tools auf dem Markt, darunter Jenkins, GitLab CI, Travis CI und CircleCI. Diese Tools automatisieren den Integrationsprozess, indem sie den Code überprüfen, bauen und testen, sobald Änderungen eingecheckt sind.

Continuous Deployment (CD)

Continuous Deployment ist ein Prozess, bei dem man automatisierte Tests und Freigabeprozesse durchführt, um neue Codeänderungen kontinuierlich und in kürzester Zeit in die Produktionsumgebung einzuführen. Im Gegensatz zu Continuous Delivery, bei dem man die Freigabe in die Produktion noch manuell auslösen muss, geschieht dies bei Continuous Deployment vollautomatisch.

Vorteile von CD:

• Schnellere Markteinführung: Durch den Einsatz von CD kann man Software schneller auf den Markt und in Umlauf bringen, da man dadurch den manuellen Aufwand für die Bereitstellung minimiert.
• Automatisierte Fehlerbehebung: CD-Systeme bieten Möglichkeiten zur automatischen Fehlerbehebung und Rollbacks, um sicherzustellen, dass die Produktionsumgebung stabil bleibt.
• Bessere Zusammenarbeit: Durch CD kann man verschiedene Teams wie die Entwicklung, QA bzw. Testing und Operations besser aufeinander abstimmen, was die Zusammenarbeit und Kommunikation wesentlich verbessert.

CD-Tools:

Zu den beliebtesten CD-Tools gehören Spinnaker, GitLab CD, Octopus Deploy und Harness. Diese Tools helfen bei der Automatisierung von Bereitstellungsprozessen, einschließlich der Erstellung von Umgebungen, dem Ausführen von Tests und dem Verwalten von Konfigurationen.

Einige wichtige Punkte, die noch bei der Einführung und Anwendung von CI/CD zu beachten sind:

• Organisationskultur: Die Implementierung von CI/CD erfordert eine Veränderung in der Denkweise und Kultur eines Teams oder einer Organisation. Es ist wichtig, dass alle Beteiligten die Vorteile erkennen und bereit sind, sich auf kontinuierliche Verbesserung und Zusammenarbeit zu konzentrieren.
• Automatisierung: Um die Vorteile von CI/CD voll auszuschöpfen, ist es entscheidend, möglichst viele Schritte im Entwicklungs- und Bereitstellungsprozess zu automatisieren. Dies kann das Schreiben von Skripten für das Erstellen, Testen und Bereitstellen von Code oder die Verwendung von Tools und Plattformen umfassen, die diese Prozesse unterstützen.
• Testabdeckung: Um sicherzustellen, dass der Code in einer CI/CD-Pipeline zuverlässig funktioniert, ist es wichtig, ausreichende Testabdeckung sicherzustellen. Dies umfasst sowohl Unit-Tests als auch Integrationstests, um sicherzustellen, dass alle Aspekte einer Anwendung korrekt funktionieren. Hier macht es Sinn den Beitrag SonarQube zu erwähnen 😉
• Monitoring und Feedback: Im Zusammenhang mit CI/CD ist es wichtig, ein effektives Monitoring-System einzurichten, um Leistungsprobleme oder Fehler frühzeitig zu erkennen. Ebenso ist ein Feedback-System für Entwickler und Stakeholder entscheidend, um kontinuierlich voneinander zu lernen und Verbesserungen vorzunehmen. Hierzu schreibe ich in zukünftigen Beiträgen mehr. Bis es so weit ist, ist der Beitrag über Grafana erwähnenswert 😉
• Sicherheit: Bei der Implementierung von CI/CD ist es unerlässlich, Sicherheitspraktiken zu berücksichtigen. Dies umfasst die regelmäßige Überprüfung von Sicherheitspatches, die Durchführung von Sicherheitstests und die Einhaltung von Best Practices für sicheren Code.

Fazit

Continuous Integration und Continuous Deployment sind entscheidende Konzepte in der modernen Softwareentwicklung, die dazu beitragen, den Entwicklungsprozess zu beschleunigen, die Codequalität zu verbessern und die Zusammenarbeit zwischen Teams zu fördern. Durch die Einführung von CI/CD-Praktiken im Entwicklungsworkflow kann man Fehler frühzeitig erkennen, den Zeitaufwand für die Behebung von Problemen reduzieren und die Bereitstellung neuer Funktionen und Updates beschleunigen.

Indem man diese Faktoren berücksichtigt und CI/CD-Praktiken erfolgreich in einem Softwareentwicklungsprozess integriert, kann man von den Vorteilen der schnelleren Entwicklungszyklen, verbesserten Zusammenarbeit und von einer höheren Codequalität profitieren.

Der Beitrag CI/CD – Continuous Integration und Continuous Deployment erschien zuerst auf CEOsBay.

Was ist Clean Code?

Clean Code bezieht sich auf den Ansatz, Code so zu schreiben, dass er leicht verständlich, wartbar und erweiterbar ist. Das Konzept wurde von Robert C. Martin, auch bekannt als „Uncle Bob“, in seinem Buch „Clean Code: A Handbook of Agile Software Craftsmanship“ populär gemacht. Im Kern geht es darum, Softwareentwicklung als Handwerk zu betrachten und stets auf hohe Qualität und Präzision in der Codegestaltung zu achten.

Warum ist es wichtig?

Sauberer Code bietet verschiedene Vorteile, sowohl für den Entwickler selbst, für das gesamte Team und meiner Meinung nach auch für die ganze Welt.

• Verständlichkeit: Clean Code ist einfacher zu lesen und zu verstehen. Das hilft Entwicklern, sich schneller mit dem Code vertraut zu machen und Fehler oder Verbesserungsmöglichkeiten schneller zu erkennen.
• Wartbarkeit: Sauberer Code ist leichter zu warten, da er klar strukturiert und weniger anfällig für Fehler oder unerwartete Probleme ist.
• Effizienz: Da Clean Code einfacher zu verstehen ist, kann das Team schneller arbeiten und die Produktivität steigt.
• Zusammenarbeit: Ein sauberer Code erleichtert die Zusammenarbeit im Team, da jeder den Code anderer Entwickler leichter lesen und verstehen kann.

Prinzipien von Clean Code

Es gibt viele Prinzipien und Praktiken, die beim Schreiben von sauberem Code helfen können. Einige der wichtigsten sind:

• Lesbarkeit: Der Code sollte leicht lesbar und verständlich sein. Das bedeutet, dass man Variablen, Funktionen und Klassen sinnvoll benamt und ihre Funktion leicht erkennbar ist. Kommentare setzt man sparsam ein, um den Code nicht zu überfrachten.

• Einfachheit: Man hält den Code so einfach wie möglich, ohne unnötige Komplexität oder Verwirrung. Das bedeutet, dass man sich auf das Wesentliche konzentrieren und abstrakte Konzepte wie Design Patterns oder Funktionen nur verwendet, wenn sie tatsächlich nützlich sind.

• Modularität: Man teilt den Code in kleine unabhängige Module auf, die jeweils eine bestimmte Funktion erfüllen. Dadurch wird der Code leichter zu verstehen und zu warten.

• Wiederverwendbarkeit: Man schreibt den Code so, dass die Wiederverwendbarkeit gewährleistet ist. Dies bedeutet, dass Funktionen oder Klassen, die eine bestimmte Aufgabe erfüllen, generisch genug sind, um in verschiedenen Situationen Verwendung zu finden.

Clean Code in der Praxis

Hier sind einige konkrete Schritte, die man beim Schreiben von Clean Code in der Praxis beachten sollte:

• Variablen-, Funktions- und Klassennamen: Man wählt sinnvolle, beschreibende Namen, die klar machen, was eine Variable, Funktion oder Klasse macht. Die Vermeidung von Abkürzungen oder unverständliche Namen ist eines der obersten Gebote.

• Single Responsibility Principle (SRP): Jede Funktion oder Klasse sollte nur eine einzige Verantwortung haben. Dies bedeutet, dass sie nur einen Aspekt des Problems lösen sollte, um den Code einfacher und leichter zu warten.

• Funktionen und Methoden: Man hält Funktionen und Methoden kurz und konzentrieren sich darauf, dass sie eine einzige Aufgabe erfüllen. Eine Funktion oder Methode sollte in der Regel nicht länger als 20 Zeilen sein, um ihre Verständlichkeit zu gewährleisten.

• KISS (Keep It Simple, Stupid) Prinzip: Man versucht, den Code so einfach wie möglich zu halten und unnötige Komplexität zu vermeiden. Wenn es eine einfachere Lösung gibt, zieht man diese der komplexeren vor.

• Don’t Repeat Yourself (DRY) Prinzip: Man vermeidet doppelten Code, indem man wiederverwendbare Funktionen oder Klassen erstellt. Das verringert die Wahrscheinlichkeit von Fehlern und macht den Code leichter zu warten.

• Code-Kommentare: Man sollte Kommentare dazu verwenden, den Zweck und die Funktionsweise von Code-Teilen zu erläutern, die nicht sofort offensichtlich sind. Man sollte jedoch nicht zu viele Kommentare schreiben, da dies den Code unübersichtlich machen kann.

• Fehlerbehandlung: Die Implementierung einer angemessenen Fehlerbehandlung sollte unabdingbar sein, um unerwartete Probleme zu erkennen und angemessen darauf zu reagieren. Die Verwendung von Exceptions und try-catch-Blöcken, kann eine gute Lösung darstellen, um Fehler abzufangen und entsprechend darauf zu reagieren.

• Testgetriebene Entwicklung (TDD): Man schreibt zuerst Tests, bevor man den eigentlichen Code entwickelt. Auf diese Weise kann man sicherstellen, dass die Implementierung den gewünschten Anforderungen entspricht und weniger fehleranfällig ist. Siehe hierzu meinen Beitrag über Test Driven Development.

• Kontinuierliche Integration (CI) und Continuous Deployment (CD): Man verwendet CI/CD-Tools, um den Code regelmäßig zu testen und automatisch zu deployen. Dies stellt sicher, dass der Code immer auf dem neuesten Stand ist und das man potenzielle Probleme schnell erkennen kann.

Fazit

Im Grunde genommen ist dies für mich eine relativ neue Angelegenheit, da ich in der Vergangenheit schon recht of den Code einfach reingehackt habe, da ich mich unter Zeitdruck gefühlt habe. Ich ertappe mich hin und wieder immer noch dabei und dies sehr oft, wie ich auf alte Gewohnheiten und Muster zurückgreife. Doch dies sollte sich hoffentlich in den nächsten Monaten und Jahren auf ein Minimum reduzieren lassen. Ich bin davon überzeugt, dass Clean Code ein wesentlicher Bestandteil einer erfolgreichen Softwareentwicklung ist. Indem man sich auf Lesbarkeit, Einfachheit, Modularität und Wiederverwendbarkeit konzentriert, kann man den eigenen Code nicht nur leichter verstehen, sondern auch schneller und effizienter arbeiten. Durch die Anwendung der oben genannten Prinzipien und Praktiken kann man den Code verbessern und letztendlich zu erfolgreichen, wartungsfreundlichen Softwareprodukten beitragen.

Der Beitrag Clean Code – Elegante Lösungen für effiziente und wartungsfreundliche Software erschien zuerst auf CEOsBay.

Funktionen

Lombok bietet eine Vielzahl von Funktionen, die Entwicklern helfen, effizienten Code zu schreiben. Hier sind einige der wichtigsten Funktionen:

Getter und Setter:

Lombok ermöglicht es Entwicklern, Getter und Setter-Methoden für Klassenvariablen automatisch zu generieren. Dies ist besonders nützlich, wenn man viele Klassenvariablen hat und nicht jedes Mal manuell Getter und Setter schreiben möchte.

Konstruktoren:

Entwickler können Konstruktoren für ihre Klassen automatisch generieren lassen. Dies ist besonders nützlich, wenn man eine Klasse mit vielen Variablen hat und einen Konstruktor erstellen möchte, der diese Variablen automatisch initialisiert.

Builder:

Mit dem Builder können Entwickler Builder-Klassen automatisch generieren lassen, die es einfach machen, komplexe Objekte zu erstellen. Der Builder generiert eine Methode für jede Klassenvariable, mit der man den Wert der Variable setzen kann. Sobald alle Variablen gesetzt sind, erfolgt die Rückgabe des Objekts.

ToString:

Entwickler können die toString-Methode automatisch generieren lassen. Dies macht es einfach, die Inhalte eines Objekts zu debuggen oder zu protokollieren.

Equals und HashCode:

Entwickler können equals- und hashCode-Methoden automatisch generieren lassen. Dies ist besonders nützlich, wenn man eine Klasse hat, die Verwendung in einer Hash-Map hat.

Log:

Es bietet eine Annotation, mit der Entwickler eine Logger-Variable automatisch generieren können. Dies macht es einfach, Protokolle in der Anwendung zu erstellen.

Installation

Um Lombok in einem Projekt zu verwenden, muss man es installieren. Es gibt mehrere Möglichkeiten, Lombok zu installieren, doch die einfachste Methode besteht darin, die Lombok-JAR-Datei in das Projektverzeichnis zu kopieren und diese dann zu der IDE-Konfiguration hinzuzufügen. Als IDE’s sind beispielsweise IntelliJ oder Eclipse zu erwähnen.

Wenn man Maven verwendet, kann man Lombok einfach zu der POM-File hinzufügen:

<dependency>

   <groupId>org.projectlombok</groupId>

   <artifactId>lombok</artifactId>

   <version>X.XX.XX</version>

   <scope>provided</scope>

</dependency>

Sobald es installiert ist, kann man die verschiedenen Annotationen verwenden, um den Code zu verbessern.

Der Beitrag Lombok – Entwicklerproduktivität steigern und Boilerplate-Code eliminieren für sauberen, effizienten Java-Code erschien zuerst auf CEOsBay.

Man verwendet den Ausdruck Modultest unter anderem bei frühen Teststufen, in denen man die inneren, detailliertesten Komponenten der Software testet. Gemäß Software Validation & Verification Plan sind diese Tests nur für Module mit geringer Kritikalität nicht notwendig. Im Grunde genommen bei Fehlern, die dem User nur geringfügige Unannehmlichkeiten bereiten.

In einer Abstraktion der verwendeten Programmiersprache, spricht man von Komponente oder Softwarebaustein. Den Test eines solchen einzelnen Softwarebausteins bezeichnet man auch allgemeiner als Komponententest.

Als Testbasis kann man in der Regel die komponentenspezifische Anforderung und das Softwaredesign der Komponente (auch Komponentenspezifikation genannt) heranziehen. Für Whitebox-Testfälle oder um Aussagen zur Codeüberdeckung zu erhalten, kann man zusätzlich den Sourcecode einer Komponente analysieren und diesen als Testbasis verwenden. Wobei dabei auch Tools wie Jacoco helfen können. Ob die Komponente auf einen Testfall richtig reagiert, muss man allerdings auch hier auf Basis der Design- und Anforderungsdokumente beurteilen.

Typische Testobjekte sind wie bereits beschrieben Programmunits, -Module bzw. Klassen. Aber auch Kommandozeilenskripte des Betriebssystems (Shell-Skripte), Datenbankskripte, Datenkonvertierungs- oder Migrationsprozeduren, Datenbankinhalte sowie Konfigurationsdaten können Testobjekte sein. Kennzeichnend ist in der Regel der isolierte Test eines einzelnen Softwarebausteins. Dies dient primär, um komponentenexterne Einflüsse beim Testen auszuschließen. Alle so ermittelten Fehler kann man so dem spezifischen Modul zuordnen.

Klar zu unterscheiden ist auf jeden Fall der Integrationstest, den ich in einem separaten Beitrag thematisiere. Bei einem Integrationstest konzentriert man sich auf die Wechselwirkung mit Nachbarkomponenten.

Die Erstellung solcher Tests ist in der Regel die Aufgabe eines Programmierers. Dies liegt zum einen daran, dass man ein ausgeprägtes Verständnis für die Programmiersprache in der die Anwendung geschrieben ist haben muss. Und zum anderen daran, dass man meist auch einen Testtreiber benötigt, dessen Programmierung in der Regel auch der Entwickler übernimmt.

Einordnung im Testprozess

Algorithmen auf Unitebene besitzen meist nur eine begrenzte Komplexität und man kann sie über klar definierte Schnittstellen aktivieren. Daher kann sie mit relativ wenigen Testfällen weitgehend vollständig testen. Dies gilt als Voraussetzung für die anschließende Teststufe. Dem Integrationstest, um dort die Testfälle auf das integrierte Zusammenwirken größerer Funktionsteile oder der gesamten Anwendung ausrichten zu können. Die modulspezifischen Detailkonstellationen lassen sich damit auf Stichproben beschränken, was die Anzahl der erforderlichen Testfälle signifikant reduziert.

Zum Vergleich: Ein Gerät wird erst dann als Ganzes getestet, wenn die Funktionsfähigkeit seiner Einzelteile gesichert ist.

Test des Vertrages und nicht der Algorithmen

Man testet bei Modultests gemäß dem Design-by-contract-Prinzip möglichst nicht die Interna einer Methode, sondern nur ihre externen Auswirkungen (Rückgabewerte, Ausgaben, Zustandsänderungen, Zusicherungen). Sind die internen Details der Methode geprüft (dies wird als White-Box-Testing bezeichnet), kann der Test fehlschlagen, obwohl sich die externen Auswirkungen nicht geändert haben. Daher empfiehlt man in der Regel das sogenannte Black-Box-Testing, bei dem man sich auf das Prüfen der externen Auswirkungen beschränkt.

Was sind die Vorteile von Unit Tests?

• Mittels automatisierter Unittests kann man im Schnitt 30 % der Fehler erkennen. Bei der Verwendung von TDD (Test Driven Development) kann man im Schnitt 45 % und im besten Fall 85 % der Fehler vermeiden.
• Fehler erkennt man durch Modultests bereits während der Entwicklung. Die durch Unittests vermiedenen Fehlerkosten sind daher gemäß der Rule of Ten (Dazu später mehr) um ein Vielfaches höher als bei späteren Teststufen, was Unittests zur effizientesten Teststufe machen.
• Im Falle eines Fehlers kann man diesen sehr viel genauer eingrenzen und damit schneller finden und beheben.
• Die Tests erfüllen den Zweck einer lebenden Dokumentation. In Kombination mit einer sinnvollen Benamung der Objekte (Clean Code) können zusätzliche Dokumentationsmaßnahmen entfallen.
• Da einzelne Module nur wenige mögliche Codeausführungspfade besitzen, muss man viel weniger mögliche kombinatorische Ausführungspfade berücksichtigen als bei anderen Testarten. Bei übergeordneten Tests kann man sich dann stichprobenartig auf die wichtigsten Ausführungspfade konzentrieren und damit die Anzahl dieser Tests deutlich reduzieren.
• Da man nur einzelne Module testet, kann man Modultests, oft um mehrere Größenordnungen, schneller und damit öfter (bzw. kontinuierlich) ausführen als andere Testarten.
• Wenn man Fehler mit einem Test absichert, kann man den erneuten Auftritt des gleichen Fehlers verhindern.
• Durch die Fehlerreduktion ergeben sich Geschwindigkeitsvorteile in der Entwicklung in mittleren bis großen Softwareprojekten.
• Da man Abhängigkeiten zwingend vermeiden muss, um einen Modultest zu ermöglichen, bleibt der Code verhältnismäßig schnell änderbar. Hierdurch kann man schneller auf wechselnde Anforderungen reagieren. Siehe Agile Manifest 😉
• Da automatisch ausgeführte Tests um mehrere Größenordnungen schneller sind als manuelle Tests, reduziert sich der Zeitaufwand für das Testen deutlich. Hierdurch kann man die Entwicklungsstufen schneller durchlaufen und die Release-Zyklen signifikant verkürzen.

Was sind die Nachteile von Unit Tests?

• Bei der Implementierung neuer Funktionen muss man nicht nur die Funktion implementieren, sondern auch die dazugehörenden Tests vorbereiten bzw. definieren. Dadurch ergibt sich ein oft mehrfacher Implementierungsaufwand.
• Bei Änderungen muss man nicht nur die geänderten Funktionen, sondern auch die dazugehörenden Tests anpassen. Insbesondere bei der Entwicklung von Prototypen, bei der sich die Codebasis schnell verändert, ist das Testen daher oft eher ein Hindernis.
• Da man die Funktionalität der Tests verwendet, ist in den IDEs schwerer ersichtlich, ob eine Funktionalität keine Verwendung mehr findet und ob man es daher entfernen kann.
• Weisen die Tests untereinander Abhängigkeiten auf (z. B. durch gemeinsame Testdaten), so können einzelne Änderungen an der Codebasis eine Vielzahl von Tests beeinflussen, was den Änderungsaufwand mit der Größe der Codebasis exponentiell erhöht.

Fehlerkosten 10er Regel (Rule of ten)

Die Zehnerregel der Fehlerkosten besagt, dass je weiter ein Fehler sich unentdeckt in die späten Phasen des Werdegangs eines Produktes oder Prozesses bewegt – oder gar bis zum Kunden –, desto höher steigen die Kosten zur Behebung des Fehlers. Eindrucksvoll untermauert durch die Ergebnisse einiger Studien aus den 70er Jahren in Japan, USA und Großbritannien, die sich mit den Ursachen von Produkt- bzw. Qualitätsmängeln beschäftigten. Alle Analysen lieferten nahezu die gleichen Ergebnisse: Ca. 70 % aller Produktmängel hatten ihre Ursache bereits in der Entwicklung, Konstruktion und Arbeitsvorbereitung. Der Herstellungsprozess selbst hat bezüglich der Endqualität des Produktes offensichtlich eher einen sekundären Einfluss. Eine VDMA-Studie zum Thema „Qualitätsbezogene Kosten“ Anfang der 90er Jahre in der Bundesrepublik Deutschland bestätigt dieses Ergebnis.

Die Zehnerregel der Fehlerkosten oder „Rule of ten“ sagt aus, dass sich die Fehlerkosten für einen nicht entdeckten Fehler von Stufe zu Stufe der Wertschöpfung um den Faktor 10 erhöhen. Je früher ein Fehler entdeckt und beseitigt wird, desto kostengünstiger ist dies für die Organisation und schlussendlich auch für den User bzw. Kunden.

Ansonsten sind diese auch in der DIN 55350-11 im Rahmen des Qualitätsmanagements festgehalten. Doch darauf gehe ich in einem separaten Beitrag ein.

Wo sind die Grenzen der Unit Tests?

Unit Tests können (wie jeder Test) die Fehlerfreiheit der getesteten Units, Module usw. nicht garantieren oder nachweisen, sondern lediglich unterstützen. Die Grenzen von Unit Tests liegen primär nur in den Fällen vor in denen man Fehler finden kann, zu deren Entdeckung die verwendeten Tests geeignet sind. Eine Softwarekomponente, die „grün“ testet, ist also nur bedingt fehlerfrei.

Das Merkmal von Code, „grün“ zu testen, und durchaus auch der Wunsch nach diesem Ergebnis, kann dazu führen, dass man tatsächlich (unbewusst) nur so viel testet, bis alle Tests „grün“ sind. Module, die keine fehlschlagenden Modultests haben, als fehlerfrei zu behandeln, ist ein Fehlschluss in der Praxis des (TDD) Test Driven Development.

Um eine ausreichende Testabdeckung zu erzielen, lohnt es sich u.U., vor dem Erstellen der Testfälle Refactoring-Maßnahmen anzuwenden. Dies erst nach abgeschlossenen Unit Tests (für den alten Code) zu tun, schafft Raum (wie jede Änderung im Code) für neue Fehlerrisiken und kann deshalb wiederholtes Testen erforderlich machen.

Wenn der Autor von Unit Tests mit dem Autor der Module identisch ist, können Denkfehler in der Implementierung auch im Test erscheinen und verpasst gegebenenfalls die Chance, diese aufzudecken. Wenn es sich um dieselbe Person handelt, kann man die vorrangige Entwicklung der Tests ebenfalls nicht garantieren, da sowohl die beabsichtigte Funktionsweise des Codes als auch die zukünftige Gestalt bereits im Gedankengut des Testautors und späteren Codeautors präsent sein können. Dies kann im Extreme Programming durch „Test Ping-Pong“ abgefangen werden, bei der sich Entwickler bei der Implementierung der Funktionalität und der Tests abwechseln.

Bei der Entwicklung von Modultests können Testfälle entstehen, die der Zielsetzung und dem Charakter von Modultests nicht oder nur zum Teil entsprechen. Wie bei der Programmierung existieren daher auch für die Entwicklung von Modultests Anti-Pattern, die man möglichst vermeiden sollte.

Der Beitrag Unit Tests – Fundament für stabile und effiziente Software erschien zuerst auf CEOsBay.

Übrigens ist BDD aus der testgetriebenen Entwicklung hervorgegangen. Über BDD bzw. Behavior Driven Development habe ich bereits gestern geschrieben.

Klassisch und fast schon nostalgisch hat man und praktiziert man die Entwicklung heute noch nach dem Wasserfall- oder dem V-Modell-Prinzip. Man entwickelt die Tests parallel zum und unabhängig vom zu testenden System oder sogar erst nachdem die Anwendung „fertiggestellt“ wurde. Aufgrund dieser Tatsache resultiert meist daraus, dass der Code schwer testbar ist und somit der Aufwand für die Tests verhältnismäßig hoch ausfällt. Darüber hinaus kommt es auch vor, dass die Tests nicht die gewünschten oder erforderlichen Testabdeckungen und Ergebnisse liefern, die man sich erhofft.

Dies kann unter anderem daran liegen, dass die fehlende oder mangelnde Testbarkeit des Systems auf die Nutzung von Fremdkomponenten zurückzuführen ist. Auch die Verweigerung einer Investition in nicht-funktionale Programmteile seitens der Entscheider bzw. Unternehmensführung kann ein Grund dafür sein. So im Sinne von, „Arbeit, von der man später im Programm nichts sieht, seien vergeudete Ressourcen.“ Die Erstellung von Tests unter Zeitdruck, rein um die gewünschte Testabdeckung zu erzielen ist ebenfalls ein Grund dafür. Nicht selten, ist es aber auch die Nachlässigkeit und mangelnde Disziplin der Entwickler bei der Testerstellung. An dieser Stelle sein auch das White-Box-Testing zu erwähnen, den ich aber in einem zukünftigen Beitrag thematisieren werde.

Die Methode der testgetriebenen Entwicklung versucht den Nachteilen entgegenzuwirken und dabei auch ein auf die Aufgabenstellung der Software besser angepasstes und wartbareres Softwaredesign zu liefern.

Alles in allem ist es eine Tatsache, dass man bei der Anwenung von testgetriebener Entwicklung im Schnitt bis zu 45 Prozent aller Fehler erkennen bzw. vermeiden kann. Im Vergleich dazu, werden beim reinen Einsatz von Unittests im Schnitt nur bis zu 30 Prozent der Fehler erkannt.

Wie funktioniert TDD?

Bei der testgetriebenen Entwicklung ist zwischen dem Testen im Großen (Integrationstests, Systemtests, Akzeptanztests) und dem Kleinen Modultests (Unit Tests) zu unterscheiden.

Testgetriebene Entwicklung mit Unit-Tests (Stichwort Tests First bzw. Middle-Out-TDD)

Man schreibt Unit-Tests in der Regel vor der eigentlichen Entwicklung der Anwendung. Es ist nicht festgelegt, ob der Entwickler, der die Implementierung vornimmt, auch die Unit-Tests erstellt. Es ist erlaubt, dass mehrere fehlschlagende Unit-Tests gleichzeitig existieren. Die Umsetzung des von einem Unit-Test geforderten Verhaltens in der Anwendung kann zeitlich verschoben werden.

Die Methode Tests First kann als Vorstufe der testgetriebenen Entwicklung betrachtet werden.

TDD nach Kent Beck

Man entwickelt Unit-Tests und die mit ihnen getesteten Units stets parallel. Die eigentliche Entwicklung erfolgt in kleinen, wiederholten Mikroiterationen. Eine solche Iteration, die nur wenige Minuten dauern sollte, hat drei Hauptteile, die man im englischen schlicht als Red, Green und Refactor bezeichnet.

1. Red: Schreibe einen Test, der ein neues zu programmierendes Verhalten (die Funktionalität) prüfen soll. Dabei fängt man mit dem einfachsten Beispiel an. Ist die Funktion schon älter, kann dies auch ein bekannter Fehler oder eine neu zu implementierende Funktionalität sein. Dieser Test wird vom vorhandenen Programmcode erst einmal nicht erfüllt und muss folglich fehlschlagen.
   
2. Green: Ändere den Programmcode mit möglichst wenig Aufwand ab und ergänze ihn, bis er nach dem anschließend angestoßenen Testdurchlauf alle Tests besteht.
   
3. Räume dann im Code auf (Refactoring): Entferne Wiederholungen (Duplizierten Code), abstrahiere wo nötig, richte ihn nach den verbindlichen Code-Konventionen aus. In dieser Phase darf kein neues Verhalten eingeführt werden. Nach jeder Änderung werden die Tests ausgeführt. Der Fehlschlag der Tests verbietet es, die offenbar fehlerhafte Änderung in den bereits genutzten Code zu übernehmen. Ziel des Aufräumens ist es, den Code schlicht, elegant und verständlich zu machen.

Diese drei Schritte wiederholt man so lange und so oft, bis die bekannten Fehler bereinigt sind, der Code die gewünschte Funktionalität liefert und dem Entwickler keine sinnvollen weiteren Tests mehr einfallen, die vielleicht noch scheitern könnten. Die so behandelte programmtechnische Einheit (Unit) wird dann als einstweilen fertig angesehen. Die gemeinsam mit ihr geschaffenen Tests werden beibehalten, damit auch nach künftigen Iterationen und Änderungen getestet werden kann, ob die schon erreichten Aspekte des Verhaltens weiterhin erfüllt werden.

Damit die – auch Transformationen genannten – Änderungen in Schritt 2 zum Ziel führen, muss jede Änderung zu einer allgemeineren Lösung führen. Sie darf also nicht etwa nur den aktuellen Testfall auf Kosten anderer behandeln. Tests, die immer mehr ins Detail gehen, treiben den Code so zu einer immer allgemeineren Lösung. Die Beachtung der Transformationsprioritäten führt dabei regelmäßig zu effizienteren Algorithmen und damit Anwendungen. Die konsequente Befolgung dieser Vorgehensweise ist eine evolutionäre Entwurfsmethode, indem jede der einzelnen Änderungen bzw. Iterationen das System von Natur aus weiterentwickelt.

Testgetriebene Entwicklung mit System- oder Akzeptanztests (Stichwort Outside-In-TDD)

Wie bereits erwähnt, entwickelt man Systemtests bei der testgetriebenen Entwicklung immer vor dem System selbst oder aber man erstellt zumindest das Konzept dafür. Aufgabe der Systementwicklung ist bei testgetriebener Entwicklung nicht mehr, wie klassisch, schriftlich formulierte Anforderungen zu erfüllen, sondern spezifizierte Systemtests zu bestehen.

Akzeptanztestgetriebene Entwicklung (ATDD)

ATDD ist zwar mit testgetriebener Entwicklung verwandt, unterscheidet sich jedoch in der Vorgehensweise von testgetriebener Entwicklung. Akzeptanztestgetriebene Entwicklung ist ein Kommunikationswerkzeug zwischen dem Kunden bzw. den Anwendern, den Entwicklern und den Testern. Es soll sicherstellen, dass die Anforderungen gut beschrieben sind. Akzeptanztestgetriebene Entwicklung verlangt keine Automatisierung der Testfälle, wenngleich diese für das Regressionstesten hilfreich sind. Die Tests bei akzeptanztestgetriebener Entwicklung müssen dafür auch für Nicht-Entwickler lesbar sein. Die Tests der testgetriebenen Entwicklung können in vielen Fällen aus den Tests der akzeptanztestgetriebenen Entwicklung abgeleitet werden.

Der Beitrag TDD – Test Driven Development – Qualitativ hochwertige Software von Anfang an erschien zuerst auf CEOsBay.

Die verhaltensgetriebene Entwicklung kombiniert die allgemeinen Techniken und Prinzipien von TDD. Unter Anderem auch mit Ideen aus dem bereichsgetriebenen Design, der objektorientierten Analyse und dem objektorientierten Design, um Softwareentwicklungs- und Managementteams gemeinsame Tools und einen gemeinsamen Prozess für die Zusammenarbeit bei der Softwareentwicklung zur Verfügung zu stellen.

So wie man die Softwareentwicklung sowohl von geschäftlichen Interessen als auch von technischem Verständnis voranbringt, setzt die BDD-Praxis den Einsatz spezieller Softwaretools zur Unterstützung des Entwicklungsprozesses voraus. Obwohl man diese Tools oft speziell für den Einsatz in BDD-Projekten entwickelt, kann man sie als spezialisierte Formen der Tools zur Unterstützung der testgetriebenen Entwicklung betrachten. Diese Tools dienen dazu, die allgegenwärtige Sprache, die ein zentrales Thema von BDD ist, zu automatisieren.

BDD wird weitestgehend durch die Verwendung einer einfachen domänenspezifischen Sprache (DSL = Domain-Specific-Language) mit natürlichen sprachlichen Konstrukten (z.B. deutsch- oder englischsprachige Sätze) erleichtert, mit denen man das Verhalten und die erwarteten Ergebnisse ausdrückt. Testskripte sind seit langem eine beliebte DSLs mit unterschiedlichem Grad an Raffinessen. BDD gilt als effektive technische Praxis, insbesondere wenn der „Problemraum“ des zu lösenden Geschäftsproblems komplex ist.

Wie funktioniert BDD?

Im Grunde genommen besteht Behavior Driven Development aus den folgenden Elementen:

• Starke Einbeziehung der Stakeholder in den Prozess durch sogenannte Outside-In-Softwareentwicklung. Diese ist fokussiert auf die Erfüllung der Anforderungen der Auftraggeber, der Enduser, des Betriebs und von Insidern.
• Textuelle Beschreibung des Verhaltens der Software und von Softwareteilen durch Fallbeispiele. Verwendung genormter Schlüsselwörter zur Markierung von Vorbedingungen, des externen Verhaltens und des gewünschten Verhaltens der Software.
• Automatisierung der Fallbeispiele unter Verwendung von Mock-Objekten zur Simulation von noch nicht implementierten Softwareteilen.
• Sukzessive Implementierung der Softwareteile und dem Ersetzen der Mock-Objekte.

Dadurch entsteht eine automatisiert prüfbare Beschreibung der zu entwickelnden Software, die jederzeit die Richtigkeit der bereits umgesetzten Teile der Software überprüfen lässt.

Wichtig ist hierbei, dass die Beschreibung nicht die Implementierung der Anwendung vorgibt, sondern den Zweck der Anwendung in Form von Anwendungsbeispielen.

Beim Behavior Driven Development werden die Anforderungen an die Software mittels Beispiele, sogenannten Szenarien beschrieben. Üblicherweise wird für die Beschreibung dieser Szenarien ein bestimmtes Format vorgegeben, damit später die automatisierte Überprüfung der Szenarien einfach umzusetzen ist. Eines dieser Formate ist die Beschreibungssprache „Gherkin“. Man kann es auch in verschiedenen Behavior-Driven-Development-Implementierungen verwenden. Diese Sprache gibt es sowohl mit englischen Schlüsselwörtern (Given, When, Then, And, …), deutschen (Gegeben, Wenn, Dann, Und, …) und in weiteren Sprachen. Mehr dazu in meinem Beitrag über Cucumber bzw. Gherkin.

Fazit

Behavior Driven Development (BDD) ist eine agile Softwareentwicklungs-Methode, die sich auf die Zusammenarbeit zwischen Entwicklern, Business Analysten und Kunden konzentriert, um sicherzustellen, dass die erstellte Software den Bedürfnissen der Anwender entspricht. BDD ist eine Erweiterung des Test Driven Developments (TDD) und legt den Schwerpunkt auf die Definition von klaren, verständlichen Anforderungen und Tests, die das Verhalten der Anwendung aus der Perspektive des Nutzers beschreiben. Durch die Verwendung von gemeinsamer Sprache und konkreten Beispielen kann man die Kommunikation zwischen den Stakeholdern verbessern und Missverständnisse vermeiden. Das Ergebnis ist eine höhere Qualität der Software, eine schnellere Markteinführung und eine höhere Kundenzufriedenheit.

Der Beitrag BDD – Behavior Driven Development – Software, die den Anforderungen der Kunden entspricht erschien zuerst auf CEOsBay.

Cucumber wurde ursprünglich in der Programmiersprache Ruby für Ruby-Anwendungen geschrieben. In der Zwischenzeit unterstützt es aber auch andere Programmiersprachen wie Java und alle anderen auf der Java Virtual Machine gängigen Programmiersprachen sowie C++ und JavaScript. Darüber hinaus gibt es Projekte, die Cucumber noch für weitere Programmiersprachen zur Verfügung stellen und sich als Teil der Cucumber-Familie sehen. Darunter beispielsweise SpecFlow, eine Implementierung für C#.

Wie funktioniert Cucumber?

Wie auch bei den meisten anderen BDD-Frameworks werden in Cucumber Funktionalitäten mittels der Beschreibungssprache „Gherkin“ beschrieben. Gherkin verwendet natürliche Schriftsprache als Grundlage. Lediglich bestimmte Schlüsselwörter werden besonders behandelt.

Gherkin

Gherkin ist die Sprache, die Cucumber verwendet, um Testfälle zu definieren. Sie ist so konzipiert, dass sie sich nicht-technisch und für den Menschen lesbar gestaltet. Es beschreibt Anwendungsfälle in Bezug auf ein Softwaresystem. Der Zweck hinter der Gherkin-Syntax ist die Förderung verhaltensorientierter Entwicklungspraktiken in einem Entwicklungsteam, einschließlich Geschäftsanalysten und Managern. Sie zielt darauf ab, bereits in den ersten Phasen der Anforderungsdefinition durch die Geschäftsleitung und in anderen Phasen des Entwicklungslebenszyklus einer Anwendung feste, eindeutige Anforderungen durchzusetzen.

Syntax

Die Syntax ist ähnlich wie bei Python zeilenorientiert aufgebaut. Die Struktur einer Datei wird durch Leerzeichen und andere Steuerzeichen definiert. # wird als Zeilen bzw. Kommentarzeichen verwendet und kann an jeder beliebigen Stelle in einer Datei stehen. Anweisungen sind jede nicht leere und nicht kommentierte Zeile. Sie bestehen aus einem konkreten Gherkin-Schlüsselwort, gefolgt von einer Zeichenkette.

Alle Gherkin-Dateien haben die Dateierweiterung .feature. Sie enthalten eine einzelne Feature-Definition für das zu testende System und sind ein ausführbares Testskript.

Neben der Bereitstellung eines Skripts für automatisierte Tests ist die Syntax von Gherkin so konzipiert, dass sie eine einfache Dokumentation des zu testenden Codes ermöglicht. Gherkin unterstützt derzeit Schlüsselwörter in Dutzenden von Sprachen.

Schlüsselwörter der Gherkin Sprache

• Feature: Name bzw. die Bezeichnung des Features
• Rule: Regeln des Features
• Example oder Scenario: Die Bezeichnung des Szenarios (Beispielsweise „Die erfolgreiche Anmeldung mit gültigen Anmeldeinformationen.“)
• Given, When, Then, And, But für die steps (oder *)- Vorbedingungen (Gegeben sei), die Aktion, die ausgeführt wird bzw. die Erweiterung durch andere Schlüsselwörter um die Aktion die ausgeführt wird zu ergänzen bzw. zu erweitern. (Der User gibt beispielsweise seine Zugangsdaten, Username and Password ein), gefolgt von der erwarteten Reaktion des Systems (Beispielsweise die Nachricht, bei einem erfolgreichen Login.)
• Background – Ein Background ermöglicht es einem, den nachfolgenden Scenarios einen gewissen Kontext hinzuzufügen. Es kann einen oder mehrere Vorgegebene Schritte enthalten, die vor jedem Scenario aber nach jedem Before hook ausgeführt werden.
• Scenario Outline oder Scenario Template – Damit lässt sich dasselbe Szenario mehrmals mit unterschiedlichen Wertekombinationen ausführen.
• Examples oder Scenarios – Eine Scenario Outline muss einen oder mehrere Abschnitte mit Examples bzw. Scenarios enthalten. Sie dienen als Steps bzw. Interpretationsvorlage, die nie direkt ausgeführt werden. Stattdessen wird die Szenariogliederung einmal für jede Zeile mit den darunter liegenden Abschnitten von Examples ausgeführt.

Gherkin in deutscher Sprache

Um eine Funktionalität auf Deutsch zu schreiben, muss am Beginn des Features # language: de angegeben werden. Damit sind u.A. folgende deutsche Schlüsselwörter verfügbar:

• Funktionalität
• Grundlage
• Szenario
• Szenariogrundriss
• Beispiele
• Angenommen
• Gegeben sei
• Wenn
• Dann
• Und und Aber, sowie *

Die Command line (CL)

Cucumber verfügt über eine integrierte Kommandozeilenschnittstelle, die eine umfassende Liste von Anweisungen enthält. Wie die meisten Kommandozeilen-Tools bietet Cucumber die Option –help an, die eine Zusammenfassung der Befehle liefert, die diese Command Line akzeptiert.

$ cucumber --help
        -r, --require LIBRARY|DIR        Require files before executing the features.
        --i18n LANG                      List keywords for in a particular language.
                                         Run with "--i18n help" to see all languages.
        -f, --format FORMAT              How to format features (Default: pretty).
        -o, --out [FILE|DIR]             Write output to a file/directory instead of
        ...

Fazit

Gherkin ist nicht nur zum Schreiben von automatisierten Tests geeignet. Man kann Gherkin grundsätzlich auch dazu verwenden, um strukturierte Tests zu erstellen, die man später als Projektdokumentation verwendet kann. Erst die Eigenschaft, strukturiert zu sein, gibt uns die Möglichkeit zu automatisieren.

Sowohl die Sprache Gherkin wie auch das Tool Cucumber, bieten weitaus mehr Funktionalitäten, die ich hier nicht thematisiert habe. Zumal ich auch recht frisch in dieses Thema eingestiegen bin. So ist beispielsweise ein Datengetriebenes Szenario mithilfe von Tabellen möglich. Fernab können verschiedene Schritte, die im Prinzip das Gleiche tun, über Platzhalter definiert werden.

Um solche und weitere Vorteile zu nutzen, ist neben Cucumber oder anderen Testtools vor allem Disziplin beim Verfassen der Dokumentation bzw. der Gherkin Dokumente gefragt. Gleichzeitig müssen die formulierten Schritte präzise genug sein, um die gewünschten Verhaltensweisen ausreichend genau zu beschreiben. Ansonsten zerfällt die Abstraktion und Gherkin Dokumente werden lediglich zu etwas besser lesbaren Testskripten statt dem Ansatz des BDD zu folgen.

Cucumber lässt sich auch mit IntelliJ nutzen. Aber darüber gibt es dann in naher Zukunft einen weiteren Beitrag.

Der Beitrag Cucumber – Das kollaborative Tool für Behavior Driven Development erschien zuerst auf CEOsBay.

Was ist DevOps?

DevOps ist ein Kofferwort, das aus den Begriffen „Development“ (Entwicklung) und „Operations“ (Betrieb) zusammengesetzt ist. Es beschreibt eine Philosophie, Kultur und Praxis, die darauf abzielt, die Zusammenarbeit und Kommunikation zwischen Entwicklern (Dev) und IT-Experten im Betrieb (Ops) zu verbessern. Der Ansatz ermöglicht es, Software schneller und mit höherer Qualität zu entwickeln, bereitzustellen und zu überwachen.

Grundprinzipien von DevOps

1. Zusammenarbeit: DevOps legt Wert auf eine enge Zusammenarbeit zwischen den verschiedenen Teams, um Wissensaustausch, gegenseitiges Verständnis und gemeinsame Verantwortung zu fördern.
2. Automatisierung: Die Automatisierung von Prozessen spielt eine zentrale Rolle in DevOps, um manuelle Aufgaben zu reduzieren und um Fehler zu minimieren.
3. Continuous Integration (CI): CI ist das automatisierte Zusammenführen von Codeänderungen aus unterschiedlichen Entwicklungsarbeiten. Dadurch kann man frühzeitig mögliche Konflikte oder Fehler erkennen und beheben.
4. Continuous Delivery (CD): Hierbei handelt es sich um die fortlaufende Bereitstellung von Software in verschiedenen Umgebungen (Test (Siehe TDD und BDD)), Staging, Produktion) zur Validierung und schnellen Bereitstellung von Updates.
5. Feedback und Lernen: DevOps ermutigt Teams, kontinuierlich Feedback zu sammeln und daraus zu lernen, um stetige Verbesserungen in der Softwareentwicklung zu erzielen.

Vorteile von DevOps

1. Schnellere Auslieferung bzw. Markteinführung: Durch die verbesserte Zusammenarbeit und Automatisierung von Prozessen kann man Software schneller entwickeln und ausliefern, was zu einem Wettbewerbsvorteil führt.
2. Höhere Qualität: Man kann Fehler frühzeitig entdecken und beheben, wodurch man die Qualität der Software verbessert.
3. Reduzierte Kosten: Durch effizientere Prozesse und Automatisierung kann man die Kosten senken und Ressourcen optimal nutzen.
4. Erhöhte Flexibilität: Die enge Zusammenarbeit und ständige Verbesserung der Prozesse ermöglichen es Unternehmen, schneller auf Veränderungen zu reagieren und Innovationen voranzutreiben.

Nachteile von DevOps

Obwohl es zahlreiche Vorteile für Unternehmen und Entwicklerteams bietet, gibt es auch einige Nachteile, die man bei der Einführung und Umsetzung dieses Ansatzes berücksichtigen sollte:

1. Kulturelle Herausforderungen: Eine der größten Herausforderungen bei der Implementierung von DevOps ist der Wandel der Unternehmenskultur. Die Zusammenarbeit zwischen Entwicklern und IT-Experten im Betrieb erfordert eine Änderung von Denkmustern und Arbeitsweisen, was nicht immer einfach ist.
2. Anfangsinvestition: Um es erfolgreich umzusetzen, müssen Unternehmen oft in neue Tools, Technologien und Schulungen investieren. Dies kann insbesondere für kleinere Unternehmen eine finanzielle Belastung darstellen.
3. Komplexität: Die Einführung von DevOps kann zu erhöhter Komplexität führen, da man zusätzliche Prozesse und Tools in den Entwicklungs- und Betriebsablauf integrieren muss. Dies erfordert eine umfangreiche Planung und Koordination, um effizient und erfolgreich zu sein.
4. Widerstand im Team: Nicht alle Teammitglieder sind von Anfang an von den Vorteilen von DevOps überzeugt. Einige können skeptisch sein oder den Wandel ablehnen, was zu Konflikten und Spannungen innerhalb des Teams führen kann.
5. Sicherheitsrisiken: Trotz des DevSecOps-Ansatzes, bei dem man Sicherheit in den Entwicklungsprozess integriert, kann die Einführung von DevOps zu zusätzlichen Sicherheitsrisiken führen. Zum Beispiel kann die automatisierte Bereitstellung von Code unbeabsichtigte Sicherheitslücken oder Fehler aufweisen, die Angreifern ausnutzen könnten.
6. Kontinuierliche Anpassung: Da DevOps ein agiles Vorgehen erfordert, müssen sich Teams ständig an neue Technologien, Methoden und Prozesse anpassen. Dies kann anstrengend und zeitaufwändig sein und dazu führen, dass sich einige Mitarbeiter überfordert fühlen.

Um diese Nachteile zu minimieren, ist es wichtig, bei der Einführung von DevOps eine gut durchdachte Strategie zu verfolgen, die alle Aspekte des Prozesses berücksichtigt. Offene Kommunikation, Schulungen und das Sammeln von Feedback sind entscheidend, um ein erfolgreiches DevOps-Umfeld zu schaffen und die möglichen Nachteile zu bewältigen.

Best Practices für DevOps

1. Kultur der Zusammenarbeit fördern: Es ist entscheidend, ein Arbeitsumfeld zu schaffen, in dem Entwickler und IT-Experten im Betrieb offen kommunizieren und zusammenarbeiten können.
2. Tools und Technologien nutzen: Für eine erfolgreiche Implementierung von DevOps ist es wichtig, geeignete Tools und Technologien einzusetzen, um Prozesse zu automatisieren und die Zusammenarbeit zu erleichtern. Dazu zählen CI/CD-Tools wie Jenkins oder GitLab bzw. GitHub, Container-Technologien wie Docker und Kubernetes sowie Monitoring- und Logging-Tools wie Grafana und ELK Stack.
3. Infrastruktur als Code (IaC) einsetzen: Mit IaC können Entwickler und Betriebsteams die Infrastruktur ähnlich wie bei Softwareanwendungen entwickeln, verwalten und versionieren. Dadurch kann man die Konsistenz und Reproduzierbarkeit der Umgebungen gewährleisten. Beispiele für IaC-Tools sind Terraform, Ansible und Chef.
4. Monitoring und Feedback: Um kontinuierlich zu lernen und Verbesserungen voranzutreiben, sollten Unternehmen umfangreiches Monitoring einsetzen, um Probleme frühzeitig zu erkennen und Feedback in den Entwicklungsprozess einfließen zu lassen.
5. Sicherheit integrieren: Man sollte auch den Aspekt der Sicherheit berücksichtigen, indem Entwickler und Betriebsteams eng mit Sicherheitsexperten zusammenarbeiten. Der Ansatz „DevSecOps“ betont die Integration von Sicherheitsmaßnahmen in den gesamten Softwarelebenszyklus.
6. Experimentieren und Lernen: Man sollte DevOps-Teams immer wieder ermutigen, kontinuierlich neue Technologien, Prozesse und Methoden auszuprobieren, um aus Fehlern zu lernen und Innovationen voranzutreiben.

Fazit

DevOps ist eine transformative Strategie, die in der modernen Softwareentwicklung unerlässlich geworden ist. Durch die Zusammenarbeit zwischen Entwicklern und IT-Experten im Betrieb, die Automatisierung von Prozessen und den kontinuierlichen Feedback- und Lernprozess wird die Softwareentwicklung beschleunigt, die Qualität verbessert und die Flexibilität erhöht.

Die Einführung von DevOps erfordert jedoch Zeit und Engagement, um sowohl die Kultur als auch die notwendigen Technologien und Prozesse in einem Unternehmen zu etablieren. Eine erfolgreiche Implementierung von DevOps setzt voraus, dass Unternehmen bereit sind, sich kontinuierlich weiterzuentwickeln und ihre Teams mit den notwendigen Ressourcen und dem Wissen auszustatten. Der Einsatz von Best Practices und eine fortwährende Verbesserung der Prozesse sind Schlüsselfaktoren für den Erfolg von DevOps in der Softwareentwicklung.

Der Beitrag DevOps – Entwickeln, bereitstellen und verbessern erschien zuerst auf CEOsBay.

Kurze Zeitreise

Jenkins ist in erster Linie eine Entwicklung von Kohsuke Kawaguchi. Einem ehemaligen Mitarbeiter von Sun Microsystems, der es unter dem Namen Hudson entwickelt hat. Kawaguchi verließ das Unternehmen, nachdem Oracle es Ende Januar 2010 übernahm. Er behielt aber die Leitung bei Hudson und arbeitete nach eigenen Angaben auf freiberuflicher Basis weiter bei Oracle. Oracle hielt nach wie vor die Namensrechte an Hudson. Aus diesem Grund hat man das Projekt schließlich in Jenkins umbenannt. Die Namensgebung erfolgte laut der Entwickler aufgrund der äquivalenten Assoziation der beiden Wörter mit dem Beruf des Butlers.

Oracle trieb die Entwicklung von Hudson weiterhin voran. Deshalb spricht man heute von einem Fork (einer „Abspaltung“) in der Softwareentwicklung. Im Jahr 2016 wurde die Entwicklung von Hudson zugunsten von Jenkins eingestellt und der Eclipse Foundation gespendet. Die Entwicklung wird jetzt als Open-Source-Projekt unter der Leitung der CD Foundation, einer Organisation innerhalb der Linux Foundation, verwaltet.

Wofür Pipelines?

Im Grunde genommen automatisieren Pipelines Tests und Berichte zu isolierten Änderungen in einer größeren Codebasis in Echtzeit und erleichtern die Integration unterschiedlicher Codezweige in einen Hauptzweig. Man erkennt dadurch schnell Fehler in einer Codebasis, erstellt die Software, automatisiert das Testen der Builds, bereitet die Codebasis für die Bereitstellung (Auslieferung) vor und stellt schließlich Code in Containern und auf virtuellen Maschinen sowie Bare-Metal- und Cloud-Servern bereit. Es gibt auch kommerzielle Versionen von Jenkins, auf die ich in diesem Beitrag aber nicht weiter eingehe.

Continious Integration / Kontinuierliche Integration

Kontinuierliche Integration hat sich seit der Erfindung weiterentwickelt. Ursprünglich war es die Norm, dass Teams einen Build pro Tag veröffentlichten. Nun ist es die Regel, dass jedes Teammitglied täglich oder häufiger Aktualisierungen einreicht, die man als Commit bezeichnet (Siehe Git / GitHub). Dies erfolgt bei jeder wesentlichen Änderung eines Builds. Bei der richtigen Anwendung bietet Continuous Integration verschiedene Vorteile, wie zum Beispiel ständige Rückmeldungen zum Status der Software. Da man durch CI, Mängel frühzeitig in der Entwicklung erkennt, sind Fehler in der Regel kleiner, weniger komplex und leichter zu beheben.

Jenkins und CI/CD

Im Laufe der Zeit wurden Jenkins Continuous Delivery und Deployment hinzugefügt. Continuous Delivery bedeutet, dass das Erstellen und Packen von Code für die spätere Bereitstellung in Test-, Produktions-Staging- und Produktionsumgebungen automatisiert wird. Continuous Deployment automatisiert den letzten Schritt der Bereitstellung des Codes an seinem endgültigen Ziel.

In beiden Fällen reduziert die Automatisierung die Anzahl der auftretenden Fehler, da die richtigen Schritte und Best Practices in Jenkins kodiert sind. Jenkins beschreibt einen gewünschten Zustand und der Automatisierungsserver stellt sicher, dass dieser Zustand erreicht wird. Darüber hinaus macht diese Automatisierung die Bereitstellung schneller, da Vorgänge nicht mehr an personelle Beschränkungen gebunden sind. Schließlich reduziert es die Belastung des Entwicklungs- und Betriebsteams, indem es die Notwendigkeit von manuellen Rollouts mitten in der Nacht und am Wochenende beseitigt.

Jenkins und Microservices

Jenkins bewährt sich besonders in Microservices-Architekturen. Da es eines der Ziele von Microservices ist, Anwendungen und Dienste häufig zu aktualisieren, sollte man dafür sorgen, dass die Bandbreite die Releases nicht verzögert. Mehr und kleinere Dienste mit schnelleren Update-Intervallen lassen sich nur durch Automatisierung gut umsetzen – und dafür ist es wohl die richtige Wahl.

Jenkins X

Das Jenkins X-Projekt wurde 2018 mit dem Ziel gestartet, eine moderne, Cloud-native Version von Jenkins zu erschaffen. Das Projekt steht ebenfalls unter der Leitung der CD Foundation. Die Architektur, Technologie und Pipeline-Sprache unterscheiden sich grundsätzlich von Jenkins. Jenkins X ist für Kubernetes konzipiert und verwendet es in einer eigenen Implementierung. Andere Cloud-native Technologien, die Jenkins X verwendet, sind Helm und Tekton, auf die ich in gesonderten Beiträgen eingehen werde.

Wie funktioniert Jenkins?

Jenkins läuft auf einer Vielzahl von Betriebssystemen bzw. Plattformen. Darunter gibt es Windows, MacOS und Unix-Varianten. Am besten jedoch läuft es auf Linux. Es erfordert mindestens eine Java 8 VM oder höher und kann auf Oracle Java Runtime Environment oder Open Java Development Kit ausgeführt werden. Normalerweise läuft es als Java-Servlet innerhalb eines Jetty-Anwendungsservers. Es kann aber auch auf anderen Java-Anwendungsservern wie Apache Tomcat ausgeführt werden. Auch kann es in einem Docker-Container ausgeführt werden. Im Docker Hub-Online-Repository sind aus diesem Grund schreibgeschützte Jenkins-Images verfügbar.

Um Jenkins zu auszuführen, werden Pipelines erstellt. Eine Pipeline ist eine Reihe von Schritten, die der Jenkins-Server ausführt. Diese Schritte sind in einem Klartext-Jenkins-File gespeichert. Das Jenkins-File verwendet eine geschweifte Klammersyntax, die einer JSON gleicht. Schritte in der Pipeline werden als Befehle mit Parametern deklariert und in geschweiften Klammern gekapselt. Der Jenkins-Server liest dann die Jenkins-Datei und führt die Befehle aus, wobei der Code die Pipeline vom festgeschriebenen Quellcode zur Produktionslaufzeit weiterleitet. Ein Jenkins-File kann über eine grafische Benutzeroberfläche oder durch Code erstellt werden.

Plugins

Für Jenkins sind eine Reihe von Plugins verfügbar, damit es mit anderen Tools zusammenarbeiten kann. Mit Plugins lässt sich auch der Funktionsumfang der Software erweitern. Fertige bzw. bewährte Plugins können aus dem Online-Repository für Jenkins-PlugIns heruntergeladen und über die Jenkins-Webbenutzeroberfläche oder -CLI (Kommandozeile, Command Line Interface) geladen werden. Man kann aber auch eigene Plugins entwickeln.

Plugins helfen bei der Integration anderer Entwicklertools in die Jenkins-Umgebung, fügen der Web-UI neue Elemente hinzu. Dies dient im Allgemeinen der erleichterten Verwaltung und Benutzung. Ein wichtiges Einsatzgebiet von Plugins ist das Bereitstellen von Integrationspunkten für CI/CD-Quellen und -Ziele. Dazu gehören Software-Versionskontrollsysteme (SVCs) wie Git und Atlassian BitBucket, Container-Laufzeitsysteme – insbesondere Docker, sowie Hypervisoren wie VMware vSphere, Public-Cloud-Instanzen wie Google Cloud Platform und AWS und schließlich Private-Cloud-Systeme wie OpenStack. Es gibt auch Plugins, die eine Kommunikation mit Betriebssystemen über FTP, CIFS und SSH unterstützen.

Plugins verwenden ihren eigenen Satz von Java-Annotationen und Designmustern, die definieren, wie sie instanziiert werden. Die Plugin-Entwicklung nutzt außerdem die Maven-Bereitstellung für Jenkins.

Sicherheit

Bei der Sicherheit geht es vor allem darum den Server und die Benutzer zu schützen. Die Serversicherheit wird mehr oder weniger auf dieselbe Art und Weise erreicht, wie auf regulären Servern. Der Zugriff auf den Standort, beispielsweise eine VM oder einen Bare-Metal-Server, ist so konfiguriert, dass möglichst wenige Prozesse mit dem Server kommunizieren dürfen. Dies wird durch typische Serverbetriebssysteme und Netzwerksicherheitsfunktionen erreicht.

Darüber hinaus ist der Zugriff auf den Server über die Jenkins-Benutzeroberfläche mit den regulären Mechanismen, wie Multi-Faktor-Authentifizierung oder der Beschränkung der Anzahl von legitimierten Benutzern, geschützt.

Jenkins enthält außerdem Sicherheitsfunktionen für die interne Nutzerdatenbank. Man unterscheidet zwei Sicherheitsbereiche. Zum einen den Sicherheitsbereich und den Autorisierungsbereich. Im Sicherheitsbereich regeln Administratoren, wer Zugriff hat, und im Autorisierungsbereich bestimmen die Nutzer selbst, was man mit dem Zugriff anstellen kann.

Fazit

Ein großer Vorteil von Jenkins sind die Unmengen an verfügbaren Plugins. Diese tragen zu einer enormen Flexibilität bei. Auch die umfangreichen Skript- und deklarativen Sprachen, mit denen man stark benutzerdefinierte Pipelines erstellen kann, stellen einen großen Mehrwert dar. Da es weitestgehend neutral ist, passt es gut in die meisten Umgebungen, einschließlich in komplexe Hybrid- und Multi-Cloud-Systeme.

Da Jenkins schon etwas länger als vergleichbare Lösungen in diesem Bereich verwendet wird, gibt es umfangreiche Dokumentationen und zahlreiche Community-Ressourcen, an denen man sich bedienen kann. Diese Ressourcen erleichtern die Installation, Verwaltung und Fehlerbehebung ungemein.

Da die gesamte Lösung auf Java basiert, steht es auf einer soliden Basis, die man mit gängigen Designmustern und Frameworks erweitern kann. Auch wenn sich die Installation relativ einfach gestaltet, kann es relativ schwierig sein, komplexe Pipelines zu entwickeln, zu debuggen und zu warten.

Das Open-Source-System ist außerdem eine Single-Server-Architektur. Dies kann jedoch die Ressourcen auf einen einzigen Computer, eine virtuelle Maschine oder einen Container einschränken. Cluster werden nicht unterstützt. Diese Tatsache kann die Leistung enorm einschränkten. Es kann auch dazu führen, dass es zum Server-Sprawl kommt und man den Überblick über all die einzelnen Jenkins-Server verliert.

Der Beitrag Jenkins – Automatisierte Arbeitsabläufe beim Testing erschien zuerst auf CEOsBay.