Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-10-09T19:20:32Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}

{{BR}}
= 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 [[Einheitstest|Einheitstests]], [[Integrationstest|Integrationstests]] und vollständige [[Anwendungsfall|Nutzungsfalltests]].

[[Datei:Testing Pyramid.svg|500px|rahmenlos|center]]

''Die Testpyramide zeigt ein mögliches Verhältnis zwischen Unit-, Integrations- und End-to-End-Tests. Grafik: Abbe98, CC BY-SA 4.0, [https://commons.wikimedia.org/wiki/File:Testing_Pyramid.svg 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.

{{BR}}
== Lernziele ==

Nach dem Kurs kannst Du:
# [[Teststufe|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.

{{BR}}
= 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.

{| class="wikitable"
! 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?

{{BR}}
== Drei Blickrichtungen auf dieselbe Software ==

{| class="wikitable"
! 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.

{{#ev:youtube| https://www.youtube.com/watch?v=TLccnKIMggA |500|center}}

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

{{BR}}
= Lerneinheit 2: Einheitstest =

'''Zeit: 15 Minuten'''

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

Unser Testobjekt heißt <code>positionswert</code>.

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

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

{| class="wikitable"
! 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.

[[Datei:Tdd-abstract.png|500px|rahmenlos|center]]

''Abbildung zum [[Testgetriebene Entwicklung|Test-driven Development]]. Grafik: Kristijan Kralj, CC0, [https://commons.wikimedia.org/wiki/File:Tdd-abstract.png Wikimedia Commons]. Testgetriebene Entwicklung ist eine mögliche, aber nicht die einzige Vorgehensweise für Einheitstests.''

{{#ev:youtube| https://www.youtube.com/watch?v=6tNS--WetLI |500|center}}

''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.

{{BR}}
= Lerneinheit 3: Integrationstest =

'''Zeit: 15 Minuten'''

Ein [[Integrationstest]] prüft die Zusammenarbeit von Komponenten und ihre [[Schnittstelle|Schnittstellen]].

Für PausenKiosk arbeiten die Funktionen <code>positionswert</code>, <code>bestellen</code> und die Klasse <code>Lager</code> zusammen.

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

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

[[Datei:V-Modell.svg|500px|rahmenlos|center]]

''Das V-Modell veranschaulicht Beziehungen zwischen Entwicklungsaktivitäten und Teststufen. Grafik: Michael Pätzold und S. Seyfert, CC BY-SA 3.0, [https://commons.wikimedia.org/wiki/File:V-Modell.svg 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.

{{BR}}
= Lerneinheit 4: Nutzungsfalltest =

'''Zeit: 15 Minuten'''

Ein [[Anwendungsfall|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.

[[Datei:UML Use Case diagram.svg|500px|rahmenlos|center]]

''Beispiel eines allgemeinen [[UML]]-Anwendungsfalldiagramms, nicht die konkrete PausenKiosk-App. Grafik: Slashme, CC BY-SA 4.0, [https://commons.wikimedia.org/wiki/File:UML_Use_Case_diagram.svg 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.

{{#ev:youtube| https://www.youtube.com/watch?v=YdZ-sduNb48 |500|center}}

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

{{BR}}
= 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 <code>pausenkiosk</code>.
# Speichere den folgenden vollständigen Code als <code>bestelltests.py</code>.
# Starte im Ordner <code>python bestelltests.py</code> oder, je nach Installation, <code>python3 bestelltests.py</code>.
# Starte die interaktive Sandbox mit <code>python bestelltests.py demo</code>.
# Unter Windows kann stattdessen der Befehl <code>py bestelltests.py</code> verwendet werden.

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

<pre>
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)
</pre>

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

{{BR}}
== Experiment A: Alle Tests starten ==

Führe <code>python bestelltests.py</code> aus.

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

{| class="wikitable"
! 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.

{{BR}}
== Experiment B: Interaktive Sandbox ==

Führe <code>python bestelltests.py demo</code> aus.

Gib nacheinander <code>2</code>, <code>2</code>, <code>1</code> und <code>q</code> ein.

{| class="wikitable"
! 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.

{{BR}}
== Experiment C: Fehler gezielt erkennen ==

Ersetze '''nur in Deiner lokalen Kopie''' die Zeile

<pre>
return preis_cent * anzahl
</pre>

durch

<pre>
return preis_cent + anzahl
</pre>

Starte anschließend alle sieben Tests erneut.

{| class="wikitable"
! 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]].

{{BR}}
== Gestufte Hilfen ==

{| class="wikitable"
! 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.

{{BR}}
= Lerneinheit 6: Einen Testplan erstellen =

'''Zeit: 10 Minuten'''

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

{| class="wikitable"
! 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.

{{BR}}
= Interaktive Aufgaben =

{{BR}}
== Quiz: Teste Dein Wissen ==

{{MC}}

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

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

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

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{MC}}

'''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)

{{E}}
<br>

{{BR}}
== Memory ==

Finde die passenden Fachbegriffe und Bedeutungen.

<div class="memo-quiz">
{|
|-
| 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
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

Ordne den Fachbegriffen ihre jeweilige Aufgabe zu.

<div class="lueckentext-quiz">

{| class="wikitable"
! 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
|}

{{E}}
<br>

{{BR}}
== Kreuzworträtsel ==

<div class="kreuzwort-quiz">
{|
|-
| 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?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

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

<iframe> https://learningapps.org/index.php?s=Anwendungsentwicklung+und+Softwarequalit%C3%A4t+%E2%80%93+Testebenen+f%C3%BCr+Software+planen </iframe>

{{BR}}
== Lückentext ==

<quiz display=simple>
{'''Vervollständige den Text.'''<br>
|type="{}"}
Eine kleine, möglichst isolierte Softwareeinheit überprüfst Du mit einem { Einheitstest } .
Die Zusammenarbeit von Komponenten wird durch einen { Integrationstest } untersucht.
Ein vollständiger Ablauf aus Anwendersicht heißt { Nutzungsfall } .
Im PausenKiosk kostet ein Brötchen 250 { Cent } .
Der noch verfügbare Warenvorrat heißt { Lagerbestand } .
Bei einer ungültigen Menge löst das Beispiel eine { ValueError } aus.
Die Python-Standardbibliothek enthält das Testframework { unittest } .
Die Methode zur Überprüfung von Gleichheit heißt { assertEqual } .
Eine wiederholte Prüfung nach Codeänderungen ist ein { Regressionstest } .
Die Festlegung der erwarteten Ergebnisse wird als { Testorakel } bezeichnet.
Eine getrennte Umgebung für gefahrlose Experimente heißt { Sandbox } .
Ein erfolgreich abgeschlossener Test beweist nicht die vollständige { Fehlerfreiheit } .
</quiz>

<br>

{{BR}}
= Offene Aufgaben =

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

{{BR}}
=== Leicht ===

# [[Testpyramide|Testpyramide zeichnen]]: Gestalte eine beschriftete Testpyramide mit Einheitstest, Integrationstest und End-to-End-Test. Erkläre ihre Aussage und eine Grenze der Darstellung.
# [[Testfall|Testfälle beschreiben]]: Formuliere drei Eingaben und ihre erwarteten Ausgaben für die Preisfunktion.
# [[Testautomatisierung|Tests untersuchen]]: Markiere im Python-Beispiel die drei Testgruppen und erläutere ihre unterschiedlichen Ziele.
# [[Sandbox|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.

{{BR}}
=== Standard ===

# [[Grenzwertanalyse|Grenzwerttests entwerfen]]: Ergänze Tests für die Mengen null, eins, drei und vier. Begründe, warum gerade diese Werte wichtig sind.
# [[Fehleranalyse|Fehlerexperiment dokumentieren]]: Ersetze lokal die Multiplikation durch eine Addition. Erstelle eine Tabelle mit fehlgeschlagenen Tests, Ursache und Korrektur.
# [[Testplanung|Testplan erweitern]]: Erstelle eine Anforderungs-Test-Matrix. Ergänze zu jedem Testobjekt Eingabe, erwartete Ausgabe und erwartete Zustandsänderung.
# [[Bildschirmaufnahme|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.

{{BR}}
=== Schwer ===

# [[Teststrategie|Risikobasierte Teststrategie]]: Du hast nur zehn Minuten Testzeit. Begründe, welche Tests Du zuerst ausführst und welche Risiken dadurch noch nicht abgedeckt sind.
# [[Mock-Objekt|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.
# [[Softwareanforderung|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.
# [[Qualitätssicherung|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.

{{:Offene Aufgabe - MOOC erstellen}}

{{BR}}
= 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.

{{BR}}
= 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.

{| class="wikitable"
! 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.

<br>
<br>

{{BR}}
= OERs zum Thema =

'''Wikipedia-Grundlagen:'''

<iframe> https://de.m.wikipedia.org/wiki/Softwaretest </iframe>

Weitere Artikel:
# [[Softwaretest]]
# [[Modultest]]
# [[Integrationstest]]
# [[Systemtest]]
# [[Abnahmetest]]
# [[Testgetriebene Entwicklung]]
# [[Testautomatisierung]]
# [[Anwendungsfall]]

'''Verifizierte fachliche Quellen:'''

# [https://istqb.org/wp-content/uploads/2024/11/ISTQB_CTFL_Syllabus_v4.0.1.pdf ISTQB Certified Tester Foundation Level Syllabus, Version 4.0.1] – Teststufen, Testarten, Testplanung und Testdesign. Offizielle fachliche Referenz.
# [https://docs.python.org/3/library/unittest.html Python-Dokumentation: unittest] – Offizielle Dokumentation des verwendeten Testframeworks.
# [https://de.wikipedia.org/wiki/Softwaretest Wikipedia: Softwaretest] – Überblick über Testziele und Teststufen.
# [https://de.wikipedia.org/wiki/Integrationstest Wikipedia: Integrationstest] – Zusammenspiel von Komponenten und Integrationsstrategien.

'''Nachweise der verwendeten Bildmedien und Nutzungsrechte:'''

# [https://commons.wikimedia.org/wiki/File:Testing_Pyramid.svg Testing Pyramid.svg] – Abbe98, Creative Commons BY-SA 4.0.
# [https://commons.wikimedia.org/wiki/File:V-Modell.svg V-Modell.svg] – Michael Pätzold und S. Seyfert, Creative Commons BY-SA 3.0.
# [https://commons.wikimedia.org/wiki/File:Tdd-abstract.png Tdd-abstract.png] – Kristijan Kralj, CC0 1.0.
# [https://commons.wikimedia.org/wiki/File:UML_Use_Case_diagram.svg UML Use Case diagram.svg] – Slashme, Creative Commons BY-SA 4.0.

Bei einer Weiterverwendung gelten die jeweils angegebenen Lizenzbedingungen, einschließlich Namensnennung und gegebenenfalls Weitergabe unter gleichen Bedingungen.

'''Videoquellen:'''

# [https://www.youtube.com/watch?v=TLccnKIMggA Lucas Paganini – Static, Unit, Integration, and End-to-End Tests Explained]
# [https://www.youtube.com/watch?v=6tNS--WetLI Corey Schafer – Python Tutorial: Unit Testing Your Code with the unittest Module]
# [https://www.youtube.com/watch?v=YdZ-sduNb48 Software Testing Mentor – Types of Software Testing]

Die Videos sind als Links beziehungsweise offizielle YouTube-Einbettungen eingebunden. Ihre öffentliche Zugänglichkeit bedeutet nicht, dass sie unter einer freien OER-Lizenz stehen. Eine Bearbeitung oder Weiterveröffentlichung benötigt die entsprechenden Nutzungsrechte.

'''Quellenstand:''' Oktober 2026. Testbegriffe wurden insbesondere anhand des ISTQB-Lehrplans 4.0.1 abgeglichen. Verfügbarkeit externer Medien und die Einbindung über YouTube, Wikimedia Commons oder iFrames können sich ändern.

{{BR}}
= Verknüpfte Lernbereiche =

{| align=center
{{:D-Tab}}
'''[[Softwaretest]]'''
# [[Komponententest]]
# [[Integrationstest]]
# [[Systemtest]]
# [[Abnahmetest]]
# [[Testautomatisierung]]
# [[Regressionstest]]
|}

{| align=center
{{:D-Tab}}
'''[[Anwendungsentwicklung]]'''
# [[Python (Programmiersprache)|Python]]
# [[Unittest]]
# [[Softwareanforderung]]
# [[Anwendungsfall]]
# [[Softwarequalität]]
# [[Fehlerbehandlung]]
|}

{| align=center
{{:D-Tab}}
'''[[Qualitätssicherung]]'''
# [[Testplanung]]
# [[Testfall]]
# [[Grenzwertanalyse]]
# [[Testumgebung]]
# [[Risikomanagement]]
# [[Softwaredokumentation]]
|}

[[Kategorie:Informatik]]
[[Kategorie:Softwareentwicklung]]
[[Kategorie:Softwaretest]]
[[Kategorie:Softwarequalität]]
[[Kategorie:Programmierung]]
[[Kategorie:Python]]
[[Kategorie:Berufsausbildung]]
[[Kategorie:Fachinformatiker Anwendungsentwicklung]]
[[Kategorie:Qualitätssicherung]]
[[Kategorie:OER]]

{{BR}}
= aiMOOC-Projekte =
[[Kategorie:AI_MOOC]] [[Kategorie:GPT aiMOOC]]
{{MT}}

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

Glanz: aiMOOC über GPT aiMOOC Action erstellt