diff options
Diffstat (limited to 'src/test')
3 files changed, 122 insertions, 0 deletions
diff --git a/src/test/java/eu/mulk/aendggner/EndToEndTest.java b/src/test/java/eu/mulk/aendggner/EndToEndTest.java index 8cd867e..109bbf6 100644 --- a/src/test/java/eu/mulk/aendggner/EndToEndTest.java +++ b/src/test/java/eu/mulk/aendggner/EndToEndTest.java @@ -1667,6 +1667,39 @@ class EndToEndTest { assertThat(ergebnis.html()).contains("keine Änderungsbefehle"); } + /** + * Die Kette und ihr Gedächtnis. Die eigene Ausgabe ist wieder Eingabe; sie trägt im Kopf, welche + * Hefte auf ihr schon vollzogen sind. Trifft dasselbe Heft ein zweites Mal auf sie, so greifen + * seine Befehle abermals — ein Befehl ist eine Anordnung und keine Zustandsbeschreibung —, und + * der angefügte Absatz stünde zweimal da. Am Wortlaut allein ist das nicht zu erkennen, wohl aber + * an dem, was die Fassung über sich selbst mitführt. + */ + @Test + void ketteRuegtDasZweimalAngewandteHeft() throws Exception { + var xml = SAMPLEDATA.resolve("UWG/BJNR141400004.xml"); + var pdf = SAMPLEDATA.resolve("UWG/bgbl126s0043_regelungstext.pdf"); + assumeTrue(Files.exists(xml) && Files.exists(pdf), "UWG-Beispieldaten fehlen"); + + var erste = Pipeline.erzeugeSynopse(Pipeline.Auftrag.von(xml, List.of(pdf))); + assertThat(erste.anzahlAngewandt()).isEqualTo(19); + // Das Heft nennt sich nach dem, was im Dokument steht (Ausfertigungsdatum), nicht nach seinem + // Dateinamen — sonst hinge die Wiedererkennung an einer Zufälligkeit des Ablageortes. + assertThat(erste.neufassung()) + .containsOnlyOnce("Fortgeschrieben durch: Änderungsgesetz vom 12. Februar 2026"); + + var zwischenfassung = + new Quelle("UWG-Zwischenfassung.txt", erste.neufassung().getBytes(StandardCharsets.UTF_8)); + var zweite = + Pipeline.erzeugeSynopse(Pipeline.Auftrag.von(zwischenfassung, List.of(Quelle.lies(pdf)))); + + assertThat(zweite.html()) + .contains("Die Fassung trägt „Änderungsgesetz vom 12. Februar 2026“ bereits") + .contains("ein zweites Mal angewandt"); + // Vermerkt bleibt das Heft einmal: Die Liste zählt Hefte, nicht Anwendungen. + assertThat(zweite.neufassung()) + .containsOnlyOnce("Fortgeschrieben durch: Änderungsgesetz vom 12. Februar 2026"); + } + private static Aenderungsbefehl befehlZu( AenderungsgesetzParser.ParseErgebnis ergebnis, String gliederungsPfad) { return ergebnis.befehle().stream() diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/DokumentErkennerTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/DokumentErkennerTest.java index aad40d5..4d756a7 100644 --- a/src/test/java/eu/mulk/aendggner/aenderung/parse/DokumentErkennerTest.java +++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/DokumentErkennerTest.java @@ -8,6 +8,7 @@ import static org.junit.jupiter.api.Assumptions.assumeTrue; import eu.mulk.aendggner.aenderung.DokumentArt; import java.nio.file.Files; import java.nio.file.Path; +import java.time.LocalDate; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; @@ -45,6 +46,51 @@ class DokumentErkennerTest { assertThat(kopf.art()).isEqualTo(erwartet); } + /** + * Das Ausfertigungsdatum aus der Zeile „Vom …“. An ihm erkennt die Fassung ein Heft wieder, das + * auf sie schon angewandt worden ist; deshalb darf es nicht geraten sein. Ein Sammelheft stellt + * mehrere Verkündungen nebeneinander (so das thüringische GVBl. Nr. 2/2026 mit vieren), und + * welche von ihnen das Dokument ausmacht, sagt sein Kopf nicht — dann bleibt das Datum leer. + */ + @ParameterizedTest + @CsvSource({ + "UWG/bgbl126s0043_regelungstext.pdf, 2026-02-12", + "Brandenburg/GVBl-I-2026-12_FraktG-AendG.pdf, 2026-04-22", + "NRW/GV-NRW-2026-S202_22-Rundfunkaenderungsgesetz.pdf, 2026-03-24", + "Hessen/GVBl-2026-05_11-AendVO-verkehrsrechtl-Zustaendigkeiten.pdf, 2026-01-28", + "Thueringen/GVBl-TH-2026-02_KiGaFinanzVO-AendVO-ua.pdf, ", + "GEG/BT-Drs-20-6875_Regierungsentwurf.pdf, ", + }) + void liestDasAusfertigungsdatum(String datei, String erwartet) throws Exception { + var pfad = SAMPLEDATA.resolve(datei.strip()); + assumeTrue(Files.exists(pfad), "Beispieldatei fehlt: " + datei); + + var kopf = DokumentErkenner.erkenne(new PatchTextExtraktor().extrahiere(pfad)); + + assertThat(kopf.ausfertigung()) + .isEqualTo(erwartet == null ? null : LocalDate.parse(erwartet.strip())); + } + + /** + * Woran ein Heft sich nennt: an seiner Drucksachennummer, sonst an seinem Ausfertigungsdatum. Der + * Dateiname bleibt außen vor — er ist eine Zufälligkeit des Ablageortes, und an der Bezeichnung + * hängt die Wiedererkennung in der Kette. + */ + @Test + void bezeichnetSichNachDemDokumentUndNichtNachDerDatei() throws Exception { + var gesetzblatt = SAMPLEDATA.resolve("UWG/bgbl126s0043_regelungstext.pdf"); + var drucksache = SAMPLEDATA.resolve("UWG/BT-Drs-21-1855_Regierungsentwurf.pdf"); + assumeTrue(Files.exists(gesetzblatt) && Files.exists(drucksache), "UWG-Beispieldaten fehlen"); + + assertThat( + DokumentErkenner.erkenne(new PatchTextExtraktor().extrahiere(gesetzblatt)) + .anzeigeName()) + .isEqualTo("Änderungsgesetz vom 12. Februar 2026"); + assertThat( + DokumentErkenner.erkenne(new PatchTextExtraktor().extrahiere(drucksache)).anzeigeName()) + .isEqualTo("Gesetzentwurf Drs. 21/1855"); + } + /** Die Drucksachennummern stiften die Verbindung zwischen Antrag und Entwurf. */ @Test void liestEigeneUndBezogeneDrucksachennummern() throws Exception { diff --git a/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java b/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java index e620a03..6d6eab2 100644 --- a/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java +++ b/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java @@ -5,12 +5,16 @@ package eu.mulk.aendggner.gesetz.land; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assumptions.assumeTrue; +import eu.mulk.aendggner.gesetz.Fortschreibung; import eu.mulk.aendggner.gesetz.Gesetz; +import eu.mulk.aendggner.gesetz.Stand; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.time.LocalDate; import java.util.List; import java.util.stream.Stream; +import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; @@ -52,6 +56,8 @@ class LandesRechtTextAusgeberTest { assertThat(wiederGelesen.kurzue()).isEqualTo(gelesen.kurzue()); assertThat(bezeichnungen(wiederGelesen)).isEqualTo(bezeichnungen(gelesen)); assertThat(wiederGelesen.gliederungen()).isEqualTo(gelesen.gliederungen()); + assertThat(wiederGelesen.stand()).isEqualTo(gelesen.stand()); + assertThat(wiederGelesen.fortschreibungen()).isEqualTo(gelesen.fortschreibungen()); for (var soll : gelesen.normen()) { var ist = wiederGelesen.norm(soll.enbez()).orElseThrow(); @@ -63,6 +69,43 @@ class LandesRechtTextAusgeberTest { } } + /** + * Der Kopf trägt das Gedächtnis der Kette: Standangabe und angewandte Hefte müssen den Rundlauf + * überstehen, sonst wüsste die nächste Stufe nicht, was der Wortlaut schon trägt — und dasselbe + * Heft ließe sich unbemerkt ein zweites Mal anwenden. + */ + @Test + void rundlaufErhaeltStandUndHefte() throws IOException { + var datei = SAMPLEDATA.resolve("Brandenburg/FraktG-alt.txt"); + assumeTrue(Files.exists(datei), "Beispieldaten fehlen"); + var gelesen = + new LandesRechtLoader() + .load(datei) + .mitFortschreibung( + new Fortschreibung("Änderungsgesetz vom 22. April 2026", LocalDate.of(2026, 4, 22))) + .mitFortschreibung(new Fortschreibung("Gesetzentwurf Drs. 7/4711", null)); + var mitStand = + new Gesetz( + gelesen.jurabk(), + gelesen.langue(), + gelesen.kurzue(), + gelesen.normen(), + gelesen.gliederungen(), + Stand.aus("Zuletzt geändert durch Art. 2 G v. 15.12.2022 I Nr. 26"), + gelesen.fortschreibungen()); + + var wiederGelesen = LandesRechtTextParser.parse(LandesRechtTextAusgeber.ausgeben(mitStand)); + + assertThat(wiederGelesen.stand()).isEqualTo(mitStand.stand()); + assertThat(wiederGelesen.stand().juengsteAenderung()).isEqualTo(LocalDate.of(2022, 12, 15)); + assertThat(wiederGelesen.fortschreibungen()).isEqualTo(mitStand.fortschreibungen()); + // Der Wortlautstand folgt dem jüngsten Heft, nicht der Standzeile: Wer fortschreibt, macht den + // Wortlaut jünger, als die Quelle ihn ausweist. + assertThat(wiederGelesen.wortlautStand()).isEqualTo(LocalDate.of(2026, 4, 22)); + assertThat(wiederGelesen.traegt(new Fortschreibung("Änderungsgesetz vom 22. April 2026", null))) + .isTrue(); + } + private static List<String> bezeichnungen(Gesetz gesetz) { return gesetz.normen().stream().map(n -> n.enbez()).toList(); } |