Die Druckversion wird nicht mehr unterstützt und kann Darstellungsfehler aufweisen. Bitte aktualisiere deine Browser-Lesezeichen und verwende stattdessen die Standard-Druckfunktion des Browsers.

aiMOOC

Anwendungsentwicklung und Softwarequalität – Testebenen für Software planen

QR-Code

Einleitung

Anwendungsentwicklung und Softwarequalität – Testebenen für Software planen

Zielgruppe: Fachinformatikerinnen und Fachinformatiker für Anwendungsentwicklung in der Ausbildung.

Dauer: Etwa 90–120 Minuten in kurzen Lerneinheiten.

Ausbildungsfall: Du entwickelst und testest eine kleine Bestell-App für einen fiktiven Schulkiosk.

Deine Mission: Plane und erprobe Einheitstests, Integrationstests und vollständige Nutzungsfalltests.

Die Testpyramide zeigt ein mögliches Verhältnis zwischen Unit-, Integrations- und End-to-End-Tests. Grafik: Abbe98, CC BY-SA 4.0, Wikimedia Commons.

Sicherheitsregel: Alle Programmierexperimente laufen ausschließlich lokal mit erfundenen Daten. Keine fremden Systeme, Produktivanlagen, Kundeninformationen, Zugangsdaten oder Netzwerkdienste verwenden. Die Aufgaben benötigen weder einen Server noch einen Internetzugang.

Datenschutzhinweis: Eingebundene YouTube-, Wikipedia- und LearningApps-Angebote sind externe Medien. Beim Laden können Verbindungsdaten an die jeweiligen Anbieter gelangen. Nutze diese Angebote nur im Rahmen der Freigaben Deiner Bildungseinrichtung. Für die praktischen Softwaretests wird keine Verbindung zu ihnen benötigt.

Lernziele

Nach dem Kurs kannst Du:

Teststufen unterscheiden und fachlich korrekt benennen.
Einen Testplan aus Anforderungen und Risiken ableiten.
Einen isolierten Unit-Test programmieren.
Das Zusammenspiel von Komponenten prüfen.
Einen vollständigen Nutzungsfall mit erwarteten Ergebnissen beschreiben.
Testresultate interpretieren und Verbesserungen begründen.

Lerneinheit 1: Der Ausbildungsfall

Zeit: 10 Minuten

Dein Ausbildungsbetrieb entwickelt die fiktive App PausenKiosk.

Eine Person bestellt Brötchen. Das Programm berechnet den Preis, prüft den Lagerbestand und bestätigt oder verweigert den Kauf.

Anforderung	Fachliche Regel
R1: Preisberechnung	Ein Brötchen kostet 250 Cent. Zwei Brötchen kosten 500 Cent.
R2: Lagerprüfung	Eine Bestellung darf den Lagerbestand nicht unterschreiten.
R3: Bestellablauf	Eine erfolgreiche Bestellung vermindert den Bestand und liefert den korrekten Gesamtpreis.
R4: Fehlerbehandlung	Mengen kleiner oder gleich null sowie ungültige Preise werden zurückgewiesen.

Dein Testauftrag: Wie überprüfst Du diese Anforderungen mit möglichst schnellen, aussagekräftigen Tests?

Drei Blickrichtungen auf dieselbe Software

Blickrichtung	Prüffrage	Beispiel
Einheitstest	Ist die einzelne Funktion richtig?	Zwei Brötchen kosten 500 Cent.
Integrationstest	Arbeiten die Komponenten zusammen?	Preisberechnung und Lagerreservierung liefern einen konsistenten Bestellzustand.
Nutzungsfalltest	Funktioniert ein Ablauf aus Anwendersicht?	Kaufen, erneut bestellen, Ablehnung erhalten und Restbestand prüfen.

Wichtige fachliche Unterscheidung: Nach dem ISTQB-Lehrplan gehören Komponenten-, Komponentenintegrations-, System-, Systemintegrations- und Abnahmetests zu den Teststufen. Ein Nutzungsfalltest ist dagegen keine zusätzliche formale Teststufe, sondern eine szenariobasierte Testperspektive. Ein vollständiger Nutzungsfall kann beispielsweise im Systemtest oder Abnahmetest überprüft werden.

Video: Lucas Paganini – Static, Unit, Integration, and End-to-End Tests Explained. Englisch, mit praktischen Beispielen. Vertiefung: Welche Fehler erkennt jede Testperspektive?

Lerneinheit 2: Einheitstest

Zeit: 15 Minuten

Ein Einheitstest prüft eine kleine, klar abgegrenzte Funktion. Andere Komponenten werden dafür möglichst nicht benötigt.

Unser Testobjekt heißt positionswert.

def positionswert(preis_cent, anzahl):
    if preis_cent <= 0 or anzahl <= 0:
        raise ValueError("Ungueltiger Wert")
    return preis_cent * anzahl

Testidee: Die Eingaben 250 und 2 müssen das Ergebnis 500 ergeben.

Testeingabe	Erwartung
Preis 250, Menge 2	Ergebnis 500 Cent
Preis 250, Menge 0	ValueError
Preis -1, Menge 1	ValueError

Merksatz: Ein guter Einheitstest ist nachvollziehbar, wiederholbar und weitgehend unabhängig von anderen Teilen der Anwendung.

Abbildung zum Test-driven Development. Grafik: Kristijan Kralj, CC0, Wikimedia Commons. Testgetriebene Entwicklung ist eine mögliche, aber nicht die einzige Vorgehensweise für Einheitstests.

Video: Corey Schafer – Python Tutorial: Unit Testing Your Code with the unittest Module. Englisch. Beobachte insbesondere Testmethoden und Assertions.

Basisaufgabe: Erkläre, weshalb ein Preisberechnungstest keinen echten Lagerdienst benötigt.

Feedback: Die Funktion berechnet nur einen Wert aus Eingaben. Ein Lagerdienst würde eine zusätzliche Abhängigkeit erzeugen und die Fehlersuche unnötig erschweren.

Lerneinheit 3: Integrationstest

Zeit: 15 Minuten

Ein Integrationstest prüft die Zusammenarbeit von Komponenten und ihre Schnittstellen.

Für PausenKiosk arbeiten die Funktionen positionswert, bestellen und die Klasse Lager zusammen.

Eingabe: 2 Broetchen
        |
        v
Preisfunktion -> 500 Cent
        |
        v
Lager -> reserviert 2 von 3
        |
        v
Antwort: bestaetigt
Restbestand: 1

Testfrage: Wird ein richtiger Preis berechnet und gleichzeitig der Lagerbestand korrekt verändert?

Das V-Modell veranschaulicht Beziehungen zwischen Entwicklungsaktivitäten und Teststufen. Grafik: Michael Pätzold und S. Seyfert, CC BY-SA 3.0, Wikimedia Commons.

Praxisentscheidung: Im Beispiel werden echte lokale Python-Komponenten miteinander verbunden. Es werden keine externen Schnittstellen kontaktiert.

Anwendungsaufgabe: Ein Test prüft nur den richtigen Kaufpreis, aber nicht die Lageränderung. Warum ist der Integrationstest unvollständig?

Feedback: Die Schnittstelle kann den Preis korrekt liefern und trotzdem den Bestand falsch verwalten. Beide Auswirkungen gehören zum erwarteten Verhalten und müssen überprüft werden.

Lerneinheit 4: Nutzungsfalltest

Zeit: 15 Minuten

Ein Nutzungsfall beschreibt, was eine Person mit einer Software erreichen möchte.

Nutzungsfall: Brötchen einkaufen

Startbestand: drei Brötchen.
Die Person bestellt zwei Brötchen.
Das System bestätigt 500 Cent; ein Brötchen bleibt übrig.
Eine weitere Bestellung von zwei Brötchen wird abgelehnt.
Anschließend kann das letzte Brötchen bestellt werden.

Beispiel eines allgemeinen UML-Anwendungsfalldiagramms, nicht die konkrete PausenKiosk-App. Grafik: Slashme, CC BY-SA 4.0, Wikimedia Commons.

Prüfkriterien: Reihenfolge, Rückmeldungen, Preis und verbleibender Bestand.

Fachliche Grenze: Unser Konsolenbeispiel testet einen vollständigen fachlichen Ablauf durch lokale Funktionen. Es simuliert keinen Webbrowser, kein Bezahlsystem und keine echte Benutzeroberfläche. Ein realer End-to-End-Test einer größeren Anwendung würde gegebenenfalls weitere Komponenten benötigen.

Video: Software Testing Mentor – Types of Software Testing. Englisch. Vergleiche Komponenten-, Integrations-, System- und Abnahmetests.

Lerneinheit 5: Dein lokales Python-Testlabor

Zeit: 20–30 Minuten

Du brauchst Python 3 und einen lokalen Texteditor. Das Programm verwendet ausschließlich die Python-Standardbibliothek und verarbeitet nur selbst erzeugte Beispieldaten im Arbeitsspeicher.

Anleitung:

Erstelle lokal einen Ordner mit dem Namen pausenkiosk.
Speichere den folgenden vollständigen Code als bestelltests.py.
Starte im Ordner python bestelltests.py oder, je nach Installation, python3 bestelltests.py.
Starte die interaktive Sandbox mit python bestelltests.py demo.
Unter Windows kann stattdessen der Befehl py bestelltests.py verwendet werden.

Vollständiges Beispiel: sieben automatisierte Tests und eine lokale Sandbox

import sys
import unittest

# Fachlogik
def positionswert(preis_cent, anzahl):
    if preis_cent <= 0 or anzahl <= 0:
        raise ValueError("Ungueltiger Wert")
    return preis_cent * anzahl

class Lager:
    def __init__(self, bestand):
        if bestand < 0:
            raise ValueError("Ungueltiger Bestand")
        self.bestand = bestand

    def reservieren(self, anzahl):
        if anzahl <= 0:
            raise ValueError("Ungueltige Menge")
        if anzahl > self.bestand:
            return False
        self.bestand -= anzahl
        return True

def bestellen(lager, anzahl, preis_cent=250):
    betrag = positionswert(preis_cent, anzahl)
    if not lager.reservieren(anzahl):
        return ("abgelehnt", 0)
    return ("bestaetigt", betrag)

# Einheitstests
class Einheitstests(unittest.TestCase):
    def test_zwei_broetchen(self):
        self.assertEqual(positionswert(250, 2), 500)

    def test_nullmenge(self):
        with self.assertRaises(ValueError):
            positionswert(250, 0)

    def test_negativer_preis(self):
        with self.assertRaises(ValueError):
            positionswert(-1, 1)

# Integrationstests
class Integrationstests(unittest.TestCase):
    def test_reservierung_und_preis(self):
        lager = Lager(3)
        self.assertEqual(
            bestellen(lager, 2),
            ("bestaetigt", 500)
        )
        self.assertEqual(lager.bestand, 1)

    def test_ablehnung_ohne_bestandsverlust(self):
        lager = Lager(1)
        self.assertEqual(
            bestellen(lager, 2),
            ("abgelehnt", 0)
        )
        self.assertEqual(lager.bestand, 1)

# Nutzungsfalltests
class Nutzungsfalltests(unittest.TestCase):
    def test_einkauf_in_schritten(self):
        lager = Lager(3)
        self.assertEqual(
            bestellen(lager, 2),
            ("bestaetigt", 500)
        )
        self.assertEqual(
            bestellen(lager, 2),
            ("abgelehnt", 0)
        )
        self.assertEqual(
            bestellen(lager, 1),
            ("bestaetigt", 250)
        )
        self.assertEqual(lager.bestand, 0)

    def test_ausverkauft(self):
        lager = Lager(0)
        self.assertEqual(
            bestellen(lager, 1),
            ("abgelehnt", 0)
        )
        self.assertEqual(lager.bestand, 0)

# Isolierte interaktive Testumgebung
def sandbox():
    lager = Lager(3)
    print("Lokale Demo: Broetchen 250 Cent")
    print("Startbestand:", lager.bestand)
    while True:
        eingabe = input("Menge oder q: ").strip()
        if eingabe.lower() == "q":
            break
        try:
            menge = int(eingabe)
            print(
                "Ergebnis:", bestellen(lager, menge),
                "Restbestand:", lager.bestand
            )
        except ValueError:
            print("Bitte eine positive ganze Zahl eingeben.")

if __name__ == "__main__":
    if len(sys.argv) == 2 and sys.argv[1] == "demo":
        sandbox()
    else:
        unittest.main(verbosity=2)

Die Sandbox ist isoliert: Kein Netzwerkzugriff, keine Datenbank und keine Verbindung zu anderen Anwendungen. Nach einem Neustart beginnt der fiktive Lagerbestand wieder bei drei.

Experiment A: Alle Tests starten

Führe python bestelltests.py aus.

Erwartung: Sieben Tests werden ausgeführt, alle erfolgreich. In der Zusammenfassung erscheint Ran 7 tests und OK.

Testgruppe	Anzahl	Darstellung
Einheitstest	3	🟩🟩🟩
Integrationstest	2	🟩🟩
Nutzungsfalltest	2	🟩🟩
Gesamt	7	7 erfolgreiche Tests

Diese Zahlen gelten nur für das bereitgestellte Beispiel. Die Anzahl erfolgreicher Tests ist weder eine Codeabdeckungsquote noch ein Beweis für vollständige Fehlerfreiheit.

Experiment B: Interaktive Sandbox

Führe python bestelltests.py demo aus.

Gib nacheinander 2, 2, 1 und q ein.

Eingabe	Erwartete Antwort	Restbestand
2	bestaetigt, 500 Cent	1
2	abgelehnt, 0 Cent	1
1	bestaetigt, 250 Cent	0
q	Simulation beendet	Keine weitere Bestellung

Feedback: Eine fehlgeschlagene Reservierung verändert den Bestand nicht. Das verhindert, dass nicht vorhandene Ware verkauft wird.

Experiment C: Fehler gezielt erkennen

Ersetze nur in Deiner lokalen Kopie die Zeile

return preis_cent * anzahl

durch

return preis_cent + anzahl

Starte anschließend alle sieben Tests erneut.

Codeversion	Erfolgreich	Fehlgeschlagen	Testbild
Original	7	0	🟩🟩🟩🟩🟩🟩🟩
Absichtlich veränderte Berechnung	4	3	🟩🟩🟩🟩🟥🟥🟥

Legende: Grün bedeutet bestandener Test, Rot fehlgeschlagener Test. Die Ergebnisse beziehen sich auf die unveränderte Testsuite.

Begründetes Feedback: Der direkte Preis-Einheitstest erkennt die falsche Rechenoperation. Ein Integrationstest und ein Nutzungsfalltest erkennen ebenfalls einen falschen Betrag. Andere Tests bleiben grün, weil ihre überprüften Eigenschaften durch diese Änderung nicht verletzt werden.

Stelle danach die Multiplikation wieder her und überprüfe erneut alle Tests. Dies ist ein einfaches Beispiel für einen Regressionstest.

Gestufte Hilfen

Stufe	Hilfe
Hilfe 1: Denkfrage	Welcher Eingabewert ist für den Fehler besonders aussagekräftig?
Hilfe 2: Testentwurf	Vergleiche für Menge 2 die erwarteten 500 Cent mit dem tatsächlich berechneten Ergebnis.
Hilfe 3: Diagnose	Bei einer Addition ergeben 250 und 2 den Wert 252 statt 500. Prüfe die Berechnungsoperation.

Lernregel: Nutze zunächst Hilfe 1. Hilfe 2 und Hilfe 3 sind für den Fall gedacht, dass Du selbst noch nicht weiterkommst.

Lerneinheit 6: Einen Testplan erstellen

Zeit: 10 Minuten

Ein Testplan verbindet Anforderungen, Testobjekte, Daten und erwartete Ergebnisse.

ID	Anforderung	Testebene oder Perspektive	Testfall	Erwartung
T1	R1	Einheit	Zwei Brötchen berechnen	500 Cent
T2	R4	Einheit	Menge null übergeben	ValueError
T3	R2	Integration	Zwei Brötchen bei Bestand eins	Ablehnung, Bestand unverändert
T4	R3	Integration	Zwei Brötchen bei Bestand drei	500 Cent, Bestand eins
T5	R2 und R3	Nutzungsfall	Mengenfolge zwei, zwei, eins	Bestätigung, Ablehnung, Bestätigung; Bestand null

Qualitätsfrage: Welche Anforderungen wurden geprüft und welche könnten noch zusätzliche Tests benötigen?

Beachte insbesondere fehlende Testfälle, Änderungen an Preisen, größere Bestellmengen und unzulässige Eingabedatentypen. Das vereinfachte Ausbildungsprogramm ist keine vollständige Produktionsanwendung.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Welcher Test prüft eine einzelne Funktion möglichst isoliert? (Einheitstest) (!Systemintegrationstest) (!Nutzungsfalltest) (!Abnahmetest)

Was ist das hauptsächliche Ziel eines Integrationstests? (Das Zusammenspiel von Komponenten prüfen) (!Nur die Gestaltung einer Benutzeroberfläche bewerten) (!Den gesamten Quellcode automatisch verbessern) (!Eine Benutzerbefragung durchführen)

Welche Aussage zu einem Nutzungsfalltest ist fachlich richtig? (Er prüft einen Ablauf aus Anwendersicht) (!Er ist immer eine eigenständige formale Teststufe) (!Er darf keine Fehlerfälle berücksichtigen) (!Er überprüft nur einzelne Variablen)

Welches Ergebnis liefern zwei Brötchen zu jeweils 250 Cent? (500 Cent) (!252 Cent) (!125 Cent) (!750 Cent)

Was muss bei einer Bestellung über dem vorhandenen Lagerbestand passieren? (Die Bestellung wird abgelehnt und der Bestand bleibt unverändert) (!Der Lagerbestand wird negativ) (!Die Bestellung wird trotzdem bestätigt) (!Der Lagerbestand wird automatisch verdoppelt)

Wofür wird assertRaises bei Python unittest verwendet? (Zum Prüfen einer erwarteten Ausnahme) (!Zum Starten eines Webservers) (!Zum dauerhaften Speichern von Kundendaten) (!Zum Ändern des Betriebssystems)

Welche Testumgebung ist für diesen Ausbildungskurs vorgesehen? (Eine lokale Sandbox mit fiktiven Daten) (!Eine fremde Produktionsdatenbank) (!Ein öffentlich erreichbarer Unternehmensserver ohne Freigabe) (!Ein unbekannter Internetdienst mit echten Kundendaten)

Wann ist ein Regressionstest besonders sinnvoll? (Nach einer Änderung an der Software) (!Nur vor dem ersten Schreiben von Quellcode) (!Ausschließlich vor der Projektidee) (!Nur wenn keinerlei Testfälle existieren)

Was zeigt ein erfolgreicher Lauf aller sieben Beispieltests? (Die sieben überprüften Fälle haben bestanden) (!Das Programm kann keine weiteren Fehler besitzen) (!Alle Qualitätsanforderungen sind vollständig erfüllt) (!Ein Abnahmetest ist grundsätzlich unnötig)

Welche Aussage beschreibt ein geeignetes Testorakel? (Es legt fest welches Ergebnis erwartet wird) (!Es ersetzt automatisch jede Anforderung) (!Es verhindert jede spätere Programmänderung) (!Es führt alle Tests ohne Programmcode aus)

Memory

Finde die passenden Fachbegriffe und Bedeutungen.

Einheitstest	Isolierte Prüfung einer kleinen Codeeinheit
Integrationstest	Prüfung des Zusammenspiels mehrerer Komponenten
Nutzungsfalltest	Prüfung eines fachlichen Anwenderablaufs
Testorakel	Festlegung des erwarteten Ergebnisses
Testdaten	Vorgegebene Werte für einen Testfall
Regressionstest	Erneute Prüfung nach einer Softwareänderung
Sandbox	Abgegrenzte Umgebung für sichere Experimente

Drag and Drop

Ordne den Fachbegriffen ihre jeweilige Aufgabe zu.

Ordne die richtigen Begriffe zu.	Aufgabe
Einheitstest	Eine einzelne Berechnungsfunktion isoliert kontrollieren
Integrationstest	Preisberechnung und Lagerreservierung gemeinsam prüfen
Nutzungsfalltest	Den vollständigen Ablauf einer fiktiven Bestellung verfolgen
Negativtest	Eine Bestellung mit unzulässiger Menge zurückweisen
Regressionstest	Nach einer Fehlerkorrektur vorherige Testfälle wiederholen
Testorakel	Erwartete Ausgabe und erwarteten Zustand festlegen

Kreuzworträtsel

Modultest	Wie heißt ein Test für eine einzelne abgegrenzte Programmeinheit?
Integration	Wie heißt das Zusammenführen von Komponenten zur gemeinsamen Nutzung?
Nutzungsfall	Wie heißt ein fachlicher Ablauf aus Anwendersicht?
Testorakel	Wie heißt die Grundlage für die erwartete Testentscheidung?
Regression	Wie heißt die Prüfung gegen unerwünschte Auswirkungen einer Änderung?
Sandbox	Wie heißt eine abgegrenzte Umgebung für sichere Experimente?

LearningApps

Hier kannst Du nach ergänzenden Übungen zum Kursthema suchen. Externe Aktivitäten nur nach Freigabe öffnen; keine echten Betriebsdaten verwenden.

Lückentext

Eine kleine, möglichst isolierte Softwareeinheit überprüfst Du mit einem

.

Die Zusammenarbeit von Komponenten wird durch einen

untersucht.

Ein vollständiger Ablauf aus Anwendersicht heißt

.

Im PausenKiosk kostet ein Brötchen 250

.

Der noch verfügbare Warenvorrat heißt

.

Bei einer ungültigen Menge löst das Beispiel eine

aus.

Die Python-Standardbibliothek enthält das Testframework

.

Die Methode zur Überprüfung von Gleichheit heißt

.

Eine wiederholte Prüfung nach Codeänderungen ist ein

.

Die Festlegung der erwarteten Ergebnisse wird als

bezeichnet.

Eine getrennte Umgebung für gefahrlose Experimente heißt

.

Ein erfolgreich abgeschlossener Test beweist nicht die vollständige

.

Offene Aufgaben

Bearbeite die Aufgaben in Deinem Tempo. Die Niveaustufen entsprechen Basis (Leicht), Anwendung (Standard) und Transfer (Schwer).

Leicht

Testpyramide zeichnen: Gestalte eine beschriftete Testpyramide mit Einheitstest, Integrationstest und End-to-End-Test. Erkläre ihre Aussage und eine Grenze der Darstellung.
Testfälle beschreiben: Formuliere drei Eingaben und ihre erwarteten Ausgaben für die Preisfunktion.
Tests untersuchen: Markiere im Python-Beispiel die drei Testgruppen und erläutere ihre unterschiedlichen Ziele.
Sandbox erproben: Probiere die Mengen eins, drei und vier lokal aus. Halte für jeden Versuch die Antwort und den Restbestand fest.

Feedback zur Basisstufe: Entscheidend sind richtige Zuordnungen und überprüfbare Erwartungen. Aussagen wie „funktioniert“ reichen ohne konkrete Sollwerte nicht aus.

Standard

Grenzwerttests entwerfen: Ergänze Tests für die Mengen null, eins, drei und vier. Begründe, warum gerade diese Werte wichtig sind.
Fehlerexperiment dokumentieren: Ersetze lokal die Multiplikation durch eine Addition. Erstelle eine Tabelle mit fehlgeschlagenen Tests, Ursache und Korrektur.
Testplan erweitern: Erstelle eine Anforderungs-Test-Matrix. Ergänze zu jedem Testobjekt Eingabe, erwartete Ausgabe und erwartete Zustandsänderung.
Lernvideo erstellen: Produziere ein kurzes Video Deiner lokalen Sandbox mit einer erfolgreichen und einer abgelehnten fiktiven Bestellung. Zeige ausschließlich Demo-Daten.

Feedback zur Anwendungsstufe: Ein vollständiger Testfall dokumentiert Ausgangszustand, Handlung und erwartetes Ergebnis. Eine nachvollziehbare Fehlerursache ist wertvoller als die bloße Feststellung eines Fehlers.

Schwer

Risikobasierte Teststrategie: Du hast nur zehn Minuten Testzeit. Begründe, welche Tests Du zuerst ausführst und welche Risiken dadurch noch nicht abgedeckt sind.
Externe Zahlung simulieren: Entwirf einen lokalen Speicher-Dummy für eine fiktive Bezahlbestätigung. Beschreibe, wie er in einem Integrationstest eingesetzt werden könnte, ohne einen Zahlungsdienst aufzurufen.
Neue Geschäftsregel: Erweitere eine lokale Kopie des Programms um einen selbst festgelegten Mengenrabatt. Formuliere neue Tests und erkläre, welche bisherigen Tests wegen der Regeländerung angepasst werden müssen.
Testkonzept verteidigen: Erstelle ein kurzes Testkonzept und präsentiere es einem Lernpartner. Begründe Teststufen, Daten, Zuständigkeiten, Risiken und Freigabekriterien. Überarbeite es nach dem Feedback.

Feedback zur Transferstufe: Gute Lösungen machen Annahmen transparent, priorisieren Risiken und erklären die Grenzen der eigenen Tests. Eine größere Testanzahl ist nicht automatisch eine bessere Teststrategie.

Lernkontrolle

Bearbeite mindestens fünf der folgenden Aufgaben schriftlich und begründe Deine Entscheidungen.

Fehlerlokalisierung: Alle Einheitstests sind erfolgreich, aber die Bestandsänderung ist falsch. Welche Testperspektive hilft Dir bei der Eingrenzung? Begründe die Wahl.
Änderungsfolgenanalyse: Der Stückpreis erhöht sich von 250 auf 300 Cent. Welche Tests müssen angepasst werden und welche unverändert bleiben? Unterscheide fachliche Änderungen von Fehlern.
Testfallentwurf: Eine Person möchte vier Brötchen kaufen, obwohl nur drei vorhanden sind. Entwirf einen Test mit Ausgangszustand, Eingabe und erwartetem Zustand.
Testpriorisierung: Ein Team kann vor einer Vorführung nur zwei Tests durchführen. Begründe anhand des Risikos, welche Tests Du auswählen würdest.
Testumgebung: Ein Teammitglied möchte statt der Sandbox eine echte Produktivdatenbank verwenden. Entwickle eine sichere Alternative und begründe Deine Entscheidung.
Qualitätsurteil: Sieben automatisierte Tests sind grün. Erkläre, weshalb dennoch weitere Prüfungen nötig sein können und welches zusätzliche Testziel Du vorschlägst.

Beurteilung: Achte auf fachlich korrekte Begriffe, begründete Entscheidungen, erkennbare Zusammenhänge und praktikable sichere Lösungen.

Lernnachweis

Zum Abschluss reichst Du ein kleines Testportfolio ein.

Es enthält:

Einen Testplan mit Anforderungen und zugeordneten Testfällen.
Eine Beschreibung der Unterschiede zwischen Einheitstest, Integrationstest und Nutzungsfallprüfung.
Den lokal ausführbaren Python-Code mit mindestens sieben dokumentierten Tests.
Ein Testprotokoll mit Eingabe, Sollwert, Istwert und Ergebnis.
Eine Fehleranalyse des absichtlich veränderten Programms.
Eine Begründung der Testpriorisierung und der Grenzen Deiner Testabdeckung.
Eine Erklärung Deiner Maßnahmen zur Datensicherheit und Isolation.

Bewertungskriterium	Gewichtung
Fachliche Zuordnung der Tests	20 %
Ausführbarkeit und Qualität der Testfälle	30 %
Nachvollziehbarkeit von Ergebnissen und Fehleranalyse	25 %
Begründete Transferleistung	15 %
Dokumentation und sicheres Arbeiten	10 %

Erfolgsmerkmal: Du kannst nicht nur Tests ausführen, sondern begründen, was ein Test überprüft, welche Aussage sein Ergebnis erlaubt und welche Risiken offenbleiben.