Plugin_SN_Basis/test/test_layerpruefer.py

# sn_basis/test/test_layerpruefer.py

import unittest

from sn_basis.modules.layerpruefer import Layerpruefer
from sn_basis.modules.pruef_ergebnis import pruef_ergebnis


# ---------------------------------------------------------
# Mock-Layer für Wrapper-Tests
# ---------------------------------------------------------
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


# ---------------------------------------------------------
# Wrapper-Mocks (monkeypatching)
# ---------------------------------------------------------
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 TestLayerpruefer(unittest.TestCase):

    def setUp(self):
        # Monkeypatching der Wrapper-Funktionen
        import sn_basis.functions.qgisqt_wrapper as wrapper

        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
    # -----------------------------------------------------

    def test_layer_exists(self):
        layer = MockLayer(exists=False)
        pruefer = Layerpruefer(layer)
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "layer_nicht_gefunden")

    def test_layer_unsichtbar(self):
        layer = MockLayer(visible=False)
        pruefer = Layerpruefer(layer, muss_sichtbar_sein=True)
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "layer_unsichtbar")

    def test_falscher_layertyp(self):
        layer = MockLayer(layer_type="raster")
        pruefer = Layerpruefer(layer, erwarteter_layertyp="vector")
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "falscher_layertyp")

    def test_falscher_geotyp(self):
        layer = MockLayer(geometry_type="Point")
        pruefer = Layerpruefer(layer, erwarteter_geotyp="Polygon")
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "falscher_geotyp")

    def test_layer_leer(self):
        layer = MockLayer(feature_count=0)
        pruefer = Layerpruefer(layer)
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "layer_leer")

    def test_falsches_crs(self):
        layer = MockLayer(crs="EPSG:4326")
        pruefer = Layerpruefer(layer, erwartetes_crs="EPSG:25833")
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "falsches_crs")

    def test_felder_fehlen(self):
        layer = MockLayer(fields=["id"])
        pruefer = Layerpruefer(layer, erforderliche_felder=["id", "name"])
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "felder_fehlen")

    def test_datenquelle_unerwartet(self):
        layer = MockLayer(source="/tmp/test.shp")
        pruefer = Layerpruefer(layer, erlaubte_datenquellen=["/tmp/allowed.shp"])
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "datenquelle_unerwartet")

    def test_layer_nicht_editierbar(self):
        layer = MockLayer(editable=False)
        pruefer = Layerpruefer(layer, muss_editierbar_sein=True)
        ergebnis = pruefer.pruefe()
        self.assertFalse(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "layer_nicht_editierbar")

    def test_layer_ok(self):
        layer = MockLayer()
        pruefer = Layerpruefer(layer)
        ergebnis = pruefer.pruefe()
        self.assertTrue(ergebnis.ok)
        self.assertEqual(ergebnis.aktion, "ok")


if __name__ == "__main__":
    unittest.main()