forked from AG_QGIS/Plugin_SN_Basis
Wrappe modular aufgebaut, Tests erfolgreich, Menüleiste und Werzeugleiste werden eingetragen (QT6 und QT5)- (Es fehlen noch Fachplugins, um zu prüfen, ob es auch wirklich in QGIS geht)
This commit is contained in:
@@ -11,18 +11,22 @@ import inspect
|
||||
import os
|
||||
import sys
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Pre-Bootstrap: Plugin-Root in sys.path eintragen
|
||||
# ---------------------------------------------------------
|
||||
|
||||
THIS_FILE = Path(__file__).resolve()
|
||||
PLUGIN_ROOT = THIS_FILE.parents[2]
|
||||
|
||||
# Minimaler Bootstrap, um sn_basis importierbar zu machen
|
||||
TEST_DIR = os.path.dirname(__file__)
|
||||
PLUGIN_ROOT = os.path.abspath(os.path.join(TEST_DIR, "..", ".."))
|
||||
if str(PLUGIN_ROOT) not in sys.path:
|
||||
sys.path.insert(0, str(PLUGIN_ROOT))
|
||||
|
||||
if PLUGIN_ROOT not in sys.path:
|
||||
sys.path.insert(0, PLUGIN_ROOT)
|
||||
|
||||
|
||||
from sn_basis.functions import syswrapper
|
||||
from sn_basis.functions import (
|
||||
get_plugin_root,
|
||||
add_to_sys_path,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Bootstrap: Plugin-Root in sys.path eintragen
|
||||
@@ -33,13 +37,12 @@ def bootstrap():
|
||||
Simuliert das QGIS-Plugin-Startverhalten:
|
||||
stellt sicher, dass sn_basis importierbar ist.
|
||||
"""
|
||||
plugin_root = syswrapper.get_plugin_root()
|
||||
syswrapper.add_to_sys_path(plugin_root)
|
||||
plugin_root = get_plugin_root()
|
||||
add_to_sys_path(plugin_root)
|
||||
|
||||
|
||||
bootstrap()
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Farben
|
||||
# ---------------------------------------------------------
|
||||
@@ -53,12 +56,14 @@ RESET = "\033[0m"
|
||||
|
||||
GLOBAL_TEST_COUNTER = 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Farbige TestResult-Klasse
|
||||
# ---------------------------------------------------------
|
||||
|
||||
class ColoredTestResult(unittest.TextTestResult):
|
||||
|
||||
_last_test_class: type | None = None
|
||||
|
||||
|
||||
def startTest(self, test):
|
||||
global GLOBAL_TEST_COUNTER
|
||||
@@ -93,16 +98,19 @@ class ColoredTestResult(unittest.TextTestResult):
|
||||
super().addSuccess(test)
|
||||
self.stream.write(f"{GREEN}OK{RESET}\n")
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Farbiger TestRunner
|
||||
# ---------------------------------------------------------
|
||||
|
||||
class ColoredTestRunner(unittest.TextTestRunner):
|
||||
resultclass = ColoredTestResult
|
||||
|
||||
def _makeResult(self):
|
||||
result = super()._makeResult()
|
||||
result = ColoredTestResult(
|
||||
self.stream,
|
||||
self.descriptions,
|
||||
self.verbosity,
|
||||
)
|
||||
|
||||
original_start_test = result.startTest
|
||||
|
||||
def patched_start_test(test):
|
||||
@@ -127,7 +135,7 @@ def main():
|
||||
f"{datetime.datetime.now():%Y-%m-%d %H:%M:%S}{RESET}"
|
||||
)
|
||||
print("=" * 70 + "\n")
|
||||
|
||||
|
||||
loader = unittest.TestLoader()
|
||||
|
||||
suite = loader.discover(
|
||||
|
||||
@@ -1,2 +1,2 @@
|
||||
from sn_basis.functions import syswrapper
|
||||
syswrapper.add_to_sys_path(syswrapper.get_plugin_root())
|
||||
from sn_basis.functions import sys_wrapper
|
||||
sys_wrapper.add_to_sys_path(sys_wrapper.get_plugin_root())
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
# sn_basis/test/test_dateipruefer.py
|
||||
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
from sn_basis.modules.Dateipruefer import Dateipruefer
|
||||
from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
|
||||
|
||||
|
||||
|
||||
|
||||
class TestDateipruefer(unittest.TestCase):
|
||||
@@ -24,6 +22,7 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "leereingabe_erlaubt")
|
||||
self.assertIsNone(result.kontext)
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 2. Leere Eingabe nicht erlaubt
|
||||
@@ -38,6 +37,7 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "leereingabe_nicht_erlaubt")
|
||||
self.assertIsNone(result.kontext)
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 3. Standarddatei vorschlagen
|
||||
@@ -52,7 +52,7 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "standarddatei_vorschlagen")
|
||||
self.assertEqual(result.pfad, "/tmp/std.txt")
|
||||
self.assertEqual(result.kontext, Path("/tmp/std.txt"))
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 4. Temporäre Datei erlaubt
|
||||
@@ -67,11 +67,12 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "temporaer_erlaubt")
|
||||
self.assertIsNone(result.kontext)
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 5. Datei existiert nicht
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists", return_value=False)
|
||||
@patch("sn_basis.modules.Dateipruefer.file_exists", return_value=False)
|
||||
def test_datei_nicht_gefunden(self, mock_exists):
|
||||
pruefer = Dateipruefer(
|
||||
pfad="/tmp/nichtvorhanden.txt"
|
||||
@@ -81,13 +82,13 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "datei_nicht_gefunden")
|
||||
self.assertEqual(result.kontext, Path("/tmp/nichtvorhanden.txt"))
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 6. Datei existiert
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists", return_value=True)
|
||||
@patch("sn_basis.functions.syswrapper.is_file", return_value=True)
|
||||
def test_datei_ok(self, mock_isfile, mock_exists):
|
||||
@patch("sn_basis.modules.Dateipruefer.file_exists", return_value=True)
|
||||
def test_datei_ok(self, mock_exists):
|
||||
pruefer = Dateipruefer(
|
||||
pfad="/tmp/test.txt"
|
||||
)
|
||||
@@ -96,7 +97,7 @@ class TestDateipruefer(unittest.TestCase):
|
||||
|
||||
self.assertTrue(result.ok)
|
||||
self.assertEqual(result.aktion, "ok")
|
||||
self.assertEqual(result.pfad, "/tmp/test.txt")
|
||||
self.assertEqual(result.kontext, Path("/tmp/test.txt"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -78,18 +78,19 @@ def mock_is_layer_editable(layer):
|
||||
class TestLayerpruefer(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
# Monkeypatching der Wrapper-Funktionen
|
||||
import sn_basis.functions.qgisqt_wrapper as wrapper
|
||||
# Monkeypatching der im Layerpruefer verwendeten Wrapper-Funktionen
|
||||
import sn_basis.modules.layerpruefer as module
|
||||
|
||||
module.layer_exists = mock_layer_exists
|
||||
module.is_layer_visible = mock_is_layer_visible
|
||||
module.get_layer_type = mock_get_layer_type
|
||||
module.get_layer_geometry_type = mock_get_layer_geometry_type
|
||||
module.get_layer_feature_count = mock_get_layer_feature_count
|
||||
module.get_layer_crs = mock_get_layer_crs
|
||||
module.get_layer_fields = mock_get_layer_fields
|
||||
module.get_layer_source = mock_get_layer_source
|
||||
module.is_layer_editable = mock_is_layer_editable
|
||||
|
||||
wrapper.layer_exists = mock_layer_exists
|
||||
wrapper.is_layer_visible = mock_is_layer_visible
|
||||
wrapper.get_layer_type = mock_get_layer_type
|
||||
wrapper.get_layer_geometry_type = mock_get_layer_geometry_type
|
||||
wrapper.get_layer_feature_count = mock_get_layer_feature_count
|
||||
wrapper.get_layer_crs = mock_get_layer_crs
|
||||
wrapper.get_layer_fields = mock_get_layer_fields
|
||||
wrapper.get_layer_source = mock_get_layer_source
|
||||
wrapper.is_layer_editable = mock_is_layer_editable
|
||||
|
||||
# -----------------------------------------------------
|
||||
# Tests
|
||||
|
||||
@@ -1,107 +1,78 @@
|
||||
# sn_basis/test/test_linkpruefer.py
|
||||
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
from sn_basis.modules.linkpruefer import Linkpruefer
|
||||
from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
|
||||
from sn_basis.functions.qgiscore_wrapper import NetworkReply
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Mock-Ergebnisse für network_head()
|
||||
# ---------------------------------------------------------
|
||||
|
||||
class MockResponseOK:
|
||||
ok = True
|
||||
status = 200
|
||||
error = None
|
||||
|
||||
|
||||
class MockResponseNotFound:
|
||||
ok = False
|
||||
status = 404
|
||||
error = "Not Found"
|
||||
|
||||
|
||||
class MockResponseConnectionError:
|
||||
ok = False
|
||||
status = None
|
||||
error = "Connection refused"
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Testklasse
|
||||
# ---------------------------------------------------------
|
||||
|
||||
class TestLinkpruefer(unittest.TestCase):
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 1. Remote-Link erreichbar
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.network_head")
|
||||
@patch("sn_basis.modules.linkpruefer.network_head")
|
||||
def test_remote_link_ok(self, mock_head):
|
||||
mock_head.return_value = MockResponseOK()
|
||||
mock_head.return_value = NetworkReply(error=0)
|
||||
|
||||
lp = Linkpruefer("http://example.com", "REST")
|
||||
result = lp.pruefe()
|
||||
lp = Linkpruefer()
|
||||
result = lp.pruefe("http://example.com")
|
||||
|
||||
self.assertTrue(result.ok)
|
||||
self.assertEqual(result.aktion, "ok")
|
||||
self.assertEqual(result.kontext, "http://example.com")
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 2. Remote-Link nicht erreichbar
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.network_head")
|
||||
@patch("sn_basis.modules.linkpruefer.network_head")
|
||||
def test_remote_link_error(self, mock_head):
|
||||
mock_head.return_value = MockResponseConnectionError()
|
||||
mock_head.return_value = NetworkReply(error=1)
|
||||
|
||||
lp = Linkpruefer("http://example.com", "REST")
|
||||
result = lp.pruefe()
|
||||
lp = Linkpruefer()
|
||||
result = lp.pruefe("http://example.com")
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "url_nicht_erreichbar")
|
||||
self.assertIn("Connection refused", result.meldung)
|
||||
self.assertEqual(result.kontext, "http://example.com")
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 3. Remote-Link 404
|
||||
# 3. Netzwerkfehler (None)
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.network_head")
|
||||
def test_remote_link_404(self, mock_head):
|
||||
mock_head.return_value = MockResponseNotFound()
|
||||
|
||||
lp = Linkpruefer("http://example.com/missing", "REST")
|
||||
result = lp.pruefe()
|
||||
@patch("sn_basis.modules.linkpruefer.network_head", return_value=None)
|
||||
def test_remote_link_network_error(self, mock_head):
|
||||
lp = Linkpruefer()
|
||||
result = lp.pruefe("http://example.com")
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "url_nicht_erreichbar")
|
||||
self.assertIn("404", result.meldung)
|
||||
self.assertEqual(result.aktion, "netzwerkfehler")
|
||||
self.assertEqual(result.kontext, "http://example.com")
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 4. Lokaler Pfad existiert nicht
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists")
|
||||
@patch("sn_basis.modules.linkpruefer.file_exists", return_value=False)
|
||||
def test_local_link_not_found(self, mock_exists):
|
||||
mock_exists.return_value = False
|
||||
|
||||
lp = Linkpruefer("/path/to/missing/file.shp", "OGR")
|
||||
result = lp.pruefe()
|
||||
lp = Linkpruefer()
|
||||
result = lp.pruefe("/path/to/missing/file.shp")
|
||||
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "pfad_nicht_gefunden")
|
||||
self.assertEqual(result.kontext, Path("/path/to/missing/file.shp"))
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 5. Lokaler Pfad existiert, aber ungewöhnlich
|
||||
# 5. Lokaler Pfad existiert
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists")
|
||||
def test_local_link_warning(self, mock_exists):
|
||||
mock_exists.return_value = True
|
||||
|
||||
lp = Linkpruefer("/path/to/file_without_extension", "OGR")
|
||||
result = lp.pruefe()
|
||||
@patch("sn_basis.modules.linkpruefer.file_exists", return_value=True)
|
||||
def test_local_link_ok(self, mock_exists):
|
||||
lp = Linkpruefer()
|
||||
result = lp.pruefe("/path/to/file.shp")
|
||||
|
||||
self.assertTrue(result.ok)
|
||||
self.assertEqual(result.aktion, "ok")
|
||||
self.assertIn("ungewöhnlich", result.meldung)
|
||||
self.assertEqual(result.kontext, Path("/path/to/file.shp"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -25,7 +25,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 2. Leere Eingabe erlaubt → Nutzer sagt JA
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=True)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=True)
|
||||
def test_leereingabe_erlaubt_ja(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Leer?", "leereingabe_erlaubt", None)
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
@@ -36,7 +36,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 3. Leere Eingabe erlaubt → Nutzer sagt NEIN
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=False)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=False)
|
||||
def test_leereingabe_erlaubt_nein(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Leer?", "leereingabe_erlaubt", None)
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
@@ -47,21 +47,33 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 4. Standarddatei vorschlagen → Nutzer sagt JA
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=True)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=True)
|
||||
def test_standarddatei_vorschlagen_ja(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Standarddatei verwenden?", "standarddatei_vorschlagen", "/tmp/std.txt")
|
||||
ergebnis = pruef_ergebnis(
|
||||
False,
|
||||
"Standarddatei verwenden?",
|
||||
"standarddatei_vorschlagen",
|
||||
"/tmp/std.txt",
|
||||
)
|
||||
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
|
||||
self.assertTrue(entscheidung.ok)
|
||||
self.assertEqual(entscheidung.aktion, "ok")
|
||||
self.assertEqual(entscheidung.pfad, "/tmp/std.txt")
|
||||
self.assertEqual(entscheidung.kontext, "/tmp/std.txt")
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 5. Standarddatei vorschlagen → Nutzer sagt NEIN
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=False)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=False)
|
||||
def test_standarddatei_vorschlagen_nein(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Standarddatei verwenden?", "standarddatei_vorschlagen", "/tmp/std.txt")
|
||||
ergebnis = pruef_ergebnis(
|
||||
False,
|
||||
"Standarddatei verwenden?",
|
||||
"standarddatei_vorschlagen",
|
||||
"/tmp/std.txt",
|
||||
)
|
||||
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
|
||||
self.assertFalse(entscheidung.ok)
|
||||
@@ -70,7 +82,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 6. Temporäre Datei erzeugen → Nutzer sagt JA
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=True)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=True)
|
||||
def test_temporaer_erlaubt_ja(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Temporär?", "temporaer_erlaubt", None)
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
@@ -81,7 +93,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 7. Temporäre Datei erzeugen → Nutzer sagt NEIN
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=False)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=False)
|
||||
def test_temporaer_erlaubt_nein(self, mock_ask):
|
||||
ergebnis = pruef_ergebnis(False, "Temporär?", "temporaer_erlaubt", None)
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
@@ -92,8 +104,8 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 8. Layer unsichtbar → Nutzer sagt JA
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=True)
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.set_layer_visible")
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=True)
|
||||
@patch("sn_basis.modules.Pruefmanager.set_layer_visible")
|
||||
def test_layer_unsichtbar_ja(self, mock_set, mock_ask):
|
||||
fake_layer = object()
|
||||
ergebnis = pruef_ergebnis(False, "Layer unsichtbar", "layer_unsichtbar", fake_layer)
|
||||
@@ -107,7 +119,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 9. Layer unsichtbar → Nutzer sagt NEIN
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.ask_yes_no", return_value=False)
|
||||
@patch("sn_basis.modules.Pruefmanager.ask_yes_no", return_value=False)
|
||||
def test_layer_unsichtbar_nein(self, mock_ask):
|
||||
fake_layer = object()
|
||||
ergebnis = pruef_ergebnis(False, "Layer unsichtbar", "layer_unsichtbar", fake_layer)
|
||||
@@ -120,7 +132,7 @@ class TestPruefmanager(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 10. Fehlerhafte Aktion → Fallback
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.warning")
|
||||
@patch("sn_basis.modules.Pruefmanager.warning")
|
||||
def test_unbekannte_aktion(self, mock_warn):
|
||||
ergebnis = pruef_ergebnis(False, "???", "unbekannt", None)
|
||||
entscheidung = self.manager.verarbeite(ergebnis)
|
||||
|
||||
@@ -11,7 +11,7 @@ class TestSettingsLogic(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# Test: load() liest alle Variablen über get_variable()
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.get_variable")
|
||||
@patch("sn_basis.functions.settings_logic.get_variable")
|
||||
def test_load(self, mock_get):
|
||||
# Mock-Rückgabe für jede Variable
|
||||
mock_get.side_effect = lambda key, scope="project": f"wert_{key}"
|
||||
@@ -30,7 +30,7 @@ class TestSettingsLogic(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# Test: save() ruft set_variable() nur für bekannte Keys auf
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.qgisqt_wrapper.set_variable")
|
||||
@patch("sn_basis.functions.settings_logic.set_variable")
|
||||
def test_save(self, mock_set):
|
||||
logic = SettingsLogic()
|
||||
|
||||
|
||||
@@ -3,10 +3,10 @@
|
||||
import unittest
|
||||
import tempfile
|
||||
import os
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
from sn_basis.modules.stilpruefer import Stilpruefer
|
||||
from sn_basis.modules.pruef_ergebnis import pruef_ergebnis
|
||||
|
||||
|
||||
class TestStilpruefer(unittest.TestCase):
|
||||
@@ -23,13 +23,13 @@ class TestStilpruefer(unittest.TestCase):
|
||||
self.assertTrue(result.ok)
|
||||
self.assertEqual(result.aktion, "ok")
|
||||
self.assertIn("Kein Stil angegeben", result.meldung)
|
||||
self.assertIsNone(result.kontext)
|
||||
|
||||
# -----------------------------------------------------
|
||||
# 2. Datei existiert und ist .qml
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists", return_value=True)
|
||||
@patch("sn_basis.functions.syswrapper.is_file", return_value=True)
|
||||
def test_datei_existiert_mit_qml(self, mock_isfile, mock_exists):
|
||||
@patch("sn_basis.modules.stilpruefer.file_exists", return_value=True)
|
||||
def test_datei_existiert_mit_qml(self, mock_exists):
|
||||
with tempfile.NamedTemporaryFile(suffix=".qml", delete=False) as tmp:
|
||||
tmp_path = tmp.name
|
||||
|
||||
@@ -37,8 +37,8 @@ class TestStilpruefer(unittest.TestCase):
|
||||
result = self.pruefer.pruefe(tmp_path)
|
||||
|
||||
self.assertTrue(result.ok)
|
||||
self.assertEqual(result.aktion, "ok")
|
||||
self.assertEqual(result.pfad, tmp_path)
|
||||
self.assertEqual(result.aktion, "stil_anwendbar")
|
||||
self.assertEqual(result.kontext, Path(tmp_path))
|
||||
|
||||
finally:
|
||||
os.remove(tmp_path)
|
||||
@@ -46,9 +46,8 @@ class TestStilpruefer(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 3. Datei existiert, aber falsche Endung
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists", return_value=True)
|
||||
@patch("sn_basis.functions.syswrapper.is_file", return_value=True)
|
||||
def test_datei_existiert_falsche_endung(self, mock_isfile, mock_exists):
|
||||
@patch("sn_basis.modules.stilpruefer.file_exists", return_value=True)
|
||||
def test_datei_existiert_falsche_endung(self, mock_exists):
|
||||
with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
|
||||
tmp_path = tmp.name
|
||||
|
||||
@@ -58,6 +57,7 @@ class TestStilpruefer(unittest.TestCase):
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "falsche_endung")
|
||||
self.assertIn(".qml", result.meldung)
|
||||
self.assertEqual(result.kontext, Path(tmp_path))
|
||||
|
||||
finally:
|
||||
os.remove(tmp_path)
|
||||
@@ -65,7 +65,7 @@ class TestStilpruefer(unittest.TestCase):
|
||||
# -----------------------------------------------------
|
||||
# 4. Datei existiert nicht
|
||||
# -----------------------------------------------------
|
||||
@patch("sn_basis.functions.syswrapper.file_exists", return_value=False)
|
||||
@patch("sn_basis.modules.stilpruefer.file_exists", return_value=False)
|
||||
def test_datei_existiert_nicht(self, mock_exists):
|
||||
fake_path = "/tmp/nichtvorhanden.qml"
|
||||
|
||||
@@ -74,6 +74,7 @@ class TestStilpruefer(unittest.TestCase):
|
||||
self.assertFalse(result.ok)
|
||||
self.assertEqual(result.aktion, "datei_nicht_gefunden")
|
||||
self.assertIn("nicht gefunden", result.meldung)
|
||||
self.assertEqual(result.kontext, Path(fake_path))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -1,164 +0,0 @@
|
||||
# sn_basis/test/test_wrapper.py
|
||||
|
||||
import unittest
|
||||
import os
|
||||
import tempfile
|
||||
|
||||
# Wrapper importieren
|
||||
import sn_basis.functions.syswrapper as syswrapper
|
||||
import sn_basis.functions.qgisqt_wrapper as qgisqt
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Mock-Layer für qgisqt_wrapper
|
||||
# ---------------------------------------------------------
|
||||
class MockLayer:
|
||||
def __init__(
|
||||
self,
|
||||
exists=True,
|
||||
visible=True,
|
||||
layer_type="vector",
|
||||
geometry_type="Polygon",
|
||||
feature_count=10,
|
||||
crs="EPSG:25833",
|
||||
fields=None,
|
||||
source="/tmp/test.shp",
|
||||
editable=True,
|
||||
):
|
||||
self.exists = exists
|
||||
self.visible = visible
|
||||
self.layer_type = layer_type
|
||||
self.geometry_type = geometry_type
|
||||
self.feature_count = feature_count
|
||||
self.crs = crs
|
||||
self.fields = fields or []
|
||||
self.source = source
|
||||
self.editable = editable
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Monkeypatching für qgisqt_wrapper
|
||||
# ---------------------------------------------------------
|
||||
def mock_layer_exists(layer):
|
||||
return layer is not None and layer.exists
|
||||
|
||||
|
||||
def mock_is_layer_visible(layer):
|
||||
return layer.visible
|
||||
|
||||
|
||||
def mock_get_layer_type(layer):
|
||||
return layer.layer_type
|
||||
|
||||
|
||||
def mock_get_layer_geometry_type(layer):
|
||||
return layer.geometry_type
|
||||
|
||||
|
||||
def mock_get_layer_feature_count(layer):
|
||||
return layer.feature_count
|
||||
|
||||
|
||||
def mock_get_layer_crs(layer):
|
||||
return layer.crs
|
||||
|
||||
|
||||
def mock_get_layer_fields(layer):
|
||||
return layer.fields
|
||||
|
||||
|
||||
def mock_get_layer_source(layer):
|
||||
return layer.source
|
||||
|
||||
|
||||
def mock_is_layer_editable(layer):
|
||||
return layer.editable
|
||||
|
||||
|
||||
# ---------------------------------------------------------
|
||||
# Testklasse
|
||||
# ---------------------------------------------------------
|
||||
class TestWrapper(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
# qgisqt_wrapper monkeypatchen
|
||||
qgisqt.layer_exists = mock_layer_exists
|
||||
qgisqt.is_layer_visible = mock_is_layer_visible
|
||||
qgisqt.get_layer_type = mock_get_layer_type
|
||||
qgisqt.get_layer_geometry_type = mock_get_layer_geometry_type
|
||||
qgisqt.get_layer_feature_count = mock_get_layer_feature_count
|
||||
qgisqt.get_layer_crs = mock_get_layer_crs
|
||||
qgisqt.get_layer_fields = mock_get_layer_fields
|
||||
qgisqt.get_layer_source = mock_get_layer_source
|
||||
qgisqt.is_layer_editable = mock_is_layer_editable
|
||||
|
||||
# -----------------------------------------------------
|
||||
# syswrapper Tests
|
||||
# -----------------------------------------------------
|
||||
|
||||
def test_syswrapper_file_exists(self):
|
||||
with tempfile.NamedTemporaryFile(delete=True) as tmp:
|
||||
self.assertTrue(syswrapper.file_exists(tmp.name))
|
||||
self.assertFalse(syswrapper.file_exists("/path/does/not/exist"))
|
||||
|
||||
def test_syswrapper_is_file(self):
|
||||
with tempfile.NamedTemporaryFile(delete=True) as tmp:
|
||||
self.assertTrue(syswrapper.is_file(tmp.name))
|
||||
self.assertFalse(syswrapper.is_file("/path/does/not/exist"))
|
||||
|
||||
def test_syswrapper_join_path(self):
|
||||
result = syswrapper.join_path("/tmp", "test.txt")
|
||||
self.assertEqual(result, "/tmp/test.txt")
|
||||
|
||||
# -----------------------------------------------------
|
||||
# qgisqt_wrapper Tests (Mock-Modus)
|
||||
# -----------------------------------------------------
|
||||
|
||||
def test_qgisqt_layer_exists(self):
|
||||
layer = MockLayer(exists=True)
|
||||
self.assertTrue(qgisqt.layer_exists(layer))
|
||||
|
||||
layer = MockLayer(exists=False)
|
||||
self.assertFalse(qgisqt.layer_exists(layer))
|
||||
|
||||
def test_qgisqt_layer_visible(self):
|
||||
layer = MockLayer(visible=True)
|
||||
self.assertTrue(qgisqt.is_layer_visible(layer))
|
||||
|
||||
layer = MockLayer(visible=False)
|
||||
self.assertFalse(qgisqt.is_layer_visible(layer))
|
||||
|
||||
def test_qgisqt_layer_type(self):
|
||||
layer = MockLayer(layer_type="vector")
|
||||
self.assertEqual(qgisqt.get_layer_type(layer), "vector")
|
||||
|
||||
def test_qgisqt_geometry_type(self):
|
||||
layer = MockLayer(geometry_type="Polygon")
|
||||
self.assertEqual(qgisqt.get_layer_geometry_type(layer), "Polygon")
|
||||
|
||||
def test_qgisqt_feature_count(self):
|
||||
layer = MockLayer(feature_count=12)
|
||||
self.assertEqual(qgisqt.get_layer_feature_count(layer), 12)
|
||||
|
||||
def test_qgisqt_crs(self):
|
||||
layer = MockLayer(crs="EPSG:4326")
|
||||
self.assertEqual(qgisqt.get_layer_crs(layer), "EPSG:4326")
|
||||
|
||||
def test_qgisqt_fields(self):
|
||||
layer = MockLayer(fields=["id", "name"])
|
||||
self.assertEqual(qgisqt.get_layer_fields(layer), ["id", "name"])
|
||||
|
||||
def test_qgisqt_source(self):
|
||||
layer = MockLayer(source="/tmp/test.shp")
|
||||
self.assertEqual(qgisqt.get_layer_source(layer), "/tmp/test.shp")
|
||||
|
||||
def test_qgisqt_editable(self):
|
||||
layer = MockLayer(editable=True)
|
||||
self.assertTrue(qgisqt.is_layer_editable(layer))
|
||||
|
||||
layer = MockLayer(editable=False)
|
||||
self.assertFalse(qgisqt.is_layer_editable(layer))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user