fbpx

Eine Einführung in die Testautomatisierung

Die Testautomatisierung ist ein fester Bestandteil der modernen Softwareentwicklung. Richtig eingesetzte kann sie einen großen Mehrwert liefern. Der Mehrwert besteht unter anderem darin, Software in besserer Qualität und schneller zu liefern. Obwohl die Testautomatisierung in vielen Softwareentwicklungsprojekten einen immer größeren Stellenwert einnimmt, stellt es viele Teams trotzdem vor eine Herausforderung. Eine Herausforderung besteht oft darin, stabile automatisierte Testfälle zu implementieren, die auch fokussiert und wartungsfreundlich sind. In diesem Artikel bekommst du einen Überblick über die Testautomatisierung und wie Teams den meisten Mehrwert aus ihr herausholen können.  

Warum Testautomatisierung? 

In agilen Softwareentwicklungsprojekten wächst Software inkrementell. Das heißt, es kommt immer mehr Funktionalität hinzu. Anfangs ist es vielleicht noch möglich, die Funktionalität manuell zu testen. Je mehr Funktionen zu einer Softwareanwendung hinzukommen, desto höher wird jedoch der Aufwand, diese zu testen.  

warum-testautomatisierung

Außerdem müssen nicht nur die neuen Funktionen getestet werden, sondern auch die alte Funktionalität einer Anwendung. Denn es können negative Seiteneffekte auftreten. Von negativen Seiteneffekten wird gesprochen, wenn etwas an einer Softwareanwendung geändert wird und dies negative Auswirkungen auf die bereits bestehende Funktionalität haben kann. Aufgrund dessen sollten in der Regel bei Änderungen auch die alten Funktionalitäten getestet werden. Diese Tests werden auch Regressionstests genannt und sind in der Regel automatisiert. Ohne automatisierte Tests ist dies in den meisten Softwareentwicklungsprojekten nicht realisierbar, da der Ressourcenaufwand zu hoch wäre. 

Ein weiterer Grund, warum die Testautomatisierung eingesetzt wird, ist, dass alle beteiligten Personen eines Softwareentwicklungsprojektes schnelles Feedback benötigen. In Softwareentwicklungsprojekten entstehen täglich Anpassungen der Software. Die Entwickler:innen können nicht erst Stunden oder Tage warten, bis sie eine Rückmeldung von den Software-Testern bekommen. Sie müssen wissen, ob die Erweiterungen oder Anpassungen negative Auswirkungen auf die Software haben und ob die neue Funktionalität wie erwartet gegeben ist. Durch manuelles Software-Testing wäre der Ressourcenaufwand zu groß, um alle Funktionalitäten der Software nach jeder Anpassung zu testen. Des Weiteren würde die Feedback-Schleife zu lange dauern, um den aktuellen Status quo der Softwareanwendung zu bekommen.  

Was kann Testautomatisierung? Verifizierung vs. Validierung

 

Bei der Verifizierung geht es darum zu prüfen, ob die dokumentierten Anforderungen umgesetzt wurden. Es ist vergleichbar mit einer Checkliste, die abgehakt wird. Hier stellen sich alle am Softwareentwicklungsprozess beteiligten Personen die Frage: “Bauen wir das System, richtig?” 

Bei der Validierung geht es darum, die Anforderungen zu hinterfragen und zu überprüfen, ob es genau das ist, was der/die Nutzer:in/Kund:in wirklich benötigt. Hier sollten sich alle am Softwareentwicklungsprozess Beteiligten die Frage stellen: “Bauen wir das richtige System?”

Eine richtig eingesetzte Testautomatisierung unterstützt das Software-Testing bei der Verifizierung und schafft freie Ressourcen, die für die Validierung genutzt werden können.

Wie funktioniert Testautomatisierung?

 

Bei der Testautomatisierung werden Aktionen automatisiert und es wird verifiziert, ob das gewünschte Ergebnis eingetroffen ist. Nehmen wir als Beispiel die Google Search Bar für Webanwendungen.

Es wird automatisiert: 

  • Dass der Browser sich öffnet
  • Dass Google.de aufgerufen wird
  • Im Suchfeld ein Wert eingegeben wird
  • Der Such-Button geklickt wird
  • Und anschließend verifiziert, ob die richtigen Themen zu meinem Wert angezeigt werden

Die Automatisierung kann durch Tools erfolgen, die keine Programmierkenntnisse voraussetzen oder mithilfe einer Programmiersprache und durch zusätzliche Bibliotheken

Die Vorteile von Testautomatisierung 

 

  • Sie kann 24/7 ausgeführt werden
  • Die Ausführungszeit ist schneller als manuelles Testen 
  • Die automatisierten Testfälle können parallel ausgeführt werden
  • Der/die Software-Tester:in kann sich auf die komplexen Aspekte der Software fokussieren 
  • Monotone Arbeit, die zu Flüchtigkeitsfehler führen kann, wird automatisiert 
  • Schnelles Feedback zum aktuellen Status quo der Software 
  • Richtig eingesetzt spart sie Ressourcen

Sie kann 24/7 ausgeführt werden

Richtig implementierte, automatisierte Testfälle können zu jeder Zeit ausgeführt werden. Auch am Wochenende und nachts, wenn kein/e Projektmitarbeiter:in mehr tätig ist. Dadurch werden Ressourcen gespart und diese können anderweitig eingesetzt werden. 

 

Die Ausführungszeit ist schneller als manuelles Testen 

Es gibt verschiedene Arten von automatisierte Tests, die unterschiedliche Ausführungszeiten benötigen. Hier sprechen wir von einer Ausführung sowohl im Millisekundenbereich als auch im Minutenbereich. Welche Arten es gibt und wie die Ausführungszeiten sind, schauen wir uns in späteren Abschnitten an.

 

Die automatisierten Testfälle können parallel ausgeführt werden 

 

Ein großer Vorteil der Testautomatisierung ist, dass die automatisierten Testfälle parallel ausgeführt werden können. Das heißt beispielsweise, dass 100 oder mehr automatisierte Testfälle zur gleichen Zeit ausgeführt werden können. 

 

Software-Tester:innen können sich auf die komplexen Aspekte der Software fokussieren 

 

Wie beschrieben, gibt es einen Unterschied zwischen dem Validieren und Verifizieren. Richtig eingesetzte Testautomatisierung kann Software-Tester:innen einen Großteil des Verifizierens abnehmen und ihnen die Ressourcen für das Validieren schaffen. 

 

Monotone Arbeit, die zu Flüchtigkeitsfehler führen kann, wird automatisiert 

 

Wir kennen es aus dem Alltag. Wenn wir monotone Arbeit ausführen, führt dies oft zu Flüchtigkeitsfehlern. Beim wiederholten Testen derselben Funktion können diese Flüchtigkeitsfehler ebenfalls auftreten. Stattdessen kann das Team die monotonen Testfälle automatisieren und die Risiken von Flüchtigkeitsfehlern minimieren

 

Schnelles Feedback zum aktuellen Status quo der Software 

 

Dadurch, dass die Ausführung einzelner automatisierter Testfälle im Millisekunden- und Minutenbereich liegt und die automatisierten Testfälle parallel ausgeführt werden können, bekommen alle am Softwareentwicklungsprozess beteiligten Personen schnelles Feedback zum aktuellen Status quo der Software. 

 

Richtig eingesetzte automatisierte Testfälle sparen Ressourcen 

 

Optimal implementierte Testautomatisierung spart in der Regel Ressourcen. Dadurch, dass die Softwareanwendung nach jeder Änderung oder Erweiterung durch automatisierte Testfälle auf den aktuellen Status quo gecheckt wird, müssen diese nicht die Software-Tester:innen manuell durchführen. Der manuelle Prozess ist oft langwieriger, kostet mehr Ressourceneinsatz und die Feedback-Schleife ist oft zu langwierig.   

 

Nachteile von Testautomatisierung 

 

  • Software-Tester:innen müssen die Programmierung beherrschen
  • Softwareentwickler:innen sollten die Grundlagen des Software-Testings beherrschen 
  • Gutes Know-how wird benötigt, um stabile, wartungsfreundliche und fokussierte Testfälle zu implementieren
  • Falsch eingesetzte automatisierte Testfälle kosten Ressourcen und bringt wenig Mehrwert 

Software-Tester:innen müssen die Programmierung beherrschen 

 

Die Software-Tester:innen beherrschen in der Regel das Handwerk des Software-Testings. Für den optimalen Einsatz der Testautomatisierung sind gute Kenntnisse im Software-Testing eine Voraussetzung. Des Weiteren sollten Software-Tester:innen die Fähigkeiten der Programmierung beherrschen. Dieses Wissen ist nicht immer gegeben und kann einen Nachteil beim Einsatz von Testautomatisierung darstellen. Zudem ist es immer von Vorteil, Wissen über die Architektur der Anwendung zu haben. Dieses Wissen fehlt vielen Software-Tester:innen.

Softwareentwickler:innen sollten die Grundlagen, des Software-Testings beherrschen 

 

Wie im vorherigen Abschnitt skizziert, ist bei Software-Tester:innen die Herausforderung, dass diese die Programmierung beherrschen und Wissen über die Architektur der Softwareanwendung haben sollten. Bei den Softwareentwickler:innen ist die Herausforderung, dass diese die Grundlagen des Software-Testings beherrschen sollten. Denn nur eine Kombination aus beidem bildet die Grundlage, um automatisierte Tests richtig einzusetzen. 

 

Gutes Know-how wird benötigt, um stabile, wartungsfreundliche und fokussierte Testfälle zu implementieren 

Stabil

Viele Softwareentwicklungsprojekte haben Schwierigkeiten stabile automatisierte Testfälle zu implementieren, sobald die Softwareanwendung skaliert. Gerade, wenn Testfälle implementiert werden, welche die ganze Softwareanwendung prüfen und über die Benutzerfläche ausgeführt werden. Testfälle, die nicht stabil sind, werden als Flaky-Testfälle bezeichnet. Diese schlagen aus unterschiedlichen Gründen fehl. Jedoch nicht, weil die Anwendung nicht dem Sollzustand entspricht. Der gerade beschriebene Fall stellt viele Softwareentwicklungsteams vor eine große Herausforderung und der Mehrwert der automatisierten Testfälle ist oft nicht gegeben.

 

Wartungsfreundlich 

 

Eine Software wächst in der Regel inkrementell. Ebenso wie die Testautomatisierung. Wichtig ist, dass sie so implementiert wird, dass auch bei Erweiterung und Änderung der Software kein großer Aufwand für die Wartung benötigt wird. Bei vielen Softwareentwicklungsprojekten nimmt der Wartungsaufwand der Testautomatisierung einen großen Ressourcenaufwand ein und es wird zum Teil mehr Aufwand für die Wartung beansprucht, als für die Implementierung neuer automatisierter Testfälle.

 

Fokussierte Testfälle 

 

Ein Testfall ist eine Frage, die der Anwendung gestellt wird. Je fokussierter und konkreter meine Frage, desto höher der Mehrwert. Es bringt keinen Mehrwert, wenn ich 1.000 automatisierte Testfälle habe, die mir dieselbe Information liefern. Um fokussierte Testfälle zu implementieren, benötigen die an der Implementierung beteiligten Personen, Wissen über die Architektur der Anwendung, der Geschäftsprozesse und gutes Know-How beim Software-Testing. Dies ist jedoch nicht immer gegeben. 

Falsch eingesetzte Testautomatisierung kostet Ressourcen und bringt wenig Mehrwert 

 

Der Einsatz von automatisierten Testfällen kostet Ressourcen. Die entscheidende Frage ist, wie groß der Mehrwert im Vergleich zu den eingesetzten Ressourcen ist. Wenn die nachstehenden Punkte nicht gegeben sind, ist der Mehrwert in der Regel sehr niedrig oder nicht vorhanden: 

 

  • Stabil
  • Wartungsfreundlich 
  • Fokussierte Testfälle 
  • Erweiterbar

Arten der Testautomatisierung 

 

Die Arten von automatisierten Testfällen gliedern sich in funktionale Tests und nicht-funktionale Tests. Zu den funktionalen Tests zählen unter anderem:

Funktionale Tests 

  • Unit-Tests 
  • Komponententests
  • Integrationstests
  • Funktionale UI-Tests
  • Systemtests
  • End-2-End-Testfälle 

 

Nicht-funktionale Tests 

  • Performance-Tests
  • Stress-Tests 
  • Load-Tests 
  • Visual-Tests
  • Security-Tests 

 

Wer sollte für die Testautomatisierung verantwortlich sein? 

 

In einem agilen Team sollte das ganze Team für die automatisierten Testfälle verantwortlich sein. Das heißt nicht, dass jede:r alle vorgestellten Arten der Testautomatisierung implementiert. Aber jede:r sollte mit seinen vorhandenen Fähigkeiten involviert sein und sich, falls notwendig, weitere Fähigkeiten aneignen, um das Team dabei zu unterstützen. Die Unit-Tests werden in der Regel von den Softwareentwickler:innen implementiert. Hier kann der/die Software-Tester:in jedoch mit dem Expertenwissen im Bereich des Software-Testings dazu beitragen, effizientere Testfälle zu implementieren. 

 

Dies hat unter anderem die nachstehenden Vorteile:

 

  • Der/die Software-Tester:in bekommt einen Überblick über die Testabdeckung auf Unit-Test-Ebene 
  • Der/die Software-Tester:in bekommt einen Überblick, aus welchen Einheiten die Anwendung aufgebaut ist. 
  • Der/die Software-Tester:in kann sein Expertenwissen mit dem Softwareentwickler teilen, um so effizientere Testfälle zu implementieren

 

Oft weiß ein/e Software-Tester:in gar nicht, was auf der Unit-Test-Ebene abgedeckt werden kann. Das hat oft zur Folge, dass die Risiken auf höherer Ebene abgedeckt werden oder sogar vergessen werden. Wenn die Software-Tester:innen und Softwareentwickler:innen ihr Wissen beim Pair Programming austauschen, kann dieses Risiko minimiert werden.  

 

Die Integrationstests werden je nach Team entweder von dem/der Softwareentwickler:in oder von dem/der Software-Tester:in implementiert. Falls der/die Softwareentwickler:in die Integrationstests implementiert, kann es vorkommen, dass der/die Software-Tester:in keinen Überblick über die Testabdeckung hat und so Risiken nicht abgedeckt sind. Des Weiteren kann es vorkommen, dass man die abgedeckten Risiken auf einer höheren Teststufe noch einmal abdeckt, die nicht optimal dafür geeignet sind.

End-2-End  

 

Diese werden oft von dem/der Software-Tester:in/Testautomatisierer:in implementiert. Hier ist es wichtig, dass die Softwareentwickler:innen die Fähigkeiten haben, die automatisierten Testfälle anzupassen. Dies kann den Prozess enorm beschleunigen, wenn die Testfälle fehlschlagen und die Softwareentwickler:innen selbst identifizieren können, woran es liegt und bei Bedarf die Testfälle anpassen. 

Testautomatisierung lernen

 

Um die Testautomatisierung zu lernen, solltest du die nachstehenden Themen meistern: 

 

  • Programmierung 
  • Software-Testing 
  • Design Patterns 
  • Testautomatisierungstools 
  • Softwareentwicklung

 

Programmierung 

 

Gute Testautomatisierer:innen haben gute Fähigkeiten in der Programmierung. Bei der Programmierung ist es wichtig, dass du die Konzepte dahinter verstehst und nicht nur eine bestimmte Programmiersprache lernst. Wenn du die Konzepte der Programmierung wirklich verstanden hast, dann ist es für dich einfach, neue Programmiersprachen zu lernen. Denn als Testautomatisierer:in wirst du in verschiedenen Softwareentwicklungsprojekten unterschiedliche Programmiersprachen einsetzen.  

 

Software-Testing 

 

Als Testautomatisierer:in solltest du auch gute Skills im Software-Testing haben. Denn du solltest entscheiden können, welche Testfälle und auf welcher Teststufe diese automatisiert werden sollen. Dazu musst du wissen, welche Testfälle sich eher für eine manuelle und eine automatisierte Ausführung eignen. Überdies solltest du auch die unterschiedlichen Testentwurfsverfahren beherrschen, um mit einer effektiven Auswahl von Testfällen eine hohe Testabdeckung zu erreichen.  

 

Design Patterns 

 

Um effiziente Testautomatisierungslösungen zu implementieren, benötigst du Wissen über Design Patterns. Design Patterns, im Deutschen auch Entwurfsmuster genannt, können uns dabei unterstützen, Testautomatisierungslösungen zu implementieren, die: 

 

  • Wartungsfreundlich sind
  • Wiederverwendbar sind
  • Erweiterbar sind

Testautomatisierungstools 

 

Es gibt eine sehr große Anzahl an Testautomatisierungstool für die unterschiedlichen Softwareanwendungen. 

Beispielsweise: 

 

  • Webanwendungen 
  • Mobile Anwendungen 
  • Desktopanwendungen 
  • APIs

 

Als Testautomatisierer:in solltest du unterschiedliche Tools kennen. Du solltest wissen, was die einzelnen Vor- und Nachteile der einzelnen Tools sind und in welchem Kontext du welches Tool einsetzen solltest. In der Regel spezialisierst du dich auf Webanwendungen oder mobile Anwendungen und lernst in diesem Bereich die unterschiedlichen Testautomatisierungstools kennen. Nachstehend findest du Tools, die oft in unterschiedlichen Softwareentwicklungsprojekten eingesetzt werden. 

 

Testautomatisierungstools – Webanwendungen 

 

Für Webanwendungen gibt es eine große Anzahl an Open Source-Lösungen, die in vielen Projekten eingesetzt werden. Die am meisten eingesetzten Open Source-Testautomatisierungstools sind hier: 

 

  • Selenium 
  • Cypress 
  • Playwright 
  • Robot Framework

 

Testautomatisierungstools – Mobile Anwendungen 

 

Bei den mobilen Anwendungen gibt es sowohl Open Source-Lösungen als auch kommerzielle Lösungen. Zu den Open Source-Lösungen gehören: 

 

  • Appium 
  • Espresso 
  • XCUITest
  • Katalon Studio

 

Softwareentwicklung 

 

Gute Testautomatisierer:innen sollten Wissen über die Architektur der Softwareanwendung haben. Sie sollten wissen, aus welchen Komponenten die Anwendung besteht und welche Schnittstellen zu den Komponenten und externen Systemen bestehen. Dieses Wissen können sie nutzen, um Risiken zu identifizieren und einen Plan zu erstellen, auf welchen Teststufen sie mit automatisierten Testfällen die Risiken minimieren können. 

 

Zusammenfassung 

Testautomatisierung ist in der agilen Softwareentwicklung nicht mehr wegzudenken. Richtig eingesetzte automatisierte Testfälle können in Softwareentwicklungsprojekten einen großen Mehrwert bieten. Der/die Testautomatisierer:in sollte nicht nur Fähigkeiten in der Programmierung haben, sondern auch gute Software-Testing-Skills, um zu entscheiden, wie er/sie mit effizienten automatisierten Testfällen eine hohe Testabdeckung erreichen kann. Es gibt nicht das beste Testautomatisierungstool, sondern das Tool sollte je nach Kontext gewählt werden. 

 

Oliver Jaworski

Oliver Jaworski

Software Test Engineer Qcademy (UG) haftungsbeschränkt

Oliver Jaworski wurde von seinem Bruder mit der Leidenschaft für das Software Testing angesteckt. Am Software Testing begeistert ihn, dass er kontinuierlich Neues lernen kann und sich mit modernen Technologien auseinandersetzen kann.

In dem nachstehenden Artikel werden wir für den Quereinstieg in die IT empfohlen: zum Artikel