144 lines
6.1 KiB
Python
144 lines
6.1 KiB
Python
import unittest
|
|
import sys
|
|
import json
|
|
import csv
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
# Sicherstellen, dass das aktuelle Verzeichnis im Python-Pfad liegt
|
|
sys.path.insert(0, str(Path(__file__).parent))
|
|
|
|
try:
|
|
import aufgabe
|
|
except ImportError as e:
|
|
raise ImportError(f"Konnte 'aufgabe.py' nicht importieren: {e}")
|
|
|
|
|
|
class TestKapitel13(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.Spieler = getattr(aufgabe, "Spieler", None)
|
|
self.Spielstand = getattr(aufgabe, "Spielstand", None)
|
|
|
|
self.assertIsNotNone(self.Spieler, "Klasse 'Spieler' nicht gefunden!")
|
|
self.assertIsNotNone(self.Spielstand, "Klasse 'Spielstand' nicht gefunden!")
|
|
|
|
def test_01_spieler_init_und_serialisierung(self):
|
|
"""Prüft Spieler-Initialisierung, to_dict() und from_dict()."""
|
|
s = self.Spieler("Geralt", 20, 8500, ["Silberschwert", "Trank"])
|
|
self.assertEqual(s.name, "Geralt")
|
|
self.assertEqual(s.level, 20)
|
|
self.assertEqual(s.punkte, 8500)
|
|
self.assertEqual(s.inventar, ["Silberschwert", "Trank"])
|
|
|
|
# to_dict
|
|
d = s.to_dict()
|
|
self.assertIsInstance(d, dict, "to_dict() muss ein Dictionary zurückgeben!")
|
|
self.assertEqual(d["name"], "Geralt")
|
|
self.assertEqual(d["level"], 20)
|
|
self.assertEqual(d["punkte"], 8500)
|
|
self.assertEqual(d["inventar"], ["Silberschwert", "Trank"])
|
|
|
|
# from_dict
|
|
reconstructed = self.Spieler.from_dict(d)
|
|
self.assertEqual(reconstructed.name, s.name)
|
|
self.assertEqual(reconstructed.level, s.level)
|
|
self.assertEqual(reconstructed.punkte, s.punkte)
|
|
self.assertEqual(reconstructed.inventar, s.inventar)
|
|
|
|
def test_02_spielstand_management(self):
|
|
"""Prüft Hinzufügen, Suchen und Ermittlung des besten Spielers."""
|
|
spielstand = self.Spielstand("Turnier 2026")
|
|
self.assertIsNone(spielstand.bester_spieler())
|
|
|
|
s1 = self.Spieler("Alice", 5, 1200)
|
|
s2 = self.Spieler("Bob", 8, 3400)
|
|
s3 = self.Spieler("Charlie", 6, 2100)
|
|
|
|
spielstand.spieler_hinzufuegen(s1)
|
|
spielstand.spieler_hinzufuegen(s2)
|
|
spielstand.spieler_hinzufuegen(s3)
|
|
|
|
self.assertEqual(len(spielstand.spieler_liste), 3)
|
|
self.assertEqual(spielstand.bester_spieler().name, "Bob")
|
|
self.assertEqual(spielstand.spieler_suchen("Alice").level, 5)
|
|
self.assertIsNone(spielstand.spieler_suchen("Unbekannt"))
|
|
|
|
def test_03_json_speichern_und_laden(self):
|
|
"""Prüft Speichern und Laden eines Spielstands im JSON-Format über temporäre Dateien."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
json_file = Path(tmpdir) / "savegame.json"
|
|
|
|
original_stand = self.Spielstand("Episches RPG")
|
|
original_stand.spieler_hinzufuegen(self.Spieler("Zelda", 30, 9999, ["Bogen", "Rubin"]))
|
|
original_stand.spieler_hinzufuegen(self.Spieler("Link", 25, 7500, ["Master-Schwert"]))
|
|
|
|
# Speichern
|
|
original_stand.speichern_als_json(json_file)
|
|
self.assertTrue(json_file.exists(), "JSON-Datei wurde nicht erstellt!")
|
|
|
|
# Rohinhalt der JSON prüfen
|
|
with open(json_file, "r", encoding="utf-8") as f:
|
|
rohdialog = json.load(f)
|
|
self.assertEqual(rohdialog["titel"], "Episches RPG")
|
|
self.assertEqual(len(rohdialog["spieler"]), 2)
|
|
self.assertEqual(rohdialog["spieler"][0]["name"], "Zelda")
|
|
|
|
# In neues Spielstand-Objekt laden
|
|
geladener_stand = self.Spielstand()
|
|
geladener_stand.laden_aus_json(json_file)
|
|
|
|
self.assertEqual(geladener_stand.titel, "Episches RPG")
|
|
self.assertEqual(len(geladener_stand.spieler_liste), 2)
|
|
self.assertEqual(geladener_stand.spieler_liste[0].name, "Zelda")
|
|
self.assertEqual(geladener_stand.spieler_liste[0].inventar, ["Bogen", "Rubin"])
|
|
self.assertEqual(geladener_stand.spieler_liste[1].punkte, 7500)
|
|
|
|
def test_04_csv_export(self):
|
|
"""Prüft den Export der Spieler-Tabelle als CSV-Datei."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
csv_file = Path(tmpdir) / "export.csv"
|
|
|
|
stand = self.Spielstand("Liga")
|
|
stand.spieler_hinzufuegen(self.Spieler("Mario", 10, 5000, ["Pilz", "Stern", "Blume"]))
|
|
stand.spieler_hinzufuegen(self.Spieler("Luigi", 8, 3200, ["Pilz"]))
|
|
|
|
stand.exportiere_als_csv(csv_file)
|
|
self.assertTrue(csv_file.exists(), "CSV-Datei wurde nicht erstellt!")
|
|
|
|
with open(csv_file, "r", newline="", encoding="utf-8") as f:
|
|
reader = list(csv.DictReader(f))
|
|
|
|
self.assertEqual(len(reader), 2)
|
|
self.assertEqual(reader[0]["name"], "Mario")
|
|
self.assertEqual(reader[0]["level"], "10")
|
|
self.assertEqual(reader[0]["punkte"], "5000")
|
|
self.assertEqual(reader[0]["inventar_anzahl"], "3")
|
|
|
|
self.assertEqual(reader[1]["name"], "Luigi")
|
|
self.assertEqual(reader[1]["inventar_anzahl"], "1")
|
|
|
|
def test_05_csv_import(self):
|
|
"""Prüft den Import von Daten aus einer CSV-Datei."""
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
csv_file = Path(tmpdir) / "import_test.csv"
|
|
|
|
# Manuell CSV-Datei vorbereiten
|
|
with open(csv_file, "w", newline="", encoding="utf-8") as f:
|
|
writer = csv.DictWriter(f, fieldnames=["name", "level", "punkte", "inventar_anzahl"])
|
|
writer.writeheader()
|
|
writer.writerow({"name": "Peach", "level": "12", "punkte": "4400", "inventar_anzahl": "0"})
|
|
writer.writerow({"name": "Toad", "level": "5", "punkte": "1500", "inventar_anzahl": "0"})
|
|
|
|
stand = self.Spielstand("Neue Runde")
|
|
anzahl = stand.importiere_aus_csv(csv_file)
|
|
|
|
self.assertEqual(anzahl, 2)
|
|
self.assertEqual(len(stand.spieler_liste), 2)
|
|
self.assertEqual(stand.spieler_liste[0].name, "Peach")
|
|
self.assertEqual(stand.spieler_liste[0].level, 12)
|
|
self.assertEqual(stand.spieler_liste[0].punkte, 4400)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|