Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

modul:m450:learningunits:lu03:inputoutput [2024/03/28 14:07] – angelegt - Externe Bearbeitung 127.0.0.1modul:m450:learningunits:lu03:inputoutput [2026/11/17 07:57] (aktuell) – Python-3-Syntax, capsys-Parameter, Eingaben als String korrigiert; Dateiausgabe mit tmp_path ergänzt; Kompetenz-Tags admin
Zeile 1: Zeile 1:
 ====== LU03c - PyTest: Input und Output ====== ====== LU03c - PyTest: Input und Output ======
-<WRAP center round info 60%> +<WRAP center round info 80%> 
-PyTest kann Ausgaben des Programms und Eingaben des Benutzers im Terminal simulieren.+**Auf einen Blick**\\ 
 +Viele Funktionen geben etwas im Terminal aus, lesen Eingaben mit ''input()'' oder schreiben in eine Datei. 
 +PyTest stellt dafür **Fixtures** bereit: ''capsys'' fängt Ausgaben ab, ''monkeypatch'' ersetzt Eingaben und ''tmp_path'' liefert einen leeren Ordner für Dateien.
 </WRAP> </WRAP>
  
-===== Ausgaben ===== +===== Lernziele ===== 
-Manche Funktionen erzeugen Ausgaben im Terminal. +Sie können 
-Besonders bei Fehlersituationen werden solche Ausgaben als Teil eines Logfiles genutzt, um Fehler zu protokollieren. +  * die Ausgaben einer Funktion mit ''capsys'' prüfen, 
-Andere Funktionen schreiben Werte in eine Datei. +  * Benutzereingaben mit ''monkeypatch'' simulieren, 
-Beide Arten von Ausgaben können wir im Rahmen von Unit Tests mit PyTest überprüfen.+  * Dateien, die eine Funktion schreibt, mit ''tmp_path'' prüfen.
  
-Indem wir unserer Testfunktion ''capsys'' als Argument mitgeben, können wir auf den Output einer Funktion zugreifen:+===== Fixtures als Parameter ===== 
 +Eine Fixture ist ein Hilfsmittel, das PyTest einem Test zur Verfügung stellt. Sie fordern eine Fixture an, indem Sie ihren Namen als **Parameter** der Testfunktion angeben:
  
 <code python> <code python>
 def test_normal(capsys): def test_normal(capsys):
-    factorial(7) +    ...
-    output = capsys.readouterr().out +
-    assert output == '5040\n'+
 </code> </code>
-In diesem Beispiel holen wir mittels ''capsys.readouterr().out'' den Output der Funktion ''factorial(x)''. 
-Diesen Output können wir dann mittels ''assert'' mit dem erwarteten Output vergleichen. 
  
-==== Beispiel ==== +Fehlt der Parameter, kennt der Test den Namen ''capsys'' nicht und bricht mit einem ''NameError'' ab. Eigene Fixtures lernen Sie in [[modul:m450:learningunits:lu04:fixture|LU04a]] kennen.
-Anhand dieses einfachen Beispiels siehst du, wie eine Python-Funktion getestet werden kann.+
  
-=== factorial.py === +===== Ausgaben prüfen mit capsys ===== 
-Ich verwende wieder das Beispiel aus dem letzten Kapitel. +==== print_factorial.py ==== 
-Diesmal gibt die Funktion das Resultat im Terminal aus.+Diese Variante gibt das Resultat mit ''print()'' aus, statt es zurückzugeben.
  
 <code python> <code python>
-def factorial(number):+def print_factorial(number):
     fact = 1     fact = 1
     for count in range(1, number + 1):     for count in range(1, number + 1):
         fact = fact * count         fact = fact * count
-    print fact+    print(fact)
 </code> </code>
  
-=== test_factorial.py === +==== test_print_factorial.py ====
-Dieses Modul enhält meine Unit Tests.+
 <code python> <code python>
-from factorial import factorial+from print_factorial import print_factorial
  
  
-def test_normal(): +def test_normal(capsys): 
-    factorial(7)+    print_factorial(7)
     output = capsys.readouterr().out     output = capsys.readouterr().out
     assert output == '5040\n'     assert output == '5040\n'
-     + 
-def test_zero(): + 
-    factorial(0)+def test_zero(capsys): 
 +    print_factorial(0)
     output = capsys.readouterr().out     output = capsys.readouterr().out
     assert output == '1\n'     assert output == '1\n'
- 
 </code> </code>
  
-===== Eingaben ===== +  * ''capsys.readouterr()'' liefert alles, was seit Beginn des Tests ausgegeben wurde. 
-Zum Simulieren von Eingaben steht uns ''monkeypatch'' zur Verfügung. +  * ''.out'' enthält die normale Ausgabe, ''.err'' die Fehlerausgabe. 
-Neben diversen anderen Funktionen, kann ''monkeypatch'' die Eingaben des Benutzers simulieren.+  * ''print()'' hängt einen Zeilenumbruch an. Deshalb steht im SOLL ''%%'5040\n'%%''. 
 + 
 +===== Eingaben simulieren mit monkeypatch ===== 
 +''monkeypatch'' kann während eines Tests eine beliebige Funktion durch eine andere ersetzen. Wir ersetzen die eingebaute Funktion ''input()'' durch eine Funktion, die vorbereitete Werte zurückgibt:
  
 <code python> <code python>
-def test_normal(capsys, monkeypatch): +inputs = iter(['7']) 
-    inputs = iter([7]) +monkeypatch.setattr('builtins.input', lambda _: next(inputs))
-    monkeypatch.setattr('builtins.input', lambda _: next(inputs)) +
-    factorial() +
-    captured = capsys.readouterr() +
-    assert captured.out == '5040\n'+
 </code> </code>
-In diesem Beispiel wird die Zahl ''7'' als Benutzereingabe an die getestete Funktion gesendet. 
-Der Befehl ''monkeypatch.setattr('builtins.input', lambda _: next(ITERATOR))'' erwartet eine Aufzählung von Eingabewerten. 
-Diese Aufzählung erzeugen wir mit dem Befehl ''inputs = iter([7])''. 
  
-==== Beispiel ==== +  * ''iter([...])'' erzeugt eine Folge von Eingaben. Jeder Aufruf von ''input()'' liefert den nächsten Wert. 
-Nun passen wir das Beispiel um den Einsatz von Benutzereingaben an. +  * ''input()'' gibt immer einen **String** zurück. Die Testeingaben sind deshalb Strings: ''%%'7'%%'' und nicht ''7''. 
- +  * ''lambda _:'' nimmt den Eingabetext (zum Beispiel ''%%'Number > '%%'') entgegen und ignoriert ihn. 
-=== factorial.py ===+  * Nach dem Test stellt PyTest das originale ''input()'' automatisch wieder her.
  
 +==== factorial_input.py ====
 <code python> <code python>
 def factorial(): def factorial():
-    number = int(input('Number >'))+    number = int(input('Number > '))
     fact = 1     fact = 1
     for count in range(1, number + 1):     for count in range(1, number + 1):
         fact = fact * count         fact = fact * count
-    print fact+    print(fact)
 </code> </code>
  
-=== test_factorial.py === +==== test_factorial_input.py ====
-Dieses Modul enhält meine Unit Tests.+
 <code python> <code python>
-from factorial import factorial+from factorial_input import factorial
  
  
 def test_normal(capsys, monkeypatch): def test_normal(capsys, monkeypatch):
-    inputs = iter([7])+    inputs = iter(['7'])
     monkeypatch.setattr('builtins.input', lambda _: next(inputs))     monkeypatch.setattr('builtins.input', lambda _: next(inputs))
     factorial()     factorial()
Zeile 99: Zeile 92:
  
 def test_zero(capsys, monkeypatch): def test_zero(capsys, monkeypatch):
-    inputs = iter([0])+    inputs = iter(['0'])
     monkeypatch.setattr('builtins.input', lambda _: next(inputs))     monkeypatch.setattr('builtins.input', lambda _: next(inputs))
     factorial()     factorial()
Zeile 106: Zeile 99:
 </code> </code>
  
 +<WRAP center round tip 80%>
 +Fragt das Programm mehrmals nach einer Eingabe, geben Sie alle Werte in der richtigen Reihenfolge an, zum Beispiel ''iter(['abc', '7'])'', um eine ungültige und danach eine gültige Eingabe zu testen.
 +</WRAP>
 +
 +===== Dateien prüfen mit tmp_path =====
 +Schreibt eine Funktion in eine Datei, soll der Test weder echte Dateien überschreiben noch Dateien liegen lassen.
 +Die Fixture ''tmp_path'' liefert dafür einen leeren, temporären Ordner.
 +
 +==== writer.py ====
 +<code python>
 +def write_factorial(number, filename):
 +    fact = 1
 +    for count in range(1, number + 1):
 +        fact = fact * count
 +    with open(filename, 'w', encoding='utf-8') as file:
 +        file.write(f'{number}! = {fact}\n')
 +</code>
 +
 +==== test_writer.py ====
 +<code python>
 +from writer import write_factorial
 +
 +
 +def test_write_file(tmp_path):
 +    filename = tmp_path / 'result.txt'
 +    write_factorial(5, filename)
 +    assert filename.read_text(encoding='utf-8') == '5! = 120\n'
 +</code>
 +
 +===== Besser: Ein- und Ausgabe von der Logik trennen =====
 +Eine Funktion, die rechnet **und** liest **und** ausgibt, ist schwer zu testen. Leichter testbar ist dieser Aufbau:
 +
 +<code python>
 +def factorial(number):          # reine Berechnung, einfach zu testen
 +    ...
 +    return fact
 +
 +def main():                     # nur Ein- und Ausgabe
 +    number = int(input('Number > '))
 +    print(factorial(number))
 +</code>
 +
 +Die Berechnung testen Sie dann ohne ''capsys'' und ''monkeypatch'' wie in [[.:pytest|LU03b]]. Nur für ''main()'' braucht es noch die Fixtures.
 +
 +===== Kontrollfragen =====
 +  - Ein Test mit ''capsys.readouterr()'' bricht mit ''NameError: name 'capsys' is not defined'' ab. Was fehlt?
 +  - Warum steht im SOLL ''%%'5040\n'%%'' und nicht ''%%'5040'%%''?
 +  - Warum simulieren wir die Eingabe mit ''%%'7'%%'' und nicht mit ''7''?
 +  - Weshalb ist es besser, Berechnung und Ein-/Ausgabe in getrennte Funktionen aufzuteilen?
  
 ---- ----
-{{tag>M450-LU03}}+{{tag>M450-LU03 M450-C1A}}
 [[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] Marcel Suter [[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] Marcel Suter
 +
  • modul/m450/learningunits/lu03/inputoutput.txt
  • Zuletzt geändert: 2026/11/17 07:57
  • von admin