AG_QGIS/Plugin_SN_Verfahrensgebiet
3
1
Fork 1
Code Issues 10 Pull Requests Actions Releases 25 Wiki Activity
Files
d1a9748461306b511fe97028b58b1195677abe93
Plugin_SN_Verfahrensgebiet/tests/test_verfahrensgebiet_alkis_komplett.py
T
Daniel b25b4c83ac Umringsprüfung-Segmentbasiert
2026-04-23 22:24:14 +02:00

609 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""sn_verfahrensgebiet/tests/test_verfahrensgebiet_alkis_komplett.py
Unit-Tests für :mod:`sn_verfahrensgebiet.functions.verfahrensgebiet_alkis_komplett`.
Getestete Szenarien:
Erfolgsfall (Flächenübereinstimmung):
- Vollständiger Workflow → enriched Layer + flst_layer + bror_layer + LoadStatus.FIRST
- VKZ aus Projektvariable wird als Feld gesetzt (wenn vorhanden)
- Kein VKZ in Projektvariable → Feld wird nicht gesetzt (kein Fehler)
Abbruchpfade:
- verfahrensgebiet_alkis gibt LoadStatus.NONE → (None, None, None, NONE)
- flurstueck_alkis gibt LoadStatus.NONE → (None, None, None, NONE)
- Keine Flurstücke selektiert → (None, flst_layer, None, NONE) + Warnung
- erstelle_verfahrensgebiet_aus_auswahl liefert ungültigen Layer → (None, flst_layer, None, NONE)
- Progress-Abbruch nach Schritt 1 → sofortiger sauberer Rückgabestatus
Flächenvergleich:
- Übereinstimmung → show_info_dialog, keine Umringsprüfung
- Abweichung + Nein → kein Umringsprüfungs-Aufruf
- Abweichung + Ja → umringspruefung aufgerufen, Ergebnislayer ins Projekt
Cleanup:
- BROR-Layer wird bei Erfolg NICHT entfernt
- BROR-Layer wird bei Fehler entfernt (wenn in diesem Lauf hinzugefügt)
- TempVerfahrensgebiet wird stets entfernt
Hilfsfunktionen:
- _select_by_location: processing-Fallback liefert 0 → keine Exception
- _fuege_vkz_feld_hinzu: leeres VKZ wird ignoriert
- _vergleiche_flaechen: korrekte Toleranzlogik
- _lese_flaechen_toleranz: Default 0.0, parst Projektvariable
"""
import sys
import types
import unittest
from unittest.mock import patch, MagicMock
# ---------------------------------------------------------------------------
# Minimales QGIS-Mock-Setup
# ---------------------------------------------------------------------------
if "qgis" not in sys.modules:
qgis_mod = types.ModuleType("qgis")
qgis_core = types.ModuleType("qgis.core")
qgis_utils = types.ModuleType("qgis.utils")
qgis_utils.iface = types.SimpleNamespace()
qgis_utils.plugins = {}
qgis_mod.utils = qgis_utils
qgis_mod.core = qgis_core
sys.modules["qgis"] = qgis_mod
sys.modules["qgis.core"] = qgis_core
sys.modules["qgis.utils"] = qgis_utils
from sn_verfahrensgebiet.functions.verfahrensgebiet_alkis import LoadStatus
from sn_verfahrensgebiet.functions.verfahrensgebiet_alkis_komplett import (
verfahrensgebiet_alkis_komplett,
_select_by_location,
_fuege_vkz_feld_hinzu,
_vergleiche_flaechen,
_lese_flaechen_toleranz,
)
# ---------------------------------------------------------------------------
# Dummies
# ---------------------------------------------------------------------------
class _DummyRect:
def xMinimum(self): return 414000.0
def yMinimum(self): return 5657000.0
def xMaximum(self): return 415000.0
def yMaximum(self): return 5658000.0
def _make_layer(valid=True, name="Layer", lid="L1", feature_count=1, area=1000.0):
"""Erzeugt einen konfigurierten Mock-Layer mit getFeatures-Support."""
layer = MagicMock()
layer.isValid.return_value = valid
layer.id.return_value = lid
layer.name.return_value = name
layer.extent.return_value = _DummyRect()
layer.featureCount.return_value = feature_count
layer.selectedFeatureCount.return_value = feature_count
mock_geom = MagicMock()
mock_geom.isEmpty.return_value = False
mock_geom.area.return_value = area
mock_geom.boundary.return_value = MagicMock(isEmpty=lambda: True)
mock_feat = MagicMock()
mock_feat.geometry.return_value = mock_geom
layer.getFeatures.return_value = [mock_feat]
mock_crs = MagicMock()
mock_crs.authid.return_value = "EPSG:25833"
layer.crs.return_value = mock_crs
return layer
class _DummyProject:
def __init__(self):
self.added = []
self.removed = []
self._layers_by_name: dict = {}
def addMapLayer(self, layer):
self.added.append(layer)
def removeMapLayer(self, lid):
self.removed.append(lid)
def mapLayersByName(self, name):
return self._layers_by_name.get(name, [])
def instance(self):
return self
def _make_progress_mock(canceled=False):
prog = MagicMock()
prog.is_canceled.return_value = canceled
return prog
# ---------------------------------------------------------------------------
# Patch-Konstanten
# ---------------------------------------------------------------------------
_MOD = "sn_verfahrensgebiet.functions.verfahrensgebiet_alkis_komplett"
_PATCH_VG_ALKIS = f"{_MOD}.verfahrensgebiet_alkis"
_PATCH_GEM = f"{_MOD}.gemarkung_schluessel_und_namen_von_vg_geometrie"
_PATCH_FLST = f"{_MOD}.flurstueck_alkis"
_PATCH_SELECT = f"{_MOD}._select_by_location"
_PATCH_ERSTELLE = f"{_MOD}.erstelle_verfahrensgebiet_aus_auswahl"
_PATCH_VKZ = f"{_MOD}._fuege_vkz_feld_hinzu"
_PATCH_PROJECT = f"{_MOD}.QgsProject"
_PATCH_MSGBOX = f"{_MOD}.QMessageBox"
_PATCH_WARNING = f"{_MOD}.warning"
_PATCH_GET_VAR = f"{_MOD}.get_variable"
_PATCH_PROGRESS = f"{_MOD}.create_progress_dialog"
_PATCH_VERGLEICHE = f"{_MOD}._vergleiche_flaechen"
_PATCH_SHOW_INFO = f"{_MOD}.show_info_dialog"
_PATCH_ASK_YES_NO = f"{_MOD}.ask_yes_no"
_PATCH_UMRING = f"{_MOD}.umringspruefung"
# ---------------------------------------------------------------------------
# Tests: _select_by_location
# ---------------------------------------------------------------------------
class TestSelectByLocation(unittest.TestCase):
def test_processing_not_available_returns_zero(self):
flst, vg = MagicMock(), MagicMock()
with patch.dict("sys.modules", {"processing": None}):
result = _select_by_location(flst, vg)
self.assertEqual(result, 0)
def test_processing_success_returns_count(self):
flst = MagicMock()
flst.selectedFeatureCount.return_value = 7
vg = MagicMock()
mock_proc = MagicMock()
with patch.dict("sys.modules", {"processing": mock_proc}):
result = _select_by_location(flst, vg)
self.assertEqual(result, 7)
def test_processing_exception_returns_zero(self):
flst, vg = MagicMock(), MagicMock()
mock_proc = MagicMock()
mock_proc.run.side_effect = RuntimeError("Kein QGIS")
with patch.dict("sys.modules", {"processing": mock_proc}):
result = _select_by_location(flst, vg)
self.assertEqual(result, 0)
# ---------------------------------------------------------------------------
# Tests: _fuege_vkz_feld_hinzu
# ---------------------------------------------------------------------------
class TestFuegeVkzFeldHinzu(unittest.TestCase):
def test_empty_vkz_does_nothing(self):
layer = MagicMock()
_fuege_vkz_feld_hinzu(layer, "")
layer.dataProvider.assert_not_called()
def test_none_vkz_does_nothing(self):
layer = MagicMock()
_fuege_vkz_feld_hinzu(layer, None)
layer.dataProvider.assert_not_called()
def test_vkz_field_added(self):
pr = MagicMock()
pr.addAttributes.return_value = True
pr.changeAttributeValues.return_value = True
layer = MagicMock()
layer.dataProvider.return_value = pr
layer.fields.return_value.indexFromName.return_value = 2
layer.getFeatures.return_value = []
_fuege_vkz_feld_hinzu(layer, "VF-2024-001")
pr.addAttributes.assert_called_once()
# ---------------------------------------------------------------------------
# Tests: _vergleiche_flaechen / _lese_flaechen_toleranz
# ---------------------------------------------------------------------------
class TestFlaechenvergleich(unittest.TestCase):
def _layer(self, area: float):
layer = MagicMock()
geom = MagicMock()
geom.isEmpty.return_value = False
geom.area.return_value = area
feat = MagicMock()
feat.geometry.return_value = geom
layer.getFeatures.return_value = [feat]
return layer
def test_gleiche_flaeche_stimmt_ueberein(self):
self.assertTrue(_vergleiche_flaechen(self._layer(1234.5), self._layer(1234.5), 0.0)[2])
def test_verschiedene_flaeche_stimmt_nicht_ueberein(self):
self.assertFalse(_vergleiche_flaechen(self._layer(1234.5), self._layer(1200.0), 0.0)[2])
def test_differenz_innerhalb_toleranz(self):
self.assertTrue(_vergleiche_flaechen(self._layer(1234.5), self._layer(1234.8), 1.0)[2])
def test_differenz_ausserhalb_toleranz(self):
self.assertFalse(_vergleiche_flaechen(self._layer(1234.5), self._layer(1236.0), 1.0)[2])
def test_flaechen_werte_korrekt(self):
bror_f, vg_f, _ = _vergleiche_flaechen(self._layer(800.0), self._layer(750.0))
self.assertAlmostEqual(bror_f, 800.0)
self.assertAlmostEqual(vg_f, 750.0)
@patch(f"{_MOD}.get_variable", return_value=None)
def test_lese_toleranz_default_ist_null(self, _):
self.assertEqual(_lese_flaechen_toleranz(), 0.0)
@patch(f"{_MOD}.get_variable", return_value="2.5")
def test_lese_toleranz_parst_string(self, _):
self.assertAlmostEqual(_lese_flaechen_toleranz(), 2.5)
@patch(f"{_MOD}.get_variable", return_value="ungueltig")
def test_lese_toleranz_ungueltig_fallback_null(self, _):
self.assertEqual(_lese_flaechen_toleranz(), 0.0)
# ---------------------------------------------------------------------------
# Tests: verfahrensgebiet_alkis_komplett (Hauptworkflow)
# ---------------------------------------------------------------------------
class TestVerfahrensgebietAlkisKomplett(unittest.TestCase):
# ------------------------------------------------------------------ #
# Abbruchpfade
# ------------------------------------------------------------------ #
@patch(_PATCH_PROGRESS)
@patch(_PATCH_PROJECT)
@patch(_PATCH_VG_ALKIS)
def test_vg_alkis_none_aborts(self, mock_vg, mock_proj, mock_prog):
mock_proj.instance.return_value = _DummyProject()
mock_vg.return_value = (None, LoadStatus.NONE, [])
mock_prog.return_value = _make_progress_mock()
enriched, flst, bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIsNone(enriched)
self.assertIsNone(flst)
self.assertIsNone(bror)
self.assertEqual(status, LoadStatus.NONE)
@patch(_PATCH_PROGRESS)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_VG_ALKIS)
def test_flst_none_aborts(self, mock_vg, mock_gem, mock_proj, mock_prog):
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = [("1234", "Muster")]
mock_prog.return_value = _make_progress_mock()
with patch(_PATCH_FLST, return_value=(None, LoadStatus.NONE)):
enriched, flst, bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIsNone(enriched)
self.assertIsNone(flst)
self.assertEqual(status, LoadStatus.NONE)
@patch(_PATCH_PROGRESS)
@patch(_PATCH_MSGBOX)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_no_selection_returns_none_enriched(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select, mock_msgbox, mock_prog
):
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke")
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 0
mock_prog.return_value = _make_progress_mock()
enriched, flst, bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIsNone(enriched)
self.assertIs(flst, flst_layer)
self.assertIsNone(bror)
self.assertEqual(status, LoadStatus.NONE)
mock_msgbox.warning.assert_called_once()
@patch(_PATCH_PROGRESS)
@patch(_PATCH_MSGBOX)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_invalid_enriched_layer_returns_none(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select, mock_erstelle, mock_msgbox, mock_prog
):
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke")
bad_enriched = _make_layer(valid=False)
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 5
mock_erstelle.return_value = (bad_enriched, 0, 5)
mock_prog.return_value = _make_progress_mock()
enriched, flst, bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIsNone(enriched)
self.assertIs(flst, flst_layer)
self.assertIsNone(bror)
self.assertEqual(status, LoadStatus.NONE)
mock_msgbox.critical.assert_called_once()
@patch(_PATCH_PROGRESS)
@patch(_PATCH_PROJECT)
@patch(_PATCH_VG_ALKIS)
def test_progress_cancel_after_step1_returns_none(self, mock_vg, mock_proj, mock_prog):
"""Abbruch nach Schritt 1 → sofortiger sauberer Rückgabestatus."""
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
prog = MagicMock()
prog.is_canceled.side_effect = [False, True] # 1. Aufruf False, 2. True
mock_prog.return_value = prog
enriched, flst, bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIsNone(enriched)
self.assertEqual(status, LoadStatus.NONE)
# ------------------------------------------------------------------ #
# Flächenvergleich – Übereinstimmung
# ------------------------------------------------------------------ #
@patch(_PATCH_PROGRESS)
@patch(_PATCH_SHOW_INFO)
@patch(_PATCH_VERGLEICHE)
@patch(_PATCH_VKZ)
@patch(_PATCH_GET_VAR)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_success_flaechen_match_zeigt_info(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_info, mock_prog,
):
"""Flächenübereinstimmung → show_info_dialog mit erwartetem Text."""
proj_inst = _DummyProject()
mock_proj.instance.return_value = proj_inst
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke", lid="FLST1")
enriched = _make_layer(name="Verfahrensgebiet", lid="VG_ENRICHED", valid=True)
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = [("1234", "Muster")]
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 3
mock_erstelle.return_value = (enriched, 3, 0)
mock_get_var.return_value = "VF-2024-001"
mock_vergl.return_value = (1234.5, 1234.5, True)
mock_prog.return_value = _make_progress_mock()
result_enriched, result_flst, result_bror, status = verfahrensgebiet_alkis_komplett(None)
self.assertIs(result_enriched, enriched)
self.assertIs(result_flst, flst_layer)
self.assertIs(result_bror, vg_layer)
self.assertEqual(status, LoadStatus.FIRST)
mock_vkz.assert_called_once_with(enriched, "VF-2024-001")
mock_info.assert_called_once()
self.assertIn("erwarteter Geometrie", mock_info.call_args[0][1])
@patch(_PATCH_PROGRESS)
@patch(_PATCH_SHOW_INFO)
@patch(_PATCH_VERGLEICHE)
@patch(_PATCH_VKZ)
@patch(_PATCH_GET_VAR)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_no_vkz_variable_passes_empty_string(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_info, mock_prog,
):
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke")
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 2
mock_erstelle.return_value = (enriched, 2, 0)
mock_get_var.return_value = ""
mock_vergl.return_value = (1000.0, 1000.0, True)
mock_prog.return_value = _make_progress_mock()
verfahrensgebiet_alkis_komplett(None)
mock_vkz.assert_called_once_with(enriched, "")
# ------------------------------------------------------------------ #
# Flächenvergleich – Abweichung + Nein
# ------------------------------------------------------------------ #
@patch(_PATCH_PROGRESS)
@patch(_PATCH_UMRING)
@patch(_PATCH_ASK_YES_NO)
@patch(_PATCH_VERGLEICHE)
@patch(_PATCH_VKZ)
@patch(_PATCH_GET_VAR)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_flaechen_abweichung_nein_kein_umring(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask, mock_umring, mock_prog,
):
"""Abweichung + Nein → umringspruefung wird NICHT aufgerufen."""
mock_proj.instance.return_value = _DummyProject()
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke")
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 3
mock_erstelle.return_value = (enriched, 3, 0)
mock_get_var.return_value = ""
mock_vergl.return_value = (1000.0, 800.0, False)
mock_ask.return_value = False
mock_prog.return_value = _make_progress_mock()
result_enriched, _, _, status = verfahrensgebiet_alkis_komplett(None)
mock_umring.assert_not_called()
self.assertIs(result_enriched, enriched)
self.assertEqual(status, LoadStatus.FIRST)
# ------------------------------------------------------------------ #
# Flächenvergleich – Abweichung + Ja → Umringsprüfung
# ------------------------------------------------------------------ #
@patch(_PATCH_PROGRESS)
@patch(_PATCH_SHOW_INFO)
@patch(_PATCH_UMRING)
@patch(_PATCH_ASK_YES_NO)
@patch(_PATCH_VERGLEICHE)
@patch(_PATCH_VKZ)
@patch(_PATCH_GET_VAR)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_flaechen_abweichung_ja_startet_umringspruefung(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_ask,
mock_umring, mock_info, mock_prog,
):
"""Abweichung + Ja → umringspruefung aufgerufen, Ergebnislayer ins Projekt,
Abschlussmeldung mit Konfliktanzahl."""
proj_inst = _DummyProject()
mock_proj.instance.return_value = proj_inst
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)")
flst_layer = _make_layer(name="Flurstücke")
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
ergebnis_layer = _make_layer(name="Umringsprüfung", lid="UMRING_L")
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 3
mock_erstelle.return_value = (enriched, 3, 0)
mock_get_var.return_value = ""
mock_vergl.return_value = (1000.0, 800.0, False)
mock_ask.return_value = True
mock_umring.return_value = (ergebnis_layer, 4)
mock_prog.return_value = _make_progress_mock()
result_enriched, _, _, status = verfahrensgebiet_alkis_komplett(None)
mock_umring.assert_called_once()
self.assertIn(ergebnis_layer, proj_inst.added)
mock_info.assert_called_once()
self.assertIn("4", mock_info.call_args[0][1])
self.assertIn("Konfliktstellen", mock_info.call_args[0][1])
self.assertEqual(status, LoadStatus.FIRST)
# ------------------------------------------------------------------ #
# Cleanup-Verhalten
# ------------------------------------------------------------------ #
@patch(_PATCH_PROGRESS)
@patch(_PATCH_SHOW_INFO)
@patch(_PATCH_VERGLEICHE)
@patch(_PATCH_VKZ)
@patch(_PATCH_GET_VAR)
@patch(_PATCH_ERSTELLE)
@patch(_PATCH_SELECT)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_FLST)
@patch(_PATCH_VG_ALKIS)
def test_bror_layer_bleibt_bei_erfolg_im_projekt(
self, mock_vg, mock_flst, mock_gem, mock_proj, mock_select,
mock_erstelle, mock_get_var, mock_vkz, mock_vergl, mock_info, mock_prog,
):
"""Bei Erfolg darf der BROR-Layer NICHT entfernt werden."""
proj_inst = _DummyProject()
mock_proj.instance.return_value = proj_inst
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)", lid="BROR_ID")
flst_layer = _make_layer(name="Flurstücke")
enriched = _make_layer(name="Verfahrensgebiet", valid=True)
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_flst.return_value = (flst_layer, LoadStatus.FIRST)
mock_select.return_value = 3
mock_erstelle.return_value = (enriched, 3, 0)
mock_get_var.return_value = ""
mock_vergl.return_value = (1000.0, 1000.0, True)
mock_prog.return_value = _make_progress_mock()
verfahrensgebiet_alkis_komplett(None)
self.assertNotIn("BROR_ID", proj_inst.removed)
@patch(_PATCH_PROGRESS)
@patch(_PATCH_PROJECT)
@patch(_PATCH_GEM)
@patch(_PATCH_VG_ALKIS)
def test_bror_layer_wird_bei_fehler_entfernt(
self, mock_vg, mock_gem, mock_proj, mock_prog
):
"""Bei Fehler (flst_alkis NONE) wird der BROR-Layer aus dem Projekt entfernt."""
proj_inst = _DummyProject()
mock_proj.instance.return_value = proj_inst
vg_layer = _make_layer(name="BauRaumOrdnungsrecht (ALKIS)", lid="BROR_ERR")
mock_vg.return_value = (vg_layer, LoadStatus.FIRST, [])
mock_gem.return_value = []
mock_prog.return_value = _make_progress_mock()
with patch(_PATCH_FLST, return_value=(None, LoadStatus.NONE)):
verfahrensgebiet_alkis_komplett(None)
self.assertIn("BROR_ERR", proj_inst.removed)
if __name__ == "__main__":
unittest.main()
Reference in New Issue View Git Blame Copy Permalink