Tutorials zu Testautomatisierung und Softwaretesten

Du willst wissen, wie Du Testautomatisierer oder Softwaretester wirst? Dann bist Du hier richtig. Dafür brauchst Du keine Vorkenntnisse. Auch als Softwaretester solltest Du die Testautomatisierung beherrschen. Gerade in der agilen Softwareentwicklung spielt Testautomatisierung eine große Rolle. Als Softwaretester im agilen Umfeld solltest Du verantwortlich für die Testautomatisierung sein.

Grundlagen des Softwaretestens

Im Bereich Softwaretesten Grundlagen, lernst Du, wie der Alltag eines Softwaretesters / Testautomatisierers aussieht. Du lernst die Fachbegriffe und Methoden kennen, die Du brauchst, um als Testautomatisierer in der Softwareentwicklung tätig zu sein. Auch als Testautomatisierer solltest Du die Grundlagen des Softwaretestens kennen und beherrschen.

Grundlagen der Testautomatisierung

Nachdem wir die Grundlagen kennengelernt haben, starten wir mit den Grundlagen der Testautomatisierung. Hier lernen wir eine Programmiersprache kennen. Als Testautomatisierer solltest Du die Technologien kennen, die eingesetzt werden, um die Anwendung zu implementieren. Für Webanwendungen wird im Frontend oft CSS, HTML und JavaScript eingesetzt. Wir schauen uns die Grundlagen der Frontend-Technologien an. Dieses Wissen wird uns später bei der Testautomatisierung von Webanwendungen helfen.

Das Fundament ist gelegt. Wir haben die Grundlagen des Softwaretestens gelernt und verinnerlicht. Die erste Programmiersprache haben wir gemeistert und die Technologien die eingesetzt werden, um das Frontend eine Webanwendung zu implementieren.

Testautomatisierung mit Selenium

Jetzt starten wir mit der Implementierung von automatisierten Tests. Unseren Anfang machen wir mit der Testautomatisierung von Webanwendungen.

Für die Implementierung der automatisierten Testfälle werden wir Selenium WebDriver einsetzen. In der Testautomatisierung von Webanwendung ist Selenium WebDriver das meist eingesetzte Automatisierungstool. Wenn man es genau nimmt, ist Selenium kein Tool, sondern eine API (Application Programming Interface). Man kann es sich wie eine Bibliothek vorstellen, die  mit den gängigen Programmiersprachen (Java, Python, C#, JavaScript, Ruby, PHP) eingesetzt werden kann. Wir werden Selenium WebDriver mit Java nutzen. Die Kombination von Java und Selenium ist die meist eingesetzte in der Industrie.

Wir lernen zuerst das Einrichten von Selenium und der Entwicklungsumgebung. Als Entwicklungsumgebung werden Eclipse und IntelliJ IDEA verwenden. Nachdem wir gelernt haben, wie wir Selenium konfigurieren müssen, starten wir mit der Implementierung der Testautomatisierung. Wir lernen wie wir Web-Elemente identifizieren und unsere eigenen Selektoren erstellen. Der nächste Schritt ist es, Aktionen auszuführen, die einen Nutzer simulieren.

Testautomatisierung mit Appium

In diesem Abschnitt lernst Du die Testautomatisierung von mobilen Anwendungen kennen. Als Testautomatisierungstool setzten wir Appium ein. Appium wird sowohl für die Testautomatisierung von Android als auch für iOS Anwendungen eingesetzt. Wir lernen, wie wir unsere Entwicklungsumgebung einrichten, damit wir mit der Implementierung der Testautomatisierung starten können.

Testautomatisierung von Webservices

Wir haben die Testautomatisierung mit Selenium und Appium gelernt. Jetzt wird es Zeit, sich mit der Testautomatisierung von Webservices zu beschäftigen. Hier lernen wir, was ein Webservice ist und wie wir Webservices manuell und automatisiert testen.Die manuellen Tests führen wir mit Postman aus, um den Service explorativ zu erforschen. Nachdem wir die einzelnen Testfälle manuell ausgeführt haben, starten wir mit der Implementierung der automatisierten Testfälle. Als Programmiersprache setzen wir Java ein und als Testingframework setzen wir REST-Assured ein.

Testautomatisierung – Was Du darüber wissen solltest.

Was ist Testautomatisierung?

Testautomatisierung ist das automatisierte Ausführen von Testaktivitäten. Dazu gehört nicht nur das automatisierte Ausführen von Testfällen, sondern bspw. auch das automatisierte Generieren von Testdaten oder auch die Konfiguration der Testumgebung etc. Es können nicht alle Aktivitäten des Softwaretestprozesses automatisiert werden, einige davon sind bspw. das Usability Testen als auch das explorative Testen. Die Testautomatisierung wird oft für das Automatisieren von funktionalen Testfällen eingesetzt. Ein automatisierter Testfall ist in der Regel ein Algorithmus, der Schritte ausführt und anschließend einen Ist-Wert mit einem Soll-Wert abgleicht.

Testautomatisierungsmythen

Es ist ein Irrglaube, dass die Testautomatisierung den Softwaretester ersetzen kann. Automatisierte Tests sollen den Softwaretester unterstützen, damit er sich auf die wichtigen Risiken der Software fokussieren kann. Es muss unterschieden werden zwischen Verifizieren und Validieren. Verifizieren ist das Abarbeiten einer Checkliste und Abhaken, ob die einzelnen Anforderungen umgesetzt wurden (bauen wir das System richtig). Dieser Teil des Softwaretestens kann zum großen Teil automatisiert werden. Das Verifizieren ist die Überprüfung, ob das richtige System gebaut wird; diese Aktivität kann nicht automatisiert werden. Die Artikelserie „Testautomatisierungsmythen“ geht auf weitere Mythen der Testautomatisierung ein.

Vorteile und Nachteile der Testautomatisierung

Vorteile:

• Schnelles Feedback über die Qualität der zu entwickelnden Anwendung
• Ausführung der Testautomatisierung 24 Stunden 7 Tage die Woche
• Je öfter die automatisierten Testfälle ausgeführt werden, desto höher der Return on Investment (RoI)
• Vermeidung von Betriebsblindheit bei wiederholten monotonen Aktivitäten
• Höhere Testabdeckung
• Möglichkeit, öfter zu releasen
• Kapazitäten für andere Aufgaben 
• Parallele Testausführung
• Sicherheit bei Änderungen

Nachteile:

• Unzuverlässige automatisierte Testfälle
• Programmierkenntnisse und Testautomatisierungskenntnisse werden benötigt
• Kann den Deployment-Prozess verhindern
• Lange Ausführungszeiten bei nicht parallel automatisierten Testfällen
• Testautomatisierung ist nicht Testen
• Wartungsaufwand

Testautomatisierungspyramide

Die Testautomatisierungspyramide wurde das erste Mal von Mike Cohen in seinem Buch „Succeding with agile“ erwähnt. Die Testautomatisierungspyramide gibt einen guten Überblick über die Verteilung der automatisierten Testfälle auf den einzelnen Teststufen (siehe Abbildung).

Unit-Tests

Auf der untersten Ebene sind die Unit-Tests. Die Unit-Tests bilden das Fundament der Testautomatisierung.  Unit-Testfälle ermöglichen schnelles Feedback über die Qualität der kleinsten ausführbaren Einheiten (Klassen, Methoden, Funktionen). Ein weiterer Vorteil ist, dass Unit-Tests sehr fokussiert sind. Tritt eine Fehlerwirkung auf, kann der Fehlerzustand schneller als bei Integrationstest oder End-2-End Testfällen identifiziert werden. Aufgrund der Tatsache, dass die einzelnen Einheiten isoliert getestet werden ohne externe Einflüsse.

Automatisierte Integrationstests

Auf der zweiten Stufe der Testautomatisierungspyramide befinden sich die Integrationstest. Als Integration versteht man einzelnen Einheiten Die integriert werden. Integrationstests können das automatisierte Testen von zwei integrierten Komponenten oder auch die Integration von Systemen und Services. Hier werden die Kommunikation und der Datenaustausche zwischen den Komponenten im Zusammenspiel getestet. Im Bereich von Webanwendungen und mobilen Anwendungen werden hier oft die Geschäftslogik ohne die Benutzeroberfläche getestet.

Automatisierung von End-2-End Testfällen

Warum deine Testautomatisierung scheitert

Testautomatisierung ist mittlerweile ein fester Bestandteil der Softwareentwicklung. Durch die immer schnelleren inkrementellen Releases eine Software, ist ein schnelles Feedback der Qualität des zu entwickelnden Systems nicht mehr alle nur durch manuelles Testen gegeben. Doch gerade bei der Einführung und dem Einsatz von Testautomatisierung scheitern viele Unternehmen. Den Mehrwert, den man sich durch die Testautomatisierung erhofft, wird meist nicht erfüllt. Oft haben die unterschiedlichen Unternehmen dieselben Herausforderungen beim Einsatz von Testautomatisierung. Der erste Artikel der Serie „Warum deine Testautomatisierung scheitert“ zeigt drei mögliche Herausforderungen beim Einsatz von Testautomatisierung auf und mögliche Lösungsansätze.

Keine optimale Abstimmung der Teststrategie

Automatisiertes Testen kann auf allen Stufen des Testprozesses eingesetzt werden. Die Testautomatisierungspyramide verdeutlicht die einzelnen automatisierten Teststufen sehr gut. In der Regel ist der Softwareentwickler zuständig für die Implementierung der Unit-Test. Die Integrationstests werden vom Softwareentwickler oder Softwaretester automatisiert. Die automatisierten Systemtests oft vom Softwaretester. Dies kann, jedoch zu Problemen führen. In den meisten Fällen wird untereinander nicht kommuniziert, welche Testfälle automatisiert werden. Dies führt dazu, dass eine Redundanz der Testfälle entstehen kann, die zu unnötigen Wartungsaufwand führt. Des Weiteren weiß der Softwaretester oft nicht, was der Softwareentwickler auf der Unit-Test Ebene automatisiert Test. Dies führt dazu, dass die Testautomatisierungsstrategie nicht optimal abgestimmt ist.

Lösungsansatz

Ein möglicher Lösungsansatz ist es, dass der Softwareentwickler und Softwaretester zusammen die Unit-Tests implementieren. Der Softwaretester kann sein Wissen über Test Design einbringen. Dies hat den Vorteil, dass einerseits ein Wissensaustausch zwischen Softwareentwickler und Softwaretester stattfindet und andererseits der Softwaretester einen Überblick über die Testabdeckung auf Unit-Test Ebene bekommt.

Verfügbare Ressourcen für die Testautomatisierung

der letzte Abschnitt hat eine Möglichkeit aufgezeigt wie man die Testautomatisierung durch die Zusammenarbeit von Softwareentwickler und Softwaretester optimieren kann. Die Herausforderung hier ist jedoch, dass sowohl der Softwaretester als auch der Softwareentwickler eine Vielzahl an Aufgabenbereiche in einem Softwareentwicklungsprojekt haben. Die Testautomatisierung ist keine einmalige Tätigkeit, die nur implementiert werden muss und von selbst kontinuierlich läuft. Testautomatisierung ist ein Softwareentwicklungsprojekt und muss geplant, implementiert und gewartet werden. Oft wird die Testautomatisierung als Nebentätigkeit ausgeführt und die Verantwortlichkeit liegt bei den Entwicklern und Softwaretestern. Keiner der beiden kann jedoch, seinen ganzen Fokus auf die Testautomatisierung setzten.

Lösungsansatz

Oft empfiehlt es sich, die Rolle des Testautomatisierers einzuführen. Der Testautomatisierer kann seinen ganzen Fokus auf die Testautomatisierung richten. Er kann die Testautomatisierung durch die Kommunikation mit den Softwaretestern und Softwareentwicklern optimal abstimmen.

Die Rolle des Testautomatisierer

Wer soll die Rolle des Testautomatisierers übernehmen? Der Softwareentwickler hat nicht die Fähigkeiten eines Softwaretesters und ist oft nicht gewillt, seinen ganzen Fokus auf die Testautomatisierung zu richten. Der Softwaretester auf der anderen Seite hat in der Regel nicht die technischen Fähigkeiten, die man braucht, um Testautomatisierung optimal zu implementieren. Dem Softwaretester fehlen die Kenntnisse in den Bereichen Clean Code,

Design Patterns und Testautomatisierung. Wie im letzten Abschnitt eignet sich ein Testautomatisierungsexperte optimal für diese Rolle. Eine andere Alternative wäre es den Softwaretester als Testautomatisierer auszubilden. Die Softwareentwickler können ihr Wissen mit dem Softwaretester austauschen und ihn kontinuierlich weiterbilden.

Falsche Erwartung an die Testautomatisierung

Eine große Anzahl an Entscheidungsträgern in einem Unternehmen haben falsche Erwartungen an die Testautomatisierung. Bevor Testautomatisierung in einem Softwareentwicklungsprojekt eingeführt wird, sollte man sich darüber klar sein, was Testautomatisierung ist und was es nicht ist. Häufige Mythen sind:

• Kann manuelles Testen vollständig ersetzten
• Man brauch keine Programmierkenntnisse, um Testautomatisierung zu implementieren.
• Das Wichtigste bei der Einführung  ist das Testautomatisierungstool
• Löst alle Softwaretest Probleme
• Ermögliche das Reduzieren von Personal
• Bringt schnellen ROI
• Findet viele Fehlerwirkungen