import { readFileSync } from 'node:fs'; import { describe, expect, it } from 'vitest'; import { HILFE } from '@/ui/help/texte'; import * as actions from '@/app/actions'; import { createEmptyProject } from '@/domain/model/factory'; import { buildSignalPlan, massgebendeRaeumbeziehung } from '@/domain/plan/signalPlan'; import { computeIntergreen, regelUeberfahrzeit } from '@/domain/rilsa/intergreen'; import type { ClearingStream, EnteringStream } from '@/domain/rilsa/types'; import { RILSA_DEFAULTS } from '@/domain/rilsa/constants'; import { resolveRilsaSettings } from '@/domain/rilsa/settings'; import { gelbzeitstaffelSatz } from '@/services/export/bewertung'; /* * Fassung 5.12.0 - die beiden Hilfetexte, die dem Anwender Falsches sagten. * * Beide Waechter stehen in zwei Stufen, wie die Unterlagenwachen derselben Fassung: * zuerst der SACHSTAND am Quelltext beziehungsweise am laufenden Rechenkern, * dann der Wortlaut des Hilfetextes. Faellt der Sachstand, faellt er zuerst - * dann hat sich nicht der Text geirrt, sondern das Programm hat sich geaendert * und der Text ist mitzufuehren. * * Die Hilfe ist ein Versprechen an den Anwender: Er handelt danach. Ein * Hilfetext, der eine Wirkung zusagt, die es nicht gibt, ist deshalb kein * Schoenheitsfehler - beim vZul-Eintrag zeigte er in die unsichere Richtung. */ const FEST = new Date('2026-01-01T00:00:00Z'); const PDF = readFileSync('src/services/export/pdf.ts', 'utf8'); /** Absaetze der Hilfe brechen selbst um; verglichen wird ohne Umbrueche. */ function einzeilig(text: string): string { return text.replace(/\s+/g, ' '); } /** * Ein langer Satz steht im Quelltext als Kette aneinandergehaengter * Zeichenkettenteile. Fuer den Wortlautvergleich werden die Nahtstellen * geschlossen; danach liest sich der Satz so, wie er auf dem Papier steht. */ function zusammengesetzt(quelltext: string): string { return einzeilig(quelltext.replace(/'\s*\+\s*'/g, '')); } describe('A.1: Der Eintrag "Raeumgeschwindigkeit" nennt den massgebenden Strom', () => { /* * Sachstand: Ueber die Fahrbeziehung entscheidet * `massgebendeRaeumbeziehung` - die der KONFLIKTBEZIEHUNG, wo eine * festgehalten ist, sonst die der SIGNALGRUPPE. */ it('entscheidet der Rechenkern an der Beziehung, nicht an der Gruppe', () => { expect( massgebendeRaeumbeziehung({ movement: 'geradeaus' }, { raeumbeziehung: 'rechts' }), 'die Fahrbeziehung der Beziehung setzt sich nicht mehr durch', ).toBe('rechts'); expect( massgebendeRaeumbeziehung({ movement: 'geradeaus' }, {}), 'ohne festgehaltenen Strom gilt nicht mehr die Gruppe', ).toBe('geradeaus'); }); const woher = einzeilig(HILFE.raeumgeschwindigkeit.woher ?? ''); it('sagt, welche Fahrbeziehung gilt', () => { expect(woher, 'der massgebende Strom ist weiterhin nicht genannt').toContain( 'entscheidet der Strom, dem der Räumweg dieser Konfliktbeziehung gehört, und nicht die ' + 'räumende Signalgruppe', ); expect(woher, 'der Regelfall der Sammelsignalgruppe fehlt').toContain( 'Führt eine Signalgruppe geradeaus und rechts aus einem Fahrstreifen', ); }); it('nennt den Rueckfall auf die Fahrbeziehung der Signalgruppe', () => { expect(woher, 'der Rueckfall fehlt').toContain( 'Ist nicht festgehalten, welcher Strom den Räumweg gefahren ist, wird mit der ' + 'Fahrbeziehung der Signalgruppe gerechnet, und der Prüfbericht meldet das.', ); expect(woher, 'woher der massgebende Strom kommt, steht nicht dabei').toContain( 'Festgehalten wird der maßgebende Strom allein bei der Übernahme aus dem Lageplan', ); }); it('sagt den Rueckfall woertlich wie die Planunterlage', () => { /* * Der Grund, aus dem der Satz einmal formuliert ist * (`raeumbeziehungSatz`, domain/rilsa/ansaetze.ts): Vier Auskunftsstellen * mit vier Formulierungen desselben Sachverhalts sind vier Gelegenheiten * auseinanderzulaufen. Aufrufen kann der Hilfetext die Funktion nicht - sie * braucht Signalgruppe und Konfliktbeziehung, die es hier nicht gibt -, * also bindet ihn diese Wache an den Wortlaut der Planunterlage. */ const rueckfall = 'Ist nicht festgehalten, welcher Strom den Räumweg gefahren ist, wird mit der ' + 'Fahrbeziehung der Signalgruppe gerechnet, und der Prüfbericht meldet das.'; expect(zusammengesetzt(PDF), 'der Wortlaut der Planunterlage hat sich geaendert').toContain( rueckfall, ); expect(woher, 'Hilfe und Planunterlage sagen den Rueckfall verschieden').toContain(rueckfall); }); }); describe('A.2: Der Eintrag "Zulaessige Hoechstgeschwindigkeit" schreibt sich die Gelbzeit nicht mehr zu', () => { /* * Sachstand am laufenden Rechenkern, nicht an einer Zeichenkette: Der * Knotenpunktwert belegt neu angelegte Signalgruppen vor - mehr nicht. Wird * er nachtraeglich angehoben, aendert sich keine Gelbzeit. */ function planMitEinerKfzGruppe(intersectionVZul: number, gruppenVZul?: number) { let projekt = createEmptyProject('A2', FEST); projekt = actions.setIntersection(projekt, { vZul: intersectionVZul }); projekt = actions.addSignalGroup(projekt, 'kfz'); const gruppe = projekt.signalGroups[0]!; if (gruppenVZul !== undefined) { projekt = actions.updateSignalGroup(projekt, gruppe.id, { vZul: gruppenVZul }); } // Ohne Phase liefert `buildSignalPlan` einen leeren Plan. projekt = actions.addPhase(projekt); projekt = actions.updatePhase(projekt, projekt.phases[0]!.id, { signalGroupIds: [gruppe.id], }); return buildSignalPlan(projekt); } it('belegt der Knotenpunktwert nur vor und bestimmt keine Gelbzeit', () => { // Vorbelegung: Die Gruppe entsteht mit dem Knotenpunktwert, und AN IHR // haengt die Gelbzeit. expect(planMitEinerKfzGruppe(50).groups[0]?.times.yellow, 'Vorbelegung 50 km/h').toBe(3); expect(planMitEinerKfzGruppe(70).groups[0]?.times.yellow, 'Vorbelegung 70 km/h').toBe(5); // Und die unsichere Richtung: Der Knotenpunktwert steht auf 70, die // bestehende Gruppe auf 50 - gerechnet wird mit 3 s, nicht mit 5 s. expect( planMitEinerKfzGruppe(70, 50).groups[0]?.times.yellow, 'der Knotenpunktwert wirkt nachtraeglich doch auf die Gelbzeit', ).toBe(3); }); const wennFalsch = einzeilig(HILFE.vZulKnoten.wennFalsch ?? ''); it('nimmt die falsche Zuschreibung zurueck und bleibt sicherheitsrelevant', () => { expect(wennFalsch, 'die falsche Zuschreibung steht noch da').not.toContain( 'Aus diesem Wert leitet das Programm die Gelbzeit ab', ); expect(wennFalsch, 'die Sicherheitsrelevanz ist mit weggefallen').toContain( 'Sicherheitsrelevant', ); expect(wennFalsch, 'der Eintrag sagt nicht, dass er selbst keine Gelbzeit bestimmt').toContain( 'Dieser Wert bestimmt selbst keine Gelbzeit', ); expect(wennFalsch, 'die Vorbelegung ist nicht benannt').toContain( 'Er belegt neu angelegte Zufahrten und Signalgruppen vor; bestehende behalten ihren Wert.', ); expect(wennFalsch, 'die mittelbare Wirkung fehlt').toContain( 'über die daraus angelegten Gruppen', ); }); it('nennt die unsichere Richtung', () => { expect(wennFalsch, 'die unsichere Richtung ist nicht benannt').toContain( 'das ist die unsichere Richtung', ); expect(wennFalsch, 'der Fall aus Befund 23 fehlt').toContain( 'von 50 auf 70 km/h setzt, um längere Zwischenzeiten zu bekommen, bekommt keine', ); // Was der Anwender statt dessen tun muss - sonst ist die Warnung // folgenlos. expect(wennFalsch, 'der Ausweg fehlt').toContain( 'an jeder betroffenen Signalgruppe nach (Spalte „V zul“ unter „Signalgruppen“)', ); }); it('gibt die einstellbare Gelbzeitstaffel nicht als geltende Zahlen aus', () => { /* * Befund C21: `yellowKfzUpTo50`, `yellowKfzUpTo60` und `yellowKfzAbove60` * sind einstellbar. Die Projektansicht setzt deshalb * `gelbzeitstaffelSatz()` ein. Die Hilfe wird einmal beim Laden des Moduls * gebildet und kennt die Vorgaben des geoeffneten Plans nicht; auch * `gelbzeitstaffelSatz()` lieferte hier nur die Regelstaffel. Deshalb nennt * der Eintrag keine Zahlen, sondern die Stellen mit dem wirksamen Wert. Der * Nachweis dafuer steht unten unter "Die Begruendungen in den Kommentaren". */ expect(wennFalsch, 'die feste Zahlenstaffel steht wieder im Text').not.toMatch(/\bSekunden?\b/); expect(wennFalsch, 'die alte Staffel ist zurueck').not.toMatch(/bis\s*50\s*km\/h/); expect(wennFalsch, 'der Verweis auf die wirksame Staffel fehlt').toContain( 'Die Staffel ist unter „Vorgaben“ einstellbar', ); }); }); describe('A.3: Die Kopplung Gelbzeit → Zwischenzeit gilt nur bei einem der beiden Ansaetze', () => { /* * NACHTRAG (Fassung 5.12.0): Beide Eintraege sagten die * Kopplung unbedingt zu - "die Gelbzeit geht zugleich als Ueberfahrzeit in * die Zwischenzeit ein". Das ist dieselbe Bauart wie die feste * Zahlenstaffel, die A.2 zu Recht entfernt hat: eine einstellbare Wirkung * als unbedingte Zusage. Der Ueberfahrzeit-Ansatz ist eine * Projekteinstellung (Vorgabe 'gelbzeit', domain/model/factory.ts). * * Sachstand am Rechenkern, nicht an einer Zeichenkette. */ const OHNE_EINFAHRWEG: EnteringStream = { mode: 'kfz', movement: 'geradeaus', enteringDistance: 0, }; /** Abbiegender Kfz-Strom, 20 m Raeumweg, Pkw - nur vZul und Ansatz wechseln. */ function abbieger(vZul: number, ueberfahrzeitAnsatz: 'gelbzeit' | 'fest'): ClearingStream { return { mode: 'kfz', movement: 'rechts', clearingDistance: 20, vehicleClass: 'pkw', vZul, ueberfahrzeitAnsatz, }; } it('haengt die Zwischenzeit bei "feste Ueberfahrzeit" nicht an der Gelbzeit', () => { // Ansatz "Ueberfahrzeit = Gelbzeit": 50 km/h -> 3 s, 70 km/h -> 5 s. Die // Gelbzeit steht in der Zwischenzeit. const gelb50 = computeIntergreen(abbieger(50, 'gelbzeit'), OHNE_EINFAHRWEG); const gelb70 = computeIntergreen(abbieger(70, 'gelbzeit'), OHNE_EINFAHRWEG); expect(gelb50.crossingTime, 'die Gelbzeit ist nicht mehr die Ueberfahrzeit').toBe(3); expect(gelb70.crossingTime).toBe(5); expect(gelb50.intergreen, 'die Gelbzeit wirkt nicht mehr auf die Zwischenzeit').not.toBe( gelb70.intergreen, ); // Ansatz "feste Ueberfahrzeit": 2 s abbiegend, gleich bei welcher // Hoechstgeschwindigkeit. `kfzUeberfahrzeit` ruft `yellowTime` gar nicht // auf - eine kuerzere Gelbzeit kuerzt hier keine Zwischenzeit. const fest50 = computeIntergreen(abbieger(50, 'fest'), OHNE_EINFAHRWEG); const fest70 = computeIntergreen(abbieger(70, 'fest'), OHNE_EINFAHRWEG); expect(fest50.crossingTime, 'die feste Ueberfahrzeit folgt doch der Gelbzeit').toBe(2); expect(fest70.crossingTime).toBe(2); expect(fest50.intergreen, 'die Zwischenzeit haengt bei "fest" doch an vZul').toBe( fest70.intergreen, ); // Und der Radverkehr: Er hat eine Gelbzeit (`yellowRad`), seine // Ueberfahrzeit haengt aber an keiner - deshalb sagt der Eintrag // "Gelbzeit" die Kopplung nur fuer den Kraftfahrzeugverkehr zu. expect( regelUeberfahrzeit({ mode: 'rad', movement: 'geradeaus', vZul: 30 }), 'die Ueberfahrzeit des Radverkehrs folgt doch der Gelbzeit', ).toBe(RILSA_DEFAULTS.crossingTime.radDefault); expect(RILSA_DEFAULTS.crossingTime.radDefault, 'Regelwert Radverkehr').not.toBe( RILSA_DEFAULTS.yellowRad, ); }); it('binden beide Hilfetexte die Kopplung an den Ansatz', () => { const vZul = einzeilig(HILFE.vZulKnoten.wennFalsch ?? ''); expect(vZul, 'die Kopplung steht wieder unbedingt da').not.toContain( 'weil die Gelbzeit zugleich als Überfahrzeit in die Zwischenzeit eingeht', ); expect(vZul, 'der Ansatz, unter dem die Kopplung gilt, ist nicht genannt').toContain( 'beim Ansatz „Überfahrzeit = Gelbzeit“ – der Vorgabe – ist die Gelbzeit zugleich die ' + 'Überfahrzeit', ); expect(vZul, 'der andere Ansatz fehlt').toContain( 'Beim Ansatz „feste Überfahrzeit“ tut sie das nicht', ); expect(vZul, 'die Folge steht weiter unbedingt da').toContain( 'solange der Ansatz „Überfahrzeit = Gelbzeit“ gilt, damit zu kurze Zwischenzeiten', ); // Derselbe Sachverhalt im Eintrag "Gelbzeit" - er stand dort wortverwandt // und ebenso unbedingt. Zwei Eintraege, die einander widersprechen, sind // schlimmer als einer, der irrt. const gelb = einzeilig(HILFE.gelbzeit.wennFalsch ?? ''); expect(gelb, 'der Eintrag "Gelbzeit" sagt die Kopplung wieder unbedingt zu').not.toContain( 'Die Gelbzeit ist zugleich die Überfahrzeit in der Zwischenzeitberechnung.', ); expect(gelb, 'der Ansatz fehlt im Eintrag "Gelbzeit"').toContain( 'Beim Kraftfahrzeugverkehr und dem Ansatz „Überfahrzeit = Gelbzeit“', ); expect(gelb, 'der Fall "feste Überfahrzeit" fehlt im Eintrag "Gelbzeit"').toContain( 'Beim Ansatz „feste Überfahrzeit“ und beim Radverkehr geht sie in keine Zwischenzeit ein', ); }); }); describe('Die Begruendungen in den Kommentaren halten dem eigenen Quelltext stand', () => { /* * NACHTRAG (Fassung 5.12.0): Zwei Kommentare begruendeten * eine richtige Behebung falsch. Eine widerlegte Begruendung ist keine * Kleinigkeit - sie laedt die naechste Gruppe zur falschen Behebung ein: Wer * liest, ein Hilfetext koenne keine Funktion aufrufen, setzt * `gelbzeitstaffelSatz()` ein und haelt C21 fuer erledigt. */ const TEXTE = readFileSync('src/ui/help/texte.ts', 'utf8'); const ANSAETZE = readFileSync('src/domain/rilsa/ansaetze.ts', 'utf8'); const ENGINE = readFileSync('src/domain/validation/engine.ts', 'utf8'); /** Blockkommentare tragen je Zeile ein fuehrendes "*"; verglichen wird ohne. */ const KOMMENTARFLUSS = einzeilig(TEXTE.replace(/\n\s*\*/g, ' ')); it('nennt fuer die fehlende Zahlenstaffel den Grund, der traegt', () => { // Widerlegung der alten Begruendung: Ein Hilfetext dieser Datei setzt sehr // wohl einen gerechneten Wert ein. expect( HILFE.mindestfreigabezeit.wasIstDas, 'kein Hilfetext dieser Datei setzt mehr einen Kennwert ein', ).toContain(`${RILSA_DEFAULTS.minGreen.oepnv} s`); // Der wirkliche Grund: `HILFE` entsteht beim Laden des Moduls, und ohne // die Vorgaben des Plans liefert `gelbzeitstaffelSatz()` die Regelstaffel. expect(gelbzeitstaffelSatz(), 'der Vorgabeparameter ist nicht mehr die Regelstaffel').toBe( gelbzeitstaffelSatz(RILSA_DEFAULTS), ); const wirksam = resolveRilsaSettings({ yellowKfzUpTo50: 4 }).defaults; expect( gelbzeitstaffelSatz(wirksam), 'die Staffel haengt nicht mehr an den Vorgaben - dann traegt die Begruendung nicht', ).not.toBe(gelbzeitstaffelSatz()); expect(KOMMENTARFLUSS, 'die widerlegte Begruendung steht wieder da').not.toContain( 'Ein Hilfetext ist eine statische Zeichenkette und kann die Funktion nicht aufrufen', ); expect(KOMMENTARFLUSS, 'der tragende Grund fehlt').toContain( 'kennt die Vorgaben des geoeffneten Plans nicht', ); }); it('nennt `raeumbeziehungSatz` an seiner Fundstelle', () => { expect(ANSAETZE, 'der Satz steht nicht mehr im Fachkern').toContain( 'export function raeumbeziehungSatz(', ); expect(ENGINE, 'der Pruefbericht fuehrt den Satz wieder selbst').not.toContain( 'function raeumbeziehungSatz(', ); expect(KOMMENTARFLUSS, 'die falsche Fundstelle steht wieder da').not.toContain( 'raeumbeziehungSatz in domain/validation/engine.ts', ); expect(KOMMENTARFLUSS, 'die richtige Fundstelle fehlt').toContain( '`raeumbeziehungSatz`, domain/rilsa/ansaetze.ts, verwendet in domain/validation/engine.ts', ); }); });