Die Startseite führt die Neuankömmlinge ein

Seit der Inbetriebnahme setzte die Startseite voraus, was gerade nicht hat, wer
sie zum ersten Mal aufruft: geeignete Dateien. Über dem Formular stand die
Tätigkeitsbeschreibung, darunter zwei leere Dateifelder, und wer nie mit
gii-Norm-XML oder einem BGBl-Regelungstext zu tun hatte, konnte das Werkzeug
nicht einmal ausprobieren. Ein zugeklappter Block tritt hinzu, der zwei
durchgerechnete Fälle mit Verweisen auf die amtlichen Fundstellen anbietet.
Zugeklappt kostet er eine Zeile; das Formular bleibt, wo es war.

Angeboten werden ein verkündetes Änderungsgesetz — das UWG nebst dem Dritten
Gesetz zu seiner Änderung (BGBl. 2026 I Nr. 43), neunzehn Befehle an sechs
Normen ohne Rest — und ein Gesetzentwurf — das AGG nebst BT-Drs. 21/6178,
dreiundzwanzig Befehle an vierzehn Normen, einer zur Prüfung markiert. Der
zweite Fall war zunächst als ProdHaftG nebst BT-Drs. 21/4297 gedacht und ist
verworfen: Die Modernisierung löst das Gesetz ab, statt es zu ändern, und ergibt
einen einzigen Befehl an einer einzigen Norm. Ein Beispiel, das nichts zeigt,
ist keines.

Mitausgeliefert wird nichts, und die Seite ruft von sich aus nichts ab; sie
verweist. Die Verweise öffnen ein eigenes Fenster, weil ein im selben Fenster
geöffnetes PDF die bereits gewählten Dateien aus dem Formular nähme. Das
Stilblatt bekommt .einfuehrung im Zuschnitt der übrigen Kästen und keine einzige
neue Farbe, sodass Hell- und Dunkelfassung ohne Zutun stimmen.

Dabei stellte sich heraus, dass gesetze-im-internet.de das Norm-XML gar nicht
als solches ausgibt: Es gibt allein …/<kurz>/xml.zip, der unmittelbare
BJNR….xml-Pfad ist 404. Eine Einführung, die auf die Fundstelle verweist, wäre
ohne Weiteres eine Anleitung zum Entpacken von Hand gewesen. Der Ladepfad nimmt
das Archiv deshalb nun unmittelbar an (ZipAuspacker, vorgeschaltet in
Pipeline.ladeStammgesetz; DateiTyp kennt die Art ZIP). Die Änderungsdokumente
bleiben unberührt — Gesetzblätter und Drucksachen kommen nirgends als Archiv.

Das Format wird von Hand gelesen, und zwar aus einem Grund, der außerhalb der
Browserfassung sinnlos wäre: Von den Archivklassen des JDK trägt dort allein der
Inflater, den InflaterErsatz auf jzlib zurückführt; ZipInputStream, ZipFile und
CRC32 beruhen auf nativen Bindungen, die Web Image nicht kennt. Auch die
Prüfsumme rechnet die Klasse deshalb selbst. Gelesen wird über das
Zentralverzeichnis am Dateiende, nicht über die örtlichen Vorspanne, deren
Größenangaben bei nachgestellten Beschreibern erst hinter den Daten stehen.
Gewählt wird der einzige auf .xml endende Eintrag: Den Gesetzen mit Anlagen legt
die Fundstelle deren Bilddateien mit ins Archiv, es ist also nicht einerlei,
welchen man nimmt. Die ZIP-Signatur wird vor der PDF-Signatur geprüft, weil sie
am ersten Byte verankert ist, während jene ein Vorschaufenster durchsucht — ein
Archiv mit der Zeichenfolge „%PDF-“ in seinen gepackten Daten wäre sonst als PDF
angesprochen worden.

Die Quellenzeile der Synopse nennt weiterhin die angegebene Datei (uwg.zip),
nicht den Eintrag; sie soll den Weg zur Fundstelle zurück beschreiben. Den
Eintragsnamen trägt die ausgepackte Quelle gleichwohl, damit Protokoll und
Ladefehler das Gesetz benennen und nicht seine Verpackung.

Geprüft ist beides gegen die Fundstelle selbst, nicht nur gegen den
Beispielkorpus: 312 Prüfungen laufen durch, darunter acht neue zum Auspacken.
Das unmittelbar bezogene uwg.zip ergibt auf der Befehlszeile mit dem
BGBl-Regelungstext dieselbe Ausfertigung wie die entpackte Fassung — die beiden
unterscheiden sich allein in der Quellenzeile —, und dieselben 19/0/6 ergeben
sich im neu gebauten Wasm-Modul im Browser, ohne eine Beanstandung in der
Konsole. Der Block hält bei 320 Pixeln Breite ohne Überlauf.

Unberührt bleiben pom.xml, deploy/webpaket.sh und die nginx-Vorlage: Da nichts
mitausgeliefert wird, braucht es weder einen zweiten Ressourcen-Block noch neue
MIME-Typen — deren types-Block ersetzt die Zuordnung vollständig und wäre sonst
die Falle gewesen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Change-Id: I5f6566ca89aa5198452b0b29ac5b38da9eb26137

1 files changed, 138 insertions, 0 deletions

diff --git a/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java b/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java
new file mode 100644
index 0000000..5f0530d
--- /dev/null
+++ b/src/test/java/eu/mulk/aendggner/ZipAuspackerTest.java
@@ -0,0 +1,138 @@
+package eu.mulk.aendggner;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Die Archive werden zur Laufzeit gebaut statt als Binärdatei abgelegt: So steht neben jedem Fall,
+ * was ihn ausmacht, und der Quellbaum bleibt frei von undurchsichtigen Beilagen.
+ */
+class ZipAuspackerTest {
+
+  private static final Path MINI_GII = Path.of("src/test/resources/eu/mulk/aendggner/mini-gii.xml");
+
+  @Test
+  void packtDenXmlEintragAus() throws Exception {
+    var xml = Files.readAllBytes(MINI_GII);
+    var archiv = zip(Map.of("BJNR000000000.xml", xml), ZipEntry.DEFLATED);
+
+    var ausgepackt = ZipAuspacker.auspacken(new Quelle("xml.zip", archiv));
+
+    assertThat(ausgepackt.inhalt()).isEqualTo(xml);
+    // Der Name folgt dem Eintrag, nicht der Verpackung: Protokoll und Ladefehler sollen das
+    // Gesetz benennen.
+    assertThat(ausgepackt.name()).isEqualTo("BJNR000000000.xml");
+  }
+
+  @Test
+  void packtAuchUnkomprimierteEintraegeAus() throws Exception {
+    var xml = Files.readAllBytes(MINI_GII);
+    var archiv = zip(Map.of("BJNR000000000.xml", xml), ZipEntry.STORED);
+
+    assertThat(ZipAuspacker.auspacken(new Quelle("xml.zip", archiv)).inhalt()).isEqualTo(xml);
+  }
+
+  @Test
+  void uebergehtBeiwerkNebenDemXml() throws Exception {
+    var xml = Files.readAllBytes(MINI_GII);
+    // So sehen die Archive der Gesetze mit Anlagen aus: neben dem Norm-XML liegen Bilddateien.
+    var eintraege = new LinkedHashMap<String, byte[]>();
+    eintraege.put("__MACOSX/", new byte[0]);
+    eintraege.put("BJNR000000000.xml", xml);
+    eintraege.put("anlage_1.gif", new byte[] {'G', 'I', 'F', '8'});
+
+    assertThat(ZipAuspacker.auspacken(new Quelle("xml.zip", zip(eintraege, ZipEntry.DEFLATED))))
+        .extracting(Quelle::name)
+        .isEqualTo("BJNR000000000.xml");
+  }
+
+  @Test
+  void reichtNichtArchiveUnveraendertDurch() throws Exception {
+    var quelle = new Quelle("stamm.xml", Files.readAllBytes(MINI_GII));
+
+    assertThat(ZipAuspacker.auspacken(quelle)).isSameAs(quelle);
+  }
+
+  @Test
+  void meldetArchivOhneXml() {
+    var archiv = zip(Map.of("liesmich.txt", "nichts hierin".getBytes(StandardCharsets.UTF_8)));
+
+    assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", archiv)))
+        .isInstanceOf(IOException.class)
+        .hasMessageContaining("keine XML-Datei");
+  }
+
+  @Test
+  void meldetArchivMitMehrerenXml() {
+    var eintraege = new LinkedHashMap<String, byte[]>();
+    eintraege.put("eins.xml", "<a/>".getBytes(StandardCharsets.UTF_8));
+    eintraege.put("zwei.xml", "<b/>".getBytes(StandardCharsets.UTF_8));
+
+    assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", zip(eintraege))))
+        .isInstanceOf(IOException.class)
+        .hasMessageContaining("eins.xml, zwei.xml");
+  }
+
+  @Test
+  void meldetBeschaedigtesArchiv() throws Exception {
+    var archiv = zip(Map.of("BJNR000000000.xml", Files.readAllBytes(MINI_GII)));
+    // Das Zentralverzeichnis steht am Ende; ein abgeschnittenes Archiv verliert es.
+    var abgeschnitten = new byte[archiv.length / 2];
+    System.arraycopy(archiv, 0, abgeschnitten, 0, abgeschnitten.length);
+
+    assertThatThrownBy(() -> ZipAuspacker.auspacken(new Quelle("xml.zip", abgeschnitten)))
+        .isInstanceOf(IOException.class)
+        .hasMessageContaining("beschädigt");
+  }
+
+  @Test
+  void gezipptesStammgesetzErgibtDasselbeGesetz() throws Exception {
+    var xml = Files.readAllBytes(MINI_GII);
+
+    var direkt = Pipeline.ladeStammgesetz(new Quelle("mini-gii.xml", xml));
+    var gezippt = Pipeline.ladeStammgesetz(new Quelle("xml.zip", zip(Map.of("mini-gii.xml", xml))));
+
+    assertThat(gezippt.normen()).isEqualTo(direkt.normen());
+    assertThat(gezippt.jurabk()).isEqualTo(direkt.jurabk());
+  }
+
+  private static byte[] zip(Map<String, byte[]> eintraege) {
+    return zip(eintraege, ZipEntry.DEFLATED);
+  }
+
+  private static byte[] zip(Map<String, byte[]> eintraege, int verfahren) {
+    var aus = new ByteArrayOutputStream();
+    try (var zip = new ZipOutputStream(aus)) {
+      for (var eintrag : eintraege.entrySet()) {
+        var kopf = new ZipEntry(eintrag.getKey());
+        kopf.setMethod(verfahren);
+        if (verfahren == ZipEntry.STORED) {
+          // Gespeicherte Einträge verlangen Größe und Prüfsumme vorab.
+          var pruefsumme = new CRC32();
+          pruefsumme.update(eintrag.getValue());
+          kopf.setSize(eintrag.getValue().length);
+          kopf.setCompressedSize(eintrag.getValue().length);
+          kopf.setCrc(pruefsumme.getValue());
+        }
+        zip.putNextEntry(kopf);
+        zip.write(eintrag.getValue());
+        zip.closeEntry();
+      }
+    } catch (IOException e) {
+      throw new AssertionError("Das Testarchiv ließ sich nicht bauen", e);
+    }
+    return aus.toByteArray();
+  }
+}