forked from AG_QGIS/Plugin_SN_Basis
Tests überarbeitet, Mocks und coverage eingefügt
This commit is contained in:
@@ -1,12 +1,106 @@
|
||||
#run_tests.py
|
||||
import sys
|
||||
import os
|
||||
import unittest
|
||||
import datetime
|
||||
import inspect
|
||||
|
||||
# Farben
|
||||
RED = "\033[91m"
|
||||
YELLOW = "\033[93m"
|
||||
GREEN = "\033[92m"
|
||||
CYAN = "\033[96m"
|
||||
MAGENTA = "\033[95m"
|
||||
RESET = "\033[0m"
|
||||
|
||||
# Globaler Testzähler
|
||||
GLOBAL_TEST_COUNTER = 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Eigene TestResult-Klasse (färbt Fehler/Skipped/OK)
|
||||
# ---------------------------------------------------------
|
||||
class ColoredTestResult(unittest.TextTestResult):
|
||||
|
||||
def startTest(self, test):
|
||||
"""Vor jedem Test eine Nummer ausgeben."""
|
||||
global GLOBAL_TEST_COUNTER
|
||||
GLOBAL_TEST_COUNTER += 1
|
||||
self.stream.write(f"{CYAN}[Test {GLOBAL_TEST_COUNTER}]{RESET}\n")
|
||||
super().startTest(test)
|
||||
|
||||
def startTestRun(self):
|
||||
"""Wird einmal zu Beginn des gesamten Testlaufs ausgeführt."""
|
||||
super().startTestRun()
|
||||
|
||||
def startTestClass(self, test):
|
||||
"""Wird aufgerufen, wenn eine neue Testklasse beginnt."""
|
||||
cls = test.__class__
|
||||
file = inspect.getfile(cls)
|
||||
filename = os.path.basename(file)
|
||||
|
||||
self.stream.write(
|
||||
f"\n{MAGENTA}{'='*70}\n"
|
||||
f"Starte Testklasse: {filename} → {cls.__name__}\n"
|
||||
f"{'='*70}{RESET}\n"
|
||||
)
|
||||
|
||||
def addError(self, test, err):
|
||||
super().addError(test, err)
|
||||
self.stream.write(f"{RED}ERROR{RESET}\n")
|
||||
|
||||
def addFailure(self, test, err):
|
||||
super().addFailure(test, err)
|
||||
self.stream.write(f"{RED}FAILURE{RESET}\n")
|
||||
|
||||
def addSkip(self, test, reason):
|
||||
super().addSkip(test, reason)
|
||||
self.stream.write(f"{YELLOW}SKIPPED{RESET}: {reason}\n")
|
||||
|
||||
# unittest ruft diese Methode nicht automatisch auf → wir patchen es unten
|
||||
def addSuccess(self, test):
|
||||
super().addSuccess(test)
|
||||
self.stream.write(f"{GREEN}OK{RESET}\n")
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Eigener TestRunner, der unser ColoredTestResult nutzt
|
||||
# ---------------------------------------------------------
|
||||
class ColoredTestRunner(unittest.TextTestRunner):
|
||||
resultclass = ColoredTestResult
|
||||
|
||||
def _makeResult(self):
|
||||
result = super()._makeResult()
|
||||
|
||||
# Patch: unittest ruft startTestClass nicht automatisch auf
|
||||
original_start_test = result.startTest
|
||||
|
||||
def patched_start_test(test):
|
||||
# Wenn neue Klasse → Kopf ausgeben
|
||||
if not hasattr(result, "_last_test_class") or \
|
||||
result._last_test_class != test.__class__:
|
||||
result.startTestClass(test)
|
||||
result._last_test_class = test.__class__
|
||||
|
||||
original_start_test(test)
|
||||
|
||||
result.startTest = patched_start_test
|
||||
return result
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Testlauf starten
|
||||
# ---------------------------------------------------------
|
||||
print("\n" + "="*70)
|
||||
print(f"{CYAN}Testlauf gestartet am: {datetime.datetime.now():%Y-%m-%d %H:%M:%S}{RESET}")
|
||||
print("="*70 + "\n")
|
||||
|
||||
# Projekt-Root dem Suchpfad hinzufügen
|
||||
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||||
if project_root not in sys.path:
|
||||
sys.path.insert(0, project_root)
|
||||
|
||||
|
||||
def main():
|
||||
loader = unittest.TestLoader()
|
||||
suite = unittest.TestSuite()
|
||||
@@ -15,15 +109,17 @@ def main():
|
||||
"test_dateipruefer",
|
||||
"test_stilpruefer",
|
||||
"test_linkpruefer",
|
||||
# "test_pruefmanager" enthält QGIS-spezifische Funktionen
|
||||
"test_qt_compat",
|
||||
"test_pruefmanager",
|
||||
]
|
||||
|
||||
for mod_name in test_modules:
|
||||
mod = __import__(mod_name)
|
||||
suite.addTests(loader.loadTestsFromModule(mod))
|
||||
|
||||
runner = unittest.TextTestRunner(verbosity=2)
|
||||
runner = ColoredTestRunner(verbosity=2)
|
||||
runner.run(suite)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
|
||||
@@ -1,10 +1,12 @@
|
||||
#test_dateipruefer.py
|
||||
import unittest
|
||||
import os
|
||||
import tempfile
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
||||
from Dateipruefer import (
|
||||
# Plugin-Root ermitteln (ein Verzeichnis über "test")
|
||||
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||||
sys.path.insert(0, ROOT)
|
||||
from modules.Dateipruefer import (
|
||||
Dateipruefer,
|
||||
LeererPfadModus,
|
||||
DateiEntscheidung,
|
||||
|
||||
@@ -1,125 +1,78 @@
|
||||
# test/test_linkpruefer.py
|
||||
|
||||
#test_linkpruefer.py
|
||||
import unittest
|
||||
import sys
|
||||
from unittest.mock import patch
|
||||
from qgis.PyQt.QtCore import QCoreApplication, QTimer
|
||||
from qgis.PyQt.QtNetwork import QNetworkRequest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from linkpruefer import Linkpruefer
|
||||
|
||||
# Stelle sicher, dass eine Qt-App existiert
|
||||
app = QCoreApplication.instance()
|
||||
if app is None:
|
||||
app = QCoreApplication(sys.argv)
|
||||
|
||||
|
||||
class DummyReply:
|
||||
"""Fake-Reply, um Netzwerkabfragen zu simulieren"""
|
||||
HttpStatusCodeAttribute = QNetworkRequest.HttpStatusCodeAttribute
|
||||
|
||||
def __init__(self, error, status_code):
|
||||
self._error = error
|
||||
self._status_code = status_code
|
||||
self.finished = self # Fake-Signal
|
||||
|
||||
def connect(self, slot):
|
||||
# sorgt dafür, dass loop.quit() nach Start von loop.exec_() ausgeführt wird
|
||||
QTimer.singleShot(0, slot)
|
||||
|
||||
def error(self):
|
||||
return self._error
|
||||
|
||||
def errorString(self):
|
||||
return "Simulierter Fehler" if self._error != 0 else ""
|
||||
|
||||
def attribute(self, attr):
|
||||
if attr == self.HttpStatusCodeAttribute:
|
||||
return self._status_code
|
||||
return None
|
||||
|
||||
def deleteLater(self):
|
||||
# kein echtes QObject → wir tun einfach nichts
|
||||
pass
|
||||
# QGIS-Module mocken, damit der Import funktioniert
|
||||
with patch.dict("sys.modules", {
|
||||
"qgis": MagicMock(),
|
||||
"qgis.PyQt": MagicMock(),
|
||||
"qgis.PyQt.QtCore": MagicMock(),
|
||||
"qgis.PyQt.QtNetwork": MagicMock(),
|
||||
"qgis.core": MagicMock(),
|
||||
}):
|
||||
from modules.linkpruefer import Linkpruefer
|
||||
|
||||
|
||||
class TestLinkpruefer(unittest.TestCase):
|
||||
"""Tests für alle Funktionen des Linkpruefer"""
|
||||
|
||||
# ----------------------------
|
||||
# Remote-Tests mit DummyReply
|
||||
# ----------------------------
|
||||
@patch('linkpruefer.QgsNetworkAccessManager.head')
|
||||
def test_remote_link_success(self, mock_head):
|
||||
mock_head.return_value = DummyReply(0, 200)
|
||||
@patch("modules.linkpruefer.QNetworkReply")
|
||||
@patch("modules.linkpruefer.QNetworkRequest")
|
||||
@patch("modules.linkpruefer.QUrl")
|
||||
@patch("modules.linkpruefer.QEventLoop")
|
||||
@patch("modules.linkpruefer.QgsNetworkAccessManager")
|
||||
def test_remote_link_ok(
|
||||
self, mock_manager, mock_loop, mock_url, mock_request, mock_reply
|
||||
):
|
||||
# Setup: simulate successful HEAD request
|
||||
reply_instance = MagicMock()
|
||||
reply_instance.error.return_value = mock_reply.NetworkError.NoError
|
||||
reply_instance.attribute.return_value = 200
|
||||
|
||||
checker = Linkpruefer("https://example.com/service", "REST")
|
||||
result = checker.ausfuehren()
|
||||
mock_manager.return_value.head.return_value = reply_instance
|
||||
|
||||
lp = Linkpruefer("http://example.com", "REST")
|
||||
result = lp.pruefe_link()
|
||||
|
||||
self.assertTrue(result.erfolgreich)
|
||||
self.assertEqual(result.daten['typ'], 'REST')
|
||||
self.assertEqual(result.daten['quelle'], 'remote')
|
||||
self.assertEqual(result.fehler, [])
|
||||
self.assertEqual(result.warnungen, [])
|
||||
self.assertEqual(result.daten["quelle"], "remote")
|
||||
|
||||
@patch('linkpruefer.QgsNetworkAccessManager.head')
|
||||
def test_remote_link_failure(self, mock_head):
|
||||
mock_head.return_value = DummyReply(1, 404)
|
||||
@patch("modules.linkpruefer.QNetworkReply")
|
||||
@patch("modules.linkpruefer.QNetworkRequest")
|
||||
@patch("modules.linkpruefer.QUrl")
|
||||
@patch("modules.linkpruefer.QEventLoop")
|
||||
@patch("modules.linkpruefer.QgsNetworkAccessManager")
|
||||
def test_remote_link_error(
|
||||
self, mock_manager, mock_loop, mock_url, mock_request, mock_reply
|
||||
):
|
||||
# Fake-Reply erzeugen
|
||||
reply_instance = MagicMock()
|
||||
reply_instance.error.return_value = mock_reply.NetworkError.ConnectionRefusedError
|
||||
reply_instance.errorString.return_value = "Connection refused"
|
||||
|
||||
checker = Linkpruefer("https://example.com/kaputt", "WMS")
|
||||
result = checker.ausfuehren()
|
||||
# WICHTIG: finished-Signal simulieren
|
||||
reply_instance.finished = MagicMock()
|
||||
reply_instance.finished.connect = MagicMock()
|
||||
|
||||
# Wenn loop.exec() aufgerufen wird, rufen wir loop.quit() sofort auf
|
||||
mock_loop.return_value.exec.side_effect = lambda: mock_loop.return_value.quit()
|
||||
|
||||
# Manager gibt unser Fake-Reply zurück
|
||||
mock_manager.return_value.head.return_value = reply_instance
|
||||
|
||||
lp = Linkpruefer("http://example.com", "REST")
|
||||
result = lp.pruefe_link()
|
||||
|
||||
self.assertFalse(result.erfolgreich)
|
||||
self.assertIn("Verbindungsfehler: Simulierter Fehler", result.fehler)
|
||||
self.assertIn("Verbindungsfehler", result.fehler[0])
|
||||
|
||||
# ----------------------------
|
||||
# Klassifizierungstests
|
||||
# ----------------------------
|
||||
def test_klassifiziere_anbieter_remote(self):
|
||||
checker = Linkpruefer("https://beispiel.de", "wms")
|
||||
daten = checker.klassifiziere_anbieter()
|
||||
self.assertEqual(daten["typ"], "WMS")
|
||||
self.assertEqual(daten["quelle"], "remote")
|
||||
|
||||
def test_klassifiziere_anbieter_local(self):
|
||||
checker = Linkpruefer("C:/daten/test.shp", "ogr")
|
||||
daten = checker.klassifiziere_anbieter()
|
||||
self.assertEqual(daten["typ"], "OGR")
|
||||
self.assertEqual(daten["quelle"], "local")
|
||||
def test_local_link_warning(self):
|
||||
lp = Linkpruefer("/path/to/file_without_extension", "OGR")
|
||||
result = lp.pruefe_link()
|
||||
|
||||
# ----------------------------
|
||||
# Lokale Links
|
||||
# ----------------------------
|
||||
def test_pruefe_link_local_ok(self):
|
||||
checker = Linkpruefer("C:/daten/test.shp", "OGR")
|
||||
result = checker.pruefe_link()
|
||||
self.assertTrue(result.erfolgreich)
|
||||
self.assertEqual(result.warnungen, [])
|
||||
|
||||
def test_pruefe_link_local_warnung(self):
|
||||
checker = Linkpruefer("C:/daten/ordner/", "OGR")
|
||||
result = checker.pruefe_link()
|
||||
self.assertTrue(result.erfolgreich)
|
||||
self.assertIn("ungewöhnlich", result.warnungen[0])
|
||||
|
||||
# ----------------------------
|
||||
# Sonderfall: leerer Link
|
||||
# ----------------------------
|
||||
def test_pruefe_link_empty(self):
|
||||
checker = Linkpruefer("", "REST")
|
||||
result = checker.pruefe_link()
|
||||
self.assertFalse(result.erfolgreich)
|
||||
self.assertIn("Link fehlt.", result.fehler)
|
||||
|
||||
# ----------------------------
|
||||
# leerer Anbieter
|
||||
# ----------------------------
|
||||
def test_pruefe_link_leerer_anbieter(self):
|
||||
checker = Linkpruefer("https://example.com/service", "")
|
||||
result = checker.pruefe_link()
|
||||
self.assertFalse(result.erfolgreich)
|
||||
self.assertIn("Anbieter muss gesetzt werden und darf nicht leer sein.", result.fehler)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -1,36 +1,87 @@
|
||||
#test_pruefmanager.py
|
||||
import unittest
|
||||
import os
|
||||
from unittest.mock import patch
|
||||
from pruefmanager import PruefManager
|
||||
from Dateipruefer import DateiEntscheidung
|
||||
import sys
|
||||
from unittest.mock import patch, MagicMock
|
||||
|
||||
# Plugin-Root ermitteln (ein Verzeichnis über "test")
|
||||
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||||
sys.path.insert(0, ROOT)
|
||||
|
||||
from modules.Pruefmanager import PruefManager
|
||||
from modules.Dateipruefer import DateiEntscheidung
|
||||
import modules.qt_compat as qt_compat
|
||||
|
||||
|
||||
# Skip-Decorator für Mock-Modus
|
||||
def skip_if_mock(reason):
|
||||
return unittest.skipIf(
|
||||
qt_compat.QT_VERSION == 0,
|
||||
f"{reason} — MOCK-Modus erkannt. "
|
||||
"Bitte diesen Test in einer echten QGIS-Umgebung ausführen."
|
||||
)
|
||||
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
||||
|
||||
class TestPruefManager(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.manager = PruefManager(plugin_pfad="/tmp")
|
||||
|
||||
@patch("PyQt5.QtWidgets.QMessageBox.exec_", return_value=QMessageBox.Yes)
|
||||
def test_frage_datei_ersetzen(self, mock_msgbox):
|
||||
# ---------------------------------------------------------
|
||||
# Tests für frage_datei_ersetzen_oder_anhaengen
|
||||
# ---------------------------------------------------------
|
||||
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=qt_compat.YES)
|
||||
def test_frage_datei_ersetzen(self, mock_exec):
|
||||
entscheidung = self.manager.frage_datei_ersetzen_oder_anhaengen("dummy.gpkg")
|
||||
self.assertEqual(entscheidung, DateiEntscheidung.ERSETZEN)
|
||||
|
||||
@patch("PyQt5.QtWidgets.QMessageBox.exec_", return_value=QMessageBox.No)
|
||||
def test_frage_datei_anhaengen(self, mock_msgbox):
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=qt_compat.NO)
|
||||
def test_frage_datei_anhaengen(self, mock_exec):
|
||||
entscheidung = self.manager.frage_datei_ersetzen_oder_anhaengen("dummy.gpkg")
|
||||
self.assertEqual(entscheidung, DateiEntscheidung.ANHAENGEN)
|
||||
|
||||
@patch("PyQt5.QtWidgets.QMessageBox.exec_", return_value=QMessageBox.Cancel)
|
||||
def test_frage_datei_abbrechen(self, mock_msgbox):
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=qt_compat.CANCEL)
|
||||
def test_frage_datei_abbrechen(self, mock_exec):
|
||||
entscheidung = self.manager.frage_datei_ersetzen_oder_anhaengen("dummy.gpkg")
|
||||
self.assertEqual(entscheidung, DateiEntscheidung.ABBRECHEN)
|
||||
|
||||
@patch("PyQt5.QtWidgets.QMessageBox.exec_", return_value=QMessageBox.Yes)
|
||||
def test_frage_temporär_verwenden_ja(self, mock_msgbox):
|
||||
# ---------------------------------------------------------
|
||||
# Fehlerfall: exec_dialog liefert etwas Unerwartetes
|
||||
# ---------------------------------------------------------
|
||||
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=999)
|
||||
def test_frage_datei_unbekannte_antwort(self, mock_exec):
|
||||
entscheidung = self.manager.frage_datei_ersetzen_oder_anhaengen("dummy.gpkg")
|
||||
self.assertEqual(entscheidung, DateiEntscheidung.ABBRECHEN)
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Tests für frage_temporär_verwenden
|
||||
# ---------------------------------------------------------
|
||||
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=qt_compat.YES)
|
||||
def test_frage_temporär_verwenden_ja(self, mock_exec):
|
||||
self.assertTrue(self.manager.frage_temporär_verwenden())
|
||||
|
||||
@patch("PyQt5.QtWidgets.QMessageBox.exec_", return_value=QMessageBox.No)
|
||||
def test_frage_temporär_verwenden_nein(self, mock_msgbox):
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=qt_compat.NO)
|
||||
def test_frage_temporär_verwenden_nein(self, mock_exec):
|
||||
self.assertFalse(self.manager.frage_temporär_verwenden())
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Fehlerfall: exec_dialog liefert etwas Unerwartetes
|
||||
# ---------------------------------------------------------
|
||||
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
@patch("modules.qt_compat.exec_dialog", return_value=None)
|
||||
def test_frage_temporär_verwenden_unbekannt(self, mock_exec):
|
||||
self.assertFalse(self.manager.frage_temporär_verwenden())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
52
test/test_qgis.bat
Normal file
52
test/test_qgis.bat
Normal file
@@ -0,0 +1,52 @@
|
||||
@echo off
|
||||
setlocal
|
||||
echo BATCH WIRD AUSGEFÜHRT
|
||||
pause
|
||||
|
||||
echo ================================================
|
||||
echo Starte Tests in QGIS-Python-Umgebung
|
||||
echo ================================================
|
||||
|
||||
REM Pfad zur QGIS-Installation
|
||||
set QGIS_BIN=D:\OSGeo\bin
|
||||
|
||||
REM Prüfen, ob python-qgis.bat existiert
|
||||
if not exist "%QGIS_BIN%\python-qgis.bat" (
|
||||
echo.
|
||||
echo [FEHLER] python-qgis.bat wurde nicht gefunden!
|
||||
echo Erwarteter Pfad:
|
||||
echo %QGIS_BIN%\python-qgis.bat
|
||||
echo.
|
||||
echo Bitte korrigiere den Pfad in test_qgis.bat.
|
||||
echo.
|
||||
pause
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [INFO] QGIS-Python gefunden. Starte Tests...
|
||||
echo.
|
||||
|
||||
"%QGIS_BIN%\python-qgis.bat" -m coverage run run_tests.py
|
||||
if errorlevel 1 (
|
||||
echo.
|
||||
echo [FEHLER] Testlauf fehlgeschlagen.
|
||||
echo.
|
||||
pause
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo.
|
||||
echo ================================================
|
||||
echo Coverage HTML-Bericht wird erzeugt...
|
||||
echo ================================================
|
||||
|
||||
"%QGIS_BIN%\python-qgis.bat" -m coverage html
|
||||
|
||||
echo.
|
||||
echo Fertig!
|
||||
echo Öffne jetzt: coverage_html\index.html
|
||||
echo ================================================
|
||||
|
||||
pause
|
||||
endlocal
|
||||
100
test/test_qt_compat.py
Normal file
100
test/test_qt_compat.py
Normal file
@@ -0,0 +1,100 @@
|
||||
#test_qt_compat.py
|
||||
import unittest
|
||||
import os
|
||||
import sys
|
||||
from unittest.mock import MagicMock
|
||||
import modules.qt_compat as qt_compat
|
||||
# Plugin-Root ermitteln (ein Verzeichnis über "test")
|
||||
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||||
sys.path.insert(0, ROOT)
|
||||
|
||||
def skip_if_mock(reason):
|
||||
"""Decorator: überspringt Test, wenn qt_compat im Mock-Modus läuft."""
|
||||
return unittest.skipIf(
|
||||
qt_compat.QT_VERSION == 0,
|
||||
f"{reason} — MOCK-Modus erkannt."
|
||||
f"Bitte diesen Test in einer echten QGIS-Umgebung ausführen."
|
||||
)
|
||||
|
||||
|
||||
class TestQtCompat(unittest.TestCase):
|
||||
|
||||
def test_exports_exist(self):
|
||||
"""Prüft, ob alle erwarteten Symbole exportiert werden."""
|
||||
expected = {
|
||||
"QMessageBox",
|
||||
"QFileDialog",
|
||||
"QEventLoop",
|
||||
"QUrl",
|
||||
"QNetworkRequest",
|
||||
"QNetworkReply",
|
||||
"YES",
|
||||
"NO",
|
||||
"CANCEL",
|
||||
"ICON_QUESTION",
|
||||
"exec_dialog",
|
||||
"QT_VERSION",
|
||||
}
|
||||
|
||||
for symbol in expected:
|
||||
self.assertTrue(
|
||||
hasattr(qt_compat, symbol),
|
||||
f"qt_compat sollte '{symbol}' exportieren"
|
||||
)
|
||||
|
||||
@skip_if_mock("QT_VERSION kann im Mock-Modus nicht 5 oder 6 sein")
|
||||
def test_qt_version_flag(self):
|
||||
"""QT_VERSION muss 5 oder 6 sein."""
|
||||
self.assertIn(qt_compat.QT_VERSION, (5, 6))
|
||||
|
||||
@skip_if_mock("Qt-Enums können im Mock-Modus nicht OR-kombiniert werden")
|
||||
def test_enums_are_valid(self):
|
||||
"""Prüft, ob die Enums gültige QMessageBox-Werte sind."""
|
||||
|
||||
msg = qt_compat.QMessageBox()
|
||||
try:
|
||||
msg.setStandardButtons(
|
||||
qt_compat.YES |
|
||||
qt_compat.NO |
|
||||
qt_compat.CANCEL
|
||||
)
|
||||
except Exception as e:
|
||||
self.fail(f"Qt-Enums sollten OR-kombinierbar sein, Fehler: {e}")
|
||||
|
||||
self.assertTrue(True)
|
||||
|
||||
@skip_if_mock("exec_dialog benötigt echtes Qt-Verhalten")
|
||||
def test_exec_dialog_calls_correct_method(self):
|
||||
"""Prüft, ob exec_dialog() die richtige Methode aufruft."""
|
||||
|
||||
mock_msg = MagicMock()
|
||||
|
||||
if qt_compat.QT_VERSION == 6:
|
||||
qt_compat.exec_dialog(mock_msg)
|
||||
mock_msg.exec.assert_called_once()
|
||||
|
||||
elif qt_compat.QT_VERSION == 5:
|
||||
qt_compat.exec_dialog(mock_msg)
|
||||
mock_msg.exec_.assert_called_once()
|
||||
|
||||
else:
|
||||
self.fail("QT_VERSION hat einen unerwarteten Wert.")
|
||||
|
||||
@skip_if_mock("Qt-Klassen können im Mock-Modus nicht real instanziiert werden")
|
||||
def test_qt_classes_importable(self):
|
||||
"""Prüft, ob die wichtigsten Qt-Klassen instanziierbar sind."""
|
||||
|
||||
loop = qt_compat.QEventLoop()
|
||||
self.assertIsNotNone(loop)
|
||||
|
||||
url = qt_compat.QUrl("http://example.com")
|
||||
self.assertTrue(url.isValid())
|
||||
|
||||
req = qt_compat.QNetworkRequest(url)
|
||||
self.assertIsNotNone(req)
|
||||
|
||||
self.assertTrue(hasattr(qt_compat.QNetworkReply, "NetworkError"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,10 +1,14 @@
|
||||
#test_stilpruefer.py
|
||||
import unittest
|
||||
import tempfile
|
||||
import os
|
||||
from stilpruefer import Stilpruefer
|
||||
from pruef_ergebnis import PruefErgebnis
|
||||
|
||||
import sys
|
||||
|
||||
# Plugin-Root ermitteln (ein Verzeichnis über "test")
|
||||
ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||||
sys.path.insert(0, ROOT)
|
||||
from modules.stilpruefer import Stilpruefer
|
||||
from modules.pruef_ergebnis import PruefErgebnis
|
||||
class TestStilpruefer(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.pruefer = Stilpruefer()
|
||||
|
||||
Reference in New Issue
Block a user