PruefManager und Daten aus P41 übertragen

test/__init__.py

@@ -0,0 +1 @@
+#Testordner

test/run_tests.py

@@ -0,0 +1,29 @@
+import sys
+import os
+import unittest
+
+# 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()
+
+    test_modules = [
+        "test_dateipruefer",
+        "test_stilpruefer",
+        "test_linkpruefer",
+        # "test_pruefmanager" enthält QGIS-spezifische Funktionen
+    ]
+
+    for mod_name in test_modules:
+        mod = __import__(mod_name)
+        suite.addTests(loader.loadTestsFromModule(mod))
+
+    runner = unittest.TextTestRunner(verbosity=2)
+    runner.run(suite)
+
+if __name__ == "__main__":
+    main()

test/start_osgeo4w_qgis.bat

@@ -0,0 +1,9 @@
+@echo off
+SET OSGEO4W_ROOT=D:\QGISQT5
+call %OSGEO4W_ROOT%\bin\o4w_env.bat
+set QGIS_PREFIX_PATH=%OSGEO4W_ROOT%\apps\qgis
+set PYTHONPATH=%QGIS_PREFIX_PATH%\python;%PYTHONPATH%
+set PATH=%OSGEO4W_ROOT%\bin;%QGIS_PREFIX_PATH%\bin;%PATH%
+
+REM Neue Eingabeaufforderung starten und Python-Skript ausführen
+start cmd /k "python run_tests.py"

test/test_dateipruefer.py

@@ -0,0 +1,88 @@
+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 (
+    Dateipruefer,
+    LeererPfadModus,
+    DateiEntscheidung,
+    DateipruefErgebnis
+)
+
+
+class TestDateipruefer(unittest.TestCase):
+    def setUp(self):
+        self.pruefer = Dateipruefer()
+        self.plugin_pfad = tempfile.gettempdir()
+        self.standardname = "test_standard.gpkg"
+
+    def test_verbotener_leerer_pfad(self):
+        result = self.pruefer.pruefe(
+            pfad="",
+            leer_modus=LeererPfadModus.VERBOTEN
+        )
+        self.assertFalse(result.erfolgreich)
+        self.assertIn("Kein Pfad angegeben.", result.fehler)
+
+    def test_standardpfad_wird_verwendet(self):
+        result = self.pruefer.pruefe(
+            pfad="",
+            leer_modus=LeererPfadModus.NUTZE_STANDARD,
+            standardname=self.standardname,
+            plugin_pfad=self.plugin_pfad
+        )
+        self.assertTrue(result.erfolgreich)
+        expected_path = os.path.join(self.plugin_pfad, self.standardname)
+        self.assertEqual(result.pfad, expected_path)
+
+    def test_temporärer_layer_wird_erkannt(self):
+        result = self.pruefer.pruefe(
+            pfad="",
+            leer_modus=LeererPfadModus.TEMPORAER_ERLAUBT
+        )
+        self.assertTrue(result.erfolgreich)
+        self.assertIsNone(result.pfad)
+        self.assertFalse(result.temporär) 
+
+    def test_existierende_datei_ohne_entscheidung(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+            tmp_path = tmp_file.name
+        try:
+            result = self.pruefer.pruefe(
+                pfad=tmp_path,
+                leer_modus=LeererPfadModus.VERBOTEN
+            )
+            self.assertTrue(result.erfolgreich)   # neu: jetzt True, nicht False
+            self.assertIn("Datei existiert bereits – Entscheidung ausstehend.", result.fehler)
+            self.assertIsNone(result.entscheidung)
+        finally:
+            os.remove(tmp_path)
+
+    def test_existierende_datei_mit_entscheidung_ersetzen(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+            tmp_path = tmp_file.name
+        try:
+            result = self.pruefer.pruefe(
+                pfad=tmp_path,
+                leer_modus=LeererPfadModus.VERBOTEN,
+                vorhandene_datei_entscheidung=DateiEntscheidung.ERSETZEN
+            )
+            self.assertTrue(result.erfolgreich)
+            self.assertEqual(result.entscheidung, DateiEntscheidung.ERSETZEN)
+        finally:
+            os.remove(tmp_path)
+
+    def test_datei_nicht_existiert(self):
+        fake_path = os.path.join(self.plugin_pfad, "nicht_existierend.gpkg")
+        result = self.pruefer.pruefe(
+            pfad=fake_path,
+            leer_modus=LeererPfadModus.VERBOTEN
+        )
+        self.assertTrue(result.erfolgreich)
+        self.assertEqual(result.pfad, fake_path)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/test_linkpruefer.py

@@ -0,0 +1,125 @@
+# test/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 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
+
+
+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)
+
+        checker = Linkpruefer("https://example.com/service", "REST")
+        result = checker.ausfuehren()
+
+        self.assertTrue(result.erfolgreich)
+        self.assertEqual(result.daten['typ'], 'REST')
+        self.assertEqual(result.daten['quelle'], 'remote')
+        self.assertEqual(result.fehler, [])
+        self.assertEqual(result.warnungen, [])
+
+    @patch('linkpruefer.QgsNetworkAccessManager.head')
+    def test_remote_link_failure(self, mock_head):
+        mock_head.return_value = DummyReply(1, 404)
+
+        checker = Linkpruefer("https://example.com/kaputt", "WMS")
+        result = checker.ausfuehren()
+
+        self.assertFalse(result.erfolgreich)
+        self.assertIn("Verbindungsfehler: Simulierter Fehler", result.fehler)
+
+    # ----------------------------
+    # 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")
+
+    # ----------------------------
+    # 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()

test/test_pruefmanager.py

@@ -0,0 +1,36 @@
+import unittest
+import os
+from unittest.mock import patch
+from pruefmanager import PruefManager
+from Dateipruefer import DateiEntscheidung
+import sys
+
+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):
+        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):
+        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):
+        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):
+        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):
+        self.assertFalse(self.manager.frage_temporär_verwenden())

test/test_stilpruefer.py

@@ -0,0 +1,47 @@
+import unittest
+import tempfile
+import os
+from stilpruefer import Stilpruefer
+from pruef_ergebnis import PruefErgebnis
+
+
+class TestStilpruefer(unittest.TestCase):
+    def setUp(self):
+        self.pruefer = Stilpruefer()
+
+    def test_keine_datei_angegeben(self):
+        result = self.pruefer.pruefe("")
+        self.assertTrue(result.erfolgreich)
+        self.assertIn("Kein Stil angegeben.", result.warnungen)
+        self.assertIsNone(result.daten["stil"])
+
+    def test_datei_existiert_mit_qml(self):
+        with tempfile.NamedTemporaryFile(suffix=".qml", delete=False) as tmp_file:
+            tmp_path = tmp_file.name
+        try:
+            result = self.pruefer.pruefe(tmp_path)
+            self.assertTrue(result.erfolgreich)
+            self.assertEqual(result.daten["stil"], tmp_path)
+            self.assertEqual(result.fehler, [])
+        finally:
+            os.remove(tmp_path)
+
+    def test_datei_existiert_falsche_endung(self):
+        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp_file:
+            tmp_path = tmp_file.name
+        try:
+            result = self.pruefer.pruefe(tmp_path)
+            self.assertFalse(result.erfolgreich)
+            self.assertIn("Ungültige Dateiendung", result.fehler[0])
+        finally:
+            os.remove(tmp_path)
+
+    def test_datei_existiert_nicht(self):
+        fake_path = os.path.join(tempfile.gettempdir(), "nichtvorhanden.qml")
+        result = self.pruefer.pruefe(fake_path)
+        self.assertFalse(result.erfolgreich)
+        self.assertIn("Stildatei nicht gefunden", result.fehler[0])
+
+
+if __name__ == "__main__":
+    unittest.main()