Tests überarbeitet, Mocks und coverage eingefügt

modules/linkpruefer.py

@@ -1,17 +1,19 @@
-# Importiert den Event-Loop und URL-Objekte aus der PyQt-Bibliothek von QGIS
-from qgis.PyQt.QtCore import QEventLoop, QUrl
-# Importiert den NetworkAccessManager aus dem QGIS Core-Modul
-from qgis.core import QgsNetworkAccessManager
-# Importiert das QNetworkRequest-Objekt für HTTP-Anfragen
-from qgis.PyQt.QtNetwork import QNetworkRequest
-# Importiert die Klasse für das Ergebnisobjekt der Prüfung
-from pruef_ergebnis import PruefErgebnis
+# Linkpruefer.py – Qt5/Qt6-kompatibel über qt_compat
+
+from modules.qt_compat import (
+    QEventLoop,
+    QUrl,
+    QNetworkRequest,
+    QNetworkReply
+)
+
+from qgis.core import QgsNetworkAccessManager
+from modules.pruef_ergebnis import PruefErgebnis
+
 
-# Definiert die Klasse zum Prüfen von Links
 class Linkpruefer:
     """Prüft den Link mit QgsNetworkAccessManager und klassifiziert Anbieter nach Attribut."""
 
-    # Statische Zuordnung möglicher Anbietertypen als Konstanten
     ANBIETER_TYPEN: dict[str, str] = {
         "REST": "REST",
         "WFS": "WFS",
@@ -19,76 +21,57 @@ class Linkpruefer:
         "OGR": "OGR"
     }
 
-    # Konstruktor zum Initialisieren der Instanz
     def __init__(self, link: str, anbieter: str):
-        # Speichert den übergebenen Link als Instanzvariable
         self.link = link
-        
-       # Speichert den Anbietertyp, bereinigt und in Großbuchstaben (auch wenn leer oder None)
         self.anbieter = anbieter.upper().strip() if anbieter else ""
-        # Erstellt einen neuen NetworkAccessManager für Netzwerkverbindungen
         self.network_manager = QgsNetworkAccessManager()
 
-    # Methode zur Klassifizierung des Anbieters und der Quelle
     def klassifiziere_anbieter(self):
-        # Bestimmt den Typ auf Basis der vorgegebenen Konstante oder nimmt den Rohwert
         typ = self.ANBIETER_TYPEN.get(self.anbieter, self.anbieter)
-        # Unterscheidet zwischen "remote" (http/https) oder "local" (Dateipfad)
         quelle = "remote" if self.link.startswith(("http://", "https://")) else "local"
-        # Gibt Typ und Quelle als Dictionary zurück
-        return {
-            "typ": typ,
-            "quelle": quelle
-        }
+        return {"typ": typ, "quelle": quelle}
 
-
-    # Prüft die Erreichbarkeit und Plausibilität des Links
     def pruefe_link(self):
-        # Initialisiert Listen für Fehler und Warnungen
         fehler = []
         warnungen = []
 
-        # Prüft, ob ein Link übergeben wurde
         if not self.link:
             fehler.append("Link fehlt.")
             return PruefErgebnis(False, fehler=fehler, warnungen=warnungen)
-        
-        # Prüft, ob ein Anbieter angegeben ist
+
         if not self.anbieter or not self.anbieter.strip():
             fehler.append("Anbieter muss gesetzt werden und darf nicht leer sein.")
 
-        # Prüfung für Remote-Links (http/https)
+        # Remote-Links prüfen
         if self.link.startswith(("http://", "https://")):
-            # Erstellt eine HTTP-Anfrage mit dem Link
             request = QNetworkRequest(QUrl(self.link))
-            # Startet eine HEAD-Anfrage über den NetworkManager
             reply = self.network_manager.head(request)
 
-            # Wartet synchron auf die Netzwerkanwort (Event Loop)
             loop = QEventLoop()
             reply.finished.connect(loop.quit)
-            loop.exec_()
+            loop.exec()  # Qt5/Qt6-kompatibel über qt_compat
 
-            # Prüft auf Netzwerkfehler
-            if reply.error():
+            # Fehlerprüfung Qt5/Qt6-kompatibel
+            if reply.error() != QNetworkReply.NetworkError.NoError:
                 fehler.append(f"Verbindungsfehler: {reply.errorString()}")
             else:
-                # Holt den HTTP-Statuscode aus der Antwort
-                status = reply.attribute(reply.HttpStatusCodeAttribute)
-                # Prüft, ob der Status außerhalb des Erfolgsbereichs liegt
+                status = reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
                 if status is None or status < 200 or status >= 400:
                     fehler.append(f"Link nicht erreichbar: HTTP {status}")
-            # Räumt die Antwort auf (Vermeidung von Speicherlecks)
+
             reply.deleteLater()
+
         else:
-            # Plausibilitäts-Check für lokale Links (Dateien), prüft auf Dateiendung
+            # Lokale Pfade: Plausibilitätscheck
             if "." not in self.link.split("/")[-1]:
                 warnungen.append("Der lokale Link sieht ungewöhnlich aus.")
 
-        # Gibt das Ergebnisobjekt mit allen gesammelten Informationen zurück
-        return PruefErgebnis(len(fehler) == 0, daten=self.klassifiziere_anbieter(), fehler=fehler, warnungen=warnungen)
+        return PruefErgebnis(
+            len(fehler) == 0,
+            daten=self.klassifiziere_anbieter(),
+            fehler=fehler,
+            warnungen=warnungen
+        )
 
-    # Führt die Linkprüfung als externe Methode aus
     def ausfuehren(self):
-        # Gibt das Ergebnis der Prüf-Methode zurück
         return self.pruefe_link()