gwoe-antragspruefer/tests/test_wahlprogramme.py

"""Tests for wahlprogramme.py — registry consistency + file existence."""
import re

import pytest

from app.wahlprogramme import (
    WAHLPROGRAMME,
    REFERENZEN_PATH,
    get_wahlprogramm,
    parteien_mit_wahlprogramm,
    regierung_aktuell,
    regierungsbildung_for,
    regierungsende_for,
)


# ─────────────────────────────────────────────────────────────────────────────
# Registry consistency
# ─────────────────────────────────────────────────────────────────────────────

class TestRegistryStructure:
    def test_active_bundeslaender_present(self):
        for code in ["NRW", "LSA", "MV", "BE"]:
            assert code in WAHLPROGRAMME, f"missing wahlprogramme entry for {code}"

    def test_each_entry_has_required_keys(self):
        required = {"file", "titel", "partei", "jahr", "seiten"}
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                missing = required - set(info.keys())
                assert not missing, f"{bl}/{partei} missing keys: {missing}"

    def test_jahr_is_integer(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                assert isinstance(info["jahr"], int), f"{bl}/{partei} jahr not int"

    def test_seiten_is_positive_integer(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                assert isinstance(info["seiten"], int)
                assert info["seiten"] > 0

    def test_file_extension_is_pdf(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                assert info["file"].endswith(".pdf")


# ─────────────────────────────────────────────────────────────────────────────
# Regierungsbildungs-Felder — Konsistenz pro Bundesland
# ─────────────────────────────────────────────────────────────────────────────

class TestRegierungsbildung:
    """Pro Bundesland gehören alle Wahlprogramm-Einträge zur gleichen
    Legislatur — d.h. dasselbe regierungsbildung-Datum. Ausnahme: BUND, wo
    Grundsatzprogramme stehen, die regierungsbildung=None tragen."""

    _ISO_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$")

    def test_every_entry_has_regierungs_fields(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                assert "regierungsbildung" in info, f"{bl}/{partei}: regierungsbildung fehlt"
                assert "regierungsende" in info, f"{bl}/{partei}: regierungsende fehlt"

    def test_regierungsbildung_iso_or_none(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                rb = info.get("regierungsbildung")
                if rb is not None:
                    assert isinstance(rb, str) and self._ISO_DATE.match(rb), \
                        f"{bl}/{partei}: regierungsbildung kein ISO-Datum: {rb!r}"

    def test_regierungsende_iso_or_none(self):
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                re_ = info.get("regierungsende")
                if re_ is not None:
                    assert isinstance(re_, str) and self._ISO_DATE.match(re_), \
                        f"{bl}/{partei}: regierungsende kein ISO-Datum: {re_!r}"

    def test_alle_parteien_eines_bl_haben_gleiches_datum(self):
        """Alle Wahlprogramm-Einträge eines Bundeslands gehören zur selben
        Regierung und müssen daher dasselbe Bildungs-/Endedatum tragen."""
        for bl, parteien in WAHLPROGRAMME.items():
            bildung = {info.get("regierungsbildung") for info in parteien.values()}
            ende = {info.get("regierungsende") for info in parteien.values()}
            assert len(bildung) == 1, \
                f"{bl}: regierungsbildung divergent: {bildung}"
            assert len(ende) == 1, \
                f"{bl}: regierungsende divergent: {ende}"

    def test_grundsatzprogramme_haben_keine_regierung(self):
        """Grundsatzprogramme (ist_grundsatz=True) tragen keine Regierungs-
        bildung — sie sind zeitlos."""
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                if info.get("ist_grundsatz"):
                    assert info.get("regierungsbildung") is None, \
                        f"{bl}/{partei} ist Grundsatzprogramm, sollte regierungsbildung=None haben"


class TestRegierungsHelper:
    def test_regierungsbildung_for_known_bl(self):
        assert regierungsbildung_for("NRW") == "2022-06-29"
        assert regierungsbildung_for("HH") == "2025-05-07"

    def test_regierungsbildung_for_bund_btw2025(self):
        # BUND tragt nun die BTW-2025-Wahlprogramme; Kabinett Merz I
        # vereidigt 06.05.2025. Grundsatzprogramme bleiben nur in
        # embeddings.PROGRAMME als zweite Referenz.
        assert regierungsbildung_for("BUND") == "2025-05-06"

    def test_regierungsbildung_for_unknown_bl(self):
        assert regierungsbildung_for("XX") is None

    def test_regierung_aktuell_true_for_active_bl(self):
        assert regierung_aktuell("NRW") is True
        assert regierung_aktuell("BB") is True
        assert regierung_aktuell("BUND") is True

    def test_regierungsende_for_active_is_none(self):
        assert regierungsende_for("NRW") is None


# ─────────────────────────────────────────────────────────────────────────────
# File existence — every registered file must exist on disk
# ─────────────────────────────────────────────────────────────────────────────

class TestFileExistence:
    """Catches typos in the file field that would silently break embedding
    indexing or PDF download links."""

    def test_every_registered_pdf_exists(self):
        missing = []
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                path = REFERENZEN_PATH / info["file"]
                if not path.exists():
                    missing.append(f"{bl}/{partei}: {info['file']}")
        assert not missing, "missing PDFs:\n  " + "\n  ".join(missing)


# ─────────────────────────────────────────────────────────────────────────────
# Lookup helpers
# ─────────────────────────────────────────────────────────────────────────────

class TestGetWahlprogramm:
    def test_returns_dict_for_known_combination(self):
        info = get_wahlprogramm("MV", "CDU")
        assert info is not None
        assert info["partei"] == "CDU Mecklenburg-Vorpommern"

    def test_returns_none_for_unknown_bundesland(self):
        assert get_wahlprogramm("XX", "CDU") is None

    def test_returns_none_for_unknown_partei(self):
        assert get_wahlprogramm("NRW", "BSW") is None


class TestParteienMitWahlprogramm:
    def test_nrw_has_five_parteien(self):
        parteien = parteien_mit_wahlprogramm("NRW")
        assert len(parteien) == 5
        assert set(parteien) == {"CDU", "SPD", "GRÜNE", "FDP", "AfD"}

    def test_mv_has_six_parteien(self):
        parteien = parteien_mit_wahlprogramm("MV")
        assert set(parteien) == {"CDU", "SPD", "GRÜNE", "FDP", "AfD", "LINKE"}

    def test_be_has_five_parteien(self):
        parteien = parteien_mit_wahlprogramm("BE")
        assert set(parteien) == {"CDU", "SPD", "GRÜNE", "LINKE", "AfD"}

    def test_bund_has_eight_parteien(self):
        # BTW 2025: CDU, CSU, SPD, GRÜNE, FDP, AfD, LINKE, BSW.
        parteien = parteien_mit_wahlprogramm("BUND")
        assert set(parteien) == {"CDU", "CSU", "SPD", "GRÜNE", "FDP", "AfD", "LINKE", "BSW"}

    def test_by_has_five_parteien(self):
        parteien = parteien_mit_wahlprogramm("BY")
        assert set(parteien) == {"CSU", "FREIE WÄHLER", "GRÜNE", "SPD", "AfD"}

    def test_hb_has_four_parteien(self):
        # AfD war wegen Listenstreit nicht zur Bürgerschaftswahl 2023 zugelassen.
        parteien = parteien_mit_wahlprogramm("HB")
        assert set(parteien) == {"SPD", "CDU", "GRÜNE", "LINKE"}

    def test_he_has_five_parteien(self):
        parteien = parteien_mit_wahlprogramm("HE")
        assert set(parteien) == {"CDU", "SPD", "GRÜNE", "FDP", "AfD"}

    def test_ni_has_four_parteien(self):
        parteien = parteien_mit_wahlprogramm("NI")
        assert set(parteien) == {"SPD", "CDU", "GRÜNE", "AfD"}

    def test_sl_has_three_parteien(self):
        parteien = parteien_mit_wahlprogramm("SL")
        assert set(parteien) == {"SPD", "CDU", "AfD"}

    def test_sn_has_six_parteien(self):
        parteien = parteien_mit_wahlprogramm("SN")
        assert set(parteien) == {"CDU", "SPD", "AfD", "BSW", "LINKE", "GRÜNE"}

    def test_unknown_bundesland_empty_list(self):
        assert parteien_mit_wahlprogramm("XX") == []


# ─────────────────────────────────────────────────────────────────────────────
# embeddings.PROGRAMME consistency cross-check
# ─────────────────────────────────────────────────────────────────────────────

class TestEmbeddingsRegistryConsistency:
    """Every entry in WAHLPROGRAMME must also exist in embeddings.PROGRAMME
    so the indexer can find it. Mismatch is the kind of bug a manual smoke
    misses but would show up during indexing."""

    def test_every_wahlprogramm_has_embeddings_entry(self):
        from app.embeddings import PROGRAMME

        # Match WAHLPROGRAMME-Eintrag → PROGRAMME-Eintrag entweder ueber den
        # file-stem (Standard: "cdu-mv-2021" matcht "cdu-mv-2021") ODER ueber
        # den `pdf`-Wert in PROGRAMME (BUND-Grundsatzprogramme nutzen kuerzere
        # PROGRAMME-Keys wie "cdu-grundsatz" obwohl die Datei
        # "cdu-grundsatzprogramm.pdf" heisst).
        pdf_to_pid = {p.get("pdf"): pid for pid, p in PROGRAMME.items() if p.get("pdf")}
        missing = []
        for bl, parteien in WAHLPROGRAMME.items():
            for partei, info in parteien.items():
                file_stem = info["file"].rsplit(".", 1)[0]
                if file_stem in PROGRAMME:
                    continue
                if info["file"] in pdf_to_pid:
                    continue
                missing.append(f"{bl}/{partei} → {info['file']}")
        assert not missing, (
            "WAHLPROGRAMME entries missing in embeddings.PROGRAMME:\n  "
            + "\n  ".join(missing)
        )


# ─────────────────────────────────────────────────────────────────────────────
# load_wahlprogramm_text — Fallback-Pfade (#134 Coverage-Backfill)
# ─────────────────────────────────────────────────────────────────────────────

class TestLoadWahlprogrammText:
    def test_returns_empty_for_unknown_combination(self):
        from app.wahlprogramme import load_wahlprogramm_text
        assert load_wahlprogramm_text("XX", "XYZ") == {}

    def test_paged_textfile_used_when_present(self, tmp_path, monkeypatch):
        """Wenn die paged-Textdatei existiert, wird sie genutzt.
        Format: '--- PAGE N ---'-Marker pro Seitenanfang."""
        from app import wahlprogramme as wp_mod
        # Mock get_wahlprogramm -> bekannte Datei
        monkeypatch.setattr(wp_mod, "get_wahlprogramm",
                            lambda bl, p: {"file": "test.pdf"})
        paged = tmp_path / "test-paged.txt"
        paged.write_text("--- PAGE 1 ---\nseite eins\n--- PAGE 2 ---\nseite zwei")
        monkeypatch.setattr(wp_mod, "KONTEXT_PATH", tmp_path)

        result = wp_mod.load_wahlprogramm_text("X", "Y")
        assert 2 in result
        assert "seite zwei" in result[2]

    def test_falls_back_to_normal_textfile(self, tmp_path, monkeypatch):
        """Ohne paged-Datei wird auf normale .txt-Datei zurueckgefallen,
        komplett unter Seite 1."""
        from app import wahlprogramme as wp_mod
        monkeypatch.setattr(wp_mod, "get_wahlprogramm",
                            lambda bl, p: {"file": "test.pdf"})
        normal = tmp_path / "test.txt"
        normal.write_text("flacher text ohne seitenmarker")
        monkeypatch.setattr(wp_mod, "KONTEXT_PATH", tmp_path)

        result = wp_mod.load_wahlprogramm_text("X", "Y")
        assert result == {1: "flacher text ohne seitenmarker"}

    def test_returns_empty_when_no_textfile(self, tmp_path, monkeypatch):
        """Weder paged- noch normale Textdatei → leeres Dict."""
        from app import wahlprogramme as wp_mod
        monkeypatch.setattr(wp_mod, "get_wahlprogramm",
                            lambda bl, p: {"file": "test.pdf"})
        # tmp_path ist leer
        monkeypatch.setattr(wp_mod, "KONTEXT_PATH", tmp_path)

        assert wp_mod.load_wahlprogramm_text("X", "Y") == {}


class TestSearchWahlprogramm:
    def test_returns_empty_for_unknown_combination(self):
        from app.wahlprogramme import search_wahlprogramm
        assert search_wahlprogramm("XX", "XYZ", ["test"]) == []

    def test_returns_empty_when_text_missing(self, monkeypatch):
        """Bekannte Partei + Bundesland aber keine Textdatei → leer."""
        from app import wahlprogramme as wp_mod
        monkeypatch.setattr(wp_mod, "get_wahlprogramm",
                            lambda bl, p: {"file": "missing.pdf"})
        monkeypatch.setattr(wp_mod, "load_wahlprogramm_text",
                            lambda bl, p: {})
        assert wp_mod.search_wahlprogramm("X", "Y", ["test"]) == []


class TestFindRelevantQuotes:
    def test_unknown_bundesland_raises(self):
        from app.wahlprogramme import find_relevant_quotes
        with pytest.raises(ValueError, match="Unbekanntes Bundesland"):
            find_relevant_quotes("Antrag-Text", ["CDU"], bundesland="ZZ")


class TestFormatQuoteForPrompt:
    def test_empty_quotes_returns_empty_string(self):
        from app.wahlprogramme import format_quote_for_prompt
        assert format_quote_for_prompt({}) == ""